sqlcipher/src/build.c at multi-lib · sqlcipher/sqlcipher · GitHub

History

3836 lines (3598 loc) · 124 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

930

931

932

933

934

935

936

937

938

939

940

941

942

943

944

945

946

947

948

949

950

951

952

953

954

955

956

957

958

959

960

961

962

963

964

965

966

967

968

969

970

971

972

973

974

975

976

977

978

979

980

981

982

983

984

985

986

987

988

989

990

991

992

993

994

995

996

997

998

999

1000

** 2001 September 15

** The author disclaims copyright to this source code. In place of

** a legal notice, here is a blessing:

** May you do good and not evil.

** May you find forgiveness for yourself and forgive others.

** May you share freely, never taking more than you give.

*************************************************************************

** This file contains C code routines that are called by the SQLite parser

** when syntax rules are reduced. The routines in this file handle the

** following kinds of SQL syntax:

** CREATE TABLE

** DROP TABLE

** CREATE INDEX

** DROP INDEX

** creating ID lists

** BEGIN TRANSACTION

** COMMIT

** ROLLBACK

#include "sqliteInt.h"

** This routine is called when a new SQL statement is beginning to

** be parsed. Initialize the pParse structure as needed.

void sqlite3BeginParse(Parse *pParse, int explainFlag){

pParse->explain = (u8)explainFlag;

pParse->nVar = 0;

}

#ifndef SQLITE_OMIT_SHARED_CACHE

** The TableLock structure is only used by the sqlite3TableLock() and

** codeTableLocks() functions.

struct TableLock {

int iDb; /* The database containing the table to be locked */

int iTab; /* The root page of the table to be locked */

u8 isWriteLock; /* True for write lock. False for a read lock */

const char *zName; /* Name of the table */

};

** Record the fact that we want to lock a table at run-time.

** The table to be locked has root page iTab and is found in database iDb.

** A read or a write lock can be taken depending on isWritelock.

** This routine just records the fact that the lock is desired. The

** code to make the lock occur is generated by a later call to

** codeTableLocks() which occurs during sqlite3FinishCoding().

