third_party/sqlite/sqlite-src-3080704/src/alter.c

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