4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
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.
11 *************************************************************************
12 ** This file contains C code routines that used to generate VDBE code
13 ** that implements the ALTER TABLE command.
15 #include "sqliteInt.h"
18 ** The code in this file only exists if we are not omitting the
19 ** ALTER TABLE logic from the build.
21 #ifndef SQLITE_OMIT_ALTERTABLE
24 ** Parameter zName is the name of a table that is about to be altered
25 ** (either with ALTER TABLE ... RENAME TO or ALTER TABLE ... ADD COLUMN).
26 ** If the table is a system table, this function leaves an error message
27 ** in pParse->zErr (system tables may not be altered) and returns non-zero.
29 ** Or, if zName is not a system table, zero is returned.
31 static int isAlterableTable(Parse
*pParse
, Table
*pTab
){
32 if( 0==sqlite3StrNICmp(pTab
->zName
, "sqlite_", 7)
33 #ifndef SQLITE_OMIT_VIRTUALTABLE
34 || ( (pTab
->tabFlags
& TF_Shadow
)!=0
35 && sqlite3ReadOnlyShadowTables(pParse
->db
)
39 sqlite3ErrorMsg(pParse
, "table %s may not be altered", pTab
->zName
);
46 ** Generate code to verify that the schemas of database zDb and, if
47 ** bTemp is not true, database "temp", can still be parsed. This is
48 ** called at the end of the generation of an ALTER TABLE ... RENAME ...
49 ** statement to ensure that the operation has not rendered any schema
52 static void renameTestSchema(Parse
*pParse
, const char *zDb
, int bTemp
){
53 sqlite3NestedParse(pParse
,
55 "FROM \"%w\"." DFLT_SCHEMA_TABLE
" "
56 "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"
57 " AND sql NOT LIKE 'create virtual%%'"
58 " AND sqlite_rename_test(%Q, sql, type, name, %d)=NULL ",
64 sqlite3NestedParse(pParse
,
66 "FROM temp." DFLT_SCHEMA_TABLE
" "
67 "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"
68 " AND sql NOT LIKE 'create virtual%%'"
69 " AND sqlite_rename_test(%Q, sql, type, name, 1)=NULL ",
76 ** Generate code to reload the schema for database iDb. And, if iDb!=1, for
77 ** the temp database as well.
79 static void renameReloadSchema(Parse
*pParse
, int iDb
){
80 Vdbe
*v
= pParse
->pVdbe
;
82 sqlite3ChangeCookie(pParse
, iDb
);
83 sqlite3VdbeAddParseSchemaOp(pParse
->pVdbe
, iDb
, 0);
84 if( iDb
!=1 ) sqlite3VdbeAddParseSchemaOp(pParse
->pVdbe
, 1, 0);
89 ** Generate code to implement the "ALTER TABLE xxx RENAME TO yyy"
92 void sqlite3AlterRenameTable(
93 Parse
*pParse
, /* Parser context. */
94 SrcList
*pSrc
, /* The table to rename. */
95 Token
*pName
/* The new table name. */
97 int iDb
; /* Database that contains the table */
98 char *zDb
; /* Name of database iDb */
99 Table
*pTab
; /* Table being renamed */
100 char *zName
= 0; /* NULL-terminated version of pName */
101 sqlite3
*db
= pParse
->db
; /* Database connection */
102 int nTabName
; /* Number of UTF-8 characters in zTabName */
103 const char *zTabName
; /* Original name of the table */
105 VTable
*pVTab
= 0; /* Non-zero if this is a v-tab with an xRename() */
106 u32 savedDbFlags
; /* Saved value of db->mDbFlags */
108 savedDbFlags
= db
->mDbFlags
;
109 if( NEVER(db
->mallocFailed
) ) goto exit_rename_table
;
110 assert( pSrc
->nSrc
==1 );
111 assert( sqlite3BtreeHoldsAllMutexes(pParse
->db
) );
113 pTab
= sqlite3LocateTableItem(pParse
, 0, &pSrc
->a
[0]);
114 if( !pTab
) goto exit_rename_table
;
115 iDb
= sqlite3SchemaToIndex(pParse
->db
, pTab
->pSchema
);
116 zDb
= db
->aDb
[iDb
].zDbSName
;
117 db
->mDbFlags
|= DBFLAG_PreferBuiltin
;
119 /* Get a NULL terminated version of the new table name. */
120 zName
= sqlite3NameFromToken(db
, pName
);
121 if( !zName
) goto exit_rename_table
;
123 /* Check that a table or index named 'zName' does not already exist
124 ** in database iDb. If so, this is an error.
126 if( sqlite3FindTable(db
, zName
, zDb
)
127 || sqlite3FindIndex(db
, zName
, zDb
)
128 || sqlite3IsShadowTableOf(db
, pTab
, zName
)
130 sqlite3ErrorMsg(pParse
,
131 "there is already another table or index with this name: %s", zName
);
132 goto exit_rename_table
;
135 /* Make sure it is not a system table being altered, or a reserved name
136 ** that the table is being renamed to.
138 if( SQLITE_OK
!=isAlterableTable(pParse
, pTab
) ){
139 goto exit_rename_table
;
141 if( SQLITE_OK
!=sqlite3CheckObjectName(pParse
,zName
,"table",zName
) ){
142 goto exit_rename_table
;
145 #ifndef SQLITE_OMIT_VIEW
147 sqlite3ErrorMsg(pParse
, "view %s may not be altered", pTab
->zName
);
148 goto exit_rename_table
;
152 #ifndef SQLITE_OMIT_AUTHORIZATION
153 /* Invoke the authorization callback. */
154 if( sqlite3AuthCheck(pParse
, SQLITE_ALTER_TABLE
, zDb
, pTab
->zName
, 0) ){
155 goto exit_rename_table
;
159 #ifndef SQLITE_OMIT_VIRTUALTABLE
160 if( sqlite3ViewGetColumnNames(pParse
, pTab
) ){
161 goto exit_rename_table
;
163 if( IsVirtual(pTab
) ){
164 pVTab
= sqlite3GetVTable(db
, pTab
);
165 if( pVTab
->pVtab
->pModule
->xRename
==0 ){
171 /* Begin a transaction for database iDb. Then modify the schema cookie
172 ** (since the ALTER TABLE modifies the schema). Call sqlite3MayAbort(),
173 ** as the scalar functions (e.g. sqlite_rename_table()) invoked by the
174 ** nested SQL may raise an exception. */
175 v
= sqlite3GetVdbe(pParse
);
177 goto exit_rename_table
;
179 sqlite3MayAbort(pParse
);
181 /* figure out how many UTF-8 characters are in zName */
182 zTabName
= pTab
->zName
;
183 nTabName
= sqlite3Utf8CharLen(zTabName
, -1);
185 /* Rewrite all CREATE TABLE, INDEX, TRIGGER or VIEW statements in
186 ** the schema to use the new table name. */
187 sqlite3NestedParse(pParse
,
188 "UPDATE \"%w\"." DFLT_SCHEMA_TABLE
" SET "
189 "sql = sqlite_rename_table(%Q, type, name, sql, %Q, %Q, %d) "
190 "WHERE (type!='index' OR tbl_name=%Q COLLATE nocase)"
191 "AND name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"
192 , zDb
, zDb
, zTabName
, zName
, (iDb
==1), zTabName
195 /* Update the tbl_name and name columns of the sqlite_schema table
197 sqlite3NestedParse(pParse
,
198 "UPDATE %Q." DFLT_SCHEMA_TABLE
" SET "
201 "WHEN type='table' THEN %Q "
202 "WHEN name LIKE 'sqliteX_autoindex%%' ESCAPE 'X' "
203 " AND type='index' THEN "
204 "'sqlite_autoindex_' || %Q || substr(name,%d+18) "
206 "WHERE tbl_name=%Q COLLATE nocase AND "
207 "(type='table' OR type='index' OR type='trigger');",
213 #ifndef SQLITE_OMIT_AUTOINCREMENT
214 /* If the sqlite_sequence table exists in this database, then update
215 ** it with the new table name.
217 if( sqlite3FindTable(db
, "sqlite_sequence", zDb
) ){
218 sqlite3NestedParse(pParse
,
219 "UPDATE \"%w\".sqlite_sequence set name = %Q WHERE name = %Q",
220 zDb
, zName
, pTab
->zName
);
224 /* If the table being renamed is not itself part of the temp database,
225 ** edit view and trigger definitions within the temp database
228 sqlite3NestedParse(pParse
,
229 "UPDATE sqlite_temp_schema SET "
230 "sql = sqlite_rename_table(%Q, type, name, sql, %Q, %Q, 1), "
232 "CASE WHEN tbl_name=%Q COLLATE nocase AND "
233 " sqlite_rename_test(%Q, sql, type, name, 1) "
234 "THEN %Q ELSE tbl_name END "
235 "WHERE type IN ('view', 'trigger')"
236 , zDb
, zTabName
, zName
, zTabName
, zDb
, zName
);
239 /* If this is a virtual table, invoke the xRename() function if
240 ** one is defined. The xRename() callback will modify the names
241 ** of any resources used by the v-table implementation (including other
242 ** SQLite tables) that are identified by the name of the virtual table.
244 #ifndef SQLITE_OMIT_VIRTUALTABLE
246 int i
= ++pParse
->nMem
;
247 sqlite3VdbeLoadString(v
, i
, zName
);
248 sqlite3VdbeAddOp4(v
, OP_VRename
, i
, 0, 0,(const char*)pVTab
, P4_VTAB
);
252 renameReloadSchema(pParse
, iDb
);
253 renameTestSchema(pParse
, zDb
, iDb
==1);
256 sqlite3SrcListDelete(db
, pSrc
);
257 sqlite3DbFree(db
, zName
);
258 db
->mDbFlags
= savedDbFlags
;
262 ** Write code that will raise an error if the table described by
263 ** zDb and zTab is not empty.
265 static void sqlite3ErrorIfNotEmpty(
266 Parse
*pParse
, /* Parsing context */
267 const char *zDb
, /* Schema holding the table */
268 const char *zTab
, /* Table to check for empty */
269 const char *zErr
/* Error message text */
271 sqlite3NestedParse(pParse
,
272 "SELECT raise(ABORT,%Q) FROM \"%w\".\"%w\"",
278 ** This function is called after an "ALTER TABLE ... ADD" statement
279 ** has been parsed. Argument pColDef contains the text of the new
280 ** column definition.
282 ** The Table structure pParse->pNewTable was extended to include
283 ** the new column during parsing.
285 void sqlite3AlterFinishAddColumn(Parse
*pParse
, Token
*pColDef
){
286 Table
*pNew
; /* Copy of pParse->pNewTable */
287 Table
*pTab
; /* Table being altered */
288 int iDb
; /* Database number */
289 const char *zDb
; /* Database name */
290 const char *zTab
; /* Table name */
291 char *zCol
; /* Null-terminated column definition */
292 Column
*pCol
; /* The new column */
293 Expr
*pDflt
; /* Default value for the new column */
294 sqlite3
*db
; /* The database connection; */
295 Vdbe
*v
; /* The prepared statement under construction */
296 int r1
; /* Temporary registers */
299 if( pParse
->nErr
|| db
->mallocFailed
) return;
300 pNew
= pParse
->pNewTable
;
303 assert( sqlite3BtreeHoldsAllMutexes(db
) );
304 iDb
= sqlite3SchemaToIndex(db
, pNew
->pSchema
);
305 zDb
= db
->aDb
[iDb
].zDbSName
;
306 zTab
= &pNew
->zName
[16]; /* Skip the "sqlite_altertab_" prefix on the name */
307 pCol
= &pNew
->aCol
[pNew
->nCol
-1];
309 pTab
= sqlite3FindTable(db
, zTab
, zDb
);
312 #ifndef SQLITE_OMIT_AUTHORIZATION
313 /* Invoke the authorization callback. */
314 if( sqlite3AuthCheck(pParse
, SQLITE_ALTER_TABLE
, zDb
, pTab
->zName
, 0) ){
320 /* Check that the new column is not specified as PRIMARY KEY or UNIQUE.
321 ** If there is a NOT NULL constraint, then the default value for the
322 ** column must not be NULL.
324 if( pCol
->colFlags
& COLFLAG_PRIMKEY
){
325 sqlite3ErrorMsg(pParse
, "Cannot add a PRIMARY KEY column");
329 sqlite3ErrorMsg(pParse
,
330 "Cannot add a UNIQUE column");
333 if( (pCol
->colFlags
& COLFLAG_GENERATED
)==0 ){
334 /* If the default value for the new column was specified with a
335 ** literal NULL, then set pDflt to 0. This simplifies checking
336 ** for an SQL NULL default below.
338 assert( pDflt
==0 || pDflt
->op
==TK_SPAN
);
339 if( pDflt
&& pDflt
->pLeft
->op
==TK_NULL
){
342 if( (db
->flags
&SQLITE_ForeignKeys
) && pNew
->pFKey
&& pDflt
){
343 sqlite3ErrorIfNotEmpty(pParse
, zDb
, zTab
,
344 "Cannot add a REFERENCES column with non-NULL default value");
346 if( pCol
->notNull
&& !pDflt
){
347 sqlite3ErrorIfNotEmpty(pParse
, zDb
, zTab
,
348 "Cannot add a NOT NULL column with default value NULL");
352 /* Ensure the default expression is something that sqlite3ValueFromExpr()
353 ** can handle (i.e. not CURRENT_TIME etc.)
356 sqlite3_value
*pVal
= 0;
358 rc
= sqlite3ValueFromExpr(db
, pDflt
, SQLITE_UTF8
, SQLITE_AFF_BLOB
, &pVal
);
359 assert( rc
==SQLITE_OK
|| rc
==SQLITE_NOMEM
);
361 assert( db
->mallocFailed
== 1 );
365 sqlite3ErrorIfNotEmpty(pParse
, zDb
, zTab
,
366 "Cannot add a column with non-constant default");
368 sqlite3ValueFree(pVal
);
370 }else if( pCol
->colFlags
& COLFLAG_STORED
){
371 sqlite3ErrorIfNotEmpty(pParse
, zDb
, zTab
, "cannot add a STORED column");
375 /* Modify the CREATE TABLE statement. */
376 zCol
= sqlite3DbStrNDup(db
, (char*)pColDef
->z
, pColDef
->n
);
378 char *zEnd
= &zCol
[pColDef
->n
-1];
379 u32 savedDbFlags
= db
->mDbFlags
;
380 while( zEnd
>zCol
&& (*zEnd
==';' || sqlite3Isspace(*zEnd
)) ){
383 db
->mDbFlags
|= DBFLAG_PreferBuiltin
;
384 sqlite3NestedParse(pParse
,
385 "UPDATE \"%w\"." DFLT_SCHEMA_TABLE
" SET "
386 "sql = substr(sql,1,%d) || ', ' || %Q || substr(sql,%d) "
387 "WHERE type = 'table' AND name = %Q",
388 zDb
, pNew
->addColOffset
, zCol
, pNew
->addColOffset
+1,
391 sqlite3DbFree(db
, zCol
);
392 db
->mDbFlags
= savedDbFlags
;
395 /* Make sure the schema version is at least 3. But do not upgrade
396 ** from less than 3 to 4, as that will corrupt any preexisting DESC
399 v
= sqlite3GetVdbe(pParse
);
401 r1
= sqlite3GetTempReg(pParse
);
402 sqlite3VdbeAddOp3(v
, OP_ReadCookie
, iDb
, r1
, BTREE_FILE_FORMAT
);
403 sqlite3VdbeUsesBtree(v
, iDb
);
404 sqlite3VdbeAddOp2(v
, OP_AddImm
, r1
, -2);
405 sqlite3VdbeAddOp2(v
, OP_IfPos
, r1
, sqlite3VdbeCurrentAddr(v
)+2);
407 sqlite3VdbeAddOp3(v
, OP_SetCookie
, iDb
, BTREE_FILE_FORMAT
, 3);
408 sqlite3ReleaseTempReg(pParse
, r1
);
411 /* Reload the table definition */
412 renameReloadSchema(pParse
, iDb
);
416 ** This function is called by the parser after the table-name in
417 ** an "ALTER TABLE <table-name> ADD" statement is parsed. Argument
418 ** pSrc is the full-name of the table being altered.
420 ** This routine makes a (partial) copy of the Table structure
421 ** for the table being altered and sets Parse.pNewTable to point
422 ** to it. Routines called by the parser as the column definition
423 ** is parsed (i.e. sqlite3AddColumn()) add the new Column data to
424 ** the copy. The copy of the Table structure is deleted by tokenize.c
425 ** after parsing is finished.
427 ** Routine sqlite3AlterFinishAddColumn() will be called to complete
428 ** coding the "ALTER TABLE ... ADD" statement.
430 void sqlite3AlterBeginAddColumn(Parse
*pParse
, SrcList
*pSrc
){
436 sqlite3
*db
= pParse
->db
;
438 /* Look up the table being altered. */
439 assert( pParse
->pNewTable
==0 );
440 assert( sqlite3BtreeHoldsAllMutexes(db
) );
441 if( db
->mallocFailed
) goto exit_begin_add_column
;
442 pTab
= sqlite3LocateTableItem(pParse
, 0, &pSrc
->a
[0]);
443 if( !pTab
) goto exit_begin_add_column
;
445 #ifndef SQLITE_OMIT_VIRTUALTABLE
446 if( IsVirtual(pTab
) ){
447 sqlite3ErrorMsg(pParse
, "virtual tables may not be altered");
448 goto exit_begin_add_column
;
452 /* Make sure this is not an attempt to ALTER a view. */
454 sqlite3ErrorMsg(pParse
, "Cannot add a column to a view");
455 goto exit_begin_add_column
;
457 if( SQLITE_OK
!=isAlterableTable(pParse
, pTab
) ){
458 goto exit_begin_add_column
;
461 sqlite3MayAbort(pParse
);
462 assert( pTab
->addColOffset
>0 );
463 iDb
= sqlite3SchemaToIndex(db
, pTab
->pSchema
);
465 /* Put a copy of the Table struct in Parse.pNewTable for the
466 ** sqlite3AddColumn() function and friends to modify. But modify
467 ** the name by adding an "sqlite_altertab_" prefix. By adding this
468 ** prefix, we insure that the name will not collide with an existing
469 ** table because user table are not allowed to have the "sqlite_"
470 ** prefix on their name.
472 pNew
= (Table
*)sqlite3DbMallocZero(db
, sizeof(Table
));
473 if( !pNew
) goto exit_begin_add_column
;
474 pParse
->pNewTable
= pNew
;
476 pNew
->nCol
= pTab
->nCol
;
477 assert( pNew
->nCol
>0 );
478 nAlloc
= (((pNew
->nCol
-1)/8)*8)+8;
479 assert( nAlloc
>=pNew
->nCol
&& nAlloc
%8==0 && nAlloc
-pNew
->nCol
<8 );
480 pNew
->aCol
= (Column
*)sqlite3DbMallocZero(db
, sizeof(Column
)*nAlloc
);
481 pNew
->zName
= sqlite3MPrintf(db
, "sqlite_altertab_%s", pTab
->zName
);
482 if( !pNew
->aCol
|| !pNew
->zName
){
483 assert( db
->mallocFailed
);
484 goto exit_begin_add_column
;
486 memcpy(pNew
->aCol
, pTab
->aCol
, sizeof(Column
)*pNew
->nCol
);
487 for(i
=0; i
<pNew
->nCol
; i
++){
488 Column
*pCol
= &pNew
->aCol
[i
];
489 pCol
->zName
= sqlite3DbStrDup(db
, pCol
->zName
);
490 pCol
->hName
= sqlite3StrIHash(pCol
->zName
);
494 pNew
->pSchema
= db
->aDb
[iDb
].pSchema
;
495 pNew
->addColOffset
= pTab
->addColOffset
;
498 exit_begin_add_column
:
499 sqlite3SrcListDelete(db
, pSrc
);
504 ** Parameter pTab is the subject of an ALTER TABLE ... RENAME COLUMN
505 ** command. This function checks if the table is a view or virtual
506 ** table (columns of views or virtual tables may not be renamed). If so,
507 ** it loads an error message into pParse and returns non-zero.
509 ** Or, if pTab is not a view or virtual table, zero is returned.
511 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
512 static int isRealTable(Parse
*pParse
, Table
*pTab
){
513 const char *zType
= 0;
514 #ifndef SQLITE_OMIT_VIEW
519 #ifndef SQLITE_OMIT_VIRTUALTABLE
520 if( IsVirtual(pTab
) ){
521 zType
= "virtual table";
526 pParse
, "cannot rename columns of %s \"%s\"", zType
, pTab
->zName
532 #else /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */
533 # define isRealTable(x,y) (0)
537 ** Handles the following parser reduction:
539 ** cmd ::= ALTER TABLE pSrc RENAME COLUMN pOld TO pNew
541 void sqlite3AlterRenameColumn(
542 Parse
*pParse
, /* Parsing context */
543 SrcList
*pSrc
, /* Table being altered. pSrc->nSrc==1 */
544 Token
*pOld
, /* Name of column being changed */
545 Token
*pNew
/* New column name */
547 sqlite3
*db
= pParse
->db
; /* Database connection */
548 Table
*pTab
; /* Table being updated */
549 int iCol
; /* Index of column being renamed */
550 char *zOld
= 0; /* Old column name */
551 char *zNew
= 0; /* New column name */
552 const char *zDb
; /* Name of schema containing the table */
553 int iSchema
; /* Index of the schema */
554 int bQuote
; /* True to quote the new name */
556 /* Locate the table to be altered */
557 pTab
= sqlite3LocateTableItem(pParse
, 0, &pSrc
->a
[0]);
558 if( !pTab
) goto exit_rename_column
;
560 /* Cannot alter a system table */
561 if( SQLITE_OK
!=isAlterableTable(pParse
, pTab
) ) goto exit_rename_column
;
562 if( SQLITE_OK
!=isRealTable(pParse
, pTab
) ) goto exit_rename_column
;
564 /* Which schema holds the table to be altered */
565 iSchema
= sqlite3SchemaToIndex(db
, pTab
->pSchema
);
566 assert( iSchema
>=0 );
567 zDb
= db
->aDb
[iSchema
].zDbSName
;
569 #ifndef SQLITE_OMIT_AUTHORIZATION
570 /* Invoke the authorization callback. */
571 if( sqlite3AuthCheck(pParse
, SQLITE_ALTER_TABLE
, zDb
, pTab
->zName
, 0) ){
572 goto exit_rename_column
;
576 /* Make sure the old name really is a column name in the table to be
577 ** altered. Set iCol to be the index of the column being renamed */
578 zOld
= sqlite3NameFromToken(db
, pOld
);
579 if( !zOld
) goto exit_rename_column
;
580 for(iCol
=0; iCol
<pTab
->nCol
; iCol
++){
581 if( 0==sqlite3StrICmp(pTab
->aCol
[iCol
].zName
, zOld
) ) break;
583 if( iCol
==pTab
->nCol
){
584 sqlite3ErrorMsg(pParse
, "no such column: \"%s\"", zOld
);
585 goto exit_rename_column
;
588 /* Do the rename operation using a recursive UPDATE statement that
589 ** uses the sqlite_rename_column() SQL function to compute the new
590 ** CREATE statement text for the sqlite_schema table.
592 sqlite3MayAbort(pParse
);
593 zNew
= sqlite3NameFromToken(db
, pNew
);
594 if( !zNew
) goto exit_rename_column
;
596 bQuote
= sqlite3Isquote(pNew
->z
[0]);
597 sqlite3NestedParse(pParse
,
598 "UPDATE \"%w\"." DFLT_SCHEMA_TABLE
" SET "
599 "sql = sqlite_rename_column(sql, type, name, %Q, %Q, %d, %Q, %d, %d) "
600 "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X' "
601 " AND (type != 'index' OR tbl_name = %Q)"
602 " AND sql NOT LIKE 'create virtual%%'",
604 zDb
, pTab
->zName
, iCol
, zNew
, bQuote
, iSchema
==1,
608 sqlite3NestedParse(pParse
,
609 "UPDATE temp." DFLT_SCHEMA_TABLE
" SET "
610 "sql = sqlite_rename_column(sql, type, name, %Q, %Q, %d, %Q, %d, 1) "
611 "WHERE type IN ('trigger', 'view')",
612 zDb
, pTab
->zName
, iCol
, zNew
, bQuote
615 /* Drop and reload the database schema. */
616 renameReloadSchema(pParse
, iSchema
);
617 renameTestSchema(pParse
, zDb
, iSchema
==1);
620 sqlite3SrcListDelete(db
, pSrc
);
621 sqlite3DbFree(db
, zOld
);
622 sqlite3DbFree(db
, zNew
);
627 ** Each RenameToken object maps an element of the parse tree into
628 ** the token that generated that element. The parse tree element
631 ** * A pointer to an Expr that represents an ID
632 ** * The name of a table column in Column.zName
634 ** A list of RenameToken objects can be constructed during parsing.
635 ** Each new object is created by sqlite3RenameTokenMap().
636 ** As the parse tree is transformed, the sqlite3RenameTokenRemap()
637 ** routine is used to keep the mapping current.
639 ** After the parse finishes, renameTokenFind() routine can be used
640 ** to look up the actual token value that created some element in
644 void *p
; /* Parse tree element created by token t */
645 Token t
; /* The token that created parse tree element p */
646 RenameToken
*pNext
; /* Next is a list of all RenameToken objects */
650 ** The context of an ALTER TABLE RENAME COLUMN operation that gets passed
651 ** down into the Walker.
653 typedef struct RenameCtx RenameCtx
;
655 RenameToken
*pList
; /* List of tokens to overwrite */
656 int nList
; /* Number of tokens in pList */
657 int iCol
; /* Index of column being renamed */
658 Table
*pTab
; /* Table being ALTERed */
659 const char *zOld
; /* Old column name */
664 ** This function is only for debugging. It performs two tasks:
666 ** 1. Checks that pointer pPtr does not already appear in the
667 ** rename-token list.
669 ** 2. Dereferences each pointer in the rename-token list.
671 ** The second is most effective when debugging under valgrind or
672 ** address-sanitizer or similar. If any of these pointers no longer
673 ** point to valid objects, an exception is raised by the memory-checking
676 ** The point of this is to prevent comparisons of invalid pointer values.
677 ** Even though this always seems to work, it is undefined according to the
678 ** C standard. Example of undefined comparison:
683 ** Technically, as x no longer points into a valid object or to the byte
684 ** following a valid object, it may not be used in comparison operations.
686 static void renameTokenCheckAll(Parse
*pParse
, void *pPtr
){
687 if( pParse
->nErr
==0 && pParse
->db
->mallocFailed
==0 ){
690 for(p
=pParse
->pRename
; p
; p
=p
->pNext
){
692 assert( p
->p
!=pPtr
);
699 # define renameTokenCheckAll(x,y)
703 ** Remember that the parser tree element pPtr was created using
706 ** In other words, construct a new RenameToken object and add it
707 ** to the list of RenameToken objects currently being built up
708 ** in pParse->pRename.
710 ** The pPtr argument is returned so that this routine can be used
711 ** with tail recursion in tokenExpr() routine, for a small performance
714 void *sqlite3RenameTokenMap(Parse
*pParse
, void *pPtr
, Token
*pToken
){
716 assert( pPtr
|| pParse
->db
->mallocFailed
);
717 renameTokenCheckAll(pParse
, pPtr
);
718 if( ALWAYS(pParse
->eParseMode
!=PARSE_MODE_UNMAP
) ){
719 pNew
= sqlite3DbMallocZero(pParse
->db
, sizeof(RenameToken
));
723 pNew
->pNext
= pParse
->pRename
;
724 pParse
->pRename
= pNew
;
732 ** It is assumed that there is already a RenameToken object associated
733 ** with parse tree element pFrom. This function remaps the associated token
734 ** to parse tree element pTo.
736 void sqlite3RenameTokenRemap(Parse
*pParse
, void *pTo
, void *pFrom
){
738 renameTokenCheckAll(pParse
, pTo
);
739 for(p
=pParse
->pRename
; p
; p
=p
->pNext
){
748 ** Walker callback used by sqlite3RenameExprUnmap().
750 static int renameUnmapExprCb(Walker
*pWalker
, Expr
*pExpr
){
751 Parse
*pParse
= pWalker
->pParse
;
752 sqlite3RenameTokenRemap(pParse
, 0, (void*)pExpr
);
757 ** Iterate through the Select objects that are part of WITH clauses attached
758 ** to select statement pSelect.
760 static void renameWalkWith(Walker
*pWalker
, Select
*pSelect
){
761 With
*pWith
= pSelect
->pWith
;
764 for(i
=0; i
<pWith
->nCte
; i
++){
765 Select
*p
= pWith
->a
[i
].pSelect
;
767 memset(&sNC
, 0, sizeof(sNC
));
768 sNC
.pParse
= pWalker
->pParse
;
769 sqlite3SelectPrep(sNC
.pParse
, p
, &sNC
);
770 sqlite3WalkSelect(pWalker
, p
);
771 sqlite3RenameExprlistUnmap(pWalker
->pParse
, pWith
->a
[i
].pCols
);
777 ** Unmap all tokens in the IdList object passed as the second argument.
779 static void unmapColumnIdlistNames(
785 for(ii
=0; ii
<pIdList
->nId
; ii
++){
786 sqlite3RenameTokenRemap(pParse
, 0, (void*)pIdList
->a
[ii
].zName
);
792 ** Walker callback used by sqlite3RenameExprUnmap().
794 static int renameUnmapSelectCb(Walker
*pWalker
, Select
*p
){
795 Parse
*pParse
= pWalker
->pParse
;
797 if( pParse
->nErr
) return WRC_Abort
;
798 if( NEVER(p
->selFlags
& SF_View
) ) return WRC_Prune
;
799 if( ALWAYS(p
->pEList
) ){
800 ExprList
*pList
= p
->pEList
;
801 for(i
=0; i
<pList
->nExpr
; i
++){
802 if( pList
->a
[i
].zEName
&& pList
->a
[i
].eEName
==ENAME_NAME
){
803 sqlite3RenameTokenRemap(pParse
, 0, (void*)pList
->a
[i
].zEName
);
807 if( ALWAYS(p
->pSrc
) ){ /* Every Select as a SrcList, even if it is empty */
808 SrcList
*pSrc
= p
->pSrc
;
809 for(i
=0; i
<pSrc
->nSrc
; i
++){
810 sqlite3RenameTokenRemap(pParse
, 0, (void*)pSrc
->a
[i
].zName
);
811 if( sqlite3WalkExpr(pWalker
, pSrc
->a
[i
].pOn
) ) return WRC_Abort
;
812 unmapColumnIdlistNames(pParse
, pSrc
->a
[i
].pUsing
);
816 renameWalkWith(pWalker
, p
);
821 ** Remove all nodes that are part of expression pExpr from the rename list.
823 void sqlite3RenameExprUnmap(Parse
*pParse
, Expr
*pExpr
){
824 u8 eMode
= pParse
->eParseMode
;
826 memset(&sWalker
, 0, sizeof(Walker
));
827 sWalker
.pParse
= pParse
;
828 sWalker
.xExprCallback
= renameUnmapExprCb
;
829 sWalker
.xSelectCallback
= renameUnmapSelectCb
;
830 pParse
->eParseMode
= PARSE_MODE_UNMAP
;
831 sqlite3WalkExpr(&sWalker
, pExpr
);
832 pParse
->eParseMode
= eMode
;
836 ** Remove all nodes that are part of expression-list pEList from the
839 void sqlite3RenameExprlistUnmap(Parse
*pParse
, ExprList
*pEList
){
843 memset(&sWalker
, 0, sizeof(Walker
));
844 sWalker
.pParse
= pParse
;
845 sWalker
.xExprCallback
= renameUnmapExprCb
;
846 sqlite3WalkExprList(&sWalker
, pEList
);
847 for(i
=0; i
<pEList
->nExpr
; i
++){
848 if( ALWAYS(pEList
->a
[i
].eEName
==ENAME_NAME
) ){
849 sqlite3RenameTokenRemap(pParse
, 0, (void*)pEList
->a
[i
].zEName
);
856 ** Free the list of RenameToken objects given in the second argument
858 static void renameTokenFree(sqlite3
*db
, RenameToken
*pToken
){
861 for(p
=pToken
; p
; p
=pNext
){
863 sqlite3DbFree(db
, p
);
868 ** Search the Parse object passed as the first argument for a RenameToken
869 ** object associated with parse tree element pPtr. If found, remove it
870 ** from the Parse object and add it to the list maintained by the
871 ** RenameCtx object passed as the second argument.
873 static void renameTokenFind(Parse
*pParse
, struct RenameCtx
*pCtx
, void *pPtr
){
876 for(pp
=&pParse
->pRename
; (*pp
); pp
=&(*pp
)->pNext
){
877 if( (*pp
)->p
==pPtr
){
878 RenameToken
*pToken
= *pp
;
880 pToken
->pNext
= pCtx
->pList
;
881 pCtx
->pList
= pToken
;
889 ** This is a Walker select callback. It does nothing. It is only required
890 ** because without a dummy callback, sqlite3WalkExpr() and similar do not
891 ** descend into sub-select statements.
893 static int renameColumnSelectCb(Walker
*pWalker
, Select
*p
){
894 if( p
->selFlags
& SF_View
) return WRC_Prune
;
895 renameWalkWith(pWalker
, p
);
900 ** This is a Walker expression callback.
902 ** For every TK_COLUMN node in the expression tree, search to see
903 ** if the column being references is the column being renamed by an
904 ** ALTER TABLE statement. If it is, then attach its associated
905 ** RenameToken object to the list of RenameToken objects being
906 ** constructed in RenameCtx object at pWalker->u.pRename.
908 static int renameColumnExprCb(Walker
*pWalker
, Expr
*pExpr
){
909 RenameCtx
*p
= pWalker
->u
.pRename
;
910 if( pExpr
->op
==TK_TRIGGER
911 && pExpr
->iColumn
==p
->iCol
912 && pWalker
->pParse
->pTriggerTab
==p
->pTab
914 renameTokenFind(pWalker
->pParse
, p
, (void*)pExpr
);
915 }else if( pExpr
->op
==TK_COLUMN
916 && pExpr
->iColumn
==p
->iCol
917 && p
->pTab
==pExpr
->y
.pTab
919 renameTokenFind(pWalker
->pParse
, p
, (void*)pExpr
);
925 ** The RenameCtx contains a list of tokens that reference a column that
926 ** is being renamed by an ALTER TABLE statement. Return the "last"
927 ** RenameToken in the RenameCtx and remove that RenameToken from the
928 ** RenameContext. "Last" means the last RenameToken encountered when
929 ** the input SQL is parsed from left to right. Repeated calls to this routine
930 ** return all column name tokens in the order that they are encountered
931 ** in the SQL statement.
933 static RenameToken
*renameColumnTokenNext(RenameCtx
*pCtx
){
934 RenameToken
*pBest
= pCtx
->pList
;
938 for(pToken
=pBest
->pNext
; pToken
; pToken
=pToken
->pNext
){
939 if( pToken
->t
.z
>pBest
->t
.z
) pBest
= pToken
;
941 for(pp
=&pCtx
->pList
; *pp
!=pBest
; pp
=&(*pp
)->pNext
);
948 ** An error occured while parsing or otherwise processing a database
949 ** object (either pParse->pNewTable, pNewIndex or pNewTrigger) as part of an
950 ** ALTER TABLE RENAME COLUMN program. The error message emitted by the
951 ** sub-routine is currently stored in pParse->zErrMsg. This function
952 ** adds context to the error message and then stores it in pCtx.
954 static void renameColumnParseError(
955 sqlite3_context
*pCtx
,
957 sqlite3_value
*pType
,
958 sqlite3_value
*pObject
,
961 const char *zT
= (const char*)sqlite3_value_text(pType
);
962 const char *zN
= (const char*)sqlite3_value_text(pObject
);
965 zErr
= sqlite3_mprintf("error in %s %s%s: %s",
966 zT
, zN
, (bPost
? " after rename" : ""),
969 sqlite3_result_error(pCtx
, zErr
, -1);
974 ** For each name in the the expression-list pEList (i.e. each
975 ** pEList->a[i].zName) that matches the string in zOld, extract the
976 ** corresponding rename-token from Parse object pParse and add it
977 ** to the RenameCtx pCtx.
979 static void renameColumnElistNames(
987 for(i
=0; i
<pEList
->nExpr
; i
++){
988 char *zName
= pEList
->a
[i
].zEName
;
989 if( ALWAYS(pEList
->a
[i
].eEName
==ENAME_NAME
)
991 && 0==sqlite3_stricmp(zName
, zOld
)
993 renameTokenFind(pParse
, pCtx
, (void*)zName
);
1000 ** For each name in the the id-list pIdList (i.e. each pIdList->a[i].zName)
1001 ** that matches the string in zOld, extract the corresponding rename-token
1002 ** from Parse object pParse and add it to the RenameCtx pCtx.
1004 static void renameColumnIdlistNames(
1012 for(i
=0; i
<pIdList
->nId
; i
++){
1013 char *zName
= pIdList
->a
[i
].zName
;
1014 if( 0==sqlite3_stricmp(zName
, zOld
) ){
1015 renameTokenFind(pParse
, pCtx
, (void*)zName
);
1023 ** Parse the SQL statement zSql using Parse object (*p). The Parse object
1024 ** is initialized by this function before it is used.
1026 static int renameParseSql(
1027 Parse
*p
, /* Memory to use for Parse object */
1028 const char *zDb
, /* Name of schema SQL belongs to */
1029 sqlite3
*db
, /* Database handle */
1030 const char *zSql
, /* SQL to parse */
1031 int bTemp
/* True if SQL is from temp schema */
1036 db
->init
.iDb
= bTemp
? 1 : sqlite3FindDbName(db
, zDb
);
1038 /* Parse the SQL statement passed as the first argument. If no error
1039 ** occurs and the parse does not result in a new table, index or
1040 ** trigger object, the database must be corrupt. */
1041 memset(p
, 0, sizeof(Parse
));
1042 p
->eParseMode
= PARSE_MODE_RENAME
;
1045 rc
= sqlite3RunParser(p
, zSql
, &zErr
);
1046 assert( p
->zErrMsg
==0 );
1047 assert( rc
!=SQLITE_OK
|| zErr
==0 );
1049 if( db
->mallocFailed
) rc
= SQLITE_NOMEM
;
1051 && p
->pNewTable
==0 && p
->pNewIndex
==0 && p
->pNewTrigger
==0
1053 rc
= SQLITE_CORRUPT_BKPT
;
1057 /* Ensure that all mappings in the Parse.pRename list really do map to
1058 ** a part of the input string. */
1059 if( rc
==SQLITE_OK
){
1060 int nSql
= sqlite3Strlen30(zSql
);
1061 RenameToken
*pToken
;
1062 for(pToken
=p
->pRename
; pToken
; pToken
=pToken
->pNext
){
1063 assert( pToken
->t
.z
>=zSql
&& &pToken
->t
.z
[pToken
->t
.n
]<=&zSql
[nSql
] );
1073 ** This function edits SQL statement zSql, replacing each token identified
1074 ** by the linked list pRename with the text of zNew. If argument bQuote is
1075 ** true, then zNew is always quoted first. If no error occurs, the result
1076 ** is loaded into context object pCtx as the result.
1078 ** Or, if an error occurs (i.e. an OOM condition), an error is left in
1079 ** pCtx and an SQLite error code returned.
1081 static int renameEditSql(
1082 sqlite3_context
*pCtx
, /* Return result here */
1083 RenameCtx
*pRename
, /* Rename context */
1084 const char *zSql
, /* SQL statement to edit */
1085 const char *zNew
, /* New token text */
1086 int bQuote
/* True to always quote token */
1088 int nNew
= sqlite3Strlen30(zNew
);
1089 int nSql
= sqlite3Strlen30(zSql
);
1090 sqlite3
*db
= sqlite3_context_db_handle(pCtx
);
1096 /* Set zQuot to point to a buffer containing a quoted copy of the
1097 ** identifier zNew. If the corresponding identifier in the original
1098 ** ALTER TABLE statement was quoted (bQuote==1), then set zNew to
1099 ** point to zQuot so that all substitutions are made using the
1100 ** quoted version of the new column name. */
1101 zQuot
= sqlite3MPrintf(db
, "\"%w\"", zNew
);
1103 return SQLITE_NOMEM
;
1105 nQuot
= sqlite3Strlen30(zQuot
);
1112 /* At this point pRename->pList contains a list of RenameToken objects
1113 ** corresponding to all tokens in the input SQL that must be replaced
1114 ** with the new column name. All that remains is to construct and
1115 ** return the edited SQL string. */
1116 assert( nQuot
>=nNew
);
1117 zOut
= sqlite3DbMallocZero(db
, nSql
+ pRename
->nList
*nQuot
+ 1);
1120 memcpy(zOut
, zSql
, nSql
);
1121 while( pRename
->pList
){
1122 int iOff
; /* Offset of token to replace in zOut */
1123 RenameToken
*pBest
= renameColumnTokenNext(pRename
);
1126 const char *zReplace
;
1127 if( sqlite3IsIdChar(*pBest
->t
.z
) ){
1135 iOff
= pBest
->t
.z
- zSql
;
1136 if( pBest
->t
.n
!=nReplace
){
1137 memmove(&zOut
[iOff
+ nReplace
], &zOut
[iOff
+ pBest
->t
.n
],
1138 nOut
- (iOff
+ pBest
->t
.n
)
1140 nOut
+= nReplace
- pBest
->t
.n
;
1143 memcpy(&zOut
[iOff
], zReplace
, nReplace
);
1144 sqlite3DbFree(db
, pBest
);
1147 sqlite3_result_text(pCtx
, zOut
, -1, SQLITE_TRANSIENT
);
1148 sqlite3DbFree(db
, zOut
);
1153 sqlite3_free(zQuot
);
1158 ** Resolve all symbols in the trigger at pParse->pNewTrigger, assuming
1159 ** it was read from the schema of database zDb. Return SQLITE_OK if
1160 ** successful. Otherwise, return an SQLite error code and leave an error
1161 ** message in the Parse object.
1163 static int renameResolveTrigger(Parse
*pParse
){
1164 sqlite3
*db
= pParse
->db
;
1165 Trigger
*pNew
= pParse
->pNewTrigger
;
1170 memset(&sNC
, 0, sizeof(sNC
));
1171 sNC
.pParse
= pParse
;
1172 assert( pNew
->pTabSchema
);
1173 pParse
->pTriggerTab
= sqlite3FindTable(db
, pNew
->table
,
1174 db
->aDb
[sqlite3SchemaToIndex(db
, pNew
->pTabSchema
)].zDbSName
1176 pParse
->eTriggerOp
= pNew
->op
;
1177 /* ALWAYS() because if the table of the trigger does not exist, the
1178 ** error would have been hit before this point */
1179 if( ALWAYS(pParse
->pTriggerTab
) ){
1180 rc
= sqlite3ViewGetColumnNames(pParse
, pParse
->pTriggerTab
);
1183 /* Resolve symbols in WHEN clause */
1184 if( rc
==SQLITE_OK
&& pNew
->pWhen
){
1185 rc
= sqlite3ResolveExprNames(&sNC
, pNew
->pWhen
);
1188 for(pStep
=pNew
->step_list
; rc
==SQLITE_OK
&& pStep
; pStep
=pStep
->pNext
){
1189 if( pStep
->pSelect
){
1190 sqlite3SelectPrep(pParse
, pStep
->pSelect
, &sNC
);
1191 if( pParse
->nErr
) rc
= pParse
->rc
;
1193 if( rc
==SQLITE_OK
&& pStep
->zTarget
){
1194 SrcList
*pSrc
= sqlite3TriggerStepSrc(pParse
, pStep
);
1197 for(i
=0; i
<pSrc
->nSrc
&& rc
==SQLITE_OK
; i
++){
1198 struct SrcList_item
*p
= &pSrc
->a
[i
];
1199 p
->pTab
= sqlite3LocateTableItem(pParse
, 0, p
);
1200 p
->iCursor
= pParse
->nTab
++;
1205 rc
= sqlite3ViewGetColumnNames(pParse
, p
->pTab
);
1208 sNC
.pSrcList
= pSrc
;
1209 if( rc
==SQLITE_OK
&& pStep
->pWhere
){
1210 rc
= sqlite3ResolveExprNames(&sNC
, pStep
->pWhere
);
1212 if( rc
==SQLITE_OK
){
1213 rc
= sqlite3ResolveExprListNames(&sNC
, pStep
->pExprList
);
1215 assert( !pStep
->pUpsert
|| (!pStep
->pWhere
&& !pStep
->pExprList
) );
1216 if( pStep
->pUpsert
){
1217 Upsert
*pUpsert
= pStep
->pUpsert
;
1218 assert( rc
==SQLITE_OK
);
1219 pUpsert
->pUpsertSrc
= pSrc
;
1220 sNC
.uNC
.pUpsert
= pUpsert
;
1221 sNC
.ncFlags
= NC_UUpsert
;
1222 rc
= sqlite3ResolveExprListNames(&sNC
, pUpsert
->pUpsertTarget
);
1223 if( rc
==SQLITE_OK
){
1224 ExprList
*pUpsertSet
= pUpsert
->pUpsertSet
;
1225 rc
= sqlite3ResolveExprListNames(&sNC
, pUpsertSet
);
1227 if( rc
==SQLITE_OK
){
1228 rc
= sqlite3ResolveExprNames(&sNC
, pUpsert
->pUpsertWhere
);
1230 if( rc
==SQLITE_OK
){
1231 rc
= sqlite3ResolveExprNames(&sNC
, pUpsert
->pUpsertTargetWhere
);
1236 sqlite3SrcListDelete(db
, pSrc
);
1246 ** Invoke sqlite3WalkExpr() or sqlite3WalkSelect() on all Select or Expr
1247 ** objects that are part of the trigger passed as the second argument.
1249 static void renameWalkTrigger(Walker
*pWalker
, Trigger
*pTrigger
){
1252 /* Find tokens to edit in WHEN clause */
1253 sqlite3WalkExpr(pWalker
, pTrigger
->pWhen
);
1255 /* Find tokens to edit in trigger steps */
1256 for(pStep
=pTrigger
->step_list
; pStep
; pStep
=pStep
->pNext
){
1257 sqlite3WalkSelect(pWalker
, pStep
->pSelect
);
1258 sqlite3WalkExpr(pWalker
, pStep
->pWhere
);
1259 sqlite3WalkExprList(pWalker
, pStep
->pExprList
);
1260 if( pStep
->pUpsert
){
1261 Upsert
*pUpsert
= pStep
->pUpsert
;
1262 sqlite3WalkExprList(pWalker
, pUpsert
->pUpsertTarget
);
1263 sqlite3WalkExprList(pWalker
, pUpsert
->pUpsertSet
);
1264 sqlite3WalkExpr(pWalker
, pUpsert
->pUpsertWhere
);
1265 sqlite3WalkExpr(pWalker
, pUpsert
->pUpsertTargetWhere
);
1271 ** Free the contents of Parse object (*pParse). Do not free the memory
1272 ** occupied by the Parse object itself.
1274 static void renameParseCleanup(Parse
*pParse
){
1275 sqlite3
*db
= pParse
->db
;
1277 if( pParse
->pVdbe
){
1278 sqlite3VdbeFinalize(pParse
->pVdbe
);
1280 sqlite3DeleteTable(db
, pParse
->pNewTable
);
1281 while( (pIdx
= pParse
->pNewIndex
)!=0 ){
1282 pParse
->pNewIndex
= pIdx
->pNext
;
1283 sqlite3FreeIndex(db
, pIdx
);
1285 sqlite3DeleteTrigger(db
, pParse
->pNewTrigger
);
1286 sqlite3DbFree(db
, pParse
->zErrMsg
);
1287 renameTokenFree(db
, pParse
->pRename
);
1288 sqlite3ParserReset(pParse
);
1294 ** sqlite_rename_column(zSql, iCol, bQuote, zNew, zTable, zOld)
1296 ** 0. zSql: SQL statement to rewrite
1297 ** 1. type: Type of object ("table", "view" etc.)
1298 ** 2. object: Name of object
1299 ** 3. Database: Database name (e.g. "main")
1300 ** 4. Table: Table name
1301 ** 5. iCol: Index of column to rename
1302 ** 6. zNew: New column name
1303 ** 7. bQuote: Non-zero if the new column name should be quoted.
1304 ** 8. bTemp: True if zSql comes from temp schema
1306 ** Do a column rename operation on the CREATE statement given in zSql.
1307 ** The iCol-th column (left-most is 0) of table zTable is renamed from zCol
1308 ** into zNew. The name should be quoted if bQuote is true.
1310 ** This function is used internally by the ALTER TABLE RENAME COLUMN command.
1311 ** It is only accessible to SQL created using sqlite3NestedParse(). It is
1312 ** not reachable from ordinary SQL passed into sqlite3_prepare().
1314 static void renameColumnFunc(
1315 sqlite3_context
*context
,
1317 sqlite3_value
**argv
1319 sqlite3
*db
= sqlite3_context_db_handle(context
);
1321 const char *zSql
= (const char*)sqlite3_value_text(argv
[0]);
1322 const char *zDb
= (const char*)sqlite3_value_text(argv
[3]);
1323 const char *zTable
= (const char*)sqlite3_value_text(argv
[4]);
1324 int iCol
= sqlite3_value_int(argv
[5]);
1325 const char *zNew
= (const char*)sqlite3_value_text(argv
[6]);
1326 int bQuote
= sqlite3_value_int(argv
[7]);
1327 int bTemp
= sqlite3_value_int(argv
[8]);
1335 #ifndef SQLITE_OMIT_AUTHORIZATION
1336 sqlite3_xauth xAuth
= db
->xAuth
;
1339 UNUSED_PARAMETER(NotUsed
);
1340 if( zSql
==0 ) return;
1341 if( zTable
==0 ) return;
1342 if( zNew
==0 ) return;
1343 if( iCol
<0 ) return;
1344 sqlite3BtreeEnterAll(db
);
1345 pTab
= sqlite3FindTable(db
, zTable
, zDb
);
1346 if( pTab
==0 || iCol
>=pTab
->nCol
){
1347 sqlite3BtreeLeaveAll(db
);
1350 zOld
= pTab
->aCol
[iCol
].zName
;
1351 memset(&sCtx
, 0, sizeof(sCtx
));
1352 sCtx
.iCol
= ((iCol
==pTab
->iPKey
) ? -1 : iCol
);
1354 #ifndef SQLITE_OMIT_AUTHORIZATION
1357 rc
= renameParseSql(&sParse
, zDb
, db
, zSql
, bTemp
);
1359 /* Find tokens that need to be replaced. */
1360 memset(&sWalker
, 0, sizeof(Walker
));
1361 sWalker
.pParse
= &sParse
;
1362 sWalker
.xExprCallback
= renameColumnExprCb
;
1363 sWalker
.xSelectCallback
= renameColumnSelectCb
;
1364 sWalker
.u
.pRename
= &sCtx
;
1367 if( rc
!=SQLITE_OK
) goto renameColumnFunc_done
;
1368 if( sParse
.pNewTable
){
1369 Select
*pSelect
= sParse
.pNewTable
->pSelect
;
1371 pSelect
->selFlags
&= ~SF_View
;
1372 sParse
.rc
= SQLITE_OK
;
1373 sqlite3SelectPrep(&sParse
, pSelect
, 0);
1374 rc
= (db
->mallocFailed
? SQLITE_NOMEM
: sParse
.rc
);
1375 if( rc
==SQLITE_OK
){
1376 sqlite3WalkSelect(&sWalker
, pSelect
);
1378 if( rc
!=SQLITE_OK
) goto renameColumnFunc_done
;
1380 /* A regular table */
1381 int bFKOnly
= sqlite3_stricmp(zTable
, sParse
.pNewTable
->zName
);
1383 assert( sParse
.pNewTable
->pSelect
==0 );
1384 sCtx
.pTab
= sParse
.pNewTable
;
1387 &sParse
, &sCtx
, (void*)sParse
.pNewTable
->aCol
[iCol
].zName
1390 renameTokenFind(&sParse
, &sCtx
, (void*)&sParse
.pNewTable
->iPKey
);
1392 sqlite3WalkExprList(&sWalker
, sParse
.pNewTable
->pCheck
);
1393 for(pIdx
=sParse
.pNewTable
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
){
1394 sqlite3WalkExprList(&sWalker
, pIdx
->aColExpr
);
1396 for(pIdx
=sParse
.pNewIndex
; pIdx
; pIdx
=pIdx
->pNext
){
1397 sqlite3WalkExprList(&sWalker
, pIdx
->aColExpr
);
1400 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1401 for(i
=0; i
<sParse
.pNewTable
->nCol
; i
++){
1402 sqlite3WalkExpr(&sWalker
, sParse
.pNewTable
->aCol
[i
].pDflt
);
1406 for(pFKey
=sParse
.pNewTable
->pFKey
; pFKey
; pFKey
=pFKey
->pNextFrom
){
1407 for(i
=0; i
<pFKey
->nCol
; i
++){
1408 if( bFKOnly
==0 && pFKey
->aCol
[i
].iFrom
==iCol
){
1409 renameTokenFind(&sParse
, &sCtx
, (void*)&pFKey
->aCol
[i
]);
1411 if( 0==sqlite3_stricmp(pFKey
->zTo
, zTable
)
1412 && 0==sqlite3_stricmp(pFKey
->aCol
[i
].zCol
, zOld
)
1414 renameTokenFind(&sParse
, &sCtx
, (void*)pFKey
->aCol
[i
].zCol
);
1419 }else if( sParse
.pNewIndex
){
1420 sqlite3WalkExprList(&sWalker
, sParse
.pNewIndex
->aColExpr
);
1421 sqlite3WalkExpr(&sWalker
, sParse
.pNewIndex
->pPartIdxWhere
);
1425 rc
= renameResolveTrigger(&sParse
);
1426 if( rc
!=SQLITE_OK
) goto renameColumnFunc_done
;
1428 for(pStep
=sParse
.pNewTrigger
->step_list
; pStep
; pStep
=pStep
->pNext
){
1429 if( pStep
->zTarget
){
1430 Table
*pTarget
= sqlite3LocateTable(&sParse
, 0, pStep
->zTarget
, zDb
);
1431 if( pTarget
==pTab
){
1432 if( pStep
->pUpsert
){
1433 ExprList
*pUpsertSet
= pStep
->pUpsert
->pUpsertSet
;
1434 renameColumnElistNames(&sParse
, &sCtx
, pUpsertSet
, zOld
);
1436 renameColumnIdlistNames(&sParse
, &sCtx
, pStep
->pIdList
, zOld
);
1437 renameColumnElistNames(&sParse
, &sCtx
, pStep
->pExprList
, zOld
);
1443 /* Find tokens to edit in UPDATE OF clause */
1444 if( sParse
.pTriggerTab
==pTab
){
1445 renameColumnIdlistNames(&sParse
, &sCtx
,sParse
.pNewTrigger
->pColumns
,zOld
);
1448 /* Find tokens to edit in various expressions and selects */
1449 renameWalkTrigger(&sWalker
, sParse
.pNewTrigger
);
1452 assert( rc
==SQLITE_OK
);
1453 rc
= renameEditSql(context
, &sCtx
, zSql
, zNew
, bQuote
);
1455 renameColumnFunc_done
:
1456 if( rc
!=SQLITE_OK
){
1457 if( sParse
.zErrMsg
){
1458 renameColumnParseError(context
, 0, argv
[1], argv
[2], &sParse
);
1460 sqlite3_result_error_code(context
, rc
);
1464 renameParseCleanup(&sParse
);
1465 renameTokenFree(db
, sCtx
.pList
);
1466 #ifndef SQLITE_OMIT_AUTHORIZATION
1469 sqlite3BtreeLeaveAll(db
);
1473 ** Walker expression callback used by "RENAME TABLE".
1475 static int renameTableExprCb(Walker
*pWalker
, Expr
*pExpr
){
1476 RenameCtx
*p
= pWalker
->u
.pRename
;
1477 if( pExpr
->op
==TK_COLUMN
&& p
->pTab
==pExpr
->y
.pTab
){
1478 renameTokenFind(pWalker
->pParse
, p
, (void*)&pExpr
->y
.pTab
);
1480 return WRC_Continue
;
1484 ** Walker select callback used by "RENAME TABLE".
1486 static int renameTableSelectCb(Walker
*pWalker
, Select
*pSelect
){
1488 RenameCtx
*p
= pWalker
->u
.pRename
;
1489 SrcList
*pSrc
= pSelect
->pSrc
;
1490 if( pSelect
->selFlags
& SF_View
) return WRC_Prune
;
1492 assert( pWalker
->pParse
->db
->mallocFailed
);
1495 for(i
=0; i
<pSrc
->nSrc
; i
++){
1496 struct SrcList_item
*pItem
= &pSrc
->a
[i
];
1497 if( pItem
->pTab
==p
->pTab
){
1498 renameTokenFind(pWalker
->pParse
, p
, pItem
->zName
);
1501 renameWalkWith(pWalker
, pSelect
);
1503 return WRC_Continue
;
1508 ** This C function implements an SQL user function that is used by SQL code
1509 ** generated by the ALTER TABLE ... RENAME command to modify the definition
1510 ** of any foreign key constraints that use the table being renamed as the
1511 ** parent table. It is passed three arguments:
1513 ** 0: The database containing the table being renamed.
1514 ** 1. type: Type of object ("table", "view" etc.)
1515 ** 2. object: Name of object
1516 ** 3: The complete text of the schema statement being modified,
1517 ** 4: The old name of the table being renamed, and
1518 ** 5: The new name of the table being renamed.
1519 ** 6: True if the schema statement comes from the temp db.
1521 ** It returns the new schema statement. For example:
1523 ** sqlite_rename_table('main', 'CREATE TABLE t1(a REFERENCES t2)','t2','t3',0)
1524 ** -> 'CREATE TABLE t1(a REFERENCES t3)'
1526 static void renameTableFunc(
1527 sqlite3_context
*context
,
1529 sqlite3_value
**argv
1531 sqlite3
*db
= sqlite3_context_db_handle(context
);
1532 const char *zDb
= (const char*)sqlite3_value_text(argv
[0]);
1533 const char *zInput
= (const char*)sqlite3_value_text(argv
[3]);
1534 const char *zOld
= (const char*)sqlite3_value_text(argv
[4]);
1535 const char *zNew
= (const char*)sqlite3_value_text(argv
[5]);
1536 int bTemp
= sqlite3_value_int(argv
[6]);
1537 UNUSED_PARAMETER(NotUsed
);
1539 if( zInput
&& zOld
&& zNew
){
1546 #ifndef SQLITE_OMIT_AUTHORIZATION
1547 sqlite3_xauth xAuth
= db
->xAuth
;
1551 sqlite3BtreeEnterAll(db
);
1553 memset(&sCtx
, 0, sizeof(RenameCtx
));
1554 sCtx
.pTab
= sqlite3FindTable(db
, zOld
, zDb
);
1555 memset(&sWalker
, 0, sizeof(Walker
));
1556 sWalker
.pParse
= &sParse
;
1557 sWalker
.xExprCallback
= renameTableExprCb
;
1558 sWalker
.xSelectCallback
= renameTableSelectCb
;
1559 sWalker
.u
.pRename
= &sCtx
;
1561 rc
= renameParseSql(&sParse
, zDb
, db
, zInput
, bTemp
);
1563 if( rc
==SQLITE_OK
){
1564 int isLegacy
= (db
->flags
& SQLITE_LegacyAlter
);
1565 if( sParse
.pNewTable
){
1566 Table
*pTab
= sParse
.pNewTable
;
1568 if( pTab
->pSelect
){
1570 Select
*pSelect
= pTab
->pSelect
;
1572 memset(&sNC
, 0, sizeof(sNC
));
1573 sNC
.pParse
= &sParse
;
1575 assert( pSelect
->selFlags
& SF_View
);
1576 pSelect
->selFlags
&= ~SF_View
;
1577 sqlite3SelectPrep(&sParse
, pTab
->pSelect
, &sNC
);
1581 sqlite3WalkSelect(&sWalker
, pTab
->pSelect
);
1585 /* Modify any FK definitions to point to the new table. */
1586 #ifndef SQLITE_OMIT_FOREIGN_KEY
1587 if( isLegacy
==0 || (db
->flags
& SQLITE_ForeignKeys
) ){
1589 for(pFKey
=pTab
->pFKey
; pFKey
; pFKey
=pFKey
->pNextFrom
){
1590 if( sqlite3_stricmp(pFKey
->zTo
, zOld
)==0 ){
1591 renameTokenFind(&sParse
, &sCtx
, (void*)pFKey
->zTo
);
1597 /* If this is the table being altered, fix any table refs in CHECK
1598 ** expressions. Also update the name that appears right after the
1599 ** "CREATE [VIRTUAL] TABLE" bit. */
1600 if( sqlite3_stricmp(zOld
, pTab
->zName
)==0 ){
1603 sqlite3WalkExprList(&sWalker
, pTab
->pCheck
);
1605 renameTokenFind(&sParse
, &sCtx
, pTab
->zName
);
1610 else if( sParse
.pNewIndex
){
1611 renameTokenFind(&sParse
, &sCtx
, sParse
.pNewIndex
->zName
);
1613 sqlite3WalkExpr(&sWalker
, sParse
.pNewIndex
->pPartIdxWhere
);
1617 #ifndef SQLITE_OMIT_TRIGGER
1619 Trigger
*pTrigger
= sParse
.pNewTrigger
;
1621 if( 0==sqlite3_stricmp(sParse
.pNewTrigger
->table
, zOld
)
1622 && sCtx
.pTab
->pSchema
==pTrigger
->pTabSchema
1624 renameTokenFind(&sParse
, &sCtx
, sParse
.pNewTrigger
->table
);
1628 rc
= renameResolveTrigger(&sParse
);
1629 if( rc
==SQLITE_OK
){
1630 renameWalkTrigger(&sWalker
, pTrigger
);
1631 for(pStep
=pTrigger
->step_list
; pStep
; pStep
=pStep
->pNext
){
1632 if( pStep
->zTarget
&& 0==sqlite3_stricmp(pStep
->zTarget
, zOld
) ){
1633 renameTokenFind(&sParse
, &sCtx
, pStep
->zTarget
);
1642 if( rc
==SQLITE_OK
){
1643 rc
= renameEditSql(context
, &sCtx
, zInput
, zNew
, bQuote
);
1645 if( rc
!=SQLITE_OK
){
1646 if( sParse
.zErrMsg
){
1647 renameColumnParseError(context
, 0, argv
[1], argv
[2], &sParse
);
1649 sqlite3_result_error_code(context
, rc
);
1653 renameParseCleanup(&sParse
);
1654 renameTokenFree(db
, sCtx
.pList
);
1655 sqlite3BtreeLeaveAll(db
);
1656 #ifndef SQLITE_OMIT_AUTHORIZATION
1665 ** An SQL user function that checks that there are no parse or symbol
1666 ** resolution problems in a CREATE TRIGGER|TABLE|VIEW|INDEX statement.
1667 ** After an ALTER TABLE .. RENAME operation is performed and the schema
1668 ** reloaded, this function is called on each SQL statement in the schema
1669 ** to ensure that it is still usable.
1671 ** 0: Database name ("main", "temp" etc.).
1672 ** 1: SQL statement.
1673 ** 2: Object type ("view", "table", "trigger" or "index").
1675 ** 4: True if object is from temp schema.
1677 ** Unless it finds an error, this function normally returns NULL. However, it
1678 ** returns integer value 1 if:
1680 ** * the SQL argument creates a trigger, and
1681 ** * the table that the trigger is attached to is in database zDb.
1683 static void renameTableTest(
1684 sqlite3_context
*context
,
1686 sqlite3_value
**argv
1688 sqlite3
*db
= sqlite3_context_db_handle(context
);
1689 char const *zDb
= (const char*)sqlite3_value_text(argv
[0]);
1690 char const *zInput
= (const char*)sqlite3_value_text(argv
[1]);
1691 int bTemp
= sqlite3_value_int(argv
[4]);
1692 int isLegacy
= (db
->flags
& SQLITE_LegacyAlter
);
1694 #ifndef SQLITE_OMIT_AUTHORIZATION
1695 sqlite3_xauth xAuth
= db
->xAuth
;
1699 UNUSED_PARAMETER(NotUsed
);
1700 if( zDb
&& zInput
){
1703 rc
= renameParseSql(&sParse
, zDb
, db
, zInput
, bTemp
);
1704 if( rc
==SQLITE_OK
){
1705 if( isLegacy
==0 && sParse
.pNewTable
&& sParse
.pNewTable
->pSelect
){
1707 memset(&sNC
, 0, sizeof(sNC
));
1708 sNC
.pParse
= &sParse
;
1709 sqlite3SelectPrep(&sParse
, sParse
.pNewTable
->pSelect
, &sNC
);
1710 if( sParse
.nErr
) rc
= sParse
.rc
;
1713 else if( sParse
.pNewTrigger
){
1715 rc
= renameResolveTrigger(&sParse
);
1717 if( rc
==SQLITE_OK
){
1718 int i1
= sqlite3SchemaToIndex(db
, sParse
.pNewTrigger
->pTabSchema
);
1719 int i2
= sqlite3FindDbName(db
, zDb
);
1720 if( i1
==i2
) sqlite3_result_int(context
, 1);
1725 if( rc
!=SQLITE_OK
){
1726 renameColumnParseError(context
, 1, argv
[2], argv
[3], &sParse
);
1728 renameParseCleanup(&sParse
);
1731 #ifndef SQLITE_OMIT_AUTHORIZATION
1737 ** Register built-in functions used to help implement ALTER TABLE
1739 void sqlite3AlterFunctions(void){
1740 static FuncDef aAlterTableFuncs
[] = {
1741 INTERNAL_FUNCTION(sqlite_rename_column
, 9, renameColumnFunc
),
1742 INTERNAL_FUNCTION(sqlite_rename_table
, 7, renameTableFunc
),
1743 INTERNAL_FUNCTION(sqlite_rename_test
, 5, renameTableTest
),
1745 sqlite3InsertBuiltinFuncs(aAlterTableFuncs
, ArraySize(aAlterTableFuncs
));
1747 #endif /* SQLITE_ALTER_TABLE */