void sqlite3TableLock(

Parse *pParse, /* Parsing context */

int iDb, /* Index of the database containing the table to lock */

int iTab, /* Root page number of the table to be locked */

u8 isWriteLock, /* True for a write lock */

const char *zName /* Name of the table to be locked */

){

Parse *pToplevel = sqlite3ParseToplevel(pParse);

int i;

int nBytes;

TableLock *p;

assert( iDb>=0 );

for(i=0; i<pToplevel->nTableLock; i++){

p = &pToplevel->aTableLock[i];

if( p->iDb==iDb && p->iTab==iTab ){

p->isWriteLock = (p->isWriteLock || isWriteLock);

return;

}

nBytes = sizeof(TableLock) * (pToplevel->nTableLock+1);

pToplevel->aTableLock =

sqlite3DbReallocOrFree(pToplevel->db, pToplevel->aTableLock, nBytes);

if( pToplevel->aTableLock ){

p = &pToplevel->aTableLock[pToplevel->nTableLock++];

p->iDb = iDb;

p->iTab = iTab;

p->isWriteLock = isWriteLock;

p->zName = zName;

}else{

pToplevel->nTableLock = 0;

pToplevel->db->mallocFailed = 1;

}

** Code an OP_TableLock instruction for each table locked by the

** statement (configured by calls to sqlite3TableLock()).

static void codeTableLocks(Parse *pParse){

int i;

Vdbe *pVdbe;

pVdbe = sqlite3GetVdbe(pParse);

assert( pVdbe!=0 ); /* sqlite3GetVdbe cannot fail: VDBE already allocated */

for(i=0; i<pParse->nTableLock; i++){

TableLock *p = &pParse->aTableLock[i];

int p1 = p->iDb;

sqlite3VdbeAddOp4(pVdbe, OP_TableLock, p1, p->iTab, p->isWriteLock,

p->zName, P4_STATIC);

}

#else

#define codeTableLocks(x)

#endif

** This routine is called after a single SQL statement has been

** parsed and a VDBE program to execute that statement has been

** prepared. This routine puts the finishing touches on the

** VDBE program and resets the pParse structure for the next

** parse.

** Note that if an error occurred, it might be the case that

** no VDBE code was generated.

void sqlite3FinishCoding(Parse *pParse){

sqlite3 *db;

Vdbe *v;

assert( pParse->pToplevel==0 );

db = pParse->db;

if( db->mallocFailed ) return;

if( pParse->nested ) return;

if( pParse->nErr ) return;

/* Begin by generating some termination code at the end of the

** vdbe program

v = sqlite3GetVdbe(pParse);

assert( !pParse->isMultiWrite

|| sqlite3VdbeAssertMayAbort(v, pParse->mayAbort));

if( v ){

sqlite3VdbeAddOp0(v, OP_Halt);

/* The cookie mask contains one bit for each database file open.

** (Bit 0 is for main, bit 1 is for temp, and so forth.) Bits are

** set for each database that is used. Generate code to start a

** transaction on each used database and to verify the schema cookie

** on each used database.

if( pParse->cookieGoto>0 ){

yDbMask mask;

int iDb;

sqlite3VdbeJumpHere(v, pParse->cookieGoto-1);

for(iDb=0, mask=1; iDb<db->nDb; mask<<=1, iDb++){

if( (mask & pParse->cookieMask)==0 ) continue;

sqlite3VdbeUsesBtree(v, iDb);

sqlite3VdbeAddOp2(v,OP_Transaction, iDb, (mask & pParse->writeMask)!=0);

if( db->init.busy==0 ){

assert( sqlite3SchemaMutexHeld(db, iDb, 0) );

sqlite3VdbeAddOp3(v, OP_VerifyCookie,

iDb, pParse->cookieValue[iDb],

db->aDb[iDb].pSchema->iGeneration);

}

#ifndef SQLITE_OMIT_VIRTUALTABLE

{

int i;

for(i=0; i<pParse->nVtabLock; i++){

char *vtab = (char *)sqlite3GetVTable(db, pParse->apVtabLock[i]);

sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB);

}

pParse->nVtabLock = 0;

}

#endif

/* Once all the cookies have been verified and transactions opened,

** obtain the required table-locks. This is a no-op unless the

** shared-cache feature is enabled.

codeTableLocks(pParse);

/* Initialize any AUTOINCREMENT data structures required.

sqlite3AutoincrementBegin(pParse);

/* Finally, jump back to the beginning of the executable code. */

sqlite3VdbeAddOp2(v, OP_Goto, 0, pParse->cookieGoto);

}

/* Get the VDBE program ready for execution

if( v && ALWAYS(pParse->nErr==0) && !db->mallocFailed ){

#ifdef SQLITE_DEBUG

FILE *trace = (db->flags & SQLITE_VdbeTrace)!=0 ? stdout : 0;

sqlite3VdbeTrace(v, trace);

#endif

assert( pParse->iCacheLevel==0 ); /* Disables and re-enables match */

/* A minimum of one cursor is required if autoincrement is used

* See ticket [a696379c1f08866] */

if( pParse->pAinc!=0 && pParse->nTab==0 ) pParse->nTab = 1;

sqlite3VdbeMakeReady(v, pParse);

pParse->rc = SQLITE_DONE;

pParse->colNamesSet = 0;

}else{

pParse->rc = SQLITE_ERROR;

}

pParse->nTab = 0;

pParse->nMem = 0;

pParse->nSet = 0;

pParse->nVar = 0;

pParse->cookieMask = 0;

pParse->cookieGoto = 0;

}

** Run the parser and code generator recursively in order to generate

** code for the SQL statement given onto the end of the pParse context

** currently under construction. When the parser is run recursively

** this way, the final OP_Halt is not appended and other initialization

** and finalization steps are omitted because those are handling by the

** outermost parser.

** Not everything is nestable. This facility is designed to permit

** INSERT, UPDATE, and DELETE operations against SQLITE_MASTER. Use

** care if you decide to try to use this routine for some other purposes.

void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){

va_list ap;

char *zSql;

char *zErrMsg = 0;

sqlite3 *db = pParse->db;

# define SAVE_SZ (sizeof(Parse) - offsetof(Parse,nVar))

char saveBuf[SAVE_SZ];

if( pParse->nErr ) return;

assert( pParse->nested<10 ); /* Nesting should only be of limited depth */

va_start(ap, zFormat);

zSql = sqlite3VMPrintf(db, zFormat, ap);

va_end(ap);

if( zSql==0 ){

return; /* A malloc must have failed */

}

pParse->nested++;

memcpy(saveBuf, &pParse->nVar, SAVE_SZ);

memset(&pParse->nVar, 0, SAVE_SZ);

sqlite3RunParser(pParse, zSql, &zErrMsg);

sqlite3DbFree(db, zErrMsg);

sqlite3DbFree(db, zSql);

memcpy(&pParse->nVar, saveBuf, SAVE_SZ);

pParse->nested--;

}

