1: /*
2: ** 2005 February 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 used to generate VDBE code
13: ** that implements the ALTER TABLE command.
14: */
15: #include "sqliteInt.h"
16:
17: /*
18: ** The code in this file only exists if we are not omitting the
19: ** ALTER TABLE logic from the build.
20: */
21: #ifndef SQLITE_OMIT_ALTERTABLE
22:
23:
24: /*
25: ** This function is used by SQL generated to implement the
26: ** ALTER TABLE command. The first argument is the text of a CREATE TABLE or
27: ** CREATE INDEX command. The second is a table name. The table name in
28: ** the CREATE TABLE or CREATE INDEX statement is replaced with the third
29: ** argument and the result returned. Examples:
30: **
31: ** sqlite_rename_table('CREATE TABLE abc(a, b, c)', 'def')
32: ** -> 'CREATE TABLE def(a, b, c)'
33: **
34: ** sqlite_rename_table('CREATE INDEX i ON abc(a)', 'def')
35: ** -> 'CREATE INDEX i ON def(a, b, c)'
36: */
37: static void renameTableFunc(
38: sqlite3_context *context,
39: int NotUsed,
40: sqlite3_value **argv
41: ){
42: unsigned char const *zSql = sqlite3_value_text(argv[0]);
43: unsigned char const *zTableName = sqlite3_value_text(argv[1]);
44:
45: int token;
46: Token tname;
47: unsigned char const *zCsr = zSql;
48: int len = 0;
49: char *zRet;
50:
51: sqlite3 *db = sqlite3_context_db_handle(context);
52:
53: UNUSED_PARAMETER(NotUsed);
54:
55: /* The principle used to locate the table name in the CREATE TABLE
56: ** statement is that the table name is the first non-space token that
57: ** is immediately followed by a TK_LP or TK_USING token.
58: */
59: if( zSql ){
60: do {
61: if( !*zCsr ){
62: /* Ran out of input before finding an opening bracket. Return NULL. */
63: return;
64: }
65:
66: /* Store the token that zCsr points to in tname. */
67: tname.z = (char*)zCsr;
68: tname.n = len;
69:
70: /* Advance zCsr to the next token. Store that token type in 'token',
71: ** and its length in 'len' (to be used next iteration of this loop).
72: */
73: do {
74: zCsr += len;
75: len = sqlite3GetToken(zCsr, &token);
76: } while( token==TK_SPACE );
77: assert( len>0 );
78: } while( token!=TK_LP && token!=TK_USING );
79:
80: zRet = sqlite3MPrintf(db, "%.*s\"%w\"%s", ((u8*)tname.z) - zSql, zSql,
81: zTableName, tname.z+tname.n);
82: sqlite3_result_text(context, zRet, -1, SQLITE_DYNAMIC);
83: }
84: }
85:
86: /*
87: ** This C function implements an SQL user function that is used by SQL code
88: ** generated by the ALTER TABLE ... RENAME command to modify the definition
89: ** of any foreign key constraints that use the table being renamed as the
90: ** parent table. It is passed three arguments:
91: **
92: ** 1) The complete text of the CREATE TABLE statement being modified,
93: ** 2) The old name of the table being renamed, and
94: ** 3) The new name of the table being renamed.
95: **
96: ** It returns the new CREATE TABLE statement. For example:
97: **
98: ** sqlite_rename_parent('CREATE TABLE t1(a REFERENCES t2)', 't2', 't3')
99: ** -> 'CREATE TABLE t1(a REFERENCES t3)'
100: */
101: #ifndef SQLITE_OMIT_FOREIGN_KEY
102: static void renameParentFunc(
103: sqlite3_context *context,
104: int NotUsed,
105: sqlite3_value **argv
106: ){
107: sqlite3 *db = sqlite3_context_db_handle(context);
108: char *zOutput = 0;
109: char *zResult;
110: unsigned char const *zInput = sqlite3_value_text(argv[0]);
111: unsigned char const *zOld = sqlite3_value_text(argv[1]);
112: unsigned char const *zNew = sqlite3_value_text(argv[2]);
113:
114: unsigned const char *z; /* Pointer to token */
115: int n; /* Length of token z */
116: int token; /* Type of token */
117:
118: UNUSED_PARAMETER(NotUsed);
119: for(z=zInput; *z; z=z+n){
120: n = sqlite3GetToken(z, &token);
121: if( token==TK_REFERENCES ){
122: char *zParent;
123: do {
124: z += n;
125: n = sqlite3GetToken(z, &token);
126: }while( token==TK_SPACE );
127:
128: zParent = sqlite3DbStrNDup(db, (const char *)z, n);
129: if( zParent==0 ) break;
130: sqlite3Dequote(zParent);
131: if( 0==sqlite3StrICmp((const char *)zOld, zParent) ){
132: char *zOut = sqlite3MPrintf(db, "%s%.*s\"%w\"",
133: (zOutput?zOutput:""), z-zInput, zInput, (const char *)zNew
134: );
135: sqlite3DbFree(db, zOutput);
136: zOutput = zOut;
137: zInput = &z[n];
138: }
139: sqlite3DbFree(db, zParent);
140: }
141: }
142:
143: zResult = sqlite3MPrintf(db, "%s%s", (zOutput?zOutput:""), zInput),
144: sqlite3_result_text(context, zResult, -1, SQLITE_DYNAMIC);
145: sqlite3DbFree(db, zOutput);
146: }
147: #endif
148:
149: #ifndef SQLITE_OMIT_TRIGGER
150: /* This function is used by SQL generated to implement the
151: ** ALTER TABLE command. The first argument is the text of a CREATE TRIGGER
152: ** statement. The second is a table name. The table name in the CREATE
153: ** TRIGGER statement is replaced with the third argument and the result
154: ** returned. This is analagous to renameTableFunc() above, except for CREATE
155: ** TRIGGER, not CREATE INDEX and CREATE TABLE.
156: */
157: static void renameTriggerFunc(
158: sqlite3_context *context,
159: int NotUsed,
160: sqlite3_value **argv
161: ){
162: unsigned char const *zSql = sqlite3_value_text(argv[0]);
163: unsigned char const *zTableName = sqlite3_value_text(argv[1]);
164:
165: int token;
166: Token tname;
167: int dist = 3;
168: unsigned char const *zCsr = zSql;
169: int len = 0;
170: char *zRet;
171: sqlite3 *db = sqlite3_context_db_handle(context);
172:
173: UNUSED_PARAMETER(NotUsed);
174:
175: /* The principle used to locate the table name in the CREATE TRIGGER
176: ** statement is that the table name is the first token that is immediatedly
177: ** preceded by either TK_ON or TK_DOT and immediatedly followed by one
178: ** of TK_WHEN, TK_BEGIN or TK_FOR.
179: */
180: if( zSql ){
181: do {
182:
183: if( !*zCsr ){
184: /* Ran out of input before finding the table name. Return NULL. */
185: return;
186: }
187:
188: /* Store the token that zCsr points to in tname. */
189: tname.z = (char*)zCsr;
190: tname.n = len;
191:
192: /* Advance zCsr to the next token. Store that token type in 'token',
193: ** and its length in 'len' (to be used next iteration of this loop).
194: */
195: do {
196: zCsr += len;
197: len = sqlite3GetToken(zCsr, &token);
198: }while( token==TK_SPACE );
199: assert( len>0 );
200:
201: /* Variable 'dist' stores the number of tokens read since the most
202: ** recent TK_DOT or TK_ON. This means that when a WHEN, FOR or BEGIN
203: ** token is read and 'dist' equals 2, the condition stated above
204: ** to be met.
205: **
206: ** Note that ON cannot be a database, table or column name, so
207: ** there is no need to worry about syntax like
208: ** "CREATE TRIGGER ... ON ON.ON BEGIN ..." etc.
209: */
210: dist++;
211: if( token==TK_DOT || token==TK_ON ){
212: dist = 0;
213: }
214: } while( dist!=2 || (token!=TK_WHEN && token!=TK_FOR && token!=TK_BEGIN) );
215:
216: /* Variable tname now contains the token that is the old table-name
217: ** in the CREATE TRIGGER statement.
218: */
219: zRet = sqlite3MPrintf(db, "%.*s\"%w\"%s", ((u8*)tname.z) - zSql, zSql,
220: zTableName, tname.z+tname.n);
221: sqlite3_result_text(context, zRet, -1, SQLITE_DYNAMIC);
222: }
223: }
224: #endif /* !SQLITE_OMIT_TRIGGER */
225:
226: /*
227: ** Register built-in functions used to help implement ALTER TABLE
228: */
229: void sqlite3AlterFunctions(void){
230: static SQLITE_WSD FuncDef aAlterTableFuncs[] = {
231: FUNCTION(sqlite_rename_table, 2, 0, 0, renameTableFunc),
232: #ifndef SQLITE_OMIT_TRIGGER
233: FUNCTION(sqlite_rename_trigger, 2, 0, 0, renameTriggerFunc),
234: #endif
235: #ifndef SQLITE_OMIT_FOREIGN_KEY
236: FUNCTION(sqlite_rename_parent, 3, 0, 0, renameParentFunc),
237: #endif
238: };
239: int i;
240: FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions);
241: FuncDef *aFunc = (FuncDef*)&GLOBAL(FuncDef, aAlterTableFuncs);
242:
243: for(i=0; i<ArraySize(aAlterTableFuncs); i++){
244: sqlite3FuncDefInsert(pHash, &aFunc[i]);
245: }
246: }
247:
248: /*
249: ** This function is used to create the text of expressions of the form:
250: **
251: ** name=<constant1> OR name=<constant2> OR ...
252: **
253: ** If argument zWhere is NULL, then a pointer string containing the text
254: ** "name=<constant>" is returned, where <constant> is the quoted version
255: ** of the string passed as argument zConstant. The returned buffer is
256: ** allocated using sqlite3DbMalloc(). It is the responsibility of the
257: ** caller to ensure that it is eventually freed.
258: **
259: ** If argument zWhere is not NULL, then the string returned is
260: ** "<where> OR name=<constant>", where <where> is the contents of zWhere.
261: ** In this case zWhere is passed to sqlite3DbFree() before returning.
262: **
263: */
264: static char *whereOrName(sqlite3 *db, char *zWhere, char *zConstant){
265: char *zNew;
266: if( !zWhere ){
267: zNew = sqlite3MPrintf(db, "name=%Q", zConstant);
268: }else{
269: zNew = sqlite3MPrintf(db, "%s OR name=%Q", zWhere, zConstant);
270: sqlite3DbFree(db, zWhere);
271: }
272: return zNew;
273: }
274:
275: #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
276: /*
277: ** Generate the text of a WHERE expression which can be used to select all
278: ** tables that have foreign key constraints that refer to table pTab (i.e.
279: ** constraints for which pTab is the parent table) from the sqlite_master
280: ** table.
281: */
282: static char *whereForeignKeys(Parse *pParse, Table *pTab){
283: FKey *p;
284: char *zWhere = 0;
285: for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
286: zWhere = whereOrName(pParse->db, zWhere, p->pFrom->zName);
287: }
288: return zWhere;
289: }
290: #endif
291:
292: /*
293: ** Generate the text of a WHERE expression which can be used to select all
294: ** temporary triggers on table pTab from the sqlite_temp_master table. If
295: ** table pTab has no temporary triggers, or is itself stored in the
296: ** temporary database, NULL is returned.
297: */
298: static char *whereTempTriggers(Parse *pParse, Table *pTab){
299: Trigger *pTrig;
300: char *zWhere = 0;
301: const Schema *pTempSchema = pParse->db->aDb[1].pSchema; /* Temp db schema */
302:
303: /* If the table is not located in the temp-db (in which case NULL is
304: ** returned, loop through the tables list of triggers. For each trigger
305: ** that is not part of the temp-db schema, add a clause to the WHERE
306: ** expression being built up in zWhere.
307: */
308: if( pTab->pSchema!=pTempSchema ){
309: sqlite3 *db = pParse->db;
310: for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
311: if( pTrig->pSchema==pTempSchema ){
312: zWhere = whereOrName(db, zWhere, pTrig->zName);
313: }
314: }
315: }
316: if( zWhere ){
317: char *zNew = sqlite3MPrintf(pParse->db, "type='trigger' AND (%s)", zWhere);
318: sqlite3DbFree(pParse->db, zWhere);
319: zWhere = zNew;
320: }
321: return zWhere;
322: }
323:
324: /*
325: ** Generate code to drop and reload the internal representation of table
326: ** pTab from the database, including triggers and temporary triggers.
327: ** Argument zName is the name of the table in the database schema at
328: ** the time the generated code is executed. This can be different from
329: ** pTab->zName if this function is being called to code part of an
330: ** "ALTER TABLE RENAME TO" statement.
331: */
332: static void reloadTableSchema(Parse *pParse, Table *pTab, const char *zName){
333: Vdbe *v;
334: char *zWhere;
335: int iDb; /* Index of database containing pTab */
336: #ifndef SQLITE_OMIT_TRIGGER
337: Trigger *pTrig;
338: #endif
339:
340: v = sqlite3GetVdbe(pParse);
341: if( NEVER(v==0) ) return;
342: assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
343: iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
344: assert( iDb>=0 );
345:
346: #ifndef SQLITE_OMIT_TRIGGER
347: /* Drop any table triggers from the internal schema. */
348: for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
349: int iTrigDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
350: assert( iTrigDb==iDb || iTrigDb==1 );
351: sqlite3VdbeAddOp4(v, OP_DropTrigger, iTrigDb, 0, 0, pTrig->zName, 0);
352: }
353: #endif
354:
355: /* Drop the table and index from the internal schema. */
356: sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
357:
358: /* Reload the table, index and permanent trigger schemas. */
359: zWhere = sqlite3MPrintf(pParse->db, "tbl_name=%Q", zName);
360: if( !zWhere ) return;
361: sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere);
362:
363: #ifndef SQLITE_OMIT_TRIGGER
364: /* Now, if the table is not stored in the temp database, reload any temp
365: ** triggers. Don't use IN(...) in case SQLITE_OMIT_SUBQUERY is defined.
366: */
367: if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){
368: sqlite3VdbeAddParseSchemaOp(v, 1, zWhere);
369: }
370: #endif
371: }
372:
373: /*
374: ** Parameter zName is the name of a table that is about to be altered
375: ** (either with ALTER TABLE ... RENAME TO or ALTER TABLE ... ADD COLUMN).
376: ** If the table is a system table, this function leaves an error message
377: ** in pParse->zErr (system tables may not be altered) and returns non-zero.
378: **
379: ** Or, if zName is not a system table, zero is returned.
380: */
381: static int isSystemTable(Parse *pParse, const char *zName){
382: if( sqlite3Strlen30(zName)>6 && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){
383: sqlite3ErrorMsg(pParse, "table %s may not be altered", zName);
384: return 1;
385: }
386: return 0;
387: }
388:
389: /*
390: ** Generate code to implement the "ALTER TABLE xxx RENAME TO yyy"
391: ** command.
392: */
393: void sqlite3AlterRenameTable(
394: Parse *pParse, /* Parser context. */
395: SrcList *pSrc, /* The table to rename. */
396: Token *pName /* The new table name. */
397: ){
398: int iDb; /* Database that contains the table */
399: char *zDb; /* Name of database iDb */
400: Table *pTab; /* Table being renamed */
401: char *zName = 0; /* NULL-terminated version of pName */
402: sqlite3 *db = pParse->db; /* Database connection */
403: int nTabName; /* Number of UTF-8 characters in zTabName */
404: const char *zTabName; /* Original name of the table */
405: Vdbe *v;
406: #ifndef SQLITE_OMIT_TRIGGER
407: char *zWhere = 0; /* Where clause to locate temp triggers */
408: #endif
409: VTable *pVTab = 0; /* Non-zero if this is a v-tab with an xRename() */
410: int savedDbFlags; /* Saved value of db->flags */
411:
412: savedDbFlags = db->flags;
413: if( NEVER(db->mallocFailed) ) goto exit_rename_table;
414: assert( pSrc->nSrc==1 );
415: assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
416:
417: pTab = sqlite3LocateTable(pParse, 0, pSrc->a[0].zName, pSrc->a[0].zDatabase);
418: if( !pTab ) goto exit_rename_table;
419: iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
420: zDb = db->aDb[iDb].zName;
421: db->flags |= SQLITE_PreferBuiltin;
422:
423: /* Get a NULL terminated version of the new table name. */
424: zName = sqlite3NameFromToken(db, pName);
425: if( !zName ) goto exit_rename_table;
426:
427: /* Check that a table or index named 'zName' does not already exist
428: ** in database iDb. If so, this is an error.
429: */
430: if( sqlite3FindTable(db, zName, zDb) || sqlite3FindIndex(db, zName, zDb) ){
431: sqlite3ErrorMsg(pParse,
432: "there is already another table or index with this name: %s", zName);
433: goto exit_rename_table;
434: }
435:
436: /* Make sure it is not a system table being altered, or a reserved name
437: ** that the table is being renamed to.
438: */
439: if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
440: goto exit_rename_table;
441: }
442: if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ goto
443: exit_rename_table;
444: }
445:
446: #ifndef SQLITE_OMIT_VIEW
447: if( pTab->pSelect ){
448: sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
449: goto exit_rename_table;
450: }
451: #endif
452:
453: #ifndef SQLITE_OMIT_AUTHORIZATION
454: /* Invoke the authorization callback. */
455: if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
456: goto exit_rename_table;
457: }
458: #endif
459:
460: #ifndef SQLITE_OMIT_VIRTUALTABLE
461: if( sqlite3ViewGetColumnNames(pParse, pTab) ){
462: goto exit_rename_table;
463: }
464: if( IsVirtual(pTab) ){
465: pVTab = sqlite3GetVTable(db, pTab);
466: if( pVTab->pVtab->pModule->xRename==0 ){
467: pVTab = 0;
468: }
469: }
470: #endif
471:
472: /* Begin a transaction and code the VerifyCookie for database iDb.
473: ** Then modify the schema cookie (since the ALTER TABLE modifies the
474: ** schema). Open a statement transaction if the table is a virtual
475: ** table.
476: */
477: v = sqlite3GetVdbe(pParse);
478: if( v==0 ){
479: goto exit_rename_table;
480: }
481: sqlite3BeginWriteOperation(pParse, pVTab!=0, iDb);
482: sqlite3ChangeCookie(pParse, iDb);
483:
484: /* If this is a virtual table, invoke the xRename() function if
485: ** one is defined. The xRename() callback will modify the names
486: ** of any resources used by the v-table implementation (including other
487: ** SQLite tables) that are identified by the name of the virtual table.
488: */
489: #ifndef SQLITE_OMIT_VIRTUALTABLE
490: if( pVTab ){
491: int i = ++pParse->nMem;
492: sqlite3VdbeAddOp4(v, OP_String8, 0, i, 0, zName, 0);
493: sqlite3VdbeAddOp4(v, OP_VRename, i, 0, 0,(const char*)pVTab, P4_VTAB);
494: sqlite3MayAbort(pParse);
495: }
496: #endif
497:
498: /* figure out how many UTF-8 characters are in zName */
499: zTabName = pTab->zName;
500: nTabName = sqlite3Utf8CharLen(zTabName, -1);
501:
502: #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
503: if( db->flags&SQLITE_ForeignKeys ){
504: /* If foreign-key support is enabled, rewrite the CREATE TABLE
505: ** statements corresponding to all child tables of foreign key constraints
506: ** for which the renamed table is the parent table. */
507: if( (zWhere=whereForeignKeys(pParse, pTab))!=0 ){
508: sqlite3NestedParse(pParse,
509: "UPDATE \"%w\".%s SET "
510: "sql = sqlite_rename_parent(sql, %Q, %Q) "
511: "WHERE %s;", zDb, SCHEMA_TABLE(iDb), zTabName, zName, zWhere);
512: sqlite3DbFree(db, zWhere);
513: }
514: }
515: #endif
516:
517: /* Modify the sqlite_master table to use the new table name. */
518: sqlite3NestedParse(pParse,
519: "UPDATE %Q.%s SET "
520: #ifdef SQLITE_OMIT_TRIGGER
521: "sql = sqlite_rename_table(sql, %Q), "
522: #else
523: "sql = CASE "
524: "WHEN type = 'trigger' THEN sqlite_rename_trigger(sql, %Q)"
525: "ELSE sqlite_rename_table(sql, %Q) END, "
526: #endif
527: "tbl_name = %Q, "
528: "name = CASE "
529: "WHEN type='table' THEN %Q "
530: "WHEN name LIKE 'sqlite_autoindex%%' AND type='index' THEN "
531: "'sqlite_autoindex_' || %Q || substr(name,%d+18) "
532: "ELSE name END "
533: "WHERE tbl_name=%Q AND "
534: "(type='table' OR type='index' OR type='trigger');",
535: zDb, SCHEMA_TABLE(iDb), zName, zName, zName,
536: #ifndef SQLITE_OMIT_TRIGGER
537: zName,
538: #endif
539: zName, nTabName, zTabName
540: );
541:
542: #ifndef SQLITE_OMIT_AUTOINCREMENT
543: /* If the sqlite_sequence table exists in this database, then update
544: ** it with the new table name.
545: */
546: if( sqlite3FindTable(db, "sqlite_sequence", zDb) ){
547: sqlite3NestedParse(pParse,
548: "UPDATE \"%w\".sqlite_sequence set name = %Q WHERE name = %Q",
549: zDb, zName, pTab->zName);
550: }
551: #endif
552:
553: #ifndef SQLITE_OMIT_TRIGGER
554: /* If there are TEMP triggers on this table, modify the sqlite_temp_master
555: ** table. Don't do this if the table being ALTERed is itself located in
556: ** the temp database.
557: */
558: if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){
559: sqlite3NestedParse(pParse,
560: "UPDATE sqlite_temp_master SET "
561: "sql = sqlite_rename_trigger(sql, %Q), "
562: "tbl_name = %Q "
563: "WHERE %s;", zName, zName, zWhere);
564: sqlite3DbFree(db, zWhere);
565: }
566: #endif
567:
568: #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
569: if( db->flags&SQLITE_ForeignKeys ){
570: FKey *p;
571: for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
572: Table *pFrom = p->pFrom;
573: if( pFrom!=pTab ){
574: reloadTableSchema(pParse, p->pFrom, pFrom->zName);
575: }
576: }
577: }
578: #endif
579:
580: /* Drop and reload the internal table schema. */
581: reloadTableSchema(pParse, pTab, zName);
582:
583: exit_rename_table:
584: sqlite3SrcListDelete(db, pSrc);
585: sqlite3DbFree(db, zName);
586: db->flags = savedDbFlags;
587: }
588:
589:
590: /*
591: ** Generate code to make sure the file format number is at least minFormat.
592: ** The generated code will increase the file format number if necessary.
593: */
594: void sqlite3MinimumFileFormat(Parse *pParse, int iDb, int minFormat){
595: Vdbe *v;
596: v = sqlite3GetVdbe(pParse);
597: /* The VDBE should have been allocated before this routine is called.
598: ** If that allocation failed, we would have quit before reaching this
599: ** point */
600: if( ALWAYS(v) ){
601: int r1 = sqlite3GetTempReg(pParse);
602: int r2 = sqlite3GetTempReg(pParse);
603: int j1;
604: sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT);
605: sqlite3VdbeUsesBtree(v, iDb);
606: sqlite3VdbeAddOp2(v, OP_Integer, minFormat, r2);
607: j1 = sqlite3VdbeAddOp3(v, OP_Ge, r2, 0, r1);
608: sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, r2);
609: sqlite3VdbeJumpHere(v, j1);
610: sqlite3ReleaseTempReg(pParse, r1);
611: sqlite3ReleaseTempReg(pParse, r2);
612: }
613: }
614:
615: /*
616: ** This function is called after an "ALTER TABLE ... ADD" statement
617: ** has been parsed. Argument pColDef contains the text of the new
618: ** column definition.
619: **
620: ** The Table structure pParse->pNewTable was extended to include
621: ** the new column during parsing.
622: */
623: void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
624: Table *pNew; /* Copy of pParse->pNewTable */
625: Table *pTab; /* Table being altered */
626: int iDb; /* Database number */
627: const char *zDb; /* Database name */
628: const char *zTab; /* Table name */
629: char *zCol; /* Null-terminated column definition */
630: Column *pCol; /* The new column */
631: Expr *pDflt; /* Default value for the new column */
632: sqlite3 *db; /* The database connection; */
633:
634: db = pParse->db;
635: if( pParse->nErr || db->mallocFailed ) return;
636: pNew = pParse->pNewTable;
637: assert( pNew );
638:
639: assert( sqlite3BtreeHoldsAllMutexes(db) );
640: iDb = sqlite3SchemaToIndex(db, pNew->pSchema);
641: zDb = db->aDb[iDb].zName;
642: zTab = &pNew->zName[16]; /* Skip the "sqlite_altertab_" prefix on the name */
643: pCol = &pNew->aCol[pNew->nCol-1];
644: pDflt = pCol->pDflt;
645: pTab = sqlite3FindTable(db, zTab, zDb);
646: assert( pTab );
647:
648: #ifndef SQLITE_OMIT_AUTHORIZATION
649: /* Invoke the authorization callback. */
650: if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
651: return;
652: }
653: #endif
654:
655: /* If the default value for the new column was specified with a
656: ** literal NULL, then set pDflt to 0. This simplifies checking
657: ** for an SQL NULL default below.
658: */
659: if( pDflt && pDflt->op==TK_NULL ){
660: pDflt = 0;
661: }
662:
663: /* Check that the new column is not specified as PRIMARY KEY or UNIQUE.
664: ** If there is a NOT NULL constraint, then the default value for the
665: ** column must not be NULL.
666: */
667: if( pCol->isPrimKey ){
668: sqlite3ErrorMsg(pParse, "Cannot add a PRIMARY KEY column");
669: return;
670: }
671: if( pNew->pIndex ){
672: sqlite3ErrorMsg(pParse, "Cannot add a UNIQUE column");
673: return;
674: }
675: if( (db->flags&SQLITE_ForeignKeys) && pNew->pFKey && pDflt ){
676: sqlite3ErrorMsg(pParse,
677: "Cannot add a REFERENCES column with non-NULL default value");
678: return;
679: }
680: if( pCol->notNull && !pDflt ){
681: sqlite3ErrorMsg(pParse,
682: "Cannot add a NOT NULL column with default value NULL");
683: return;
684: }
685:
686: /* Ensure the default expression is something that sqlite3ValueFromExpr()
687: ** can handle (i.e. not CURRENT_TIME etc.)
688: */
689: if( pDflt ){
690: sqlite3_value *pVal;
691: if( sqlite3ValueFromExpr(db, pDflt, SQLITE_UTF8, SQLITE_AFF_NONE, &pVal) ){
692: db->mallocFailed = 1;
693: return;
694: }
695: if( !pVal ){
696: sqlite3ErrorMsg(pParse, "Cannot add a column with non-constant default");
697: return;
698: }
699: sqlite3ValueFree(pVal);
700: }
701:
702: /* Modify the CREATE TABLE statement. */
703: zCol = sqlite3DbStrNDup(db, (char*)pColDef->z, pColDef->n);
704: if( zCol ){
705: char *zEnd = &zCol[pColDef->n-1];
706: int savedDbFlags = db->flags;
707: while( zEnd>zCol && (*zEnd==';' || sqlite3Isspace(*zEnd)) ){
708: *zEnd-- = '\0';
709: }
710: db->flags |= SQLITE_PreferBuiltin;
711: sqlite3NestedParse(pParse,
712: "UPDATE \"%w\".%s SET "
713: "sql = substr(sql,1,%d) || ', ' || %Q || substr(sql,%d) "
714: "WHERE type = 'table' AND name = %Q",
715: zDb, SCHEMA_TABLE(iDb), pNew->addColOffset, zCol, pNew->addColOffset+1,
716: zTab
717: );
718: sqlite3DbFree(db, zCol);
719: db->flags = savedDbFlags;
720: }
721:
722: /* If the default value of the new column is NULL, then set the file
723: ** format to 2. If the default value of the new column is not NULL,
724: ** the file format becomes 3.
725: */
726: sqlite3MinimumFileFormat(pParse, iDb, pDflt ? 3 : 2);
727:
728: /* Reload the schema of the modified table. */
729: reloadTableSchema(pParse, pTab, pTab->zName);
730: }
731:
732: /*
733: ** This function is called by the parser after the table-name in
734: ** an "ALTER TABLE <table-name> ADD" statement is parsed. Argument
735: ** pSrc is the full-name of the table being altered.
736: **
737: ** This routine makes a (partial) copy of the Table structure
738: ** for the table being altered and sets Parse.pNewTable to point
739: ** to it. Routines called by the parser as the column definition
740: ** is parsed (i.e. sqlite3AddColumn()) add the new Column data to
741: ** the copy. The copy of the Table structure is deleted by tokenize.c
742: ** after parsing is finished.
743: **
744: ** Routine sqlite3AlterFinishAddColumn() will be called to complete
745: ** coding the "ALTER TABLE ... ADD" statement.
746: */
747: void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){
748: Table *pNew;
749: Table *pTab;
750: Vdbe *v;
751: int iDb;
752: int i;
753: int nAlloc;
754: sqlite3 *db = pParse->db;
755:
756: /* Look up the table being altered. */
757: assert( pParse->pNewTable==0 );
758: assert( sqlite3BtreeHoldsAllMutexes(db) );
759: if( db->mallocFailed ) goto exit_begin_add_column;
760: pTab = sqlite3LocateTable(pParse, 0, pSrc->a[0].zName, pSrc->a[0].zDatabase);
761: if( !pTab ) goto exit_begin_add_column;
762:
763: #ifndef SQLITE_OMIT_VIRTUALTABLE
764: if( IsVirtual(pTab) ){
765: sqlite3ErrorMsg(pParse, "virtual tables may not be altered");
766: goto exit_begin_add_column;
767: }
768: #endif
769:
770: /* Make sure this is not an attempt to ALTER a view. */
771: if( pTab->pSelect ){
772: sqlite3ErrorMsg(pParse, "Cannot add a column to a view");
773: goto exit_begin_add_column;
774: }
775: if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
776: goto exit_begin_add_column;
777: }
778:
779: assert( pTab->addColOffset>0 );
780: iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
781:
782: /* Put a copy of the Table struct in Parse.pNewTable for the
783: ** sqlite3AddColumn() function and friends to modify. But modify
784: ** the name by adding an "sqlite_altertab_" prefix. By adding this
785: ** prefix, we insure that the name will not collide with an existing
786: ** table because user table are not allowed to have the "sqlite_"
787: ** prefix on their name.
788: */
789: pNew = (Table*)sqlite3DbMallocZero(db, sizeof(Table));
790: if( !pNew ) goto exit_begin_add_column;
791: pParse->pNewTable = pNew;
792: pNew->nRef = 1;
793: pNew->nCol = pTab->nCol;
794: assert( pNew->nCol>0 );
795: nAlloc = (((pNew->nCol-1)/8)*8)+8;
796: assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
797: pNew->aCol = (Column*)sqlite3DbMallocZero(db, sizeof(Column)*nAlloc);
798: pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
799: if( !pNew->aCol || !pNew->zName ){
800: db->mallocFailed = 1;
801: goto exit_begin_add_column;
802: }
803: memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
804: for(i=0; i<pNew->nCol; i++){
805: Column *pCol = &pNew->aCol[i];
806: pCol->zName = sqlite3DbStrDup(db, pCol->zName);
807: pCol->zColl = 0;
808: pCol->zType = 0;
809: pCol->pDflt = 0;
810: pCol->zDflt = 0;
811: }
812: pNew->pSchema = db->aDb[iDb].pSchema;
813: pNew->addColOffset = pTab->addColOffset;
814: pNew->nRef = 1;
815:
816: /* Begin a transaction and increment the schema cookie. */
817: sqlite3BeginWriteOperation(pParse, 0, iDb);
818: v = sqlite3GetVdbe(pParse);
819: if( !v ) goto exit_begin_add_column;
820: sqlite3ChangeCookie(pParse, iDb);
821:
822: exit_begin_add_column:
823: sqlite3SrcListDelete(db, pSrc);
824: return;
825: }
826: #endif /* SQLITE_ALTER_TABLE */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to alter.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