1: /*
2: ** 2001 September 15
3: **
4: ** The author disclaims copyright to this source code. In place of
5: ** a legal notice, here is a blessing:
6: **
7: ** May you do good and not evil.
8: ** May you find forgiveness for yourself and forgive others.
9: ** May you share freely, never taking more than you give.
10: **
11: *************************************************************************
12: ** This file contains C code routines that are called by the SQLite parser
13: ** when syntax rules are reduced. The routines in this file handle the
14: ** following kinds of SQL syntax:
15: **
16: ** CREATE TABLE
17: ** DROP TABLE
18: ** CREATE INDEX
19: ** DROP INDEX
20: ** creating ID lists
21: ** BEGIN TRANSACTION
22: ** COMMIT
23: ** ROLLBACK
24: */
25: #include "sqliteInt.h"
26:
27: /*
28: ** This routine is called when a new SQL statement is beginning to
29: ** be parsed. Initialize the pParse structure as needed.
30: */
31: void sqlite3BeginParse(Parse *pParse, int explainFlag){
32: pParse->explain = (u8)explainFlag;
33: pParse->nVar = 0;
34: }
35:
36: #ifndef SQLITE_OMIT_SHARED_CACHE
37: /*
38: ** The TableLock structure is only used by the sqlite3TableLock() and
39: ** codeTableLocks() functions.
40: */
41: struct TableLock {
42: int iDb; /* The database containing the table to be locked */
43: int iTab; /* The root page of the table to be locked */
44: u8 isWriteLock; /* True for write lock. False for a read lock */
45: const char *zName; /* Name of the table */
46: };
47:
48: /*
49: ** Record the fact that we want to lock a table at run-time.
50: **
51: ** The table to be locked has root page iTab and is found in database iDb.
52: ** A read or a write lock can be taken depending on isWritelock.
53: **
54: ** This routine just records the fact that the lock is desired. The
55: ** code to make the lock occur is generated by a later call to
56: ** codeTableLocks() which occurs during sqlite3FinishCoding().
57: */
58: void sqlite3TableLock(
59: Parse *pParse, /* Parsing context */
60: int iDb, /* Index of the database containing the table to lock */
61: int iTab, /* Root page number of the table to be locked */
62: u8 isWriteLock, /* True for a write lock */
63: const char *zName /* Name of the table to be locked */
64: ){
65: Parse *pToplevel = sqlite3ParseToplevel(pParse);
66: int i;
67: int nBytes;
68: TableLock *p;
69: assert( iDb>=0 );
70:
71: for(i=0; i<pToplevel->nTableLock; i++){
72: p = &pToplevel->aTableLock[i];
73: if( p->iDb==iDb && p->iTab==iTab ){
74: p->isWriteLock = (p->isWriteLock || isWriteLock);
75: return;
76: }
77: }
78:
79: nBytes = sizeof(TableLock) * (pToplevel->nTableLock+1);
80: pToplevel->aTableLock =
81: sqlite3DbReallocOrFree(pToplevel->db, pToplevel->aTableLock, nBytes);
82: if( pToplevel->aTableLock ){
83: p = &pToplevel->aTableLock[pToplevel->nTableLock++];
84: p->iDb = iDb;
85: p->iTab = iTab;
86: p->isWriteLock = isWriteLock;
87: p->zName = zName;
88: }else{
89: pToplevel->nTableLock = 0;
90: pToplevel->db->mallocFailed = 1;
91: }
92: }
93:
94: /*
95: ** Code an OP_TableLock instruction for each table locked by the
96: ** statement (configured by calls to sqlite3TableLock()).
97: */
98: static void codeTableLocks(Parse *pParse){
99: int i;
100: Vdbe *pVdbe;
101:
102: pVdbe = sqlite3GetVdbe(pParse);
103: assert( pVdbe!=0 ); /* sqlite3GetVdbe cannot fail: VDBE already allocated */
104:
105: for(i=0; i<pParse->nTableLock; i++){
106: TableLock *p = &pParse->aTableLock[i];
107: int p1 = p->iDb;
108: sqlite3VdbeAddOp4(pVdbe, OP_TableLock, p1, p->iTab, p->isWriteLock,
109: p->zName, P4_STATIC);
110: }
111: }
112: #else
113: #define codeTableLocks(x)
114: #endif
115:
116: /*
117: ** This routine is called after a single SQL statement has been
118: ** parsed and a VDBE program to execute that statement has been
119: ** prepared. This routine puts the finishing touches on the
120: ** VDBE program and resets the pParse structure for the next
121: ** parse.
122: **
123: ** Note that if an error occurred, it might be the case that
124: ** no VDBE code was generated.
125: */
126: void sqlite3FinishCoding(Parse *pParse){
127: sqlite3 *db;
128: Vdbe *v;
129:
130: db = pParse->db;
131: if( db->mallocFailed ) return;
132: if( pParse->nested ) return;
133: if( pParse->nErr ) return;
134:
135: /* Begin by generating some termination code at the end of the
136: ** vdbe program
137: */
138: v = sqlite3GetVdbe(pParse);
139: assert( !pParse->isMultiWrite
140: || sqlite3VdbeAssertMayAbort(v, pParse->mayAbort));
141: if( v ){
142: sqlite3VdbeAddOp0(v, OP_Halt);
143:
144: /* The cookie mask contains one bit for each database file open.
145: ** (Bit 0 is for main, bit 1 is for temp, and so forth.) Bits are
146: ** set for each database that is used. Generate code to start a
147: ** transaction on each used database and to verify the schema cookie
148: ** on each used database.
149: */
150: if( pParse->cookieGoto>0 ){
151: yDbMask mask;
152: int iDb;
153: sqlite3VdbeJumpHere(v, pParse->cookieGoto-1);
154: for(iDb=0, mask=1; iDb<db->nDb; mask<<=1, iDb++){
155: if( (mask & pParse->cookieMask)==0 ) continue;
156: sqlite3VdbeUsesBtree(v, iDb);
157: sqlite3VdbeAddOp2(v,OP_Transaction, iDb, (mask & pParse->writeMask)!=0);
158: if( db->init.busy==0 ){
159: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
160: sqlite3VdbeAddOp3(v, OP_VerifyCookie,
161: iDb, pParse->cookieValue[iDb],
162: db->aDb[iDb].pSchema->iGeneration);
163: }
164: }
165: #ifndef SQLITE_OMIT_VIRTUALTABLE
166: {
167: int i;
168: for(i=0; i<pParse->nVtabLock; i++){
169: char *vtab = (char *)sqlite3GetVTable(db, pParse->apVtabLock[i]);
170: sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB);
171: }
172: pParse->nVtabLock = 0;
173: }
174: #endif
175:
176: /* Once all the cookies have been verified and transactions opened,
177: ** obtain the required table-locks. This is a no-op unless the
178: ** shared-cache feature is enabled.
179: */
180: codeTableLocks(pParse);
181:
182: /* Initialize any AUTOINCREMENT data structures required.
183: */
184: sqlite3AutoincrementBegin(pParse);
185:
186: /* Finally, jump back to the beginning of the executable code. */
187: sqlite3VdbeAddOp2(v, OP_Goto, 0, pParse->cookieGoto);
188: }
189: }
190:
191:
192: /* Get the VDBE program ready for execution
193: */
194: if( v && ALWAYS(pParse->nErr==0) && !db->mallocFailed ){
195: #ifdef SQLITE_DEBUG
196: FILE *trace = (db->flags & SQLITE_VdbeTrace)!=0 ? stdout : 0;
197: sqlite3VdbeTrace(v, trace);
198: #endif
199: assert( pParse->iCacheLevel==0 ); /* Disables and re-enables match */
200: /* A minimum of one cursor is required if autoincrement is used
201: * See ticket [a696379c1f08866] */
202: if( pParse->pAinc!=0 && pParse->nTab==0 ) pParse->nTab = 1;
203: sqlite3VdbeMakeReady(v, pParse);
204: pParse->rc = SQLITE_DONE;
205: pParse->colNamesSet = 0;
206: }else{
207: pParse->rc = SQLITE_ERROR;
208: }
209: pParse->nTab = 0;
210: pParse->nMem = 0;
211: pParse->nSet = 0;
212: pParse->nVar = 0;
213: pParse->cookieMask = 0;
214: pParse->cookieGoto = 0;
215: }
216:
217: /*
218: ** Run the parser and code generator recursively in order to generate
219: ** code for the SQL statement given onto the end of the pParse context
220: ** currently under construction. When the parser is run recursively
221: ** this way, the final OP_Halt is not appended and other initialization
222: ** and finalization steps are omitted because those are handling by the
223: ** outermost parser.
224: **
225: ** Not everything is nestable. This facility is designed to permit
226: ** INSERT, UPDATE, and DELETE operations against SQLITE_MASTER. Use
227: ** care if you decide to try to use this routine for some other purposes.
228: */
229: void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
230: va_list ap;
231: char *zSql;
232: char *zErrMsg = 0;
233: sqlite3 *db = pParse->db;
234: # define SAVE_SZ (sizeof(Parse) - offsetof(Parse,nVar))
235: char saveBuf[SAVE_SZ];
236:
237: if( pParse->nErr ) return;
238: assert( pParse->nested<10 ); /* Nesting should only be of limited depth */
239: va_start(ap, zFormat);
240: zSql = sqlite3VMPrintf(db, zFormat, ap);
241: va_end(ap);
242: if( zSql==0 ){
243: return; /* A malloc must have failed */
244: }
245: pParse->nested++;
246: memcpy(saveBuf, &pParse->nVar, SAVE_SZ);
247: memset(&pParse->nVar, 0, SAVE_SZ);
248: sqlite3RunParser(pParse, zSql, &zErrMsg);
249: sqlite3DbFree(db, zErrMsg);
250: sqlite3DbFree(db, zSql);
251: memcpy(&pParse->nVar, saveBuf, SAVE_SZ);
252: pParse->nested--;
253: }
254:
255: /*
256: ** Locate the in-memory structure that describes a particular database
257: ** table given the name of that table and (optionally) the name of the
258: ** database containing the table. Return NULL if not found.
259: **
260: ** If zDatabase is 0, all databases are searched for the table and the
261: ** first matching table is returned. (No checking for duplicate table
262: ** names is done.) The search order is TEMP first, then MAIN, then any
263: ** auxiliary databases added using the ATTACH command.
264: **
265: ** See also sqlite3LocateTable().
266: */
267: Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){
268: Table *p = 0;
269: int i;
270: int nName;
271: assert( zName!=0 );
272: nName = sqlite3Strlen30(zName);
273: /* All mutexes are required for schema access. Make sure we hold them. */
274: assert( zDatabase!=0 || sqlite3BtreeHoldsAllMutexes(db) );
275: for(i=OMIT_TEMPDB; i<db->nDb; i++){
276: int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */
277: if( zDatabase!=0 && sqlite3StrICmp(zDatabase, db->aDb[j].zName) ) continue;
278: assert( sqlite3SchemaMutexHeld(db, j, 0) );
279: p = sqlite3HashFind(&db->aDb[j].pSchema->tblHash, zName, nName);
280: if( p ) break;
281: }
282: return p;
283: }
284:
285: /*
286: ** Locate the in-memory structure that describes a particular database
287: ** table given the name of that table and (optionally) the name of the
288: ** database containing the table. Return NULL if not found. Also leave an
289: ** error message in pParse->zErrMsg.
290: **
291: ** The difference between this routine and sqlite3FindTable() is that this
292: ** routine leaves an error message in pParse->zErrMsg where
293: ** sqlite3FindTable() does not.
294: */
295: Table *sqlite3LocateTable(
296: Parse *pParse, /* context in which to report errors */
297: int isView, /* True if looking for a VIEW rather than a TABLE */
298: const char *zName, /* Name of the table we are looking for */
299: const char *zDbase /* Name of the database. Might be NULL */
300: ){
301: Table *p;
302:
303: /* Read the database schema. If an error occurs, leave an error message
304: ** and code in pParse and return NULL. */
305: if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
306: return 0;
307: }
308:
309: p = sqlite3FindTable(pParse->db, zName, zDbase);
310: if( p==0 ){
311: const char *zMsg = isView ? "no such view" : "no such table";
312: if( zDbase ){
313: sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
314: }else{
315: sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
316: }
317: pParse->checkSchema = 1;
318: }
319: return p;
320: }
321:
322: /*
323: ** Locate the in-memory structure that describes
324: ** a particular index given the name of that index
325: ** and the name of the database that contains the index.
326: ** Return NULL if not found.
327: **
328: ** If zDatabase is 0, all databases are searched for the
329: ** table and the first matching index is returned. (No checking
330: ** for duplicate index names is done.) The search order is
331: ** TEMP first, then MAIN, then any auxiliary databases added
332: ** using the ATTACH command.
333: */
334: Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){
335: Index *p = 0;
336: int i;
337: int nName = sqlite3Strlen30(zName);
338: /* All mutexes are required for schema access. Make sure we hold them. */
339: assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
340: for(i=OMIT_TEMPDB; i<db->nDb; i++){
341: int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */
342: Schema *pSchema = db->aDb[j].pSchema;
343: assert( pSchema );
344: if( zDb && sqlite3StrICmp(zDb, db->aDb[j].zName) ) continue;
345: assert( sqlite3SchemaMutexHeld(db, j, 0) );
346: p = sqlite3HashFind(&pSchema->idxHash, zName, nName);
347: if( p ) break;
348: }
349: return p;
350: }
351:
352: /*
353: ** Reclaim the memory used by an index
354: */
355: static void freeIndex(sqlite3 *db, Index *p){
356: #ifndef SQLITE_OMIT_ANALYZE
357: sqlite3DeleteIndexSamples(db, p);
358: #endif
359: sqlite3DbFree(db, p->zColAff);
360: sqlite3DbFree(db, p);
361: }
362:
363: /*
364: ** For the index called zIdxName which is found in the database iDb,
365: ** unlike that index from its Table then remove the index from
366: ** the index hash table and free all memory structures associated
367: ** with the index.
368: */
369: void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){
370: Index *pIndex;
371: int len;
372: Hash *pHash;
373:
374: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
375: pHash = &db->aDb[iDb].pSchema->idxHash;
376: len = sqlite3Strlen30(zIdxName);
377: pIndex = sqlite3HashInsert(pHash, zIdxName, len, 0);
378: if( ALWAYS(pIndex) ){
379: if( pIndex->pTable->pIndex==pIndex ){
380: pIndex->pTable->pIndex = pIndex->pNext;
381: }else{
382: Index *p;
383: /* Justification of ALWAYS(); The index must be on the list of
384: ** indices. */
385: p = pIndex->pTable->pIndex;
386: while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; }
387: if( ALWAYS(p && p->pNext==pIndex) ){
388: p->pNext = pIndex->pNext;
389: }
390: }
391: freeIndex(db, pIndex);
392: }
393: db->flags |= SQLITE_InternChanges;
394: }
395:
396: /*
397: ** Erase all schema information from the in-memory hash tables of
398: ** a single database. This routine is called to reclaim memory
399: ** before the database closes. It is also called during a rollback
400: ** if there were schema changes during the transaction or if a
401: ** schema-cookie mismatch occurs.
402: **
403: ** If iDb<0 then reset the internal schema tables for all database
404: ** files. If iDb>=0 then reset the internal schema for only the
405: ** single file indicated.
406: */
407: void sqlite3ResetInternalSchema(sqlite3 *db, int iDb){
408: int i, j;
409: assert( iDb<db->nDb );
410:
411: if( iDb>=0 ){
412: /* Case 1: Reset the single schema identified by iDb */
413: Db *pDb = &db->aDb[iDb];
414: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
415: assert( pDb->pSchema!=0 );
416: sqlite3SchemaClear(pDb->pSchema);
417:
418: /* If any database other than TEMP is reset, then also reset TEMP
419: ** since TEMP might be holding triggers that reference tables in the
420: ** other database.
421: */
422: if( iDb!=1 ){
423: pDb = &db->aDb[1];
424: assert( pDb->pSchema!=0 );
425: sqlite3SchemaClear(pDb->pSchema);
426: }
427: return;
428: }
429: /* Case 2 (from here to the end): Reset all schemas for all attached
430: ** databases. */
431: assert( iDb<0 );
432: sqlite3BtreeEnterAll(db);
433: for(i=0; i<db->nDb; i++){
434: Db *pDb = &db->aDb[i];
435: if( pDb->pSchema ){
436: sqlite3SchemaClear(pDb->pSchema);
437: }
438: }
439: db->flags &= ~SQLITE_InternChanges;
440: sqlite3VtabUnlockList(db);
441: sqlite3BtreeLeaveAll(db);
442:
443: /* If one or more of the auxiliary database files has been closed,
444: ** then remove them from the auxiliary database list. We take the
445: ** opportunity to do this here since we have just deleted all of the
446: ** schema hash tables and therefore do not have to make any changes
447: ** to any of those tables.
448: */
449: for(i=j=2; i<db->nDb; i++){
450: struct Db *pDb = &db->aDb[i];
451: if( pDb->pBt==0 ){
452: sqlite3DbFree(db, pDb->zName);
453: pDb->zName = 0;
454: continue;
455: }
456: if( j<i ){
457: db->aDb[j] = db->aDb[i];
458: }
459: j++;
460: }
461: memset(&db->aDb[j], 0, (db->nDb-j)*sizeof(db->aDb[j]));
462: db->nDb = j;
463: if( db->nDb<=2 && db->aDb!=db->aDbStatic ){
464: memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));
465: sqlite3DbFree(db, db->aDb);
466: db->aDb = db->aDbStatic;
467: }
468: }
469:
470: /*
471: ** This routine is called when a commit occurs.
472: */
473: void sqlite3CommitInternalChanges(sqlite3 *db){
474: db->flags &= ~SQLITE_InternChanges;
475: }
476:
477: /*
478: ** Delete memory allocated for the column names of a table or view (the
479: ** Table.aCol[] array).
480: */
481: static void sqliteDeleteColumnNames(sqlite3 *db, Table *pTable){
482: int i;
483: Column *pCol;
484: assert( pTable!=0 );
485: if( (pCol = pTable->aCol)!=0 ){
486: for(i=0; i<pTable->nCol; i++, pCol++){
487: sqlite3DbFree(db, pCol->zName);
488: sqlite3ExprDelete(db, pCol->pDflt);
489: sqlite3DbFree(db, pCol->zDflt);
490: sqlite3DbFree(db, pCol->zType);
491: sqlite3DbFree(db, pCol->zColl);
492: }
493: sqlite3DbFree(db, pTable->aCol);
494: }
495: }
496:
497: /*
498: ** Remove the memory data structures associated with the given
499: ** Table. No changes are made to disk by this routine.
500: **
501: ** This routine just deletes the data structure. It does not unlink
502: ** the table data structure from the hash table. But it does destroy
503: ** memory structures of the indices and foreign keys associated with
504: ** the table.
505: */
506: void sqlite3DeleteTable(sqlite3 *db, Table *pTable){
507: Index *pIndex, *pNext;
508:
509: assert( !pTable || pTable->nRef>0 );
510:
511: /* Do not delete the table until the reference count reaches zero. */
512: if( !pTable ) return;
513: if( ((!db || db->pnBytesFreed==0) && (--pTable->nRef)>0) ) return;
514:
515: /* Delete all indices associated with this table. */
516: for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){
517: pNext = pIndex->pNext;
518: assert( pIndex->pSchema==pTable->pSchema );
519: if( !db || db->pnBytesFreed==0 ){
520: char *zName = pIndex->zName;
521: TESTONLY ( Index *pOld = ) sqlite3HashInsert(
522: &pIndex->pSchema->idxHash, zName, sqlite3Strlen30(zName), 0
523: );
524: assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
525: assert( pOld==pIndex || pOld==0 );
526: }
527: freeIndex(db, pIndex);
528: }
529:
530: /* Delete any foreign keys attached to this table. */
531: sqlite3FkDelete(db, pTable);
532:
533: /* Delete the Table structure itself.
534: */
535: sqliteDeleteColumnNames(db, pTable);
536: sqlite3DbFree(db, pTable->zName);
537: sqlite3DbFree(db, pTable->zColAff);
538: sqlite3SelectDelete(db, pTable->pSelect);
539: #ifndef SQLITE_OMIT_CHECK
540: sqlite3ExprDelete(db, pTable->pCheck);
541: #endif
542: #ifndef SQLITE_OMIT_VIRTUALTABLE
543: sqlite3VtabClear(db, pTable);
544: #endif
545: sqlite3DbFree(db, pTable);
546: }
547:
548: /*
549: ** Unlink the given table from the hash tables and the delete the
550: ** table structure with all its indices and foreign keys.
551: */
552: void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){
553: Table *p;
554: Db *pDb;
555:
556: assert( db!=0 );
557: assert( iDb>=0 && iDb<db->nDb );
558: assert( zTabName );
559: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
560: testcase( zTabName[0]==0 ); /* Zero-length table names are allowed */
561: pDb = &db->aDb[iDb];
562: p = sqlite3HashInsert(&pDb->pSchema->tblHash, zTabName,
563: sqlite3Strlen30(zTabName),0);
564: sqlite3DeleteTable(db, p);
565: db->flags |= SQLITE_InternChanges;
566: }
567:
568: /*
569: ** Given a token, return a string that consists of the text of that
570: ** token. Space to hold the returned string
571: ** is obtained from sqliteMalloc() and must be freed by the calling
572: ** function.
573: **
574: ** Any quotation marks (ex: "name", 'name', [name], or `name`) that
575: ** surround the body of the token are removed.
576: **
577: ** Tokens are often just pointers into the original SQL text and so
578: ** are not \000 terminated and are not persistent. The returned string
579: ** is \000 terminated and is persistent.
580: */
581: char *sqlite3NameFromToken(sqlite3 *db, Token *pName){
582: char *zName;
583: if( pName ){
584: zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n);
585: sqlite3Dequote(zName);
586: }else{
587: zName = 0;
588: }
589: return zName;
590: }
591:
592: /*
593: ** Open the sqlite_master table stored in database number iDb for
594: ** writing. The table is opened using cursor 0.
595: */
596: void sqlite3OpenMasterTable(Parse *p, int iDb){
597: Vdbe *v = sqlite3GetVdbe(p);
598: sqlite3TableLock(p, iDb, MASTER_ROOT, 1, SCHEMA_TABLE(iDb));
599: sqlite3VdbeAddOp3(v, OP_OpenWrite, 0, MASTER_ROOT, iDb);
600: sqlite3VdbeChangeP4(v, -1, (char *)5, P4_INT32); /* 5 column table */
601: if( p->nTab==0 ){
602: p->nTab = 1;
603: }
604: }
605:
606: /*
607: ** Parameter zName points to a nul-terminated buffer containing the name
608: ** of a database ("main", "temp" or the name of an attached db). This
609: ** function returns the index of the named database in db->aDb[], or
610: ** -1 if the named db cannot be found.
611: */
612: int sqlite3FindDbName(sqlite3 *db, const char *zName){
613: int i = -1; /* Database number */
614: if( zName ){
615: Db *pDb;
616: int n = sqlite3Strlen30(zName);
617: for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){
618: if( (!OMIT_TEMPDB || i!=1 ) && n==sqlite3Strlen30(pDb->zName) &&
619: 0==sqlite3StrICmp(pDb->zName, zName) ){
620: break;
621: }
622: }
623: }
624: return i;
625: }
626:
627: /*
628: ** The token *pName contains the name of a database (either "main" or
629: ** "temp" or the name of an attached db). This routine returns the
630: ** index of the named database in db->aDb[], or -1 if the named db
631: ** does not exist.
632: */
633: int sqlite3FindDb(sqlite3 *db, Token *pName){
634: int i; /* Database number */
635: char *zName; /* Name we are searching for */
636: zName = sqlite3NameFromToken(db, pName);
637: i = sqlite3FindDbName(db, zName);
638: sqlite3DbFree(db, zName);
639: return i;
640: }
641:
642: /* The table or view or trigger name is passed to this routine via tokens
643: ** pName1 and pName2. If the table name was fully qualified, for example:
644: **
645: ** CREATE TABLE xxx.yyy (...);
646: **
647: ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
648: ** the table name is not fully qualified, i.e.:
649: **
650: ** CREATE TABLE yyy(...);
651: **
652: ** Then pName1 is set to "yyy" and pName2 is "".
653: **
654: ** This routine sets the *ppUnqual pointer to point at the token (pName1 or
655: ** pName2) that stores the unqualified table name. The index of the
656: ** database "xxx" is returned.
657: */
658: int sqlite3TwoPartName(
659: Parse *pParse, /* Parsing and code generating context */
660: Token *pName1, /* The "xxx" in the name "xxx.yyy" or "xxx" */
661: Token *pName2, /* The "yyy" in the name "xxx.yyy" */
662: Token **pUnqual /* Write the unqualified object name here */
663: ){
664: int iDb; /* Database holding the object */
665: sqlite3 *db = pParse->db;
666:
667: if( ALWAYS(pName2!=0) && pName2->n>0 ){
668: if( db->init.busy ) {
669: sqlite3ErrorMsg(pParse, "corrupt database");
670: pParse->nErr++;
671: return -1;
672: }
673: *pUnqual = pName2;
674: iDb = sqlite3FindDb(db, pName1);
675: if( iDb<0 ){
676: sqlite3ErrorMsg(pParse, "unknown database %T", pName1);
677: pParse->nErr++;
678: return -1;
679: }
680: }else{
681: assert( db->init.iDb==0 || db->init.busy );
682: iDb = db->init.iDb;
683: *pUnqual = pName1;
684: }
685: return iDb;
686: }
687:
688: /*
689: ** This routine is used to check if the UTF-8 string zName is a legal
690: ** unqualified name for a new schema object (table, index, view or
691: ** trigger). All names are legal except those that begin with the string
692: ** "sqlite_" (in upper, lower or mixed case). This portion of the namespace
693: ** is reserved for internal use.
694: */
695: int sqlite3CheckObjectName(Parse *pParse, const char *zName){
696: if( !pParse->db->init.busy && pParse->nested==0
697: && (pParse->db->flags & SQLITE_WriteSchema)==0
698: && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){
699: sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s", zName);
700: return SQLITE_ERROR;
701: }
702: return SQLITE_OK;
703: }
704:
705: /*
706: ** Begin constructing a new table representation in memory. This is
707: ** the first of several action routines that get called in response
708: ** to a CREATE TABLE statement. In particular, this routine is called
709: ** after seeing tokens "CREATE" and "TABLE" and the table name. The isTemp
710: ** flag is true if the table should be stored in the auxiliary database
711: ** file instead of in the main database file. This is normally the case
712: ** when the "TEMP" or "TEMPORARY" keyword occurs in between
713: ** CREATE and TABLE.
714: **
715: ** The new table record is initialized and put in pParse->pNewTable.
716: ** As more of the CREATE TABLE statement is parsed, additional action
717: ** routines will be called to add more information to this record.
718: ** At the end of the CREATE TABLE statement, the sqlite3EndTable() routine
719: ** is called to complete the construction of the new table record.
720: */
721: void sqlite3StartTable(
722: Parse *pParse, /* Parser context */
723: Token *pName1, /* First part of the name of the table or view */
724: Token *pName2, /* Second part of the name of the table or view */
725: int isTemp, /* True if this is a TEMP table */
726: int isView, /* True if this is a VIEW */
727: int isVirtual, /* True if this is a VIRTUAL table */
728: int noErr /* Do nothing if table already exists */
729: ){
730: Table *pTable;
731: char *zName = 0; /* The name of the new table */
732: sqlite3 *db = pParse->db;
733: Vdbe *v;
734: int iDb; /* Database number to create the table in */
735: Token *pName; /* Unqualified name of the table to create */
736:
737: /* The table or view name to create is passed to this routine via tokens
738: ** pName1 and pName2. If the table name was fully qualified, for example:
739: **
740: ** CREATE TABLE xxx.yyy (...);
741: **
742: ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
743: ** the table name is not fully qualified, i.e.:
744: **
745: ** CREATE TABLE yyy(...);
746: **
747: ** Then pName1 is set to "yyy" and pName2 is "".
748: **
749: ** The call below sets the pName pointer to point at the token (pName1 or
750: ** pName2) that stores the unqualified table name. The variable iDb is
751: ** set to the index of the database that the table or view is to be
752: ** created in.
753: */
754: iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
755: if( iDb<0 ) return;
756: if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){
757: /* If creating a temp table, the name may not be qualified. Unless
758: ** the database name is "temp" anyway. */
759: sqlite3ErrorMsg(pParse, "temporary table name must be unqualified");
760: return;
761: }
762: if( !OMIT_TEMPDB && isTemp ) iDb = 1;
763:
764: pParse->sNameToken = *pName;
765: zName = sqlite3NameFromToken(db, pName);
766: if( zName==0 ) return;
767: if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
768: goto begin_table_error;
769: }
770: if( db->init.iDb==1 ) isTemp = 1;
771: #ifndef SQLITE_OMIT_AUTHORIZATION
772: assert( (isTemp & 1)==isTemp );
773: {
774: int code;
775: char *zDb = db->aDb[iDb].zName;
776: if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){
777: goto begin_table_error;
778: }
779: if( isView ){
780: if( !OMIT_TEMPDB && isTemp ){
781: code = SQLITE_CREATE_TEMP_VIEW;
782: }else{
783: code = SQLITE_CREATE_VIEW;
784: }
785: }else{
786: if( !OMIT_TEMPDB && isTemp ){
787: code = SQLITE_CREATE_TEMP_TABLE;
788: }else{
789: code = SQLITE_CREATE_TABLE;
790: }
791: }
792: if( !isVirtual && sqlite3AuthCheck(pParse, code, zName, 0, zDb) ){
793: goto begin_table_error;
794: }
795: }
796: #endif
797:
798: /* Make sure the new table name does not collide with an existing
799: ** index or table name in the same database. Issue an error message if
800: ** it does. The exception is if the statement being parsed was passed
801: ** to an sqlite3_declare_vtab() call. In that case only the column names
802: ** and types will be used, so there is no need to test for namespace
803: ** collisions.
804: */
805: if( !IN_DECLARE_VTAB ){
806: char *zDb = db->aDb[iDb].zName;
807: if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
808: goto begin_table_error;
809: }
810: pTable = sqlite3FindTable(db, zName, zDb);
811: if( pTable ){
812: if( !noErr ){
813: sqlite3ErrorMsg(pParse, "table %T already exists", pName);
814: }else{
815: assert( !db->init.busy );
816: sqlite3CodeVerifySchema(pParse, iDb);
817: }
818: goto begin_table_error;
819: }
820: if( sqlite3FindIndex(db, zName, zDb)!=0 ){
821: sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
822: goto begin_table_error;
823: }
824: }
825:
826: pTable = sqlite3DbMallocZero(db, sizeof(Table));
827: if( pTable==0 ){
828: db->mallocFailed = 1;
829: pParse->rc = SQLITE_NOMEM;
830: pParse->nErr++;
831: goto begin_table_error;
832: }
833: pTable->zName = zName;
834: pTable->iPKey = -1;
835: pTable->pSchema = db->aDb[iDb].pSchema;
836: pTable->nRef = 1;
837: pTable->nRowEst = 1000000;
838: assert( pParse->pNewTable==0 );
839: pParse->pNewTable = pTable;
840:
841: /* If this is the magic sqlite_sequence table used by autoincrement,
842: ** then record a pointer to this table in the main database structure
843: ** so that INSERT can find the table easily.
844: */
845: #ifndef SQLITE_OMIT_AUTOINCREMENT
846: if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){
847: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
848: pTable->pSchema->pSeqTab = pTable;
849: }
850: #endif
851:
852: /* Begin generating the code that will insert the table record into
853: ** the SQLITE_MASTER table. Note in particular that we must go ahead
854: ** and allocate the record number for the table entry now. Before any
855: ** PRIMARY KEY or UNIQUE keywords are parsed. Those keywords will cause
856: ** indices to be created and the table record must come before the
857: ** indices. Hence, the record number for the table must be allocated
858: ** now.
859: */
860: if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){
861: int j1;
862: int fileFormat;
863: int reg1, reg2, reg3;
864: sqlite3BeginWriteOperation(pParse, 0, iDb);
865:
866: #ifndef SQLITE_OMIT_VIRTUALTABLE
867: if( isVirtual ){
868: sqlite3VdbeAddOp0(v, OP_VBegin);
869: }
870: #endif
871:
872: /* If the file format and encoding in the database have not been set,
873: ** set them now.
874: */
875: reg1 = pParse->regRowid = ++pParse->nMem;
876: reg2 = pParse->regRoot = ++pParse->nMem;
877: reg3 = ++pParse->nMem;
878: sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT);
879: sqlite3VdbeUsesBtree(v, iDb);
880: j1 = sqlite3VdbeAddOp1(v, OP_If, reg3);
881: fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ?
882: 1 : SQLITE_MAX_FILE_FORMAT;
883: sqlite3VdbeAddOp2(v, OP_Integer, fileFormat, reg3);
884: sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, reg3);
885: sqlite3VdbeAddOp2(v, OP_Integer, ENC(db), reg3);
886: sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, reg3);
887: sqlite3VdbeJumpHere(v, j1);
888:
889: /* This just creates a place-holder record in the sqlite_master table.
890: ** The record created does not contain anything yet. It will be replaced
891: ** by the real entry in code generated at sqlite3EndTable().
892: **
893: ** The rowid for the new entry is left in register pParse->regRowid.
894: ** The root page number of the new table is left in reg pParse->regRoot.
895: ** The rowid and root page number values are needed by the code that
896: ** sqlite3EndTable will generate.
897: */
898: #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
899: if( isView || isVirtual ){
900: sqlite3VdbeAddOp2(v, OP_Integer, 0, reg2);
901: }else
902: #endif
903: {
904: sqlite3VdbeAddOp2(v, OP_CreateTable, iDb, reg2);
905: }
906: sqlite3OpenMasterTable(pParse, iDb);
907: sqlite3VdbeAddOp2(v, OP_NewRowid, 0, reg1);
908: sqlite3VdbeAddOp2(v, OP_Null, 0, reg3);
909: sqlite3VdbeAddOp3(v, OP_Insert, 0, reg3, reg1);
910: sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
911: sqlite3VdbeAddOp0(v, OP_Close);
912: }
913:
914: /* Normal (non-error) return. */
915: return;
916:
917: /* If an error occurs, we jump here */
918: begin_table_error:
919: sqlite3DbFree(db, zName);
920: return;
921: }
922:
923: /*
924: ** This macro is used to compare two strings in a case-insensitive manner.
925: ** It is slightly faster than calling sqlite3StrICmp() directly, but
926: ** produces larger code.
927: **
928: ** WARNING: This macro is not compatible with the strcmp() family. It
929: ** returns true if the two strings are equal, otherwise false.
930: */
931: #define STRICMP(x, y) (\
932: sqlite3UpperToLower[*(unsigned char *)(x)]== \
933: sqlite3UpperToLower[*(unsigned char *)(y)] \
934: && sqlite3StrICmp((x)+1,(y)+1)==0 )
935:
936: /*
937: ** Add a new column to the table currently being constructed.
938: **
939: ** The parser calls this routine once for each column declaration
940: ** in a CREATE TABLE statement. sqlite3StartTable() gets called
941: ** first to get things going. Then this routine is called for each
942: ** column.
943: */
944: void sqlite3AddColumn(Parse *pParse, Token *pName){
945: Table *p;
946: int i;
947: char *z;
948: Column *pCol;
949: sqlite3 *db = pParse->db;
950: if( (p = pParse->pNewTable)==0 ) return;
951: #if SQLITE_MAX_COLUMN
952: if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
953: sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
954: return;
955: }
956: #endif
957: z = sqlite3NameFromToken(db, pName);
958: if( z==0 ) return;
959: for(i=0; i<p->nCol; i++){
960: if( STRICMP(z, p->aCol[i].zName) ){
961: sqlite3ErrorMsg(pParse, "duplicate column name: %s", z);
962: sqlite3DbFree(db, z);
963: return;
964: }
965: }
966: if( (p->nCol & 0x7)==0 ){
967: Column *aNew;
968: aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
969: if( aNew==0 ){
970: sqlite3DbFree(db, z);
971: return;
972: }
973: p->aCol = aNew;
974: }
975: pCol = &p->aCol[p->nCol];
976: memset(pCol, 0, sizeof(p->aCol[0]));
977: pCol->zName = z;
978:
979: /* If there is no type specified, columns have the default affinity
980: ** 'NONE'. If there is a type specified, then sqlite3AddColumnType() will
981: ** be called next to set pCol->affinity correctly.
982: */
983: pCol->affinity = SQLITE_AFF_NONE;
984: p->nCol++;
985: }
986:
987: /*
988: ** This routine is called by the parser while in the middle of
989: ** parsing a CREATE TABLE statement. A "NOT NULL" constraint has
990: ** been seen on a column. This routine sets the notNull flag on
991: ** the column currently under construction.
992: */
993: void sqlite3AddNotNull(Parse *pParse, int onError){
994: Table *p;
995: p = pParse->pNewTable;
996: if( p==0 || NEVER(p->nCol<1) ) return;
997: p->aCol[p->nCol-1].notNull = (u8)onError;
998: }
999:
1000: /*
1001: ** Scan the column type name zType (length nType) and return the
1002: ** associated affinity type.
1003: **
1004: ** This routine does a case-independent search of zType for the
1005: ** substrings in the following table. If one of the substrings is
1006: ** found, the corresponding affinity is returned. If zType contains
1007: ** more than one of the substrings, entries toward the top of
1008: ** the table take priority. For example, if zType is 'BLOBINT',
1009: ** SQLITE_AFF_INTEGER is returned.
1010: **
1011: ** Substring | Affinity
1012: ** --------------------------------
1013: ** 'INT' | SQLITE_AFF_INTEGER
1014: ** 'CHAR' | SQLITE_AFF_TEXT
1015: ** 'CLOB' | SQLITE_AFF_TEXT
1016: ** 'TEXT' | SQLITE_AFF_TEXT
1017: ** 'BLOB' | SQLITE_AFF_NONE
1018: ** 'REAL' | SQLITE_AFF_REAL
1019: ** 'FLOA' | SQLITE_AFF_REAL
1020: ** 'DOUB' | SQLITE_AFF_REAL
1021: **
1022: ** If none of the substrings in the above table are found,
1023: ** SQLITE_AFF_NUMERIC is returned.
1024: */
1025: char sqlite3AffinityType(const char *zIn){
1026: u32 h = 0;
1027: char aff = SQLITE_AFF_NUMERIC;
1028:
1029: if( zIn ) while( zIn[0] ){
1030: h = (h<<8) + sqlite3UpperToLower[(*zIn)&0xff];
1031: zIn++;
1032: if( h==(('c'<<24)+('h'<<16)+('a'<<8)+'r') ){ /* CHAR */
1033: aff = SQLITE_AFF_TEXT;
1034: }else if( h==(('c'<<24)+('l'<<16)+('o'<<8)+'b') ){ /* CLOB */
1035: aff = SQLITE_AFF_TEXT;
1036: }else if( h==(('t'<<24)+('e'<<16)+('x'<<8)+'t') ){ /* TEXT */
1037: aff = SQLITE_AFF_TEXT;
1038: }else if( h==(('b'<<24)+('l'<<16)+('o'<<8)+'b') /* BLOB */
1039: && (aff==SQLITE_AFF_NUMERIC || aff==SQLITE_AFF_REAL) ){
1040: aff = SQLITE_AFF_NONE;
1041: #ifndef SQLITE_OMIT_FLOATING_POINT
1042: }else if( h==(('r'<<24)+('e'<<16)+('a'<<8)+'l') /* REAL */
1043: && aff==SQLITE_AFF_NUMERIC ){
1044: aff = SQLITE_AFF_REAL;
1045: }else if( h==(('f'<<24)+('l'<<16)+('o'<<8)+'a') /* FLOA */
1046: && aff==SQLITE_AFF_NUMERIC ){
1047: aff = SQLITE_AFF_REAL;
1048: }else if( h==(('d'<<24)+('o'<<16)+('u'<<8)+'b') /* DOUB */
1049: && aff==SQLITE_AFF_NUMERIC ){
1050: aff = SQLITE_AFF_REAL;
1051: #endif
1052: }else if( (h&0x00FFFFFF)==(('i'<<16)+('n'<<8)+'t') ){ /* INT */
1053: aff = SQLITE_AFF_INTEGER;
1054: break;
1055: }
1056: }
1057:
1058: return aff;
1059: }
1060:
1061: /*
1062: ** This routine is called by the parser while in the middle of
1063: ** parsing a CREATE TABLE statement. The pFirst token is the first
1064: ** token in the sequence of tokens that describe the type of the
1065: ** column currently under construction. pLast is the last token
1066: ** in the sequence. Use this information to construct a string
1067: ** that contains the typename of the column and store that string
1068: ** in zType.
1069: */
1070: void sqlite3AddColumnType(Parse *pParse, Token *pType){
1071: Table *p;
1072: Column *pCol;
1073:
1074: p = pParse->pNewTable;
1075: if( p==0 || NEVER(p->nCol<1) ) return;
1076: pCol = &p->aCol[p->nCol-1];
1077: assert( pCol->zType==0 );
1078: pCol->zType = sqlite3NameFromToken(pParse->db, pType);
1079: pCol->affinity = sqlite3AffinityType(pCol->zType);
1080: }
1081:
1082: /*
1083: ** The expression is the default value for the most recently added column
1084: ** of the table currently under construction.
1085: **
1086: ** Default value expressions must be constant. Raise an exception if this
1087: ** is not the case.
1088: **
1089: ** This routine is called by the parser while in the middle of
1090: ** parsing a CREATE TABLE statement.
1091: */
1092: void sqlite3AddDefaultValue(Parse *pParse, ExprSpan *pSpan){
1093: Table *p;
1094: Column *pCol;
1095: sqlite3 *db = pParse->db;
1096: p = pParse->pNewTable;
1097: if( p!=0 ){
1098: pCol = &(p->aCol[p->nCol-1]);
1099: if( !sqlite3ExprIsConstantOrFunction(pSpan->pExpr) ){
1100: sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
1101: pCol->zName);
1102: }else{
1103: /* A copy of pExpr is used instead of the original, as pExpr contains
1104: ** tokens that point to volatile memory. The 'span' of the expression
1105: ** is required by pragma table_info.
1106: */
1107: sqlite3ExprDelete(db, pCol->pDflt);
1108: pCol->pDflt = sqlite3ExprDup(db, pSpan->pExpr, EXPRDUP_REDUCE);
1109: sqlite3DbFree(db, pCol->zDflt);
1110: pCol->zDflt = sqlite3DbStrNDup(db, (char*)pSpan->zStart,
1111: (int)(pSpan->zEnd - pSpan->zStart));
1112: }
1113: }
1114: sqlite3ExprDelete(db, pSpan->pExpr);
1115: }
1116:
1117: /*
1118: ** Designate the PRIMARY KEY for the table. pList is a list of names
1119: ** of columns that form the primary key. If pList is NULL, then the
1120: ** most recently added column of the table is the primary key.
1121: **
1122: ** A table can have at most one primary key. If the table already has
1123: ** a primary key (and this is the second primary key) then create an
1124: ** error.
1125: **
1126: ** If the PRIMARY KEY is on a single column whose datatype is INTEGER,
1127: ** then we will try to use that column as the rowid. Set the Table.iPKey
1128: ** field of the table under construction to be the index of the
1129: ** INTEGER PRIMARY KEY column. Table.iPKey is set to -1 if there is
1130: ** no INTEGER PRIMARY KEY.
1131: **
1132: ** If the key is not an INTEGER PRIMARY KEY, then create a unique
1133: ** index for the key. No index is created for INTEGER PRIMARY KEYs.
1134: */
1135: void sqlite3AddPrimaryKey(
1136: Parse *pParse, /* Parsing context */
1137: ExprList *pList, /* List of field names to be indexed */
1138: int onError, /* What to do with a uniqueness conflict */
1139: int autoInc, /* True if the AUTOINCREMENT keyword is present */
1140: int sortOrder /* SQLITE_SO_ASC or SQLITE_SO_DESC */
1141: ){
1142: Table *pTab = pParse->pNewTable;
1143: char *zType = 0;
1144: int iCol = -1, i;
1145: if( pTab==0 || IN_DECLARE_VTAB ) goto primary_key_exit;
1146: if( pTab->tabFlags & TF_HasPrimaryKey ){
1147: sqlite3ErrorMsg(pParse,
1148: "table \"%s\" has more than one primary key", pTab->zName);
1149: goto primary_key_exit;
1150: }
1151: pTab->tabFlags |= TF_HasPrimaryKey;
1152: if( pList==0 ){
1153: iCol = pTab->nCol - 1;
1154: pTab->aCol[iCol].isPrimKey = 1;
1155: }else{
1156: for(i=0; i<pList->nExpr; i++){
1157: for(iCol=0; iCol<pTab->nCol; iCol++){
1158: if( sqlite3StrICmp(pList->a[i].zName, pTab->aCol[iCol].zName)==0 ){
1159: break;
1160: }
1161: }
1162: if( iCol<pTab->nCol ){
1163: pTab->aCol[iCol].isPrimKey = 1;
1164: }
1165: }
1166: if( pList->nExpr>1 ) iCol = -1;
1167: }
1168: if( iCol>=0 && iCol<pTab->nCol ){
1169: zType = pTab->aCol[iCol].zType;
1170: }
1171: if( zType && sqlite3StrICmp(zType, "INTEGER")==0
1172: && sortOrder==SQLITE_SO_ASC ){
1173: pTab->iPKey = iCol;
1174: pTab->keyConf = (u8)onError;
1175: assert( autoInc==0 || autoInc==1 );
1176: pTab->tabFlags |= autoInc*TF_Autoincrement;
1177: }else if( autoInc ){
1178: #ifndef SQLITE_OMIT_AUTOINCREMENT
1179: sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an "
1180: "INTEGER PRIMARY KEY");
1181: #endif
1182: }else{
1183: Index *p;
1184: p = sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0, 0, sortOrder, 0);
1185: if( p ){
1186: p->autoIndex = 2;
1187: }
1188: pList = 0;
1189: }
1190:
1191: primary_key_exit:
1192: sqlite3ExprListDelete(pParse->db, pList);
1193: return;
1194: }
1195:
1196: /*
1197: ** Add a new CHECK constraint to the table currently under construction.
1198: */
1199: void sqlite3AddCheckConstraint(
1200: Parse *pParse, /* Parsing context */
1201: Expr *pCheckExpr /* The check expression */
1202: ){
1203: sqlite3 *db = pParse->db;
1204: #ifndef SQLITE_OMIT_CHECK
1205: Table *pTab = pParse->pNewTable;
1206: if( pTab && !IN_DECLARE_VTAB ){
1207: pTab->pCheck = sqlite3ExprAnd(db, pTab->pCheck, pCheckExpr);
1208: }else
1209: #endif
1210: {
1211: sqlite3ExprDelete(db, pCheckExpr);
1212: }
1213: }
1214:
1215: /*
1216: ** Set the collation function of the most recently parsed table column
1217: ** to the CollSeq given.
1218: */
1219: void sqlite3AddCollateType(Parse *pParse, Token *pToken){
1220: Table *p;
1221: int i;
1222: char *zColl; /* Dequoted name of collation sequence */
1223: sqlite3 *db;
1224:
1225: if( (p = pParse->pNewTable)==0 ) return;
1226: i = p->nCol-1;
1227: db = pParse->db;
1228: zColl = sqlite3NameFromToken(db, pToken);
1229: if( !zColl ) return;
1230:
1231: if( sqlite3LocateCollSeq(pParse, zColl) ){
1232: Index *pIdx;
1233: p->aCol[i].zColl = zColl;
1234:
1235: /* If the column is declared as "<name> PRIMARY KEY COLLATE <type>",
1236: ** then an index may have been created on this column before the
1237: ** collation type was added. Correct this if it is the case.
1238: */
1239: for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
1240: assert( pIdx->nColumn==1 );
1241: if( pIdx->aiColumn[0]==i ){
1242: pIdx->azColl[0] = p->aCol[i].zColl;
1243: }
1244: }
1245: }else{
1246: sqlite3DbFree(db, zColl);
1247: }
1248: }
1249:
1250: /*
1251: ** This function returns the collation sequence for database native text
1252: ** encoding identified by the string zName, length nName.
1253: **
1254: ** If the requested collation sequence is not available, or not available
1255: ** in the database native encoding, the collation factory is invoked to
1256: ** request it. If the collation factory does not supply such a sequence,
1257: ** and the sequence is available in another text encoding, then that is
1258: ** returned instead.
1259: **
1260: ** If no versions of the requested collations sequence are available, or
1261: ** another error occurs, NULL is returned and an error message written into
1262: ** pParse.
1263: **
1264: ** This routine is a wrapper around sqlite3FindCollSeq(). This routine
1265: ** invokes the collation factory if the named collation cannot be found
1266: ** and generates an error message.
1267: **
1268: ** See also: sqlite3FindCollSeq(), sqlite3GetCollSeq()
1269: */
1270: CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){
1271: sqlite3 *db = pParse->db;
1272: u8 enc = ENC(db);
1273: u8 initbusy = db->init.busy;
1274: CollSeq *pColl;
1275:
1276: pColl = sqlite3FindCollSeq(db, enc, zName, initbusy);
1277: if( !initbusy && (!pColl || !pColl->xCmp) ){
1278: pColl = sqlite3GetCollSeq(db, enc, pColl, zName);
1279: if( !pColl ){
1280: sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);
1281: }
1282: }
1283:
1284: return pColl;
1285: }
1286:
1287:
1288: /*
1289: ** Generate code that will increment the schema cookie.
1290: **
1291: ** The schema cookie is used to determine when the schema for the
1292: ** database changes. After each schema change, the cookie value
1293: ** changes. When a process first reads the schema it records the
1294: ** cookie. Thereafter, whenever it goes to access the database,
1295: ** it checks the cookie to make sure the schema has not changed
1296: ** since it was last read.
1297: **
1298: ** This plan is not completely bullet-proof. It is possible for
1299: ** the schema to change multiple times and for the cookie to be
1300: ** set back to prior value. But schema changes are infrequent
1301: ** and the probability of hitting the same cookie value is only
1302: ** 1 chance in 2^32. So we're safe enough.
1303: */
1304: void sqlite3ChangeCookie(Parse *pParse, int iDb){
1305: int r1 = sqlite3GetTempReg(pParse);
1306: sqlite3 *db = pParse->db;
1307: Vdbe *v = pParse->pVdbe;
1308: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
1309: sqlite3VdbeAddOp2(v, OP_Integer, db->aDb[iDb].pSchema->schema_cookie+1, r1);
1310: sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION, r1);
1311: sqlite3ReleaseTempReg(pParse, r1);
1312: }
1313:
1314: /*
1315: ** Measure the number of characters needed to output the given
1316: ** identifier. The number returned includes any quotes used
1317: ** but does not include the null terminator.
1318: **
1319: ** The estimate is conservative. It might be larger that what is
1320: ** really needed.
1321: */
1322: static int identLength(const char *z){
1323: int n;
1324: for(n=0; *z; n++, z++){
1325: if( *z=='"' ){ n++; }
1326: }
1327: return n + 2;
1328: }
1329:
1330: /*
1331: ** The first parameter is a pointer to an output buffer. The second
1332: ** parameter is a pointer to an integer that contains the offset at
1333: ** which to write into the output buffer. This function copies the
1334: ** nul-terminated string pointed to by the third parameter, zSignedIdent,
1335: ** to the specified offset in the buffer and updates *pIdx to refer
1336: ** to the first byte after the last byte written before returning.
1337: **
1338: ** If the string zSignedIdent consists entirely of alpha-numeric
1339: ** characters, does not begin with a digit and is not an SQL keyword,
1340: ** then it is copied to the output buffer exactly as it is. Otherwise,
1341: ** it is quoted using double-quotes.
1342: */
1343: static void identPut(char *z, int *pIdx, char *zSignedIdent){
1344: unsigned char *zIdent = (unsigned char*)zSignedIdent;
1345: int i, j, needQuote;
1346: i = *pIdx;
1347:
1348: for(j=0; zIdent[j]; j++){
1349: if( !sqlite3Isalnum(zIdent[j]) && zIdent[j]!='_' ) break;
1350: }
1351: needQuote = sqlite3Isdigit(zIdent[0]) || sqlite3KeywordCode(zIdent, j)!=TK_ID;
1352: if( !needQuote ){
1353: needQuote = zIdent[j];
1354: }
1355:
1356: if( needQuote ) z[i++] = '"';
1357: for(j=0; zIdent[j]; j++){
1358: z[i++] = zIdent[j];
1359: if( zIdent[j]=='"' ) z[i++] = '"';
1360: }
1361: if( needQuote ) z[i++] = '"';
1362: z[i] = 0;
1363: *pIdx = i;
1364: }
1365:
1366: /*
1367: ** Generate a CREATE TABLE statement appropriate for the given
1368: ** table. Memory to hold the text of the statement is obtained
1369: ** from sqliteMalloc() and must be freed by the calling function.
1370: */
1371: static char *createTableStmt(sqlite3 *db, Table *p){
1372: int i, k, n;
1373: char *zStmt;
1374: char *zSep, *zSep2, *zEnd;
1375: Column *pCol;
1376: n = 0;
1377: for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
1378: n += identLength(pCol->zName) + 5;
1379: }
1380: n += identLength(p->zName);
1381: if( n<50 ){
1382: zSep = "";
1383: zSep2 = ",";
1384: zEnd = ")";
1385: }else{
1386: zSep = "\n ";
1387: zSep2 = ",\n ";
1388: zEnd = "\n)";
1389: }
1390: n += 35 + 6*p->nCol;
1391: zStmt = sqlite3DbMallocRaw(0, n);
1392: if( zStmt==0 ){
1393: db->mallocFailed = 1;
1394: return 0;
1395: }
1396: sqlite3_snprintf(n, zStmt, "CREATE TABLE ");
1397: k = sqlite3Strlen30(zStmt);
1398: identPut(zStmt, &k, p->zName);
1399: zStmt[k++] = '(';
1400: for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
1401: static const char * const azType[] = {
1402: /* SQLITE_AFF_TEXT */ " TEXT",
1403: /* SQLITE_AFF_NONE */ "",
1404: /* SQLITE_AFF_NUMERIC */ " NUM",
1405: /* SQLITE_AFF_INTEGER */ " INT",
1406: /* SQLITE_AFF_REAL */ " REAL"
1407: };
1408: int len;
1409: const char *zType;
1410:
1411: sqlite3_snprintf(n-k, &zStmt[k], zSep);
1412: k += sqlite3Strlen30(&zStmt[k]);
1413: zSep = zSep2;
1414: identPut(zStmt, &k, pCol->zName);
1415: assert( pCol->affinity-SQLITE_AFF_TEXT >= 0 );
1416: assert( pCol->affinity-SQLITE_AFF_TEXT < ArraySize(azType) );
1417: testcase( pCol->affinity==SQLITE_AFF_TEXT );
1418: testcase( pCol->affinity==SQLITE_AFF_NONE );
1419: testcase( pCol->affinity==SQLITE_AFF_NUMERIC );
1420: testcase( pCol->affinity==SQLITE_AFF_INTEGER );
1421: testcase( pCol->affinity==SQLITE_AFF_REAL );
1422:
1423: zType = azType[pCol->affinity - SQLITE_AFF_TEXT];
1424: len = sqlite3Strlen30(zType);
1425: assert( pCol->affinity==SQLITE_AFF_NONE
1426: || pCol->affinity==sqlite3AffinityType(zType) );
1427: memcpy(&zStmt[k], zType, len);
1428: k += len;
1429: assert( k<=n );
1430: }
1431: sqlite3_snprintf(n-k, &zStmt[k], "%s", zEnd);
1432: return zStmt;
1433: }
1434:
1435: /*
1436: ** This routine is called to report the final ")" that terminates
1437: ** a CREATE TABLE statement.
1438: **
1439: ** The table structure that other action routines have been building
1440: ** is added to the internal hash tables, assuming no errors have
1441: ** occurred.
1442: **
1443: ** An entry for the table is made in the master table on disk, unless
1444: ** this is a temporary table or db->init.busy==1. When db->init.busy==1
1445: ** it means we are reading the sqlite_master table because we just
1446: ** connected to the database or because the sqlite_master table has
1447: ** recently changed, so the entry for this table already exists in
1448: ** the sqlite_master table. We do not want to create it again.
1449: **
1450: ** If the pSelect argument is not NULL, it means that this routine
1451: ** was called to create a table generated from a
1452: ** "CREATE TABLE ... AS SELECT ..." statement. The column names of
1453: ** the new table will match the result set of the SELECT.
1454: */
1455: void sqlite3EndTable(
1456: Parse *pParse, /* Parse context */
1457: Token *pCons, /* The ',' token after the last column defn. */
1458: Token *pEnd, /* The final ')' token in the CREATE TABLE */
1459: Select *pSelect /* Select from a "CREATE ... AS SELECT" */
1460: ){
1461: Table *p;
1462: sqlite3 *db = pParse->db;
1463: int iDb;
1464:
1465: if( (pEnd==0 && pSelect==0) || db->mallocFailed ){
1466: return;
1467: }
1468: p = pParse->pNewTable;
1469: if( p==0 ) return;
1470:
1471: assert( !db->init.busy || !pSelect );
1472:
1473: iDb = sqlite3SchemaToIndex(db, p->pSchema);
1474:
1475: #ifndef SQLITE_OMIT_CHECK
1476: /* Resolve names in all CHECK constraint expressions.
1477: */
1478: if( p->pCheck ){
1479: SrcList sSrc; /* Fake SrcList for pParse->pNewTable */
1480: NameContext sNC; /* Name context for pParse->pNewTable */
1481:
1482: memset(&sNC, 0, sizeof(sNC));
1483: memset(&sSrc, 0, sizeof(sSrc));
1484: sSrc.nSrc = 1;
1485: sSrc.a[0].zName = p->zName;
1486: sSrc.a[0].pTab = p;
1487: sSrc.a[0].iCursor = -1;
1488: sNC.pParse = pParse;
1489: sNC.pSrcList = &sSrc;
1490: sNC.isCheck = 1;
1491: if( sqlite3ResolveExprNames(&sNC, p->pCheck) ){
1492: return;
1493: }
1494: }
1495: #endif /* !defined(SQLITE_OMIT_CHECK) */
1496:
1497: /* If the db->init.busy is 1 it means we are reading the SQL off the
1498: ** "sqlite_master" or "sqlite_temp_master" table on the disk.
1499: ** So do not write to the disk again. Extract the root page number
1500: ** for the table from the db->init.newTnum field. (The page number
1501: ** should have been put there by the sqliteOpenCb routine.)
1502: */
1503: if( db->init.busy ){
1504: p->tnum = db->init.newTnum;
1505: }
1506:
1507: /* If not initializing, then create a record for the new table
1508: ** in the SQLITE_MASTER table of the database.
1509: **
1510: ** If this is a TEMPORARY table, write the entry into the auxiliary
1511: ** file instead of into the main database file.
1512: */
1513: if( !db->init.busy ){
1514: int n;
1515: Vdbe *v;
1516: char *zType; /* "view" or "table" */
1517: char *zType2; /* "VIEW" or "TABLE" */
1518: char *zStmt; /* Text of the CREATE TABLE or CREATE VIEW statement */
1519:
1520: v = sqlite3GetVdbe(pParse);
1521: if( NEVER(v==0) ) return;
1522:
1523: sqlite3VdbeAddOp1(v, OP_Close, 0);
1524:
1525: /*
1526: ** Initialize zType for the new view or table.
1527: */
1528: if( p->pSelect==0 ){
1529: /* A regular table */
1530: zType = "table";
1531: zType2 = "TABLE";
1532: #ifndef SQLITE_OMIT_VIEW
1533: }else{
1534: /* A view */
1535: zType = "view";
1536: zType2 = "VIEW";
1537: #endif
1538: }
1539:
1540: /* If this is a CREATE TABLE xx AS SELECT ..., execute the SELECT
1541: ** statement to populate the new table. The root-page number for the
1542: ** new table is in register pParse->regRoot.
1543: **
1544: ** Once the SELECT has been coded by sqlite3Select(), it is in a
1545: ** suitable state to query for the column names and types to be used
1546: ** by the new table.
1547: **
1548: ** A shared-cache write-lock is not required to write to the new table,
1549: ** as a schema-lock must have already been obtained to create it. Since
1550: ** a schema-lock excludes all other database users, the write-lock would
1551: ** be redundant.
1552: */
1553: if( pSelect ){
1554: SelectDest dest;
1555: Table *pSelTab;
1556:
1557: assert(pParse->nTab==1);
1558: sqlite3VdbeAddOp3(v, OP_OpenWrite, 1, pParse->regRoot, iDb);
1559: sqlite3VdbeChangeP5(v, 1);
1560: pParse->nTab = 2;
1561: sqlite3SelectDestInit(&dest, SRT_Table, 1);
1562: sqlite3Select(pParse, pSelect, &dest);
1563: sqlite3VdbeAddOp1(v, OP_Close, 1);
1564: if( pParse->nErr==0 ){
1565: pSelTab = sqlite3ResultSetOfSelect(pParse, pSelect);
1566: if( pSelTab==0 ) return;
1567: assert( p->aCol==0 );
1568: p->nCol = pSelTab->nCol;
1569: p->aCol = pSelTab->aCol;
1570: pSelTab->nCol = 0;
1571: pSelTab->aCol = 0;
1572: sqlite3DeleteTable(db, pSelTab);
1573: }
1574: }
1575:
1576: /* Compute the complete text of the CREATE statement */
1577: if( pSelect ){
1578: zStmt = createTableStmt(db, p);
1579: }else{
1580: n = (int)(pEnd->z - pParse->sNameToken.z) + 1;
1581: zStmt = sqlite3MPrintf(db,
1582: "CREATE %s %.*s", zType2, n, pParse->sNameToken.z
1583: );
1584: }
1585:
1586: /* A slot for the record has already been allocated in the
1587: ** SQLITE_MASTER table. We just need to update that slot with all
1588: ** the information we've collected.
1589: */
1590: sqlite3NestedParse(pParse,
1591: "UPDATE %Q.%s "
1592: "SET type='%s', name=%Q, tbl_name=%Q, rootpage=#%d, sql=%Q "
1593: "WHERE rowid=#%d",
1594: db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
1595: zType,
1596: p->zName,
1597: p->zName,
1598: pParse->regRoot,
1599: zStmt,
1600: pParse->regRowid
1601: );
1602: sqlite3DbFree(db, zStmt);
1603: sqlite3ChangeCookie(pParse, iDb);
1604:
1605: #ifndef SQLITE_OMIT_AUTOINCREMENT
1606: /* Check to see if we need to create an sqlite_sequence table for
1607: ** keeping track of autoincrement keys.
1608: */
1609: if( p->tabFlags & TF_Autoincrement ){
1610: Db *pDb = &db->aDb[iDb];
1611: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
1612: if( pDb->pSchema->pSeqTab==0 ){
1613: sqlite3NestedParse(pParse,
1614: "CREATE TABLE %Q.sqlite_sequence(name,seq)",
1615: pDb->zName
1616: );
1617: }
1618: }
1619: #endif
1620:
1621: /* Reparse everything to update our internal data structures */
1622: sqlite3VdbeAddParseSchemaOp(v, iDb,
1623: sqlite3MPrintf(db, "tbl_name='%q'", p->zName));
1624: }
1625:
1626:
1627: /* Add the table to the in-memory representation of the database.
1628: */
1629: if( db->init.busy ){
1630: Table *pOld;
1631: Schema *pSchema = p->pSchema;
1632: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
1633: pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName,
1634: sqlite3Strlen30(p->zName),p);
1635: if( pOld ){
1636: assert( p==pOld ); /* Malloc must have failed inside HashInsert() */
1637: db->mallocFailed = 1;
1638: return;
1639: }
1640: pParse->pNewTable = 0;
1641: db->nTable++;
1642: db->flags |= SQLITE_InternChanges;
1643:
1644: #ifndef SQLITE_OMIT_ALTERTABLE
1645: if( !p->pSelect ){
1646: const char *zName = (const char *)pParse->sNameToken.z;
1647: int nName;
1648: assert( !pSelect && pCons && pEnd );
1649: if( pCons->z==0 ){
1650: pCons = pEnd;
1651: }
1652: nName = (int)((const char *)pCons->z - zName);
1653: p->addColOffset = 13 + sqlite3Utf8CharLen(zName, nName);
1654: }
1655: #endif
1656: }
1657: }
1658:
1659: #ifndef SQLITE_OMIT_VIEW
1660: /*
1661: ** The parser calls this routine in order to create a new VIEW
1662: */
1663: void sqlite3CreateView(
1664: Parse *pParse, /* The parsing context */
1665: Token *pBegin, /* The CREATE token that begins the statement */
1666: Token *pName1, /* The token that holds the name of the view */
1667: Token *pName2, /* The token that holds the name of the view */
1668: Select *pSelect, /* A SELECT statement that will become the new view */
1669: int isTemp, /* TRUE for a TEMPORARY view */
1670: int noErr /* Suppress error messages if VIEW already exists */
1671: ){
1672: Table *p;
1673: int n;
1674: const char *z;
1675: Token sEnd;
1676: DbFixer sFix;
1677: Token *pName = 0;
1678: int iDb;
1679: sqlite3 *db = pParse->db;
1680:
1681: if( pParse->nVar>0 ){
1682: sqlite3ErrorMsg(pParse, "parameters are not allowed in views");
1683: sqlite3SelectDelete(db, pSelect);
1684: return;
1685: }
1686: sqlite3StartTable(pParse, pName1, pName2, isTemp, 1, 0, noErr);
1687: p = pParse->pNewTable;
1688: if( p==0 || pParse->nErr ){
1689: sqlite3SelectDelete(db, pSelect);
1690: return;
1691: }
1692: sqlite3TwoPartName(pParse, pName1, pName2, &pName);
1693: iDb = sqlite3SchemaToIndex(db, p->pSchema);
1694: if( sqlite3FixInit(&sFix, pParse, iDb, "view", pName)
1695: && sqlite3FixSelect(&sFix, pSelect)
1696: ){
1697: sqlite3SelectDelete(db, pSelect);
1698: return;
1699: }
1700:
1701: /* Make a copy of the entire SELECT statement that defines the view.
1702: ** This will force all the Expr.token.z values to be dynamically
1703: ** allocated rather than point to the input string - which means that
1704: ** they will persist after the current sqlite3_exec() call returns.
1705: */
1706: p->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
1707: sqlite3SelectDelete(db, pSelect);
1708: if( db->mallocFailed ){
1709: return;
1710: }
1711: if( !db->init.busy ){
1712: sqlite3ViewGetColumnNames(pParse, p);
1713: }
1714:
1715: /* Locate the end of the CREATE VIEW statement. Make sEnd point to
1716: ** the end.
1717: */
1718: sEnd = pParse->sLastToken;
1719: if( ALWAYS(sEnd.z[0]!=0) && sEnd.z[0]!=';' ){
1720: sEnd.z += sEnd.n;
1721: }
1722: sEnd.n = 0;
1723: n = (int)(sEnd.z - pBegin->z);
1724: z = pBegin->z;
1725: while( ALWAYS(n>0) && sqlite3Isspace(z[n-1]) ){ n--; }
1726: sEnd.z = &z[n-1];
1727: sEnd.n = 1;
1728:
1729: /* Use sqlite3EndTable() to add the view to the SQLITE_MASTER table */
1730: sqlite3EndTable(pParse, 0, &sEnd, 0);
1731: return;
1732: }
1733: #endif /* SQLITE_OMIT_VIEW */
1734:
1735: #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
1736: /*
1737: ** The Table structure pTable is really a VIEW. Fill in the names of
1738: ** the columns of the view in the pTable structure. Return the number
1739: ** of errors. If an error is seen leave an error message in pParse->zErrMsg.
1740: */
1741: int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
1742: Table *pSelTab; /* A fake table from which we get the result set */
1743: Select *pSel; /* Copy of the SELECT that implements the view */
1744: int nErr = 0; /* Number of errors encountered */
1745: int n; /* Temporarily holds the number of cursors assigned */
1746: sqlite3 *db = pParse->db; /* Database connection for malloc errors */
1747: int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
1748:
1749: assert( pTable );
1750:
1751: #ifndef SQLITE_OMIT_VIRTUALTABLE
1752: if( sqlite3VtabCallConnect(pParse, pTable) ){
1753: return SQLITE_ERROR;
1754: }
1755: if( IsVirtual(pTable) ) return 0;
1756: #endif
1757:
1758: #ifndef SQLITE_OMIT_VIEW
1759: /* A positive nCol means the columns names for this view are
1760: ** already known.
1761: */
1762: if( pTable->nCol>0 ) return 0;
1763:
1764: /* A negative nCol is a special marker meaning that we are currently
1765: ** trying to compute the column names. If we enter this routine with
1766: ** a negative nCol, it means two or more views form a loop, like this:
1767: **
1768: ** CREATE VIEW one AS SELECT * FROM two;
1769: ** CREATE VIEW two AS SELECT * FROM one;
1770: **
1771: ** Actually, the error above is now caught prior to reaching this point.
1772: ** But the following test is still important as it does come up
1773: ** in the following:
1774: **
1775: ** CREATE TABLE main.ex1(a);
1776: ** CREATE TEMP VIEW ex1 AS SELECT a FROM ex1;
1777: ** SELECT * FROM temp.ex1;
1778: */
1779: if( pTable->nCol<0 ){
1780: sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
1781: return 1;
1782: }
1783: assert( pTable->nCol>=0 );
1784:
1785: /* If we get this far, it means we need to compute the table names.
1786: ** Note that the call to sqlite3ResultSetOfSelect() will expand any
1787: ** "*" elements in the results set of the view and will assign cursors
1788: ** to the elements of the FROM clause. But we do not want these changes
1789: ** to be permanent. So the computation is done on a copy of the SELECT
1790: ** statement that defines the view.
1791: */
1792: assert( pTable->pSelect );
1793: pSel = sqlite3SelectDup(db, pTable->pSelect, 0);
1794: if( pSel ){
1795: u8 enableLookaside = db->lookaside.bEnabled;
1796: n = pParse->nTab;
1797: sqlite3SrcListAssignCursors(pParse, pSel->pSrc);
1798: pTable->nCol = -1;
1799: db->lookaside.bEnabled = 0;
1800: #ifndef SQLITE_OMIT_AUTHORIZATION
1801: xAuth = db->xAuth;
1802: db->xAuth = 0;
1803: pSelTab = sqlite3ResultSetOfSelect(pParse, pSel);
1804: db->xAuth = xAuth;
1805: #else
1806: pSelTab = sqlite3ResultSetOfSelect(pParse, pSel);
1807: #endif
1808: db->lookaside.bEnabled = enableLookaside;
1809: pParse->nTab = n;
1810: if( pSelTab ){
1811: assert( pTable->aCol==0 );
1812: pTable->nCol = pSelTab->nCol;
1813: pTable->aCol = pSelTab->aCol;
1814: pSelTab->nCol = 0;
1815: pSelTab->aCol = 0;
1816: sqlite3DeleteTable(db, pSelTab);
1817: assert( sqlite3SchemaMutexHeld(db, 0, pTable->pSchema) );
1818: pTable->pSchema->flags |= DB_UnresetViews;
1819: }else{
1820: pTable->nCol = 0;
1821: nErr++;
1822: }
1823: sqlite3SelectDelete(db, pSel);
1824: } else {
1825: nErr++;
1826: }
1827: #endif /* SQLITE_OMIT_VIEW */
1828: return nErr;
1829: }
1830: #endif /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */
1831:
1832: #ifndef SQLITE_OMIT_VIEW
1833: /*
1834: ** Clear the column names from every VIEW in database idx.
1835: */
1836: static void sqliteViewResetAll(sqlite3 *db, int idx){
1837: HashElem *i;
1838: assert( sqlite3SchemaMutexHeld(db, idx, 0) );
1839: if( !DbHasProperty(db, idx, DB_UnresetViews) ) return;
1840: for(i=sqliteHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqliteHashNext(i)){
1841: Table *pTab = sqliteHashData(i);
1842: if( pTab->pSelect ){
1843: sqliteDeleteColumnNames(db, pTab);
1844: pTab->aCol = 0;
1845: pTab->nCol = 0;
1846: }
1847: }
1848: DbClearProperty(db, idx, DB_UnresetViews);
1849: }
1850: #else
1851: # define sqliteViewResetAll(A,B)
1852: #endif /* SQLITE_OMIT_VIEW */
1853:
1854: /*
1855: ** This function is called by the VDBE to adjust the internal schema
1856: ** used by SQLite when the btree layer moves a table root page. The
1857: ** root-page of a table or index in database iDb has changed from iFrom
1858: ** to iTo.
1859: **
1860: ** Ticket #1728: The symbol table might still contain information
1861: ** on tables and/or indices that are the process of being deleted.
1862: ** If you are unlucky, one of those deleted indices or tables might
1863: ** have the same rootpage number as the real table or index that is
1864: ** being moved. So we cannot stop searching after the first match
1865: ** because the first match might be for one of the deleted indices
1866: ** or tables and not the table/index that is actually being moved.
1867: ** We must continue looping until all tables and indices with
1868: ** rootpage==iFrom have been converted to have a rootpage of iTo
1869: ** in order to be certain that we got the right one.
1870: */
1871: #ifndef SQLITE_OMIT_AUTOVACUUM
1872: void sqlite3RootPageMoved(sqlite3 *db, int iDb, int iFrom, int iTo){
1873: HashElem *pElem;
1874: Hash *pHash;
1875: Db *pDb;
1876:
1877: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
1878: pDb = &db->aDb[iDb];
1879: pHash = &pDb->pSchema->tblHash;
1880: for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
1881: Table *pTab = sqliteHashData(pElem);
1882: if( pTab->tnum==iFrom ){
1883: pTab->tnum = iTo;
1884: }
1885: }
1886: pHash = &pDb->pSchema->idxHash;
1887: for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
1888: Index *pIdx = sqliteHashData(pElem);
1889: if( pIdx->tnum==iFrom ){
1890: pIdx->tnum = iTo;
1891: }
1892: }
1893: }
1894: #endif
1895:
1896: /*
1897: ** Write code to erase the table with root-page iTable from database iDb.
1898: ** Also write code to modify the sqlite_master table and internal schema
1899: ** if a root-page of another table is moved by the btree-layer whilst
1900: ** erasing iTable (this can happen with an auto-vacuum database).
1901: */
1902: static void destroyRootPage(Parse *pParse, int iTable, int iDb){
1903: Vdbe *v = sqlite3GetVdbe(pParse);
1904: int r1 = sqlite3GetTempReg(pParse);
1905: sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
1906: sqlite3MayAbort(pParse);
1907: #ifndef SQLITE_OMIT_AUTOVACUUM
1908: /* OP_Destroy stores an in integer r1. If this integer
1909: ** is non-zero, then it is the root page number of a table moved to
1910: ** location iTable. The following code modifies the sqlite_master table to
1911: ** reflect this.
1912: **
1913: ** The "#NNN" in the SQL is a special constant that means whatever value
1914: ** is in register NNN. See grammar rules associated with the TK_REGISTER
1915: ** token for additional information.
1916: */
1917: sqlite3NestedParse(pParse,
1918: "UPDATE %Q.%s SET rootpage=%d WHERE #%d AND rootpage=#%d",
1919: pParse->db->aDb[iDb].zName, SCHEMA_TABLE(iDb), iTable, r1, r1);
1920: #endif
1921: sqlite3ReleaseTempReg(pParse, r1);
1922: }
1923:
1924: /*
1925: ** Write VDBE code to erase table pTab and all associated indices on disk.
1926: ** Code to update the sqlite_master tables and internal schema definitions
1927: ** in case a root-page belonging to another table is moved by the btree layer
1928: ** is also added (this can happen with an auto-vacuum database).
1929: */
1930: static void destroyTable(Parse *pParse, Table *pTab){
1931: #ifdef SQLITE_OMIT_AUTOVACUUM
1932: Index *pIdx;
1933: int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
1934: destroyRootPage(pParse, pTab->tnum, iDb);
1935: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
1936: destroyRootPage(pParse, pIdx->tnum, iDb);
1937: }
1938: #else
1939: /* If the database may be auto-vacuum capable (if SQLITE_OMIT_AUTOVACUUM
1940: ** is not defined), then it is important to call OP_Destroy on the
1941: ** table and index root-pages in order, starting with the numerically
1942: ** largest root-page number. This guarantees that none of the root-pages
1943: ** to be destroyed is relocated by an earlier OP_Destroy. i.e. if the
1944: ** following were coded:
1945: **
1946: ** OP_Destroy 4 0
1947: ** ...
1948: ** OP_Destroy 5 0
1949: **
1950: ** and root page 5 happened to be the largest root-page number in the
1951: ** database, then root page 5 would be moved to page 4 by the
1952: ** "OP_Destroy 4 0" opcode. The subsequent "OP_Destroy 5 0" would hit
1953: ** a free-list page.
1954: */
1955: int iTab = pTab->tnum;
1956: int iDestroyed = 0;
1957:
1958: while( 1 ){
1959: Index *pIdx;
1960: int iLargest = 0;
1961:
1962: if( iDestroyed==0 || iTab<iDestroyed ){
1963: iLargest = iTab;
1964: }
1965: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
1966: int iIdx = pIdx->tnum;
1967: assert( pIdx->pSchema==pTab->pSchema );
1968: if( (iDestroyed==0 || (iIdx<iDestroyed)) && iIdx>iLargest ){
1969: iLargest = iIdx;
1970: }
1971: }
1972: if( iLargest==0 ){
1973: return;
1974: }else{
1975: int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
1976: destroyRootPage(pParse, iLargest, iDb);
1977: iDestroyed = iLargest;
1978: }
1979: }
1980: #endif
1981: }
1982:
1983: /*
1984: ** Remove entries from the sqlite_statN tables (for N in (1,2,3))
1985: ** after a DROP INDEX or DROP TABLE command.
1986: */
1987: static void sqlite3ClearStatTables(
1988: Parse *pParse, /* The parsing context */
1989: int iDb, /* The database number */
1990: const char *zType, /* "idx" or "tbl" */
1991: const char *zName /* Name of index or table */
1992: ){
1993: int i;
1994: const char *zDbName = pParse->db->aDb[iDb].zName;
1995: for(i=1; i<=3; i++){
1996: char zTab[24];
1997: sqlite3_snprintf(sizeof(zTab),zTab,"sqlite_stat%d",i);
1998: if( sqlite3FindTable(pParse->db, zTab, zDbName) ){
1999: sqlite3NestedParse(pParse,
2000: "DELETE FROM %Q.%s WHERE %s=%Q",
2001: zDbName, zTab, zType, zName
2002: );
2003: }
2004: }
2005: }
2006:
2007: /*
2008: ** Generate code to drop a table.
2009: */
2010: void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){
2011: Vdbe *v;
2012: sqlite3 *db = pParse->db;
2013: Trigger *pTrigger;
2014: Db *pDb = &db->aDb[iDb];
2015:
2016: v = sqlite3GetVdbe(pParse);
2017: assert( v!=0 );
2018: sqlite3BeginWriteOperation(pParse, 1, iDb);
2019:
2020: #ifndef SQLITE_OMIT_VIRTUALTABLE
2021: if( IsVirtual(pTab) ){
2022: sqlite3VdbeAddOp0(v, OP_VBegin);
2023: }
2024: #endif
2025:
2026: /* Drop all triggers associated with the table being dropped. Code
2027: ** is generated to remove entries from sqlite_master and/or
2028: ** sqlite_temp_master if required.
2029: */
2030: pTrigger = sqlite3TriggerList(pParse, pTab);
2031: while( pTrigger ){
2032: assert( pTrigger->pSchema==pTab->pSchema ||
2033: pTrigger->pSchema==db->aDb[1].pSchema );
2034: sqlite3DropTriggerPtr(pParse, pTrigger);
2035: pTrigger = pTrigger->pNext;
2036: }
2037:
2038: #ifndef SQLITE_OMIT_AUTOINCREMENT
2039: /* Remove any entries of the sqlite_sequence table associated with
2040: ** the table being dropped. This is done before the table is dropped
2041: ** at the btree level, in case the sqlite_sequence table needs to
2042: ** move as a result of the drop (can happen in auto-vacuum mode).
2043: */
2044: if( pTab->tabFlags & TF_Autoincrement ){
2045: sqlite3NestedParse(pParse,
2046: "DELETE FROM %Q.sqlite_sequence WHERE name=%Q",
2047: pDb->zName, pTab->zName
2048: );
2049: }
2050: #endif
2051:
2052: /* Drop all SQLITE_MASTER table and index entries that refer to the
2053: ** table. The program name loops through the master table and deletes
2054: ** every row that refers to a table of the same name as the one being
2055: ** dropped. Triggers are handled seperately because a trigger can be
2056: ** created in the temp database that refers to a table in another
2057: ** database.
2058: */
2059: sqlite3NestedParse(pParse,
2060: "DELETE FROM %Q.%s WHERE tbl_name=%Q and type!='trigger'",
2061: pDb->zName, SCHEMA_TABLE(iDb), pTab->zName);
2062: if( !isView && !IsVirtual(pTab) ){
2063: destroyTable(pParse, pTab);
2064: }
2065:
2066: /* Remove the table entry from SQLite's internal schema and modify
2067: ** the schema cookie.
2068: */
2069: if( IsVirtual(pTab) ){
2070: sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
2071: }
2072: sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
2073: sqlite3ChangeCookie(pParse, iDb);
2074: sqliteViewResetAll(db, iDb);
2075: }
2076:
2077: /*
2078: ** This routine is called to do the work of a DROP TABLE statement.
2079: ** pName is the name of the table to be dropped.
2080: */
2081: void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){
2082: Table *pTab;
2083: Vdbe *v;
2084: sqlite3 *db = pParse->db;
2085: int iDb;
2086:
2087: if( db->mallocFailed ){
2088: goto exit_drop_table;
2089: }
2090: assert( pParse->nErr==0 );
2091: assert( pName->nSrc==1 );
2092: if( noErr ) db->suppressErr++;
2093: pTab = sqlite3LocateTable(pParse, isView,
2094: pName->a[0].zName, pName->a[0].zDatabase);
2095: if( noErr ) db->suppressErr--;
2096:
2097: if( pTab==0 ){
2098: if( noErr ) sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
2099: goto exit_drop_table;
2100: }
2101: iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
2102: assert( iDb>=0 && iDb<db->nDb );
2103:
2104: /* If pTab is a virtual table, call ViewGetColumnNames() to ensure
2105: ** it is initialized.
2106: */
2107: if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){
2108: goto exit_drop_table;
2109: }
2110: #ifndef SQLITE_OMIT_AUTHORIZATION
2111: {
2112: int code;
2113: const char *zTab = SCHEMA_TABLE(iDb);
2114: const char *zDb = db->aDb[iDb].zName;
2115: const char *zArg2 = 0;
2116: if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){
2117: goto exit_drop_table;
2118: }
2119: if( isView ){
2120: if( !OMIT_TEMPDB && iDb==1 ){
2121: code = SQLITE_DROP_TEMP_VIEW;
2122: }else{
2123: code = SQLITE_DROP_VIEW;
2124: }
2125: #ifndef SQLITE_OMIT_VIRTUALTABLE
2126: }else if( IsVirtual(pTab) ){
2127: code = SQLITE_DROP_VTABLE;
2128: zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
2129: #endif
2130: }else{
2131: if( !OMIT_TEMPDB && iDb==1 ){
2132: code = SQLITE_DROP_TEMP_TABLE;
2133: }else{
2134: code = SQLITE_DROP_TABLE;
2135: }
2136: }
2137: if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
2138: goto exit_drop_table;
2139: }
2140: if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
2141: goto exit_drop_table;
2142: }
2143: }
2144: #endif
2145: if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
2146: && sqlite3StrNICmp(pTab->zName, "sqlite_stat", 11)!=0 ){
2147: sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
2148: goto exit_drop_table;
2149: }
2150:
2151: #ifndef SQLITE_OMIT_VIEW
2152: /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
2153: ** on a table.
2154: */
2155: if( isView && pTab->pSelect==0 ){
2156: sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
2157: goto exit_drop_table;
2158: }
2159: if( !isView && pTab->pSelect ){
2160: sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
2161: goto exit_drop_table;
2162: }
2163: #endif
2164:
2165: /* Generate code to remove the table from the master table
2166: ** on disk.
2167: */
2168: v = sqlite3GetVdbe(pParse);
2169: if( v ){
2170: sqlite3BeginWriteOperation(pParse, 1, iDb);
2171: sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
2172: sqlite3FkDropTable(pParse, pName, pTab);
2173: sqlite3CodeDropTable(pParse, pTab, iDb, isView);
2174: }
2175:
2176: exit_drop_table:
2177: sqlite3SrcListDelete(db, pName);
2178: }
2179:
2180: /*
2181: ** This routine is called to create a new foreign key on the table
2182: ** currently under construction. pFromCol determines which columns
2183: ** in the current table point to the foreign key. If pFromCol==0 then
2184: ** connect the key to the last column inserted. pTo is the name of
2185: ** the table referred to. pToCol is a list of tables in the other
2186: ** pTo table that the foreign key points to. flags contains all
2187: ** information about the conflict resolution algorithms specified
2188: ** in the ON DELETE, ON UPDATE and ON INSERT clauses.
2189: **
2190: ** An FKey structure is created and added to the table currently
2191: ** under construction in the pParse->pNewTable field.
2192: **
2193: ** The foreign key is set for IMMEDIATE processing. A subsequent call
2194: ** to sqlite3DeferForeignKey() might change this to DEFERRED.
2195: */
2196: void sqlite3CreateForeignKey(
2197: Parse *pParse, /* Parsing context */
2198: ExprList *pFromCol, /* Columns in this table that point to other table */
2199: Token *pTo, /* Name of the other table */
2200: ExprList *pToCol, /* Columns in the other table */
2201: int flags /* Conflict resolution algorithms. */
2202: ){
2203: sqlite3 *db = pParse->db;
2204: #ifndef SQLITE_OMIT_FOREIGN_KEY
2205: FKey *pFKey = 0;
2206: FKey *pNextTo;
2207: Table *p = pParse->pNewTable;
2208: int nByte;
2209: int i;
2210: int nCol;
2211: char *z;
2212:
2213: assert( pTo!=0 );
2214: if( p==0 || IN_DECLARE_VTAB ) goto fk_end;
2215: if( pFromCol==0 ){
2216: int iCol = p->nCol-1;
2217: if( NEVER(iCol<0) ) goto fk_end;
2218: if( pToCol && pToCol->nExpr!=1 ){
2219: sqlite3ErrorMsg(pParse, "foreign key on %s"
2220: " should reference only one column of table %T",
2221: p->aCol[iCol].zName, pTo);
2222: goto fk_end;
2223: }
2224: nCol = 1;
2225: }else if( pToCol && pToCol->nExpr!=pFromCol->nExpr ){
2226: sqlite3ErrorMsg(pParse,
2227: "number of columns in foreign key does not match the number of "
2228: "columns in the referenced table");
2229: goto fk_end;
2230: }else{
2231: nCol = pFromCol->nExpr;
2232: }
2233: nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
2234: if( pToCol ){
2235: for(i=0; i<pToCol->nExpr; i++){
2236: nByte += sqlite3Strlen30(pToCol->a[i].zName) + 1;
2237: }
2238: }
2239: pFKey = sqlite3DbMallocZero(db, nByte );
2240: if( pFKey==0 ){
2241: goto fk_end;
2242: }
2243: pFKey->pFrom = p;
2244: pFKey->pNextFrom = p->pFKey;
2245: z = (char*)&pFKey->aCol[nCol];
2246: pFKey->zTo = z;
2247: memcpy(z, pTo->z, pTo->n);
2248: z[pTo->n] = 0;
2249: sqlite3Dequote(z);
2250: z += pTo->n+1;
2251: pFKey->nCol = nCol;
2252: if( pFromCol==0 ){
2253: pFKey->aCol[0].iFrom = p->nCol-1;
2254: }else{
2255: for(i=0; i<nCol; i++){
2256: int j;
2257: for(j=0; j<p->nCol; j++){
2258: if( sqlite3StrICmp(p->aCol[j].zName, pFromCol->a[i].zName)==0 ){
2259: pFKey->aCol[i].iFrom = j;
2260: break;
2261: }
2262: }
2263: if( j>=p->nCol ){
2264: sqlite3ErrorMsg(pParse,
2265: "unknown column \"%s\" in foreign key definition",
2266: pFromCol->a[i].zName);
2267: goto fk_end;
2268: }
2269: }
2270: }
2271: if( pToCol ){
2272: for(i=0; i<nCol; i++){
2273: int n = sqlite3Strlen30(pToCol->a[i].zName);
2274: pFKey->aCol[i].zCol = z;
2275: memcpy(z, pToCol->a[i].zName, n);
2276: z[n] = 0;
2277: z += n+1;
2278: }
2279: }
2280: pFKey->isDeferred = 0;
2281: pFKey->aAction[0] = (u8)(flags & 0xff); /* ON DELETE action */
2282: pFKey->aAction[1] = (u8)((flags >> 8 ) & 0xff); /* ON UPDATE action */
2283:
2284: assert( sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
2285: pNextTo = (FKey *)sqlite3HashInsert(&p->pSchema->fkeyHash,
2286: pFKey->zTo, sqlite3Strlen30(pFKey->zTo), (void *)pFKey
2287: );
2288: if( pNextTo==pFKey ){
2289: db->mallocFailed = 1;
2290: goto fk_end;
2291: }
2292: if( pNextTo ){
2293: assert( pNextTo->pPrevTo==0 );
2294: pFKey->pNextTo = pNextTo;
2295: pNextTo->pPrevTo = pFKey;
2296: }
2297:
2298: /* Link the foreign key to the table as the last step.
2299: */
2300: p->pFKey = pFKey;
2301: pFKey = 0;
2302:
2303: fk_end:
2304: sqlite3DbFree(db, pFKey);
2305: #endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
2306: sqlite3ExprListDelete(db, pFromCol);
2307: sqlite3ExprListDelete(db, pToCol);
2308: }
2309:
2310: /*
2311: ** This routine is called when an INITIALLY IMMEDIATE or INITIALLY DEFERRED
2312: ** clause is seen as part of a foreign key definition. The isDeferred
2313: ** parameter is 1 for INITIALLY DEFERRED and 0 for INITIALLY IMMEDIATE.
2314: ** The behavior of the most recently created foreign key is adjusted
2315: ** accordingly.
2316: */
2317: void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){
2318: #ifndef SQLITE_OMIT_FOREIGN_KEY
2319: Table *pTab;
2320: FKey *pFKey;
2321: if( (pTab = pParse->pNewTable)==0 || (pFKey = pTab->pFKey)==0 ) return;
2322: assert( isDeferred==0 || isDeferred==1 ); /* EV: R-30323-21917 */
2323: pFKey->isDeferred = (u8)isDeferred;
2324: #endif
2325: }
2326:
2327: /*
2328: ** Generate code that will erase and refill index *pIdx. This is
2329: ** used to initialize a newly created index or to recompute the
2330: ** content of an index in response to a REINDEX command.
2331: **
2332: ** if memRootPage is not negative, it means that the index is newly
2333: ** created. The register specified by memRootPage contains the
2334: ** root page number of the index. If memRootPage is negative, then
2335: ** the index already exists and must be cleared before being refilled and
2336: ** the root page number of the index is taken from pIndex->tnum.
2337: */
2338: static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){
2339: Table *pTab = pIndex->pTable; /* The table that is indexed */
2340: int iTab = pParse->nTab++; /* Btree cursor used for pTab */
2341: int iIdx = pParse->nTab++; /* Btree cursor used for pIndex */
2342: int iSorter; /* Cursor opened by OpenSorter (if in use) */
2343: int addr1; /* Address of top of loop */
2344: int addr2; /* Address to jump to for next iteration */
2345: int tnum; /* Root page of index */
2346: Vdbe *v; /* Generate code into this virtual machine */
2347: KeyInfo *pKey; /* KeyInfo for index */
2348: #ifdef SQLITE_OMIT_MERGE_SORT
2349: int regIdxKey; /* Registers containing the index key */
2350: #endif
2351: int regRecord; /* Register holding assemblied index record */
2352: sqlite3 *db = pParse->db; /* The database connection */
2353: int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
2354:
2355: #ifndef SQLITE_OMIT_AUTHORIZATION
2356: if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
2357: db->aDb[iDb].zName ) ){
2358: return;
2359: }
2360: #endif
2361:
2362: /* Require a write-lock on the table to perform this operation */
2363: sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
2364:
2365: v = sqlite3GetVdbe(pParse);
2366: if( v==0 ) return;
2367: if( memRootPage>=0 ){
2368: tnum = memRootPage;
2369: }else{
2370: tnum = pIndex->tnum;
2371: sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb);
2372: }
2373: pKey = sqlite3IndexKeyinfo(pParse, pIndex);
2374: sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, tnum, iDb,
2375: (char *)pKey, P4_KEYINFO_HANDOFF);
2376: if( memRootPage>=0 ){
2377: sqlite3VdbeChangeP5(v, 1);
2378: }
2379:
2380: #ifndef SQLITE_OMIT_MERGE_SORT
2381: /* Open the sorter cursor if we are to use one. */
2382: iSorter = pParse->nTab++;
2383: sqlite3VdbeAddOp4(v, OP_SorterOpen, iSorter, 0, 0, (char*)pKey, P4_KEYINFO);
2384: #else
2385: iSorter = iTab;
2386: #endif
2387:
2388: /* Open the table. Loop through all rows of the table, inserting index
2389: ** records into the sorter. */
2390: sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
2391: addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0);
2392: regRecord = sqlite3GetTempReg(pParse);
2393:
2394: #ifndef SQLITE_OMIT_MERGE_SORT
2395: sqlite3GenerateIndexKey(pParse, pIndex, iTab, regRecord, 1);
2396: sqlite3VdbeAddOp2(v, OP_SorterInsert, iSorter, regRecord);
2397: sqlite3VdbeAddOp2(v, OP_Next, iTab, addr1+1);
2398: sqlite3VdbeJumpHere(v, addr1);
2399: addr1 = sqlite3VdbeAddOp2(v, OP_SorterSort, iSorter, 0);
2400: if( pIndex->onError!=OE_None ){
2401: int j2 = sqlite3VdbeCurrentAddr(v) + 3;
2402: sqlite3VdbeAddOp2(v, OP_Goto, 0, j2);
2403: addr2 = sqlite3VdbeCurrentAddr(v);
2404: sqlite3VdbeAddOp3(v, OP_SorterCompare, iSorter, j2, regRecord);
2405: sqlite3HaltConstraint(
2406: pParse, OE_Abort, "indexed columns are not unique", P4_STATIC
2407: );
2408: }else{
2409: addr2 = sqlite3VdbeCurrentAddr(v);
2410: }
2411: sqlite3VdbeAddOp2(v, OP_SorterData, iSorter, regRecord);
2412: sqlite3VdbeAddOp3(v, OP_IdxInsert, iIdx, regRecord, 1);
2413: sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
2414: #else
2415: regIdxKey = sqlite3GenerateIndexKey(pParse, pIndex, iTab, regRecord, 1);
2416: addr2 = addr1 + 1;
2417: if( pIndex->onError!=OE_None ){
2418: const int regRowid = regIdxKey + pIndex->nColumn;
2419: const int j2 = sqlite3VdbeCurrentAddr(v) + 2;
2420: void * const pRegKey = SQLITE_INT_TO_PTR(regIdxKey);
2421:
2422: /* The registers accessed by the OP_IsUnique opcode were allocated
2423: ** using sqlite3GetTempRange() inside of the sqlite3GenerateIndexKey()
2424: ** call above. Just before that function was freed they were released
2425: ** (made available to the compiler for reuse) using
2426: ** sqlite3ReleaseTempRange(). So in some ways having the OP_IsUnique
2427: ** opcode use the values stored within seems dangerous. However, since
2428: ** we can be sure that no other temp registers have been allocated
2429: ** since sqlite3ReleaseTempRange() was called, it is safe to do so.
2430: */
2431: sqlite3VdbeAddOp4(v, OP_IsUnique, iIdx, j2, regRowid, pRegKey, P4_INT32);
2432: sqlite3HaltConstraint(
2433: pParse, OE_Abort, "indexed columns are not unique", P4_STATIC);
2434: }
2435: sqlite3VdbeAddOp3(v, OP_IdxInsert, iIdx, regRecord, 0);
2436: sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
2437: #endif
2438: sqlite3ReleaseTempReg(pParse, regRecord);
2439: sqlite3VdbeAddOp2(v, OP_SorterNext, iSorter, addr2);
2440: sqlite3VdbeJumpHere(v, addr1);
2441:
2442: sqlite3VdbeAddOp1(v, OP_Close, iTab);
2443: sqlite3VdbeAddOp1(v, OP_Close, iIdx);
2444: sqlite3VdbeAddOp1(v, OP_Close, iSorter);
2445: }
2446:
2447: /*
2448: ** Create a new index for an SQL table. pName1.pName2 is the name of the index
2449: ** and pTblList is the name of the table that is to be indexed. Both will
2450: ** be NULL for a primary key or an index that is created to satisfy a
2451: ** UNIQUE constraint. If pTable and pIndex are NULL, use pParse->pNewTable
2452: ** as the table to be indexed. pParse->pNewTable is a table that is
2453: ** currently being constructed by a CREATE TABLE statement.
2454: **
2455: ** pList is a list of columns to be indexed. pList will be NULL if this
2456: ** is a primary key or unique-constraint on the most recent column added
2457: ** to the table currently under construction.
2458: **
2459: ** If the index is created successfully, return a pointer to the new Index
2460: ** structure. This is used by sqlite3AddPrimaryKey() to mark the index
2461: ** as the tables primary key (Index.autoIndex==2).
2462: */
2463: Index *sqlite3CreateIndex(
2464: Parse *pParse, /* All information about this parse */
2465: Token *pName1, /* First part of index name. May be NULL */
2466: Token *pName2, /* Second part of index name. May be NULL */
2467: SrcList *pTblName, /* Table to index. Use pParse->pNewTable if 0 */
2468: ExprList *pList, /* A list of columns to be indexed */
2469: int onError, /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
2470: Token *pStart, /* The CREATE token that begins this statement */
2471: Token *pEnd, /* The ")" that closes the CREATE INDEX statement */
2472: int sortOrder, /* Sort order of primary key when pList==NULL */
2473: int ifNotExist /* Omit error if index already exists */
2474: ){
2475: Index *pRet = 0; /* Pointer to return */
2476: Table *pTab = 0; /* Table to be indexed */
2477: Index *pIndex = 0; /* The index to be created */
2478: char *zName = 0; /* Name of the index */
2479: int nName; /* Number of characters in zName */
2480: int i, j;
2481: Token nullId; /* Fake token for an empty ID list */
2482: DbFixer sFix; /* For assigning database names to pTable */
2483: int sortOrderMask; /* 1 to honor DESC in index. 0 to ignore. */
2484: sqlite3 *db = pParse->db;
2485: Db *pDb; /* The specific table containing the indexed database */
2486: int iDb; /* Index of the database that is being written */
2487: Token *pName = 0; /* Unqualified name of the index to create */
2488: struct ExprList_item *pListItem; /* For looping over pList */
2489: int nCol;
2490: int nExtra = 0;
2491: char *zExtra;
2492:
2493: assert( pStart==0 || pEnd!=0 ); /* pEnd must be non-NULL if pStart is */
2494: assert( pParse->nErr==0 ); /* Never called with prior errors */
2495: if( db->mallocFailed || IN_DECLARE_VTAB ){
2496: goto exit_create_index;
2497: }
2498: if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
2499: goto exit_create_index;
2500: }
2501:
2502: /*
2503: ** Find the table that is to be indexed. Return early if not found.
2504: */
2505: if( pTblName!=0 ){
2506:
2507: /* Use the two-part index name to determine the database
2508: ** to search for the table. 'Fix' the table name to this db
2509: ** before looking up the table.
2510: */
2511: assert( pName1 && pName2 );
2512: iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
2513: if( iDb<0 ) goto exit_create_index;
2514: assert( pName && pName->z );
2515:
2516: #ifndef SQLITE_OMIT_TEMPDB
2517: /* If the index name was unqualified, check if the the table
2518: ** is a temp table. If so, set the database to 1. Do not do this
2519: ** if initialising a database schema.
2520: */
2521: if( !db->init.busy ){
2522: pTab = sqlite3SrcListLookup(pParse, pTblName);
2523: if( pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){
2524: iDb = 1;
2525: }
2526: }
2527: #endif
2528:
2529: if( sqlite3FixInit(&sFix, pParse, iDb, "index", pName) &&
2530: sqlite3FixSrcList(&sFix, pTblName)
2531: ){
2532: /* Because the parser constructs pTblName from a single identifier,
2533: ** sqlite3FixSrcList can never fail. */
2534: assert(0);
2535: }
2536: pTab = sqlite3LocateTable(pParse, 0, pTblName->a[0].zName,
2537: pTblName->a[0].zDatabase);
2538: if( !pTab || db->mallocFailed ) goto exit_create_index;
2539: assert( db->aDb[iDb].pSchema==pTab->pSchema );
2540: }else{
2541: assert( pName==0 );
2542: assert( pStart==0 );
2543: pTab = pParse->pNewTable;
2544: if( !pTab ) goto exit_create_index;
2545: iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
2546: }
2547: pDb = &db->aDb[iDb];
2548:
2549: assert( pTab!=0 );
2550: assert( pParse->nErr==0 );
2551: if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
2552: && memcmp(&pTab->zName[7],"altertab_",9)!=0 ){
2553: sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
2554: goto exit_create_index;
2555: }
2556: #ifndef SQLITE_OMIT_VIEW
2557: if( pTab->pSelect ){
2558: sqlite3ErrorMsg(pParse, "views may not be indexed");
2559: goto exit_create_index;
2560: }
2561: #endif
2562: #ifndef SQLITE_OMIT_VIRTUALTABLE
2563: if( IsVirtual(pTab) ){
2564: sqlite3ErrorMsg(pParse, "virtual tables may not be indexed");
2565: goto exit_create_index;
2566: }
2567: #endif
2568:
2569: /*
2570: ** Find the name of the index. Make sure there is not already another
2571: ** index or table with the same name.
2572: **
2573: ** Exception: If we are reading the names of permanent indices from the
2574: ** sqlite_master table (because some other process changed the schema) and
2575: ** one of the index names collides with the name of a temporary table or
2576: ** index, then we will continue to process this index.
2577: **
2578: ** If pName==0 it means that we are
2579: ** dealing with a primary key or UNIQUE constraint. We have to invent our
2580: ** own name.
2581: */
2582: if( pName ){
2583: zName = sqlite3NameFromToken(db, pName);
2584: if( zName==0 ) goto exit_create_index;
2585: assert( pName->z!=0 );
2586: if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
2587: goto exit_create_index;
2588: }
2589: if( !db->init.busy ){
2590: if( sqlite3FindTable(db, zName, 0)!=0 ){
2591: sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
2592: goto exit_create_index;
2593: }
2594: }
2595: if( sqlite3FindIndex(db, zName, pDb->zName)!=0 ){
2596: if( !ifNotExist ){
2597: sqlite3ErrorMsg(pParse, "index %s already exists", zName);
2598: }else{
2599: assert( !db->init.busy );
2600: sqlite3CodeVerifySchema(pParse, iDb);
2601: }
2602: goto exit_create_index;
2603: }
2604: }else{
2605: int n;
2606: Index *pLoop;
2607: for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
2608: zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
2609: if( zName==0 ){
2610: goto exit_create_index;
2611: }
2612: }
2613:
2614: /* Check for authorization to create an index.
2615: */
2616: #ifndef SQLITE_OMIT_AUTHORIZATION
2617: {
2618: const char *zDb = pDb->zName;
2619: if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
2620: goto exit_create_index;
2621: }
2622: i = SQLITE_CREATE_INDEX;
2623: if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX;
2624: if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
2625: goto exit_create_index;
2626: }
2627: }
2628: #endif
2629:
2630: /* If pList==0, it means this routine was called to make a primary
2631: ** key out of the last column added to the table under construction.
2632: ** So create a fake list to simulate this.
2633: */
2634: if( pList==0 ){
2635: nullId.z = pTab->aCol[pTab->nCol-1].zName;
2636: nullId.n = sqlite3Strlen30((char*)nullId.z);
2637: pList = sqlite3ExprListAppend(pParse, 0, 0);
2638: if( pList==0 ) goto exit_create_index;
2639: sqlite3ExprListSetName(pParse, pList, &nullId, 0);
2640: pList->a[0].sortOrder = (u8)sortOrder;
2641: }
2642:
2643: /* Figure out how many bytes of space are required to store explicitly
2644: ** specified collation sequence names.
2645: */
2646: for(i=0; i<pList->nExpr; i++){
2647: Expr *pExpr = pList->a[i].pExpr;
2648: if( pExpr ){
2649: CollSeq *pColl = pExpr->pColl;
2650: /* Either pColl!=0 or there was an OOM failure. But if an OOM
2651: ** failure we have quit before reaching this point. */
2652: if( ALWAYS(pColl) ){
2653: nExtra += (1 + sqlite3Strlen30(pColl->zName));
2654: }
2655: }
2656: }
2657:
2658: /*
2659: ** Allocate the index structure.
2660: */
2661: nName = sqlite3Strlen30(zName);
2662: nCol = pList->nExpr;
2663: pIndex = sqlite3DbMallocZero(db,
2664: ROUND8(sizeof(Index)) + /* Index structure */
2665: ROUND8(sizeof(tRowcnt)*(nCol+1)) + /* Index.aiRowEst */
2666: sizeof(char *)*nCol + /* Index.azColl */
2667: sizeof(int)*nCol + /* Index.aiColumn */
2668: sizeof(u8)*nCol + /* Index.aSortOrder */
2669: nName + 1 + /* Index.zName */
2670: nExtra /* Collation sequence names */
2671: );
2672: if( db->mallocFailed ){
2673: goto exit_create_index;
2674: }
2675: zExtra = (char*)pIndex;
2676: pIndex->aiRowEst = (tRowcnt*)&zExtra[ROUND8(sizeof(Index))];
2677: pIndex->azColl = (char**)
2678: ((char*)pIndex->aiRowEst + ROUND8(sizeof(tRowcnt)*nCol+1));
2679: assert( EIGHT_BYTE_ALIGNMENT(pIndex->aiRowEst) );
2680: assert( EIGHT_BYTE_ALIGNMENT(pIndex->azColl) );
2681: pIndex->aiColumn = (int *)(&pIndex->azColl[nCol]);
2682: pIndex->aSortOrder = (u8 *)(&pIndex->aiColumn[nCol]);
2683: pIndex->zName = (char *)(&pIndex->aSortOrder[nCol]);
2684: zExtra = (char *)(&pIndex->zName[nName+1]);
2685: memcpy(pIndex->zName, zName, nName+1);
2686: pIndex->pTable = pTab;
2687: pIndex->nColumn = pList->nExpr;
2688: pIndex->onError = (u8)onError;
2689: pIndex->autoIndex = (u8)(pName==0);
2690: pIndex->pSchema = db->aDb[iDb].pSchema;
2691: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
2692:
2693: /* Check to see if we should honor DESC requests on index columns
2694: */
2695: if( pDb->pSchema->file_format>=4 ){
2696: sortOrderMask = -1; /* Honor DESC */
2697: }else{
2698: sortOrderMask = 0; /* Ignore DESC */
2699: }
2700:
2701: /* Scan the names of the columns of the table to be indexed and
2702: ** load the column indices into the Index structure. Report an error
2703: ** if any column is not found.
2704: **
2705: ** TODO: Add a test to make sure that the same column is not named
2706: ** more than once within the same index. Only the first instance of
2707: ** the column will ever be used by the optimizer. Note that using the
2708: ** same column more than once cannot be an error because that would
2709: ** break backwards compatibility - it needs to be a warning.
2710: */
2711: for(i=0, pListItem=pList->a; i<pList->nExpr; i++, pListItem++){
2712: const char *zColName = pListItem->zName;
2713: Column *pTabCol;
2714: int requestedSortOrder;
2715: char *zColl; /* Collation sequence name */
2716:
2717: for(j=0, pTabCol=pTab->aCol; j<pTab->nCol; j++, pTabCol++){
2718: if( sqlite3StrICmp(zColName, pTabCol->zName)==0 ) break;
2719: }
2720: if( j>=pTab->nCol ){
2721: sqlite3ErrorMsg(pParse, "table %s has no column named %s",
2722: pTab->zName, zColName);
2723: pParse->checkSchema = 1;
2724: goto exit_create_index;
2725: }
2726: pIndex->aiColumn[i] = j;
2727: /* Justification of the ALWAYS(pListItem->pExpr->pColl): Because of
2728: ** the way the "idxlist" non-terminal is constructed by the parser,
2729: ** if pListItem->pExpr is not null then either pListItem->pExpr->pColl
2730: ** must exist or else there must have been an OOM error. But if there
2731: ** was an OOM error, we would never reach this point. */
2732: if( pListItem->pExpr && ALWAYS(pListItem->pExpr->pColl) ){
2733: int nColl;
2734: zColl = pListItem->pExpr->pColl->zName;
2735: nColl = sqlite3Strlen30(zColl) + 1;
2736: assert( nExtra>=nColl );
2737: memcpy(zExtra, zColl, nColl);
2738: zColl = zExtra;
2739: zExtra += nColl;
2740: nExtra -= nColl;
2741: }else{
2742: zColl = pTab->aCol[j].zColl;
2743: if( !zColl ){
2744: zColl = db->pDfltColl->zName;
2745: }
2746: }
2747: if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl) ){
2748: goto exit_create_index;
2749: }
2750: pIndex->azColl[i] = zColl;
2751: requestedSortOrder = pListItem->sortOrder & sortOrderMask;
2752: pIndex->aSortOrder[i] = (u8)requestedSortOrder;
2753: }
2754: sqlite3DefaultRowEst(pIndex);
2755:
2756: if( pTab==pParse->pNewTable ){
2757: /* This routine has been called to create an automatic index as a
2758: ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or
2759: ** a PRIMARY KEY or UNIQUE clause following the column definitions.
2760: ** i.e. one of:
2761: **
2762: ** CREATE TABLE t(x PRIMARY KEY, y);
2763: ** CREATE TABLE t(x, y, UNIQUE(x, y));
2764: **
2765: ** Either way, check to see if the table already has such an index. If
2766: ** so, don't bother creating this one. This only applies to
2767: ** automatically created indices. Users can do as they wish with
2768: ** explicit indices.
2769: **
2770: ** Two UNIQUE or PRIMARY KEY constraints are considered equivalent
2771: ** (and thus suppressing the second one) even if they have different
2772: ** sort orders.
2773: **
2774: ** If there are different collating sequences or if the columns of
2775: ** the constraint occur in different orders, then the constraints are
2776: ** considered distinct and both result in separate indices.
2777: */
2778: Index *pIdx;
2779: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
2780: int k;
2781: assert( pIdx->onError!=OE_None );
2782: assert( pIdx->autoIndex );
2783: assert( pIndex->onError!=OE_None );
2784:
2785: if( pIdx->nColumn!=pIndex->nColumn ) continue;
2786: for(k=0; k<pIdx->nColumn; k++){
2787: const char *z1;
2788: const char *z2;
2789: if( pIdx->aiColumn[k]!=pIndex->aiColumn[k] ) break;
2790: z1 = pIdx->azColl[k];
2791: z2 = pIndex->azColl[k];
2792: if( z1!=z2 && sqlite3StrICmp(z1, z2) ) break;
2793: }
2794: if( k==pIdx->nColumn ){
2795: if( pIdx->onError!=pIndex->onError ){
2796: /* This constraint creates the same index as a previous
2797: ** constraint specified somewhere in the CREATE TABLE statement.
2798: ** However the ON CONFLICT clauses are different. If both this
2799: ** constraint and the previous equivalent constraint have explicit
2800: ** ON CONFLICT clauses this is an error. Otherwise, use the
2801: ** explicitly specified behaviour for the index.
2802: */
2803: if( !(pIdx->onError==OE_Default || pIndex->onError==OE_Default) ){
2804: sqlite3ErrorMsg(pParse,
2805: "conflicting ON CONFLICT clauses specified", 0);
2806: }
2807: if( pIdx->onError==OE_Default ){
2808: pIdx->onError = pIndex->onError;
2809: }
2810: }
2811: goto exit_create_index;
2812: }
2813: }
2814: }
2815:
2816: /* Link the new Index structure to its table and to the other
2817: ** in-memory database structures.
2818: */
2819: if( db->init.busy ){
2820: Index *p;
2821: assert( sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
2822: p = sqlite3HashInsert(&pIndex->pSchema->idxHash,
2823: pIndex->zName, sqlite3Strlen30(pIndex->zName),
2824: pIndex);
2825: if( p ){
2826: assert( p==pIndex ); /* Malloc must have failed */
2827: db->mallocFailed = 1;
2828: goto exit_create_index;
2829: }
2830: db->flags |= SQLITE_InternChanges;
2831: if( pTblName!=0 ){
2832: pIndex->tnum = db->init.newTnum;
2833: }
2834: }
2835:
2836: /* If the db->init.busy is 0 then create the index on disk. This
2837: ** involves writing the index into the master table and filling in the
2838: ** index with the current table contents.
2839: **
2840: ** The db->init.busy is 0 when the user first enters a CREATE INDEX
2841: ** command. db->init.busy is 1 when a database is opened and
2842: ** CREATE INDEX statements are read out of the master table. In
2843: ** the latter case the index already exists on disk, which is why
2844: ** we don't want to recreate it.
2845: **
2846: ** If pTblName==0 it means this index is generated as a primary key
2847: ** or UNIQUE constraint of a CREATE TABLE statement. Since the table
2848: ** has just been created, it contains no data and the index initialization
2849: ** step can be skipped.
2850: */
2851: else{ /* if( db->init.busy==0 ) */
2852: Vdbe *v;
2853: char *zStmt;
2854: int iMem = ++pParse->nMem;
2855:
2856: v = sqlite3GetVdbe(pParse);
2857: if( v==0 ) goto exit_create_index;
2858:
2859:
2860: /* Create the rootpage for the index
2861: */
2862: sqlite3BeginWriteOperation(pParse, 1, iDb);
2863: sqlite3VdbeAddOp2(v, OP_CreateIndex, iDb, iMem);
2864:
2865: /* Gather the complete text of the CREATE INDEX statement into
2866: ** the zStmt variable
2867: */
2868: if( pStart ){
2869: assert( pEnd!=0 );
2870: /* A named index with an explicit CREATE INDEX statement */
2871: zStmt = sqlite3MPrintf(db, "CREATE%s INDEX %.*s",
2872: onError==OE_None ? "" : " UNIQUE",
2873: (int)(pEnd->z - pName->z) + 1,
2874: pName->z);
2875: }else{
2876: /* An automatic index created by a PRIMARY KEY or UNIQUE constraint */
2877: /* zStmt = sqlite3MPrintf(""); */
2878: zStmt = 0;
2879: }
2880:
2881: /* Add an entry in sqlite_master for this index
2882: */
2883: sqlite3NestedParse(pParse,
2884: "INSERT INTO %Q.%s VALUES('index',%Q,%Q,#%d,%Q);",
2885: db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
2886: pIndex->zName,
2887: pTab->zName,
2888: iMem,
2889: zStmt
2890: );
2891: sqlite3DbFree(db, zStmt);
2892:
2893: /* Fill the index with data and reparse the schema. Code an OP_Expire
2894: ** to invalidate all pre-compiled statements.
2895: */
2896: if( pTblName ){
2897: sqlite3RefillIndex(pParse, pIndex, iMem);
2898: sqlite3ChangeCookie(pParse, iDb);
2899: sqlite3VdbeAddParseSchemaOp(v, iDb,
2900: sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName));
2901: sqlite3VdbeAddOp1(v, OP_Expire, 0);
2902: }
2903: }
2904:
2905: /* When adding an index to the list of indices for a table, make
2906: ** sure all indices labeled OE_Replace come after all those labeled
2907: ** OE_Ignore. This is necessary for the correct constraint check
2908: ** processing (in sqlite3GenerateConstraintChecks()) as part of
2909: ** UPDATE and INSERT statements.
2910: */
2911: if( db->init.busy || pTblName==0 ){
2912: if( onError!=OE_Replace || pTab->pIndex==0
2913: || pTab->pIndex->onError==OE_Replace){
2914: pIndex->pNext = pTab->pIndex;
2915: pTab->pIndex = pIndex;
2916: }else{
2917: Index *pOther = pTab->pIndex;
2918: while( pOther->pNext && pOther->pNext->onError!=OE_Replace ){
2919: pOther = pOther->pNext;
2920: }
2921: pIndex->pNext = pOther->pNext;
2922: pOther->pNext = pIndex;
2923: }
2924: pRet = pIndex;
2925: pIndex = 0;
2926: }
2927:
2928: /* Clean up before exiting */
2929: exit_create_index:
2930: if( pIndex ){
2931: sqlite3DbFree(db, pIndex->zColAff);
2932: sqlite3DbFree(db, pIndex);
2933: }
2934: sqlite3ExprListDelete(db, pList);
2935: sqlite3SrcListDelete(db, pTblName);
2936: sqlite3DbFree(db, zName);
2937: return pRet;
2938: }
2939:
2940: /*
2941: ** Fill the Index.aiRowEst[] array with default information - information
2942: ** to be used when we have not run the ANALYZE command.
2943: **
2944: ** aiRowEst[0] is suppose to contain the number of elements in the index.
2945: ** Since we do not know, guess 1 million. aiRowEst[1] is an estimate of the
2946: ** number of rows in the table that match any particular value of the
2947: ** first column of the index. aiRowEst[2] is an estimate of the number
2948: ** of rows that match any particular combiniation of the first 2 columns
2949: ** of the index. And so forth. It must always be the case that
2950: *
2951: ** aiRowEst[N]<=aiRowEst[N-1]
2952: ** aiRowEst[N]>=1
2953: **
2954: ** Apart from that, we have little to go on besides intuition as to
2955: ** how aiRowEst[] should be initialized. The numbers generated here
2956: ** are based on typical values found in actual indices.
2957: */
2958: void sqlite3DefaultRowEst(Index *pIdx){
2959: tRowcnt *a = pIdx->aiRowEst;
2960: int i;
2961: tRowcnt n;
2962: assert( a!=0 );
2963: a[0] = pIdx->pTable->nRowEst;
2964: if( a[0]<10 ) a[0] = 10;
2965: n = 10;
2966: for(i=1; i<=pIdx->nColumn; i++){
2967: a[i] = n;
2968: if( n>5 ) n--;
2969: }
2970: if( pIdx->onError!=OE_None ){
2971: a[pIdx->nColumn] = 1;
2972: }
2973: }
2974:
2975: /*
2976: ** This routine will drop an existing named index. This routine
2977: ** implements the DROP INDEX statement.
2978: */
2979: void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){
2980: Index *pIndex;
2981: Vdbe *v;
2982: sqlite3 *db = pParse->db;
2983: int iDb;
2984:
2985: assert( pParse->nErr==0 ); /* Never called with prior errors */
2986: if( db->mallocFailed ){
2987: goto exit_drop_index;
2988: }
2989: assert( pName->nSrc==1 );
2990: if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
2991: goto exit_drop_index;
2992: }
2993: pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
2994: if( pIndex==0 ){
2995: if( !ifExists ){
2996: sqlite3ErrorMsg(pParse, "no such index: %S", pName, 0);
2997: }else{
2998: sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
2999: }
3000: pParse->checkSchema = 1;
3001: goto exit_drop_index;
3002: }
3003: if( pIndex->autoIndex ){
3004: sqlite3ErrorMsg(pParse, "index associated with UNIQUE "
3005: "or PRIMARY KEY constraint cannot be dropped", 0);
3006: goto exit_drop_index;
3007: }
3008: iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
3009: #ifndef SQLITE_OMIT_AUTHORIZATION
3010: {
3011: int code = SQLITE_DROP_INDEX;
3012: Table *pTab = pIndex->pTable;
3013: const char *zDb = db->aDb[iDb].zName;
3014: const char *zTab = SCHEMA_TABLE(iDb);
3015: if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
3016: goto exit_drop_index;
3017: }
3018: if( !OMIT_TEMPDB && iDb ) code = SQLITE_DROP_TEMP_INDEX;
3019: if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
3020: goto exit_drop_index;
3021: }
3022: }
3023: #endif
3024:
3025: /* Generate code to remove the index and from the master table */
3026: v = sqlite3GetVdbe(pParse);
3027: if( v ){
3028: sqlite3BeginWriteOperation(pParse, 1, iDb);
3029: sqlite3NestedParse(pParse,
3030: "DELETE FROM %Q.%s WHERE name=%Q AND type='index'",
3031: db->aDb[iDb].zName, SCHEMA_TABLE(iDb), pIndex->zName
3032: );
3033: sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
3034: sqlite3ChangeCookie(pParse, iDb);
3035: destroyRootPage(pParse, pIndex->tnum, iDb);
3036: sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
3037: }
3038:
3039: exit_drop_index:
3040: sqlite3SrcListDelete(db, pName);
3041: }
3042:
3043: /*
3044: ** pArray is a pointer to an array of objects. Each object in the
3045: ** array is szEntry bytes in size. This routine allocates a new
3046: ** object on the end of the array.
3047: **
3048: ** *pnEntry is the number of entries already in use. *pnAlloc is
3049: ** the previously allocated size of the array. initSize is the
3050: ** suggested initial array size allocation.
3051: **
3052: ** The index of the new entry is returned in *pIdx.
3053: **
3054: ** This routine returns a pointer to the array of objects. This
3055: ** might be the same as the pArray parameter or it might be a different
3056: ** pointer if the array was resized.
3057: */
3058: void *sqlite3ArrayAllocate(
3059: sqlite3 *db, /* Connection to notify of malloc failures */
3060: void *pArray, /* Array of objects. Might be reallocated */
3061: int szEntry, /* Size of each object in the array */
3062: int initSize, /* Suggested initial allocation, in elements */
3063: int *pnEntry, /* Number of objects currently in use */
3064: int *pnAlloc, /* Current size of the allocation, in elements */
3065: int *pIdx /* Write the index of a new slot here */
3066: ){
3067: char *z;
3068: if( *pnEntry >= *pnAlloc ){
3069: void *pNew;
3070: int newSize;
3071: newSize = (*pnAlloc)*2 + initSize;
3072: pNew = sqlite3DbRealloc(db, pArray, newSize*szEntry);
3073: if( pNew==0 ){
3074: *pIdx = -1;
3075: return pArray;
3076: }
3077: *pnAlloc = sqlite3DbMallocSize(db, pNew)/szEntry;
3078: pArray = pNew;
3079: }
3080: z = (char*)pArray;
3081: memset(&z[*pnEntry * szEntry], 0, szEntry);
3082: *pIdx = *pnEntry;
3083: ++*pnEntry;
3084: return pArray;
3085: }
3086:
3087: /*
3088: ** Append a new element to the given IdList. Create a new IdList if
3089: ** need be.
3090: **
3091: ** A new IdList is returned, or NULL if malloc() fails.
3092: */
3093: IdList *sqlite3IdListAppend(sqlite3 *db, IdList *pList, Token *pToken){
3094: int i;
3095: if( pList==0 ){
3096: pList = sqlite3DbMallocZero(db, sizeof(IdList) );
3097: if( pList==0 ) return 0;
3098: pList->nAlloc = 0;
3099: }
3100: pList->a = sqlite3ArrayAllocate(
3101: db,
3102: pList->a,
3103: sizeof(pList->a[0]),
3104: 5,
3105: &pList->nId,
3106: &pList->nAlloc,
3107: &i
3108: );
3109: if( i<0 ){
3110: sqlite3IdListDelete(db, pList);
3111: return 0;
3112: }
3113: pList->a[i].zName = sqlite3NameFromToken(db, pToken);
3114: return pList;
3115: }
3116:
3117: /*
3118: ** Delete an IdList.
3119: */
3120: void sqlite3IdListDelete(sqlite3 *db, IdList *pList){
3121: int i;
3122: if( pList==0 ) return;
3123: for(i=0; i<pList->nId; i++){
3124: sqlite3DbFree(db, pList->a[i].zName);
3125: }
3126: sqlite3DbFree(db, pList->a);
3127: sqlite3DbFree(db, pList);
3128: }
3129:
3130: /*
3131: ** Return the index in pList of the identifier named zId. Return -1
3132: ** if not found.
3133: */
3134: int sqlite3IdListIndex(IdList *pList, const char *zName){
3135: int i;
3136: if( pList==0 ) return -1;
3137: for(i=0; i<pList->nId; i++){
3138: if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
3139: }
3140: return -1;
3141: }
3142:
3143: /*
3144: ** Expand the space allocated for the given SrcList object by
3145: ** creating nExtra new slots beginning at iStart. iStart is zero based.
3146: ** New slots are zeroed.
3147: **
3148: ** For example, suppose a SrcList initially contains two entries: A,B.
3149: ** To append 3 new entries onto the end, do this:
3150: **
3151: ** sqlite3SrcListEnlarge(db, pSrclist, 3, 2);
3152: **
3153: ** After the call above it would contain: A, B, nil, nil, nil.
3154: ** If the iStart argument had been 1 instead of 2, then the result
3155: ** would have been: A, nil, nil, nil, B. To prepend the new slots,
3156: ** the iStart value would be 0. The result then would
3157: ** be: nil, nil, nil, A, B.
3158: **
3159: ** If a memory allocation fails the SrcList is unchanged. The
3160: ** db->mallocFailed flag will be set to true.
3161: */
3162: SrcList *sqlite3SrcListEnlarge(
3163: sqlite3 *db, /* Database connection to notify of OOM errors */
3164: SrcList *pSrc, /* The SrcList to be enlarged */
3165: int nExtra, /* Number of new slots to add to pSrc->a[] */
3166: int iStart /* Index in pSrc->a[] of first new slot */
3167: ){
3168: int i;
3169:
3170: /* Sanity checking on calling parameters */
3171: assert( iStart>=0 );
3172: assert( nExtra>=1 );
3173: assert( pSrc!=0 );
3174: assert( iStart<=pSrc->nSrc );
3175:
3176: /* Allocate additional space if needed */
3177: if( pSrc->nSrc+nExtra>pSrc->nAlloc ){
3178: SrcList *pNew;
3179: int nAlloc = pSrc->nSrc+nExtra;
3180: int nGot;
3181: pNew = sqlite3DbRealloc(db, pSrc,
3182: sizeof(*pSrc) + (nAlloc-1)*sizeof(pSrc->a[0]) );
3183: if( pNew==0 ){
3184: assert( db->mallocFailed );
3185: return pSrc;
3186: }
3187: pSrc = pNew;
3188: nGot = (sqlite3DbMallocSize(db, pNew) - sizeof(*pSrc))/sizeof(pSrc->a[0])+1;
3189: pSrc->nAlloc = (u16)nGot;
3190: }
3191:
3192: /* Move existing slots that come after the newly inserted slots
3193: ** out of the way */
3194: for(i=pSrc->nSrc-1; i>=iStart; i--){
3195: pSrc->a[i+nExtra] = pSrc->a[i];
3196: }
3197: pSrc->nSrc += (i16)nExtra;
3198:
3199: /* Zero the newly allocated slots */
3200: memset(&pSrc->a[iStart], 0, sizeof(pSrc->a[0])*nExtra);
3201: for(i=iStart; i<iStart+nExtra; i++){
3202: pSrc->a[i].iCursor = -1;
3203: }
3204:
3205: /* Return a pointer to the enlarged SrcList */
3206: return pSrc;
3207: }
3208:
3209:
3210: /*
3211: ** Append a new table name to the given SrcList. Create a new SrcList if
3212: ** need be. A new entry is created in the SrcList even if pTable is NULL.
3213: **
3214: ** A SrcList is returned, or NULL if there is an OOM error. The returned
3215: ** SrcList might be the same as the SrcList that was input or it might be
3216: ** a new one. If an OOM error does occurs, then the prior value of pList
3217: ** that is input to this routine is automatically freed.
3218: **
3219: ** If pDatabase is not null, it means that the table has an optional
3220: ** database name prefix. Like this: "database.table". The pDatabase
3221: ** points to the table name and the pTable points to the database name.
3222: ** The SrcList.a[].zName field is filled with the table name which might
3223: ** come from pTable (if pDatabase is NULL) or from pDatabase.
3224: ** SrcList.a[].zDatabase is filled with the database name from pTable,
3225: ** or with NULL if no database is specified.
3226: **
3227: ** In other words, if call like this:
3228: **
3229: ** sqlite3SrcListAppend(D,A,B,0);
3230: **
3231: ** Then B is a table name and the database name is unspecified. If called
3232: ** like this:
3233: **
3234: ** sqlite3SrcListAppend(D,A,B,C);
3235: **
3236: ** Then C is the table name and B is the database name. If C is defined
3237: ** then so is B. In other words, we never have a case where:
3238: **
3239: ** sqlite3SrcListAppend(D,A,0,C);
3240: **
3241: ** Both pTable and pDatabase are assumed to be quoted. They are dequoted
3242: ** before being added to the SrcList.
3243: */
3244: SrcList *sqlite3SrcListAppend(
3245: sqlite3 *db, /* Connection to notify of malloc failures */
3246: SrcList *pList, /* Append to this SrcList. NULL creates a new SrcList */
3247: Token *pTable, /* Table to append */
3248: Token *pDatabase /* Database of the table */
3249: ){
3250: struct SrcList_item *pItem;
3251: assert( pDatabase==0 || pTable!=0 ); /* Cannot have C without B */
3252: if( pList==0 ){
3253: pList = sqlite3DbMallocZero(db, sizeof(SrcList) );
3254: if( pList==0 ) return 0;
3255: pList->nAlloc = 1;
3256: }
3257: pList = sqlite3SrcListEnlarge(db, pList, 1, pList->nSrc);
3258: if( db->mallocFailed ){
3259: sqlite3SrcListDelete(db, pList);
3260: return 0;
3261: }
3262: pItem = &pList->a[pList->nSrc-1];
3263: if( pDatabase && pDatabase->z==0 ){
3264: pDatabase = 0;
3265: }
3266: if( pDatabase ){
3267: Token *pTemp = pDatabase;
3268: pDatabase = pTable;
3269: pTable = pTemp;
3270: }
3271: pItem->zName = sqlite3NameFromToken(db, pTable);
3272: pItem->zDatabase = sqlite3NameFromToken(db, pDatabase);
3273: return pList;
3274: }
3275:
3276: /*
3277: ** Assign VdbeCursor index numbers to all tables in a SrcList
3278: */
3279: void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){
3280: int i;
3281: struct SrcList_item *pItem;
3282: assert(pList || pParse->db->mallocFailed );
3283: if( pList ){
3284: for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
3285: if( pItem->iCursor>=0 ) break;
3286: pItem->iCursor = pParse->nTab++;
3287: if( pItem->pSelect ){
3288: sqlite3SrcListAssignCursors(pParse, pItem->pSelect->pSrc);
3289: }
3290: }
3291: }
3292: }
3293:
3294: /*
3295: ** Delete an entire SrcList including all its substructure.
3296: */
3297: void sqlite3SrcListDelete(sqlite3 *db, SrcList *pList){
3298: int i;
3299: struct SrcList_item *pItem;
3300: if( pList==0 ) return;
3301: for(pItem=pList->a, i=0; i<pList->nSrc; i++, pItem++){
3302: sqlite3DbFree(db, pItem->zDatabase);
3303: sqlite3DbFree(db, pItem->zName);
3304: sqlite3DbFree(db, pItem->zAlias);
3305: sqlite3DbFree(db, pItem->zIndex);
3306: sqlite3DeleteTable(db, pItem->pTab);
3307: sqlite3SelectDelete(db, pItem->pSelect);
3308: sqlite3ExprDelete(db, pItem->pOn);
3309: sqlite3IdListDelete(db, pItem->pUsing);
3310: }
3311: sqlite3DbFree(db, pList);
3312: }
3313:
3314: /*
3315: ** This routine is called by the parser to add a new term to the
3316: ** end of a growing FROM clause. The "p" parameter is the part of
3317: ** the FROM clause that has already been constructed. "p" is NULL
3318: ** if this is the first term of the FROM clause. pTable and pDatabase
3319: ** are the name of the table and database named in the FROM clause term.
3320: ** pDatabase is NULL if the database name qualifier is missing - the
3321: ** usual case. If the term has a alias, then pAlias points to the
3322: ** alias token. If the term is a subquery, then pSubquery is the
3323: ** SELECT statement that the subquery encodes. The pTable and
3324: ** pDatabase parameters are NULL for subqueries. The pOn and pUsing
3325: ** parameters are the content of the ON and USING clauses.
3326: **
3327: ** Return a new SrcList which encodes is the FROM with the new
3328: ** term added.
3329: */
3330: SrcList *sqlite3SrcListAppendFromTerm(
3331: Parse *pParse, /* Parsing context */
3332: SrcList *p, /* The left part of the FROM clause already seen */
3333: Token *pTable, /* Name of the table to add to the FROM clause */
3334: Token *pDatabase, /* Name of the database containing pTable */
3335: Token *pAlias, /* The right-hand side of the AS subexpression */
3336: Select *pSubquery, /* A subquery used in place of a table name */
3337: Expr *pOn, /* The ON clause of a join */
3338: IdList *pUsing /* The USING clause of a join */
3339: ){
3340: struct SrcList_item *pItem;
3341: sqlite3 *db = pParse->db;
3342: if( !p && (pOn || pUsing) ){
3343: sqlite3ErrorMsg(pParse, "a JOIN clause is required before %s",
3344: (pOn ? "ON" : "USING")
3345: );
3346: goto append_from_error;
3347: }
3348: p = sqlite3SrcListAppend(db, p, pTable, pDatabase);
3349: if( p==0 || NEVER(p->nSrc==0) ){
3350: goto append_from_error;
3351: }
3352: pItem = &p->a[p->nSrc-1];
3353: assert( pAlias!=0 );
3354: if( pAlias->n ){
3355: pItem->zAlias = sqlite3NameFromToken(db, pAlias);
3356: }
3357: pItem->pSelect = pSubquery;
3358: pItem->pOn = pOn;
3359: pItem->pUsing = pUsing;
3360: return p;
3361:
3362: append_from_error:
3363: assert( p==0 );
3364: sqlite3ExprDelete(db, pOn);
3365: sqlite3IdListDelete(db, pUsing);
3366: sqlite3SelectDelete(db, pSubquery);
3367: return 0;
3368: }
3369:
3370: /*
3371: ** Add an INDEXED BY or NOT INDEXED clause to the most recently added
3372: ** element of the source-list passed as the second argument.
3373: */
3374: void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){
3375: assert( pIndexedBy!=0 );
3376: if( p && ALWAYS(p->nSrc>0) ){
3377: struct SrcList_item *pItem = &p->a[p->nSrc-1];
3378: assert( pItem->notIndexed==0 && pItem->zIndex==0 );
3379: if( pIndexedBy->n==1 && !pIndexedBy->z ){
3380: /* A "NOT INDEXED" clause was supplied. See parse.y
3381: ** construct "indexed_opt" for details. */
3382: pItem->notIndexed = 1;
3383: }else{
3384: pItem->zIndex = sqlite3NameFromToken(pParse->db, pIndexedBy);
3385: }
3386: }
3387: }
3388:
3389: /*
3390: ** When building up a FROM clause in the parser, the join operator
3391: ** is initially attached to the left operand. But the code generator
3392: ** expects the join operator to be on the right operand. This routine
3393: ** Shifts all join operators from left to right for an entire FROM
3394: ** clause.
3395: **
3396: ** Example: Suppose the join is like this:
3397: **
3398: ** A natural cross join B
3399: **
3400: ** The operator is "natural cross join". The A and B operands are stored
3401: ** in p->a[0] and p->a[1], respectively. The parser initially stores the
3402: ** operator with A. This routine shifts that operator over to B.
3403: */
3404: void sqlite3SrcListShiftJoinType(SrcList *p){
3405: if( p ){
3406: int i;
3407: assert( p->a || p->nSrc==0 );
3408: for(i=p->nSrc-1; i>0; i--){
3409: p->a[i].jointype = p->a[i-1].jointype;
3410: }
3411: p->a[0].jointype = 0;
3412: }
3413: }
3414:
3415: /*
3416: ** Begin a transaction
3417: */
3418: void sqlite3BeginTransaction(Parse *pParse, int type){
3419: sqlite3 *db;
3420: Vdbe *v;
3421: int i;
3422:
3423: assert( pParse!=0 );
3424: db = pParse->db;
3425: assert( db!=0 );
3426: /* if( db->aDb[0].pBt==0 ) return; */
3427: if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ){
3428: return;
3429: }
3430: v = sqlite3GetVdbe(pParse);
3431: if( !v ) return;
3432: if( type!=TK_DEFERRED ){
3433: for(i=0; i<db->nDb; i++){
3434: sqlite3VdbeAddOp2(v, OP_Transaction, i, (type==TK_EXCLUSIVE)+1);
3435: sqlite3VdbeUsesBtree(v, i);
3436: }
3437: }
3438: sqlite3VdbeAddOp2(v, OP_AutoCommit, 0, 0);
3439: }
3440:
3441: /*
3442: ** Commit a transaction
3443: */
3444: void sqlite3CommitTransaction(Parse *pParse){
3445: Vdbe *v;
3446:
3447: assert( pParse!=0 );
3448: assert( pParse->db!=0 );
3449: if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "COMMIT", 0, 0) ){
3450: return;
3451: }
3452: v = sqlite3GetVdbe(pParse);
3453: if( v ){
3454: sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, 0);
3455: }
3456: }
3457:
3458: /*
3459: ** Rollback a transaction
3460: */
3461: void sqlite3RollbackTransaction(Parse *pParse){
3462: Vdbe *v;
3463:
3464: assert( pParse!=0 );
3465: assert( pParse->db!=0 );
3466: if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "ROLLBACK", 0, 0) ){
3467: return;
3468: }
3469: v = sqlite3GetVdbe(pParse);
3470: if( v ){
3471: sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, 1);
3472: }
3473: }
3474:
3475: /*
3476: ** This function is called by the parser when it parses a command to create,
3477: ** release or rollback an SQL savepoint.
3478: */
3479: void sqlite3Savepoint(Parse *pParse, int op, Token *pName){
3480: char *zName = sqlite3NameFromToken(pParse->db, pName);
3481: if( zName ){
3482: Vdbe *v = sqlite3GetVdbe(pParse);
3483: #ifndef SQLITE_OMIT_AUTHORIZATION
3484: static const char * const az[] = { "BEGIN", "RELEASE", "ROLLBACK" };
3485: assert( !SAVEPOINT_BEGIN && SAVEPOINT_RELEASE==1 && SAVEPOINT_ROLLBACK==2 );
3486: #endif
3487: if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
3488: sqlite3DbFree(pParse->db, zName);
3489: return;
3490: }
3491: sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
3492: }
3493: }
3494:
3495: /*
3496: ** Make sure the TEMP database is open and available for use. Return
3497: ** the number of errors. Leave any error messages in the pParse structure.
3498: */
3499: int sqlite3OpenTempDatabase(Parse *pParse){
3500: sqlite3 *db = pParse->db;
3501: if( db->aDb[1].pBt==0 && !pParse->explain ){
3502: int rc;
3503: Btree *pBt;
3504: static const int flags =
3505: SQLITE_OPEN_READWRITE |
3506: SQLITE_OPEN_CREATE |
3507: SQLITE_OPEN_EXCLUSIVE |
3508: SQLITE_OPEN_DELETEONCLOSE |
3509: SQLITE_OPEN_TEMP_DB;
3510:
3511: rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pBt, 0, flags);
3512: if( rc!=SQLITE_OK ){
3513: sqlite3ErrorMsg(pParse, "unable to open a temporary database "
3514: "file for storing temporary tables");
3515: pParse->rc = rc;
3516: return 1;
3517: }
3518: db->aDb[1].pBt = pBt;
3519: assert( db->aDb[1].pSchema );
3520: if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, -1, 0) ){
3521: db->mallocFailed = 1;
3522: return 1;
3523: }
3524: }
3525: return 0;
3526: }
3527:
3528: /*
3529: ** Generate VDBE code that will verify the schema cookie and start
3530: ** a read-transaction for all named database files.
3531: **
3532: ** It is important that all schema cookies be verified and all
3533: ** read transactions be started before anything else happens in
3534: ** the VDBE program. But this routine can be called after much other
3535: ** code has been generated. So here is what we do:
3536: **
3537: ** The first time this routine is called, we code an OP_Goto that
3538: ** will jump to a subroutine at the end of the program. Then we
3539: ** record every database that needs its schema verified in the
3540: ** pParse->cookieMask field. Later, after all other code has been
3541: ** generated, the subroutine that does the cookie verifications and
3542: ** starts the transactions will be coded and the OP_Goto P2 value
3543: ** will be made to point to that subroutine. The generation of the
3544: ** cookie verification subroutine code happens in sqlite3FinishCoding().
3545: **
3546: ** If iDb<0 then code the OP_Goto only - don't set flag to verify the
3547: ** schema on any databases. This can be used to position the OP_Goto
3548: ** early in the code, before we know if any database tables will be used.
3549: */
3550: void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
3551: Parse *pToplevel = sqlite3ParseToplevel(pParse);
3552:
3553: if( pToplevel->cookieGoto==0 ){
3554: Vdbe *v = sqlite3GetVdbe(pToplevel);
3555: if( v==0 ) return; /* This only happens if there was a prior error */
3556: pToplevel->cookieGoto = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0)+1;
3557: }
3558: if( iDb>=0 ){
3559: sqlite3 *db = pToplevel->db;
3560: yDbMask mask;
3561:
3562: assert( iDb<db->nDb );
3563: assert( db->aDb[iDb].pBt!=0 || iDb==1 );
3564: assert( iDb<SQLITE_MAX_ATTACHED+2 );
3565: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
3566: mask = ((yDbMask)1)<<iDb;
3567: if( (pToplevel->cookieMask & mask)==0 ){
3568: pToplevel->cookieMask |= mask;
3569: pToplevel->cookieValue[iDb] = db->aDb[iDb].pSchema->schema_cookie;
3570: if( !OMIT_TEMPDB && iDb==1 ){
3571: sqlite3OpenTempDatabase(pToplevel);
3572: }
3573: }
3574: }
3575: }
3576:
3577: /*
3578: ** If argument zDb is NULL, then call sqlite3CodeVerifySchema() for each
3579: ** attached database. Otherwise, invoke it for the database named zDb only.
3580: */
3581: void sqlite3CodeVerifyNamedSchema(Parse *pParse, const char *zDb){
3582: sqlite3 *db = pParse->db;
3583: int i;
3584: for(i=0; i<db->nDb; i++){
3585: Db *pDb = &db->aDb[i];
3586: if( pDb->pBt && (!zDb || 0==sqlite3StrICmp(zDb, pDb->zName)) ){
3587: sqlite3CodeVerifySchema(pParse, i);
3588: }
3589: }
3590: }
3591:
3592: /*
3593: ** Generate VDBE code that prepares for doing an operation that
3594: ** might change the database.
3595: **
3596: ** This routine starts a new transaction if we are not already within
3597: ** a transaction. If we are already within a transaction, then a checkpoint
3598: ** is set if the setStatement parameter is true. A checkpoint should
3599: ** be set for operations that might fail (due to a constraint) part of
3600: ** the way through and which will need to undo some writes without having to
3601: ** rollback the whole transaction. For operations where all constraints
3602: ** can be checked before any changes are made to the database, it is never
3603: ** necessary to undo a write and the checkpoint should not be set.
3604: */
3605: void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
3606: Parse *pToplevel = sqlite3ParseToplevel(pParse);
3607: sqlite3CodeVerifySchema(pParse, iDb);
3608: pToplevel->writeMask |= ((yDbMask)1)<<iDb;
3609: pToplevel->isMultiWrite |= setStatement;
3610: }
3611:
3612: /*
3613: ** Indicate that the statement currently under construction might write
3614: ** more than one entry (example: deleting one row then inserting another,
3615: ** inserting multiple rows in a table, or inserting a row and index entries.)
3616: ** If an abort occurs after some of these writes have completed, then it will
3617: ** be necessary to undo the completed writes.
3618: */
3619: void sqlite3MultiWrite(Parse *pParse){
3620: Parse *pToplevel = sqlite3ParseToplevel(pParse);
3621: pToplevel->isMultiWrite = 1;
3622: }
3623:
3624: /*
3625: ** The code generator calls this routine if is discovers that it is
3626: ** possible to abort a statement prior to completion. In order to
3627: ** perform this abort without corrupting the database, we need to make
3628: ** sure that the statement is protected by a statement transaction.
3629: **
3630: ** Technically, we only need to set the mayAbort flag if the
3631: ** isMultiWrite flag was previously set. There is a time dependency
3632: ** such that the abort must occur after the multiwrite. This makes
3633: ** some statements involving the REPLACE conflict resolution algorithm
3634: ** go a little faster. But taking advantage of this time dependency
3635: ** makes it more difficult to prove that the code is correct (in
3636: ** particular, it prevents us from writing an effective
3637: ** implementation of sqlite3AssertMayAbort()) and so we have chosen
3638: ** to take the safe route and skip the optimization.
3639: */
3640: void sqlite3MayAbort(Parse *pParse){
3641: Parse *pToplevel = sqlite3ParseToplevel(pParse);
3642: pToplevel->mayAbort = 1;
3643: }
3644:
3645: /*
3646: ** Code an OP_Halt that causes the vdbe to return an SQLITE_CONSTRAINT
3647: ** error. The onError parameter determines which (if any) of the statement
3648: ** and/or current transaction is rolled back.
3649: */
3650: void sqlite3HaltConstraint(Parse *pParse, int onError, char *p4, int p4type){
3651: Vdbe *v = sqlite3GetVdbe(pParse);
3652: if( onError==OE_Abort ){
3653: sqlite3MayAbort(pParse);
3654: }
3655: sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CONSTRAINT, onError, 0, p4, p4type);
3656: }
3657:
3658: /*
3659: ** Check to see if pIndex uses the collating sequence pColl. Return
3660: ** true if it does and false if it does not.
3661: */
3662: #ifndef SQLITE_OMIT_REINDEX
3663: static int collationMatch(const char *zColl, Index *pIndex){
3664: int i;
3665: assert( zColl!=0 );
3666: for(i=0; i<pIndex->nColumn; i++){
3667: const char *z = pIndex->azColl[i];
3668: assert( z!=0 );
3669: if( 0==sqlite3StrICmp(z, zColl) ){
3670: return 1;
3671: }
3672: }
3673: return 0;
3674: }
3675: #endif
3676:
3677: /*
3678: ** Recompute all indices of pTab that use the collating sequence pColl.
3679: ** If pColl==0 then recompute all indices of pTab.
3680: */
3681: #ifndef SQLITE_OMIT_REINDEX
3682: static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){
3683: Index *pIndex; /* An index associated with pTab */
3684:
3685: for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
3686: if( zColl==0 || collationMatch(zColl, pIndex) ){
3687: int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
3688: sqlite3BeginWriteOperation(pParse, 0, iDb);
3689: sqlite3RefillIndex(pParse, pIndex, -1);
3690: }
3691: }
3692: }
3693: #endif
3694:
3695: /*
3696: ** Recompute all indices of all tables in all databases where the
3697: ** indices use the collating sequence pColl. If pColl==0 then recompute
3698: ** all indices everywhere.
3699: */
3700: #ifndef SQLITE_OMIT_REINDEX
3701: static void reindexDatabases(Parse *pParse, char const *zColl){
3702: Db *pDb; /* A single database */
3703: int iDb; /* The database index number */
3704: sqlite3 *db = pParse->db; /* The database connection */
3705: HashElem *k; /* For looping over tables in pDb */
3706: Table *pTab; /* A table in the database */
3707:
3708: assert( sqlite3BtreeHoldsAllMutexes(db) ); /* Needed for schema access */
3709: for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
3710: assert( pDb!=0 );
3711: for(k=sqliteHashFirst(&pDb->pSchema->tblHash); k; k=sqliteHashNext(k)){
3712: pTab = (Table*)sqliteHashData(k);
3713: reindexTable(pParse, pTab, zColl);
3714: }
3715: }
3716: }
3717: #endif
3718:
3719: /*
3720: ** Generate code for the REINDEX command.
3721: **
3722: ** REINDEX -- 1
3723: ** REINDEX <collation> -- 2
3724: ** REINDEX ?<database>.?<tablename> -- 3
3725: ** REINDEX ?<database>.?<indexname> -- 4
3726: **
3727: ** Form 1 causes all indices in all attached databases to be rebuilt.
3728: ** Form 2 rebuilds all indices in all databases that use the named
3729: ** collating function. Forms 3 and 4 rebuild the named index or all
3730: ** indices associated with the named table.
3731: */
3732: #ifndef SQLITE_OMIT_REINDEX
3733: void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){
3734: CollSeq *pColl; /* Collating sequence to be reindexed, or NULL */
3735: char *z; /* Name of a table or index */
3736: const char *zDb; /* Name of the database */
3737: Table *pTab; /* A table in the database */
3738: Index *pIndex; /* An index associated with pTab */
3739: int iDb; /* The database index number */
3740: sqlite3 *db = pParse->db; /* The database connection */
3741: Token *pObjName; /* Name of the table or index to be reindexed */
3742:
3743: /* Read the database schema. If an error occurs, leave an error message
3744: ** and code in pParse and return NULL. */
3745: if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
3746: return;
3747: }
3748:
3749: if( pName1==0 ){
3750: reindexDatabases(pParse, 0);
3751: return;
3752: }else if( NEVER(pName2==0) || pName2->z==0 ){
3753: char *zColl;
3754: assert( pName1->z );
3755: zColl = sqlite3NameFromToken(pParse->db, pName1);
3756: if( !zColl ) return;
3757: pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
3758: if( pColl ){
3759: reindexDatabases(pParse, zColl);
3760: sqlite3DbFree(db, zColl);
3761: return;
3762: }
3763: sqlite3DbFree(db, zColl);
3764: }
3765: iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName);
3766: if( iDb<0 ) return;
3767: z = sqlite3NameFromToken(db, pObjName);
3768: if( z==0 ) return;
3769: zDb = db->aDb[iDb].zName;
3770: pTab = sqlite3FindTable(db, z, zDb);
3771: if( pTab ){
3772: reindexTable(pParse, pTab, 0);
3773: sqlite3DbFree(db, z);
3774: return;
3775: }
3776: pIndex = sqlite3FindIndex(db, z, zDb);
3777: sqlite3DbFree(db, z);
3778: if( pIndex ){
3779: sqlite3BeginWriteOperation(pParse, 0, iDb);
3780: sqlite3RefillIndex(pParse, pIndex, -1);
3781: return;
3782: }
3783: sqlite3ErrorMsg(pParse, "unable to identify the object to be reindexed");
3784: }
3785: #endif
3786:
3787: /*
3788: ** Return a dynamicly allocated KeyInfo structure that can be used
3789: ** with OP_OpenRead or OP_OpenWrite to access database index pIdx.
3790: **
3791: ** If successful, a pointer to the new structure is returned. In this case
3792: ** the caller is responsible for calling sqlite3DbFree(db, ) on the returned
3793: ** pointer. If an error occurs (out of memory or missing collation
3794: ** sequence), NULL is returned and the state of pParse updated to reflect
3795: ** the error.
3796: */
3797: KeyInfo *sqlite3IndexKeyinfo(Parse *pParse, Index *pIdx){
3798: int i;
3799: int nCol = pIdx->nColumn;
3800: int nBytes = sizeof(KeyInfo) + (nCol-1)*sizeof(CollSeq*) + nCol;
3801: sqlite3 *db = pParse->db;
3802: KeyInfo *pKey = (KeyInfo *)sqlite3DbMallocZero(db, nBytes);
3803:
3804: if( pKey ){
3805: pKey->db = pParse->db;
3806: pKey->aSortOrder = (u8 *)&(pKey->aColl[nCol]);
3807: assert( &pKey->aSortOrder[nCol]==&(((u8 *)pKey)[nBytes]) );
3808: for(i=0; i<nCol; i++){
3809: char *zColl = pIdx->azColl[i];
3810: assert( zColl );
3811: pKey->aColl[i] = sqlite3LocateCollSeq(pParse, zColl);
3812: pKey->aSortOrder[i] = pIdx->aSortOrder[i];
3813: }
3814: pKey->nField = (u16)nCol;
3815: }
3816:
3817: if( pParse->nErr ){
3818: sqlite3DbFree(db, pKey);
3819: pKey = 0;
3820: }
3821: return pKey;
3822: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to build.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src