** Locate the in-memory structure that describes a particular database

** table given the name of that table and (optionally) the name of the

** database containing the table. Return NULL if not found.

** If zDatabase is 0, all databases are searched for the table and the

** first matching table is returned. (No checking for duplicate table

** names is done.) The search order is TEMP first, then MAIN, then any

** auxiliary databases added using the ATTACH command.

** See also sqlite3LocateTable().

Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){

Table *p = 0;

int i;

int nName;

assert( zName!=0 );

nName = sqlite3Strlen30(zName);

/* All mutexes are required for schema access. Make sure we hold them. */

assert( zDatabase!=0 || sqlite3BtreeHoldsAllMutexes(db) );

for(i=OMIT_TEMPDB; i<db->nDb; i++){

int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */

if( zDatabase!=0 && sqlite3StrICmp(zDatabase, db->aDb[j].zName) ) continue;

assert( sqlite3SchemaMutexHeld(db, j, 0) );

p = sqlite3HashFind(&db->aDb[j].pSchema->tblHash, zName, nName);

if( p ) break;

}

return p;

}

** Locate the in-memory structure that describes a particular database

** table given the name of that table and (optionally) the name of the

** database containing the table. Return NULL if not found. Also leave an

** error message in pParse->zErrMsg.

** The difference between this routine and sqlite3FindTable() is that this

** routine leaves an error message in pParse->zErrMsg where

** sqlite3FindTable() does not.

Table *sqlite3LocateTable(

Parse *pParse, /* context in which to report errors */

int isView, /* True if looking for a VIEW rather than a TABLE */

const char *zName, /* Name of the table we are looking for */

const char *zDbase /* Name of the database. Might be NULL */

){

Table *p;

/* Read the database schema. If an error occurs, leave an error message

** and code in pParse and return NULL. */

if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){

return 0;

}

p = sqlite3FindTable(pParse->db, zName, zDbase);

if( p==0 ){

const char *zMsg = isView ? "no such view" : "no such table";

if( zDbase ){

sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);

}else{

sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);

}

pParse->checkSchema = 1;

}

return p;

}

** Locate the table identified by *p.

** This is a wrapper around sqlite3LocateTable(). The difference between

** sqlite3LocateTable() and this function is that this function restricts

** the search to schema (p->pSchema) if it is not NULL. p->pSchema may be

** non-NULL if it is part of a view or trigger program definition. See

** sqlite3FixSrcList() for details.

Table *sqlite3LocateTableItem(

Parse *pParse,

int isView,

struct SrcList_item *p

){

const char *zDb;

assert( p->pSchema==0 || p->zDatabase==0 );

if( p->pSchema ){

int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema);

zDb = pParse->db->aDb[iDb].zName;

}else{

zDb = p->zDatabase;

}

return sqlite3LocateTable(pParse, isView, p->zName, zDb);

}

** Locate the in-memory structure that describes

** a particular index given the name of that index

** and the name of the database that contains the index.

** Return NULL if not found.

** If zDatabase is 0, all databases are searched for the

** table and the first matching index is returned. (No checking

** for duplicate index names is done.) The search order is

** TEMP first, then MAIN, then any auxiliary databases added

** using the ATTACH command.

Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){

Index *p = 0;

int i;

int nName = sqlite3Strlen30(zName);

/* All mutexes are required for schema access. Make sure we hold them. */

assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );

