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
->iCursor
= pParse
->nTab
++;
1201 sqlite3SelectPrep(pParse
, p
->pSelect
, 0);
1202 sqlite3ExpandSubquery(pParse
, p
);
1204 assert( pStep
->pFrom
->a
[i
-1].pSelect
);
1205 sqlite3SelectPrep(pParse
, pStep
->pFrom
->a
[i
-1].pSelect
, 0);
1207 p
->pTab
= sqlite3LocateTableItem(pParse
, 0, p
);
1212 rc
= sqlite3ViewGetColumnNames(pParse
, p
->pTab
);
1216 sNC
.pSrcList
= pSrc
;
1217 if( rc
==SQLITE_OK
&& pStep
->pWhere
){
1218 rc
= sqlite3ResolveExprNames(&sNC
, pStep
->pWhere
);
1220 if( rc
==SQLITE_OK
){
1221 rc
= sqlite3ResolveExprListNames(&sNC
, pStep
->pExprList
);
1223 assert( !pStep
->pUpsert
|| (!pStep
->pWhere
&& !pStep
->pExprList
) );
1224 if( pStep
->pUpsert
){
1225 Upsert
*pUpsert
= pStep
->pUpsert
;
1226 assert( rc
==SQLITE_OK
);
1227 pUpsert
->pUpsertSrc
= pSrc
;
1228 sNC
.uNC
.pUpsert
= pUpsert
;
1229 sNC
.ncFlags
= NC_UUpsert
;
1230 rc
= sqlite3ResolveExprListNames(&sNC
, pUpsert
->pUpsertTarget
);
1231 if( rc
==SQLITE_OK
){
1232 ExprList
*pUpsertSet
= pUpsert
->pUpsertSet
;
1233 rc
= sqlite3ResolveExprListNames(&sNC
, pUpsertSet
);
1235 if( rc
==SQLITE_OK
){
1236 rc
= sqlite3ResolveExprNames(&sNC
, pUpsert
->pUpsertWhere
);
1238 if( rc
==SQLITE_OK
){
1239 rc
= sqlite3ResolveExprNames(&sNC
, pUpsert
->pUpsertTargetWhere
);
1244 sqlite3SrcListDelete(db
, pSrc
);
1254 ** Invoke sqlite3WalkExpr() or sqlite3WalkSelect() on all Select or Expr
1255 ** objects that are part of the trigger passed as the second argument.
1257 static void renameWalkTrigger(Walker
*pWalker
, Trigger
*pTrigger
){
1260 /* Find tokens to edit in WHEN clause */
1261 sqlite3WalkExpr(pWalker
, pTrigger
->pWhen
);
1263 /* Find tokens to edit in trigger steps */
1264 for(pStep
=pTrigger
->step_list
; pStep
; pStep
=pStep
->pNext
){
1265 sqlite3WalkSelect(pWalker
, pStep
->pSelect
);
1266 sqlite3WalkExpr(pWalker
, pStep
->pWhere
);
1267 sqlite3WalkExprList(pWalker
, pStep
->pExprList
);
1268 if( pStep
->pUpsert
){
1269 Upsert
*pUpsert
= pStep
->pUpsert
;
1270 sqlite3WalkExprList(pWalker
, pUpsert
->pUpsertTarget
);
1271 sqlite3WalkExprList(pWalker
, pUpsert
->pUpsertSet
);
1272 sqlite3WalkExpr(pWalker
, pUpsert
->pUpsertWhere
);
1273 sqlite3WalkExpr(pWalker
, pUpsert
->pUpsertTargetWhere
);
1277 for(i
=0; i
<pStep
->pFrom
->nSrc
; i
++){
1278 sqlite3WalkSelect(pWalker
, pStep
->pFrom
->a
[i
].pSelect
);
1285 ** Free the contents of Parse object (*pParse). Do not free the memory
1286 ** occupied by the Parse object itself.
1288 static void renameParseCleanup(Parse
*pParse
){
1289 sqlite3
*db
= pParse
->db
;
1291 if( pParse
->pVdbe
){
1292 sqlite3VdbeFinalize(pParse
->pVdbe
);
1294 sqlite3DeleteTable(db
, pParse
->pNewTable
);
1295 while( (pIdx
= pParse
->pNewIndex
)!=0 ){
1296 pParse
->pNewIndex
= pIdx
->pNext
;
1297 sqlite3FreeIndex(db
, pIdx
);
1299 sqlite3DeleteTrigger(db
, pParse
->pNewTrigger
);
1300 sqlite3DbFree(db
, pParse
->zErrMsg
);
1301 renameTokenFree(db
, pParse
->pRename
);
1302 sqlite3ParserReset(pParse
);
1308 ** sqlite_rename_column(zSql, iCol, bQuote, zNew, zTable, zOld)
1310 ** 0. zSql: SQL statement to rewrite
1311 ** 1. type: Type of object ("table", "view" etc.)
1312 ** 2. object: Name of object
1313 ** 3. Database: Database name (e.g. "main")
1314 ** 4. Table: Table name
1315 ** 5. iCol: Index of column to rename
1316 ** 6. zNew: New column name
1317 ** 7. bQuote: Non-zero if the new column name should be quoted.
1318 ** 8. bTemp: True if zSql comes from temp schema
1320 ** Do a column rename operation on the CREATE statement given in zSql.
1321 ** The iCol-th column (left-most is 0) of table zTable is renamed from zCol
1322 ** into zNew. The name should be quoted if bQuote is true.
1324 ** This function is used internally by the ALTER TABLE RENAME COLUMN command.
1325 ** It is only accessible to SQL created using sqlite3NestedParse(). It is
1326 ** not reachable from ordinary SQL passed into sqlite3_prepare().
1328 static void renameColumnFunc(
1329 sqlite3_context
*context
,
1331 sqlite3_value
**argv
1333 sqlite3
*db
= sqlite3_context_db_handle(context
);
1335 const char *zSql
= (const char*)sqlite3_value_text(argv
[0]);
1336 const char *zDb
= (const char*)sqlite3_value_text(argv
[3]);
1337 const char *zTable
= (const char*)sqlite3_value_text(argv
[4]);
1338 int iCol
= sqlite3_value_int(argv
[5]);
1339 const char *zNew
= (const char*)sqlite3_value_text(argv
[6]);
1340 int bQuote
= sqlite3_value_int(argv
[7]);
1341 int bTemp
= sqlite3_value_int(argv
[8]);
1349 #ifndef SQLITE_OMIT_AUTHORIZATION
1350 sqlite3_xauth xAuth
= db
->xAuth
;
1353 UNUSED_PARAMETER(NotUsed
);
1354 if( zSql
==0 ) return;
1355 if( zTable
==0 ) return;
1356 if( zNew
==0 ) return;
1357 if( iCol
<0 ) return;
1358 sqlite3BtreeEnterAll(db
);
1359 pTab
= sqlite3FindTable(db
, zTable
, zDb
);
1360 if( pTab
==0 || iCol
>=pTab
->nCol
){
1361 sqlite3BtreeLeaveAll(db
);
1364 zOld
= pTab
->aCol
[iCol
].zName
;
1365 memset(&sCtx
, 0, sizeof(sCtx
));
1366 sCtx
.iCol
= ((iCol
==pTab
->iPKey
) ? -1 : iCol
);
1368 #ifndef SQLITE_OMIT_AUTHORIZATION
1371 rc
= renameParseSql(&sParse
, zDb
, db
, zSql
, bTemp
);
1373 /* Find tokens that need to be replaced. */
1374 memset(&sWalker
, 0, sizeof(Walker
));
1375 sWalker
.pParse
= &sParse
;
1376 sWalker
.xExprCallback
= renameColumnExprCb
;
1377 sWalker
.xSelectCallback
= renameColumnSelectCb
;
1378 sWalker
.u
.pRename
= &sCtx
;
1381 if( rc
!=SQLITE_OK
) goto renameColumnFunc_done
;
1382 if( sParse
.pNewTable
){
1383 Select
*pSelect
= sParse
.pNewTable
->pSelect
;
1385 pSelect
->selFlags
&= ~SF_View
;
1386 sParse
.rc
= SQLITE_OK
;
1387 sqlite3SelectPrep(&sParse
, pSelect
, 0);
1388 rc
= (db
->mallocFailed
? SQLITE_NOMEM
: sParse
.rc
);
1389 if( rc
==SQLITE_OK
){
1390 sqlite3WalkSelect(&sWalker
, pSelect
);
1392 if( rc
!=SQLITE_OK
) goto renameColumnFunc_done
;
1394 /* A regular table */
1395 int bFKOnly
= sqlite3_stricmp(zTable
, sParse
.pNewTable
->zName
);
1397 assert( sParse
.pNewTable
->pSelect
==0 );
1398 sCtx
.pTab
= sParse
.pNewTable
;
1401 &sParse
, &sCtx
, (void*)sParse
.pNewTable
->aCol
[iCol
].zName
1404 renameTokenFind(&sParse
, &sCtx
, (void*)&sParse
.pNewTable
->iPKey
);
1406 sqlite3WalkExprList(&sWalker
, sParse
.pNewTable
->pCheck
);
1407 for(pIdx
=sParse
.pNewTable
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
){
1408 sqlite3WalkExprList(&sWalker
, pIdx
->aColExpr
);
1410 for(pIdx
=sParse
.pNewIndex
; pIdx
; pIdx
=pIdx
->pNext
){
1411 sqlite3WalkExprList(&sWalker
, pIdx
->aColExpr
);
1414 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1415 for(i
=0; i
<sParse
.pNewTable
->nCol
; i
++){
1416 sqlite3WalkExpr(&sWalker
, sParse
.pNewTable
->aCol
[i
].pDflt
);
1420 for(pFKey
=sParse
.pNewTable
->pFKey
; pFKey
; pFKey
=pFKey
->pNextFrom
){
1421 for(i
=0; i
<pFKey
->nCol
; i
++){
1422 if( bFKOnly
==0 && pFKey
->aCol
[i
].iFrom
==iCol
){
1423 renameTokenFind(&sParse
, &sCtx
, (void*)&pFKey
->aCol
[i
]);
1425 if( 0==sqlite3_stricmp(pFKey
->zTo
, zTable
)
1426 && 0==sqlite3_stricmp(pFKey
->aCol
[i
].zCol
, zOld
)
1428 renameTokenFind(&sParse
, &sCtx
, (void*)pFKey
->aCol
[i
].zCol
);
1433 }else if( sParse
.pNewIndex
){
1434 sqlite3WalkExprList(&sWalker
, sParse
.pNewIndex
->aColExpr
);
1435 sqlite3WalkExpr(&sWalker
, sParse
.pNewIndex
->pPartIdxWhere
);
1439 rc
= renameResolveTrigger(&sParse
);
1440 if( rc
!=SQLITE_OK
) goto renameColumnFunc_done
;
1442 for(pStep
=sParse
.pNewTrigger
->step_list
; pStep
; pStep
=pStep
->pNext
){
1443 if( pStep
->zTarget
){
1444 Table
*pTarget
= sqlite3LocateTable(&sParse
, 0, pStep
->zTarget
, zDb
);
1445 if( pTarget
==pTab
){
1446 if( pStep
->pUpsert
){
1447 ExprList
*pUpsertSet
= pStep
->pUpsert
->pUpsertSet
;
1448 renameColumnElistNames(&sParse
, &sCtx
, pUpsertSet
, zOld
);
1450 renameColumnIdlistNames(&sParse
, &sCtx
, pStep
->pIdList
, zOld
);
1451 renameColumnElistNames(&sParse
, &sCtx
, pStep
->pExprList
, zOld
);
1457 /* Find tokens to edit in UPDATE OF clause */
1458 if( sParse
.pTriggerTab
==pTab
){
1459 renameColumnIdlistNames(&sParse
, &sCtx
,sParse
.pNewTrigger
->pColumns
,zOld
);
1462 /* Find tokens to edit in various expressions and selects */
1463 renameWalkTrigger(&sWalker
, sParse
.pNewTrigger
);
1466 assert( rc
==SQLITE_OK
);
1467 rc
= renameEditSql(context
, &sCtx
, zSql
, zNew
, bQuote
);
1469 renameColumnFunc_done
:
1470 if( rc
!=SQLITE_OK
){
1471 if( sParse
.zErrMsg
){
1472 renameColumnParseError(context
, 0, argv
[1], argv
[2], &sParse
);
1474 sqlite3_result_error_code(context
, rc
);
1478 renameParseCleanup(&sParse
);
1479 renameTokenFree(db
, sCtx
.pList
);
1480 #ifndef SQLITE_OMIT_AUTHORIZATION
1483 sqlite3BtreeLeaveAll(db
);
1487 ** Walker expression callback used by "RENAME TABLE".
1489 static int renameTableExprCb(Walker
*pWalker
, Expr
*pExpr
){
1490 RenameCtx
*p
= pWalker
->u
.pRename
;
1491 if( pExpr
->op
==TK_COLUMN
&& p
->pTab
==pExpr
->y
.pTab
){
1492 renameTokenFind(pWalker
->pParse
, p
, (void*)&pExpr
->y
.pTab
);
1494 return WRC_Continue
;
1498 ** Walker select callback used by "RENAME TABLE".
1500 static int renameTableSelectCb(Walker
*pWalker
, Select
*pSelect
){
1502 RenameCtx
*p
= pWalker
->u
.pRename
;
1503 SrcList
*pSrc
= pSelect
->pSrc
;
1504 if( pSelect
->selFlags
& SF_View
) return WRC_Prune
;
1506 assert( pWalker
->pParse
->db
->mallocFailed
);
1509 for(i
=0; i
<pSrc
->nSrc
; i
++){
1510 struct SrcList_item
*pItem
= &pSrc
->a
[i
];
1511 if( pItem
->pTab
==p
->pTab
){
1512 renameTokenFind(pWalker
->pParse
, p
, pItem
->zName
);
1515 renameWalkWith(pWalker
, pSelect
);
1517 return WRC_Continue
;
1522 ** This C function implements an SQL user function that is used by SQL code
1523 ** generated by the ALTER TABLE ... RENAME command to modify the definition
1524 ** of any foreign key constraints that use the table being renamed as the
1525 ** parent table. It is passed three arguments:
1527 ** 0: The database containing the table being renamed.
1528 ** 1. type: Type of object ("table", "view" etc.)
1529 ** 2. object: Name of object
1530 ** 3: The complete text of the schema statement being modified,
1531 ** 4: The old name of the table being renamed, and
1532 ** 5: The new name of the table being renamed.
1533 ** 6: True if the schema statement comes from the temp db.
1535 ** It returns the new schema statement. For example:
1537 ** sqlite_rename_table('main', 'CREATE TABLE t1(a REFERENCES t2)','t2','t3',0)
1538 ** -> 'CREATE TABLE t1(a REFERENCES t3)'
1540 static void renameTableFunc(
1541 sqlite3_context
*context
,
1543 sqlite3_value
**argv
1545 sqlite3
*db
= sqlite3_context_db_handle(context
);
1546 const char *zDb
= (const char*)sqlite3_value_text(argv
[0]);
1547 const char *zInput
= (const char*)sqlite3_value_text(argv
[3]);
1548 const char *zOld
= (const char*)sqlite3_value_text(argv
[4]);
1549 const char *zNew
= (const char*)sqlite3_value_text(argv
[5]);
1550 int bTemp
= sqlite3_value_int(argv
[6]);
1551 UNUSED_PARAMETER(NotUsed
);
1553 if( zInput
&& zOld
&& zNew
){
1560 #ifndef SQLITE_OMIT_AUTHORIZATION
1561 sqlite3_xauth xAuth
= db
->xAuth
;
1565 sqlite3BtreeEnterAll(db
);
1567 memset(&sCtx
, 0, sizeof(RenameCtx
));
1568 sCtx
.pTab
= sqlite3FindTable(db
, zOld
, zDb
);
1569 memset(&sWalker
, 0, sizeof(Walker
));
1570 sWalker
.pParse
= &sParse
;
1571 sWalker
.xExprCallback
= renameTableExprCb
;
1572 sWalker
.xSelectCallback
= renameTableSelectCb
;
1573 sWalker
.u
.pRename
= &sCtx
;
1575 rc
= renameParseSql(&sParse
, zDb
, db
, zInput
, bTemp
);
1577 if( rc
==SQLITE_OK
){
1578 int isLegacy
= (db
->flags
& SQLITE_LegacyAlter
);
1579 if( sParse
.pNewTable
){
1580 Table
*pTab
= sParse
.pNewTable
;
1582 if( pTab
->pSelect
){
1584 Select
*pSelect
= pTab
->pSelect
;
1586 memset(&sNC
, 0, sizeof(sNC
));
1587 sNC
.pParse
= &sParse
;
1589 assert( pSelect
->selFlags
& SF_View
);
1590 pSelect
->selFlags
&= ~SF_View
;
1591 sqlite3SelectPrep(&sParse
, pTab
->pSelect
, &sNC
);
1595 sqlite3WalkSelect(&sWalker
, pTab
->pSelect
);
1599 /* Modify any FK definitions to point to the new table. */
1600 #ifndef SQLITE_OMIT_FOREIGN_KEY
1601 if( isLegacy
==0 || (db
->flags
& SQLITE_ForeignKeys
) ){
1603 for(pFKey
=pTab
->pFKey
; pFKey
; pFKey
=pFKey
->pNextFrom
){
1604 if( sqlite3_stricmp(pFKey
->zTo
, zOld
)==0 ){
1605 renameTokenFind(&sParse
, &sCtx
, (void*)pFKey
->zTo
);
1611 /* If this is the table being altered, fix any table refs in CHECK
1612 ** expressions. Also update the name that appears right after the
1613 ** "CREATE [VIRTUAL] TABLE" bit. */
1614 if( sqlite3_stricmp(zOld
, pTab
->zName
)==0 ){
1617 sqlite3WalkExprList(&sWalker
, pTab
->pCheck
);
1619 renameTokenFind(&sParse
, &sCtx
, pTab
->zName
);
1624 else if( sParse
.pNewIndex
){
1625 renameTokenFind(&sParse
, &sCtx
, sParse
.pNewIndex
->zName
);
1627 sqlite3WalkExpr(&sWalker
, sParse
.pNewIndex
->pPartIdxWhere
);
1631 #ifndef SQLITE_OMIT_TRIGGER
1633 Trigger
*pTrigger
= sParse
.pNewTrigger
;
1635 if( 0==sqlite3_stricmp(sParse
.pNewTrigger
->table
, zOld
)
1636 && sCtx
.pTab
->pSchema
==pTrigger
->pTabSchema
1638 renameTokenFind(&sParse
, &sCtx
, sParse
.pNewTrigger
->table
);
1642 rc
= renameResolveTrigger(&sParse
);
1643 if( rc
==SQLITE_OK
){
1644 renameWalkTrigger(&sWalker
, pTrigger
);
1645 for(pStep
=pTrigger
->step_list
; pStep
; pStep
=pStep
->pNext
){
1646 if( pStep
->zTarget
&& 0==sqlite3_stricmp(pStep
->zTarget
, zOld
) ){
1647 renameTokenFind(&sParse
, &sCtx
, pStep
->zTarget
);
1656 if( rc
==SQLITE_OK
){
1657 rc
= renameEditSql(context
, &sCtx
, zInput
, zNew
, bQuote
);
1659 if( rc
!=SQLITE_OK
){
1660 if( sParse
.zErrMsg
){
1661 renameColumnParseError(context
, 0, argv
[1], argv
[2], &sParse
);
1663 sqlite3_result_error_code(context
, rc
);
1667 renameParseCleanup(&sParse
);
1668 renameTokenFree(db
, sCtx
.pList
);
1669 sqlite3BtreeLeaveAll(db
);
1670 #ifndef SQLITE_OMIT_AUTHORIZATION
1679 ** An SQL user function that checks that there are no parse or symbol
1680 ** resolution problems in a CREATE TRIGGER|TABLE|VIEW|INDEX statement.
1681 ** After an ALTER TABLE .. RENAME operation is performed and the schema
1682 ** reloaded, this function is called on each SQL statement in the schema
1683 ** to ensure that it is still usable.
1685 ** 0: Database name ("main", "temp" etc.).
1686 ** 1: SQL statement.
1687 ** 2: Object type ("view", "table", "trigger" or "index").
1689 ** 4: True if object is from temp schema.
1691 ** Unless it finds an error, this function normally returns NULL. However, it
1692 ** returns integer value 1 if:
1694 ** * the SQL argument creates a trigger, and
1695 ** * the table that the trigger is attached to is in database zDb.
1697 static void renameTableTest(
1698 sqlite3_context
*context
,
1700 sqlite3_value
**argv
1702 sqlite3
*db
= sqlite3_context_db_handle(context
);
1703 char const *zDb
= (const char*)sqlite3_value_text(argv
[0]);
1704 char const *zInput
= (const char*)sqlite3_value_text(argv
[1]);
1705 int bTemp
= sqlite3_value_int(argv
[4]);
1706 int isLegacy
= (db
->flags
& SQLITE_LegacyAlter
);
1708 #ifndef SQLITE_OMIT_AUTHORIZATION
1709 sqlite3_xauth xAuth
= db
->xAuth
;
1713 UNUSED_PARAMETER(NotUsed
);
1714 if( zDb
&& zInput
){
1717 rc
= renameParseSql(&sParse
, zDb
, db
, zInput
, bTemp
);
1718 if( rc
==SQLITE_OK
){
1719 if( isLegacy
==0 && sParse
.pNewTable
&& sParse
.pNewTable
->pSelect
){
1721 memset(&sNC
, 0, sizeof(sNC
));
1722 sNC
.pParse
= &sParse
;
1723 sqlite3SelectPrep(&sParse
, sParse
.pNewTable
->pSelect
, &sNC
);
1724 if( sParse
.nErr
) rc
= sParse
.rc
;
1727 else if( sParse
.pNewTrigger
){
1729 rc
= renameResolveTrigger(&sParse
);
1731 if( rc
==SQLITE_OK
){
1732 int i1
= sqlite3SchemaToIndex(db
, sParse
.pNewTrigger
->pTabSchema
);
1733 int i2
= sqlite3FindDbName(db
, zDb
);
1734 if( i1
==i2
) sqlite3_result_int(context
, 1);
1739 if( rc
!=SQLITE_OK
){
1740 renameColumnParseError(context
, 1, argv
[2], argv
[3], &sParse
);
1742 renameParseCleanup(&sParse
);
1745 #ifndef SQLITE_OMIT_AUTHORIZATION
1751 ** Register built-in functions used to help implement ALTER TABLE
1753 void sqlite3AlterFunctions(void){
1754 static FuncDef aAlterTableFuncs
[] = {
1755 INTERNAL_FUNCTION(sqlite_rename_column
, 9, renameColumnFunc
),
1756 INTERNAL_FUNCTION(sqlite_rename_table
, 7, renameTableFunc
),
1757 INTERNAL_FUNCTION(sqlite_rename_test
, 5, renameTableTest
),
1759 sqlite3InsertBuiltinFuncs(aAlterTableFuncs
, ArraySize(aAlterTableFuncs
));
1761 #endif /* SQLITE_ALTER_TABLE */