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