for(i=OMIT_TEMPDB; i<db->nDb; i++){

int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */

Schema *pSchema = db->aDb[j].pSchema;

assert( pSchema );

if( zDb && sqlite3StrICmp(zDb, db->aDb[j].zName) ) continue;

assert( sqlite3SchemaMutexHeld(db, j, 0) );

p = sqlite3HashFind(&pSchema->idxHash, zName, nName);

if( p ) break;

}

return p;

}

** Reclaim the memory used by an index

static void freeIndex(sqlite3 *db, Index *p){

#ifndef SQLITE_OMIT_ANALYZE

sqlite3DeleteIndexSamples(db, p);

#endif

sqlite3DbFree(db, p->zColAff);

sqlite3DbFree(db, p);

}

** For the index called zIdxName which is found in the database iDb,

** unlike that index from its Table then remove the index from

** the index hash table and free all memory structures associated

** with the index.

void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){

Index *pIndex;

int len;

Hash *pHash;

assert( sqlite3SchemaMutexHeld(db, iDb, 0) );

pHash = &db->aDb[iDb].pSchema->idxHash;

len = sqlite3Strlen30(zIdxName);

pIndex = sqlite3HashInsert(pHash, zIdxName, len, 0);

if( ALWAYS(pIndex) ){

if( pIndex->pTable->pIndex==pIndex ){

pIndex->pTable->pIndex = pIndex->pNext;

}else{

Index *p;

/* Justification of ALWAYS(); The index must be on the list of

** indices. */

p = pIndex->pTable->pIndex;

while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; }

if( ALWAYS(p && p->pNext==pIndex) ){

p->pNext = pIndex->pNext;

}

freeIndex(db, pIndex);

}

db->flags |= SQLITE_InternChanges;

}

** Look through the list of open database files in db->aDb[] and if

** any have been closed, remove them from the list. Reallocate the

** db->aDb[] structure to a smaller size, if possible.

** Entry 0 (the "main" database) and entry 1 (the "temp" database)

** are never candidates for being collapsed.

void sqlite3CollapseDatabaseArray(sqlite3 *db){

int i, j;

for(i=j=2; i<db->nDb; i++){

struct Db *pDb = &db->aDb[i];

if( pDb->pBt==0 ){

sqlite3DbFree(db, pDb->zName);

pDb->zName = 0;

continue;

}

if( j<i ){

db->aDb[j] = db->aDb[i];

}

j++;

}

memset(&db->aDb[j], 0, (db->nDb-j)*sizeof(db->aDb[j]));

db->nDb = j;

if( db->nDb<=2 && db->aDb!=db->aDbStatic ){

memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));

sqlite3DbFree(db, db->aDb);

db->aDb = db->aDbStatic;

}

** Reset the schema for the database at index iDb. Also reset the

** TEMP schema.

void sqlite3ResetOneSchema(sqlite3 *db, int iDb){

Db *pDb;

assert( iDb<db->nDb );

/* Case 1: Reset the single schema identified by iDb */

pDb = &db->aDb[iDb];

assert( sqlite3SchemaMutexHeld(db, iDb, 0) );

assert( pDb->pSchema!=0 );

sqlite3SchemaClear(pDb->pSchema);

/* If any database other than TEMP is reset, then also reset TEMP

** since TEMP might be holding triggers that reference tables in the

** other database.

if( iDb!=1 ){

pDb = &db->aDb[1];

assert( pDb->pSchema!=0 );

sqlite3SchemaClear(pDb->pSchema);

}

return;

}

** Erase all schema information from all attached databases (including

** "main" and "temp") for a single database connection.

void sqlite3ResetAllSchemasOfConnection(sqlite3 *db){

int i;

sqlite3BtreeEnterAll(db);

for(i=0; i<db->nDb; i++){

Db *pDb = &db->aDb[i];

if( pDb->pSchema ){

sqlite3SchemaClear(pDb->pSchema);

}

db->flags &= ~SQLITE_InternChanges;

sqlite3VtabUnlockList(db);

sqlite3BtreeLeaveAll(db);

sqlite3CollapseDatabaseArray(db);

}

** This routine is called when a commit occurs.

void sqlite3CommitInternalChanges(sqlite3 *db){

db->flags &= ~SQLITE_InternChanges;

}

** Delete memory allocated for the column names of a table or view (the

** Table.aCol[] array).

static void sqliteDeleteColumnNames(sqlite3 *db, Table *pTable){

int i;

Column *pCol;

assert( pTable!=0 );

if( (pCol = pTable->aCol)!=0 ){

for(i=0; i<pTable->nCol; i++, pCol++){

sqlite3DbFree(db, pCol->zName);

sqlite3ExprDelete(db, pCol->pDflt);

sqlite3DbFree(db, pCol->zDflt);

sqlite3DbFree(db, pCol->zType);

sqlite3DbFree(db, pCol->zColl);

}

sqlite3DbFree(db, pTable->aCol);

}

** Remove the memory data structures associated with the given

** Table. No changes are made to disk by this routine.

** This routine just deletes the data structure. It does not unlink

** the table data structure from the hash table. But it does destroy

** memory structures of the indices and foreign keys associated with

** the table.

** The db parameter is optional. It is needed if the Table object

** contains lookaside memory. (Table objects in the schema do not use

** lookaside memory, but some ephemeral Table objects do.) Or the

** db parameter can be used with db->pnBytesFreed to measure the memory

** used by the Table object.

void sqlite3DeleteTable(sqlite3 *db, Table *pTable){

Index *pIndex, *pNext;

TESTONLY( int nLookaside; ) /* Used to verify lookaside not used for schema */

assert( !pTable || pTable->nRef>0 );

/* Do not delete the table until the reference count reaches zero. */

if( !pTable ) return;

if( ((!db || db->pnBytesFreed==0) && (--pTable->nRef)>0) ) return;

/* Record the number of outstanding lookaside allocations in schema Tables

** prior to doing any free() operations. Since schema Tables do not use

** lookaside, this number should not change. */

TESTONLY( nLookaside = (db && (pTable->tabFlags & TF_Ephemeral)==0) ?

db->lookaside.nOut : 0 );

/* Delete all indices associated with this table. */

for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){

pNext = pIndex->pNext;

assert( pIndex->pSchema==pTable->pSchema );

if( !db || db->pnBytesFreed==0 ){

char *zName = pIndex->zName;

TESTONLY ( Index *pOld = ) sqlite3HashInsert(

&pIndex->pSchema->idxHash, zName, sqlite3Strlen30(zName), 0

);

assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );

assert( pOld==pIndex || pOld==0 );

}

freeIndex(db, pIndex);

}

/* Delete any foreign keys attached to this table. */

sqlite3FkDelete(db, pTable);

/* Delete the Table structure itself.

sqliteDeleteColumnNames(db, pTable);

sqlite3DbFree(db, pTable->zName);

sqlite3DbFree(db, pTable->zColAff);

sqlite3SelectDelete(db, pTable->pSelect);

#ifndef SQLITE_OMIT_CHECK

sqlite3ExprListDelete(db, pTable->pCheck);

#endif

#ifndef SQLITE_OMIT_VIRTUALTABLE

sqlite3VtabClear(db, pTable);

#endif

sqlite3DbFree(db, pTable);

/* Verify that no lookaside memory was used by schema tables */

assert( nLookaside==0 || nLookaside==db->lookaside.nOut );

}

** Unlink the given table from the hash tables and the delete the

** table structure with all its indices and foreign keys.

void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){

Table *p;

Db *pDb;

assert( db!=0 );

assert( iDb>=0 && iDb<db->nDb );

assert( zTabName );

assert( sqlite3SchemaMutexHeld(db, iDb, 0) );

testcase( zTabName[0]==0 ); /* Zero-length table names are allowed */

pDb = &db->aDb[iDb];

p = sqlite3HashInsert(&pDb->pSchema->tblHash, zTabName,

sqlite3Strlen30(zTabName),0);

sqlite3DeleteTable(db, p);

db->flags |= SQLITE_InternChanges;

}

** Given a token, return a string that consists of the text of that

** token. Space to hold the returned string

** is obtained from sqliteMalloc() and must be freed by the calling

** function.

** Any quotation marks (ex: "name", 'name', [name], or `name`) that

** surround the body of the token are removed.

** Tokens are often just pointers into the original SQL text and so

** are not \000 terminated and are not persistent. The returned string

** is \000 terminated and is persistent.

char *sqlite3NameFromToken(sqlite3 *db, Token *pName){

char *zName;

if( pName ){

zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n);

sqlite3Dequote(zName);

}else{

zName = 0;

}

return zName;

}

** Open the sqlite_master table stored in database number iDb for

** writing. The table is opened using cursor 0.

void sqlite3OpenMasterTable(Parse *p, int iDb){

Vdbe *v = sqlite3GetVdbe(p);

sqlite3TableLock(p, iDb, MASTER_ROOT, 1, SCHEMA_TABLE(iDb));

sqlite3VdbeAddOp3(v, OP_OpenWrite, 0, MASTER_ROOT, iDb);

sqlite3VdbeChangeP4(v, -1, (char *)5, P4_INT32); /* 5 column table */

if( p->nTab==0 ){

p->nTab = 1;

}

** Parameter zName points to a nul-terminated buffer containing the name

** of a database ("main", "temp" or the name of an attached db). This

** function returns the index of the named database in db->aDb[], or

** -1 if the named db cannot be found.

int sqlite3FindDbName(sqlite3 *db, const char *zName){

int i = -1; /* Database number */

if( zName ){

Db *pDb;

int n = sqlite3Strlen30(zName);

for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){

if( (!OMIT_TEMPDB || i!=1 ) && n==sqlite3Strlen30(pDb->zName) &&

0==sqlite3StrICmp(pDb->zName, zName) ){

break;

}

return i;

}

** The token *pName contains the name of a database (either "main" or

** "temp" or the name of an attached db). This routine returns the

** index of the named database in db->aDb[], or -1 if the named db

** does not exist.

int sqlite3FindDb(sqlite3 *db, Token *pName){

int i; /* Database number */

char *zName; /* Name we are searching for */

zName = sqlite3NameFromToken(db, pName);

i = sqlite3FindDbName(db, zName);

sqlite3DbFree(db, zName);

return i;

}

/* The table or view or trigger name is passed to this routine via tokens

** pName1 and pName2. If the table name was fully qualified, for example:

** CREATE TABLE xxx.yyy (...);

** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if

** the table name is not fully qualified, i.e.:

** CREATE TABLE yyy(...);

** Then pName1 is set to "yyy" and pName2 is "".

** This routine sets the *ppUnqual pointer to point at the token (pName1 or

** pName2) that stores the unqualified table name. The index of the

** database "xxx" is returned.

int sqlite3TwoPartName(

Parse *pParse, /* Parsing and code generating context */

Token *pName1, /* The "xxx" in the name "xxx.yyy" or "xxx" */

Token *pName2, /* The "yyy" in the name "xxx.yyy" */

Token **pUnqual /* Write the unqualified object name here */

){

int iDb; /* Database holding the object */

sqlite3 *db = pParse->db;

if( ALWAYS(pName2!=0) && pName2->n>0 ){

if( db->init.busy ) {

sqlite3ErrorMsg(pParse, "corrupt database");

pParse->nErr++;

return -1;

}

*pUnqual = pName2;

iDb = sqlite3FindDb(db, pName1);

if( iDb<0 ){

sqlite3ErrorMsg(pParse, "unknown database %T", pName1);

pParse->nErr++;

return -1;

}

}else{

assert( db->init.iDb==0 || db->init.busy );

iDb = db->init.iDb;

*pUnqual = pName1;

}

return iDb;

}

** This routine is used to check if the UTF-8 string zName is a legal

** unqualified name for a new schema object (table, index, view or

** trigger). All names are legal except those that begin with the string

** "sqlite_" (in upper, lower or mixed case). This portion of the namespace

** is reserved for internal use.

int sqlite3CheckObjectName(Parse *pParse, const char *zName){

if( !pParse->db->init.busy && pParse->nested==0

&& (pParse->db->flags & SQLITE_WriteSchema)==0

&& 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){

sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s", zName);

return SQLITE_ERROR;

}

return SQLITE_OK;

}

** Begin constructing a new table representation in memory. This is

** the first of several action routines that get called in response

** to a CREATE TABLE statement. In particular, this routine is called

** after seeing tokens "CREATE" and "TABLE" and the table name. The isTemp

** flag is true if the table should be stored in the auxiliary database

** file instead of in the main database file. This is normally the case

** when the "TEMP" or "TEMPORARY" keyword occurs in between

** CREATE and TABLE.

** The new table record is initialized and put in pParse->pNewTable.

** As more of the CREATE TABLE statement is parsed, additional action

** routines will be called to add more information to this record.

** At the end of the CREATE TABLE statement, the sqlite3EndTable() routine

** is called to complete the construction of the new table record.

void sqlite3StartTable(

Parse *pParse, /* Parser context */

Token *pName1, /* First part of the name of the table or view */

Token *pName2, /* Second part of the name of the table or view */

int isTemp, /* True if this is a TEMP table */

int isView, /* True if this is a VIEW */

int isVirtual, /* True if this is a VIRTUAL table */

int noErr /* Do nothing if table already exists */

){

Table *pTable;

char *zName = 0; /* The name of the new table */

sqlite3 *db = pParse->db;

Vdbe *v;

int iDb; /* Database number to create the table in */

Token *pName; /* Unqualified name of the table to create */

/* The table or view name to create is passed to this routine via tokens

** pName1 and pName2. If the table name was fully qualified, for example:

** CREATE TABLE xxx.yyy (...);

** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if

** the table name is not fully qualified, i.e.:

** CREATE TABLE yyy(...);

** Then pName1 is set to "yyy" and pName2 is "".

** The call below sets the pName pointer to point at the token (pName1 or

** pName2) that stores the unqualified table name. The variable iDb is

** set to the index of the database that the table or view is to be

** created in.

iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);

if( iDb<0 ) return;

if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){

/* If creating a temp table, the name may not be qualified. Unless

** the database name is "temp" anyway. */

sqlite3ErrorMsg(pParse, "temporary table name must be unqualified");

return;

}

if( !OMIT_TEMPDB && isTemp ) iDb = 1;

pParse->sNameToken = *pName;

zName = sqlite3NameFromToken(db, pName);

if( zName==0 ) return;

if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){

goto begin_table_error;

}

if( db->init.iDb==1 ) isTemp = 1;

#ifndef SQLITE_OMIT_AUTHORIZATION

assert( (isTemp & 1)==isTemp );

{

int code;

char *zDb = db->aDb[iDb].zName;

if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){

goto begin_table_error;

}

if( isView ){

if( !OMIT_TEMPDB && isTemp ){

code = SQLITE_CREATE_TEMP_VIEW;

}else{

code = SQLITE_CREATE_VIEW;

}

}else{

if( !OMIT_TEMPDB && isTemp ){

code = SQLITE_CREATE_TEMP_TABLE;

}else{

code = SQLITE_CREATE_TABLE;

}

if( !isVirtual && sqlite3AuthCheck(pParse, code, zName, 0, zDb) ){

goto begin_table_error;

}

#endif

/* Make sure the new table name does not collide with an existing

** index or table name in the same database. Issue an error message if

** it does. The exception is if the statement being parsed was passed

** to an sqlite3_declare_vtab() call. In that case only the column names

** and types will be used, so there is no need to test for namespace

** collisions.

if( !IN_DECLARE_VTAB ){

char *zDb = db->aDb[iDb].zName;

if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){

goto begin_table_error;

}

pTable = sqlite3FindTable(db, zName, zDb);

if( pTable ){

if( !noErr ){

sqlite3ErrorMsg(pParse, "table %T already exists", pName);

}else{

assert( !db->init.busy );

sqlite3CodeVerifySchema(pParse, iDb);

}

goto begin_table_error;

}

if( sqlite3FindIndex(db, zName, zDb)!=0 ){

sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);

goto begin_table_error;

}

pTable = sqlite3DbMallocZero(db, sizeof(Table));

if( pTable==0 ){

db->mallocFailed = 1;

pParse->rc = SQLITE_NOMEM;

pParse->nErr++;

goto begin_table_error;

}

pTable->zName = zName;

pTable->iPKey = -1;

pTable->pSchema = db->aDb[iDb].pSchema;

pTable->nRef = 1;

pTable->nRowEst = 1000000;

assert( pParse->pNewTable==0 );

pParse->pNewTable = pTable;

/* If this is the magic sqlite_sequence table used by autoincrement,

** then record a pointer to this table in the main database structure

** so that INSERT can find the table easily.

#ifndef SQLITE_OMIT_AUTOINCREMENT

if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){

assert( sqlite3SchemaMutexHeld(db, iDb, 0) );

pTable->pSchema->pSeqTab = pTable;

}

#endif

/* Begin generating the code that will insert the table record into

** the SQLITE_MASTER table. Note in particular that we must go ahead

** and allocate the record number for the table entry now. Before any

** PRIMARY KEY or UNIQUE keywords are parsed. Those keywords will cause

** indices to be created and the table record must come before the

** indices. Hence, the record number for the table must be allocated

** now.

if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){

int j1;

int fileFormat;

int reg1, reg2, reg3;

sqlite3BeginWriteOperation(pParse, 0, iDb);

#ifndef SQLITE_OMIT_VIRTUALTABLE

if( isVirtual ){

sqlite3VdbeAddOp0(v, OP_VBegin);

}

#endif

/* If the file format and encoding in the database have not been set,

** set them now.

reg1 = pParse->regRowid = ++pParse->nMem;

reg2 = pParse->regRoot = ++pParse->nMem;

reg3 = ++pParse->nMem;

sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT);

sqlite3VdbeUsesBtree(v, iDb);

j1 = sqlite3VdbeAddOp1(v, OP_If, reg3);

fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ?

1 : SQLITE_MAX_FILE_FORMAT;

sqlite3VdbeAddOp2(v, OP_Integer, fileFormat, reg3);

sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, reg3);

sqlite3VdbeAddOp2(v, OP_Integer, ENC(db), reg3);

sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, reg3);

sqlite3VdbeJumpHere(v, j1);

/* This just creates a place-holder record in the sqlite_master table.

** The record created does not contain anything yet. It will be replaced

** by the real entry in code generated at sqlite3EndTable().

** The rowid for the new entry is left in register pParse->regRowid.

** The root page number of the new table is left in reg pParse->regRoot.

** The rowid and root page number values are needed by the code that

** sqlite3EndTable will generate.

#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)

if( isView || isVirtual ){

sqlite3VdbeAddOp2(v, OP_Integer, 0, reg2);

}else

#endif

{

sqlite3VdbeAddOp2(v, OP_CreateTable, iDb, reg2);

}

sqlite3OpenMasterTable(pParse, iDb);

sqlite3VdbeAddOp2(v, OP_NewRowid, 0, reg1);

sqlite3VdbeAddOp2(v, OP_Null, 0, reg3);

sqlite3VdbeAddOp3(v, OP_Insert, 0, reg3, reg1);

sqlite3VdbeChangeP5(v, OPFLAG_APPEND);

sqlite3VdbeAddOp0(v, OP_Close);

}

/* Normal (non-error) return. */

return;

/* If an error occurs, we jump here */

begin_table_error:

sqlite3DbFree(db, zName);

return;

}

** This macro is used to compare two strings in a case-insensitive manner.

** It is slightly faster than calling sqlite3StrICmp() directly, but

** produces larger code.

** WARNING: This macro is not compatible with the strcmp() family. It

** returns true if the two strings are equal, otherwise false.

#define STRICMP(x, y) (\

sqlite3UpperToLower[*(unsigned char *)(x)]== \

sqlite3UpperToLower[*(unsigned char *)(y)] \

&& sqlite3StrICmp((x)+1,(y)+1)==0 )

** Add a new column to the table currently being constructed.

** The parser calls this routine once for each column declaration

** in a CREATE TABLE statement. sqlite3StartTable() gets called

** first to get things going. Then this routine is called for each

** column.

void sqlite3AddColumn(Parse *pParse, Token *pName){

Table *p;

int i;

char *z;

Column *pCol;

sqlite3 *db = pParse->db;

if( (p = pParse->pNewTable)==0 ) return;

#if SQLITE_MAX_COLUMN

if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){

sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);

return;

}

#endif

View remainder of file in raw view

sqlcipher/src/build.c at multi-lib · sqlcipher/sqlcipher · GitHub

Uh oh!

Expand file tree

Breadcrumbs

build.c

Latest commit

History

Breadcrumbs

build.c

File metadata and controls