/*

** 2005 February 15

**

** The author disclaims copyright to this source code. In place of

** a legal notice, here is a blessing:

**

** May you do good and not evil.

** May you find forgiveness for yourself and forgive others.

** May you share freely, never taking more than you give.

**

*************************************************************************

** This file contains C code routines that used to generate VDBE code

** that implements the ALTER TABLE command.

*/

#include "sqliteInt.h"

/*

** The code in this file only exists if we are not omitting the

** ALTER TABLE logic from the build.

*/

#ifndef SQLITE_OMIT_ALTERTABLE

/*

** Parameter zName is the name of a table that is about to be altered

** (either with ALTER TABLE ... RENAME TO or ALTER TABLE ... ADD COLUMN).

** If the table is a system table, this function leaves an error message

** in pParse->zErr (system tables may not be altered) and returns non-zero.

**

** Or, if zName is not a system table, zero is returned.

*/

static int isAlterableTable(Parse *pParse, Table *pTab){

if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7)

#ifndef SQLITE_OMIT_VIRTUALTABLE

|| (pTab->tabFlags & TF_Eponymous)!=0

|| ( (pTab->tabFlags & TF_Shadow)!=0

&& sqlite3ReadOnlyShadowTables(pParse->db)

)

#endif

){

sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName);

return 1;

}

return 0;

}

/*

** Generate code to verify that the schemas of database zDb and, if

** bTemp is not true, database "temp", can still be parsed. This is

** called at the end of the generation of an ALTER TABLE ... RENAME ...

** statement to ensure that the operation has not rendered any schema

** objects unusable.

*/

static void renameTestSchema(

Parse *pParse, /* Parse context */

const char *zDb, /* Name of db to verify schema of */

int bTemp, /* True if this is the temp db */

const char *zWhen, /* "when" part of error message */

int bNoDQS /* Do not allow DQS in the schema */

){

pParse->colNamesSet = 1;

sqlite3NestedParse(pParse,

"SELECT 1 "

"FROM \"%w\"." LEGACY_SCHEMA_TABLE " "

"WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"

" AND sql NOT LIKE 'create virtual%%'"

" AND sqlite_rename_test(%Q, sql, type, name, %d, %Q, %d)=NULL ",

zDb,

zDb, bTemp, zWhen, bNoDQS

);

if( bTemp==0 ){

sqlite3NestedParse(pParse,

"SELECT 1 "

"FROM temp." LEGACY_SCHEMA_TABLE " "

"WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"

" AND sql NOT LIKE 'create virtual%%'"

" AND sqlite_rename_test(%Q, sql, type, name, 1, %Q, %d)=NULL ",

zDb, zWhen, bNoDQS

);

}

}

/*

** Generate VM code to replace any double-quoted strings (but not double-quoted

** identifiers) within the "sql" column of the sqlite_schema table in

** database zDb with their single-quoted equivalents. If argument bTemp is

** not true, similarly update all SQL statements in the sqlite_schema table

** of the temp db.

*/

static void renameFixQuotes(Parse *pParse, const char *zDb, int bTemp){

sqlite3NestedParse(pParse,

"UPDATE \"%w\"." LEGACY_SCHEMA_TABLE

" SET sql = sqlite_rename_quotefix(%Q, sql)"

"WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"

" AND sql NOT LIKE 'create virtual%%'" , zDb, zDb

);

if( bTemp==0 ){

sqlite3NestedParse(pParse,

"UPDATE temp." LEGACY_SCHEMA_TABLE

" SET sql = sqlite_rename_quotefix('temp', sql)"

"WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"

" AND sql NOT LIKE 'create virtual%%'"

);

}

}

/*

** Generate code to reload the schema for database iDb. And, if iDb!=1, for

** the temp database as well.

*/

static void renameReloadSchema(Parse *pParse, int iDb, u16 p5){

Vdbe *v = pParse->pVdbe;

if( v ){

sqlite3ChangeCookie(pParse, iDb);

sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, iDb, 0, p5);

if( iDb!=1 ) sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, 1, 0, p5);

}

}

/*

** Generate code to implement the "ALTER TABLE xxx RENAME TO yyy"

** command.

*/

void sqlite3AlterRenameTable(

Parse *pParse, /* Parser context. */

SrcList *pSrc, /* The table to rename. */

Token *pName /* The new table name. */

){

int iDb; /* Database that contains the table */

char *zDb; /* Name of database iDb */

Table *pTab; /* Table being renamed */

char *zName = 0; /* NULL-terminated version of pName */

sqlite3 *db = pParse->db; /* Database connection */

int nTabName; /* Number of UTF-8 characters in zTabName */

const char *zTabName; /* Original name of the table */

Vdbe *v;

VTable *pVTab = 0; /* Non-zero if this is a v-tab with an xRename() */

if( NEVER(db->mallocFailed) ) goto exit_rename_table;

assert( pSrc->nSrc==1 );

assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );

pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);

if( !pTab ) goto exit_rename_table;

iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);

zDb = db->aDb[iDb].zDbSName;

/* Get a NULL terminated version of the new table name. */

zName = sqlite3NameFromToken(db, pName);

if( !zName ) goto exit_rename_table;

/* Check that a table or index named 'zName' does not already exist

** in database iDb. If so, this is an error.

*/

if( sqlite3FindTable(db, zName, zDb)

|| sqlite3FindIndex(db, zName, zDb)

|| sqlite3IsShadowTableOf(db, pTab, zName)

){

sqlite3ErrorMsg(pParse,

"there is already another table or index with this name: %s", zName);

goto exit_rename_table;

}

/* Make sure it is not a system table being altered, or a reserved name

** that the table is being renamed to.

*/

if( SQLITE_OK!=isAlterableTable(pParse, pTab) ){

goto exit_rename_table;

}

if( SQLITE_OK!=sqlite3CheckObjectName(pParse,zName,"table",zName) ){

goto exit_rename_table;

}

#ifndef SQLITE_OMIT_VIEW

if( IsView(pTab) ){

sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);

goto exit_rename_table;

}

#endif

#ifndef SQLITE_OMIT_AUTHORIZATION

/* Invoke the authorization callback. */

if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){

goto exit_rename_table;

}

#endif

#ifndef SQLITE_OMIT_VIRTUALTABLE

if( sqlite3ViewGetColumnNames(pParse, pTab) ){

goto exit_rename_table;

}

if( IsVirtual(pTab) ){

pVTab = sqlite3GetVTable(db, pTab);

if( pVTab->pVtab->pModule->xRename==0 ){

pVTab = 0;

}

}

#endif

/* Begin a transaction for database iDb. Then modify the schema cookie

** (since the ALTER TABLE modifies the schema). Call sqlite3MayAbort(),

** as the scalar functions (e.g. sqlite_rename_table()) invoked by the

** nested SQL may raise an exception. */

v = sqlite3GetVdbe(pParse);

if( v==0 ){

goto exit_rename_table;

}

sqlite3MayAbort(pParse);

/* figure out how many UTF-8 characters are in zName */

zTabName = pTab->zName;

nTabName = sqlite3Utf8CharLen(zTabName, -1);

/* Rewrite all CREATE TABLE, INDEX, TRIGGER or VIEW statements in

** the schema to use the new table name. */

sqlite3NestedParse(pParse,

"UPDATE \"%w\"." LEGACY_SCHEMA_TABLE " SET "

"sql = sqlite_rename_table(%Q, type, name, sql, %Q, %Q, %d) "

"WHERE (type!='index' OR tbl_name=%Q COLLATE nocase)"

"AND name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"

, zDb, zDb, zTabName, zName, (iDb==1), zTabName

);

/* Update the tbl_name and name columns of the sqlite_schema table

** as required. */

sqlite3NestedParse(pParse,

"UPDATE %Q." LEGACY_SCHEMA_TABLE " SET "

"tbl_name = %Q, "

"name = CASE "

"WHEN type='table' THEN %Q "

"WHEN name LIKE 'sqliteX_autoindex%%' ESCAPE 'X' "

" AND type='index' THEN "

"'sqlite_autoindex_' || %Q || substr(name,%d+18) "

"ELSE name END "

"WHERE tbl_name=%Q COLLATE nocase AND "

"(type='table' OR type='index' OR type='trigger');",

zDb,

zName, zName, zName,

nTabName, zTabName

);

#ifndef SQLITE_OMIT_AUTOINCREMENT

/* If the sqlite_sequence table exists in this database, then update

** it with the new table name.

*/

if( sqlite3FindTable(db, "sqlite_sequence", zDb) ){

sqlite3NestedParse(pParse,

"UPDATE \"%w\".sqlite_sequence set name = %Q WHERE name = %Q",

zDb, zName, pTab->zName);

}

#endif

/* If the table being renamed is not itself part of the temp database,

** edit view and trigger definitions within the temp database

** as required. */

if( iDb!=1 ){

sqlite3NestedParse(pParse,

"UPDATE sqlite_temp_schema SET "

"sql = sqlite_rename_table(%Q, type, name, sql, %Q, %Q, 1), "

"tbl_name = "

"CASE WHEN tbl_name=%Q COLLATE nocase AND "

" sqlite_rename_test(%Q, sql, type, name, 1, 'after rename', 0) "

"THEN %Q ELSE tbl_name END "

"WHERE type IN ('view', 'trigger')"

, zDb, zTabName, zName, zTabName, zDb, zName);

}

/* If this is a virtual table, invoke the xRename() function if

** one is defined. The xRename() callback will modify the names

** of any resources used by the v-table implementation (including other

** SQLite tables) that are identified by the name of the virtual table.

*/

#ifndef SQLITE_OMIT_VIRTUALTABLE

if( pVTab ){

int i = ++pParse->nMem;

sqlite3VdbeLoadString(v, i, zName);

sqlite3VdbeAddOp4(v, OP_VRename, i, 0, 0,(const char*)pVTab, P4_VTAB);

}

#endif

renameReloadSchema(pParse, iDb, INITFLAG_AlterRename);

renameTestSchema(pParse, zDb, iDb==1, "after rename", 0);

exit_rename_table:

sqlite3SrcListDelete(db, pSrc);

sqlite3DbFree(db, zName);

}

/*

** Write code that will raise an error if the table described by

** zDb and zTab is not empty.

*/

static void sqlite3ErrorIfNotEmpty(

Parse *pParse, /* Parsing context */

const char *zDb, /* Schema holding the table */

const char *zTab, /* Table to check for empty */

const char *zErr /* Error message text */

){

sqlite3NestedParse(pParse,

"SELECT raise(ABORT,%Q) FROM \"%w\".\"%w\"",

zErr, zDb, zTab

);

}

/*

** This function is called after an "ALTER TABLE ... ADD" statement

** has been parsed. Argument pColDef contains the text of the new

** column definition.

**

** The Table structure pParse->pNewTable was extended to include

** the new column during parsing.

*/

void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){

Table *pNew; /* Copy of pParse->pNewTable */

Table *pTab; /* Table being altered */

int iDb; /* Database number */

const char *zDb; /* Database name */

const char *zTab; /* Table name */

char *zCol; /* Null-terminated column definition */

Column *pCol; /* The new column */

Expr *pDflt; /* Default value for the new column */

sqlite3 *db; /* The database connection; */

Vdbe *v; /* The prepared statement under construction */

int r1; /* Temporary registers */

db = pParse->db;

if( pParse->nErr || db->mallocFailed ) return;

pNew = pParse->pNewTable;

assert( pNew );

assert( sqlite3BtreeHoldsAllMutexes(db) );

iDb = sqlite3SchemaToIndex(db, pNew->pSchema);

zDb = db->aDb[iDb].zDbSName;

zTab = &pNew->zName[16]; /* Skip the "sqlite_altertab_" prefix on the name */

pCol = &pNew->aCol[pNew->nCol-1];

pDflt = sqlite3ColumnExpr(pNew, pCol);

pTab = sqlite3FindTable(db, zTab, zDb);

assert( pTab );

#ifndef SQLITE_OMIT_AUTHORIZATION

/* Invoke the authorization callback. */

if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){

return;

}

#endif

/* Check that the new column is not specified as PRIMARY KEY or UNIQUE.

** If there is a NOT NULL constraint, then the default value for the

** column must not be NULL.

*/

if( pCol->colFlags & COLFLAG_PRIMKEY ){

sqlite3ErrorMsg(pParse, "Cannot add a PRIMARY KEY column");

return;

}

if( pNew->pIndex ){

sqlite3ErrorMsg(pParse,

"Cannot add a UNIQUE column");

return;

}

if( (pCol->colFlags & COLFLAG_GENERATED)==0 ){

/* If the default value for the new column was specified with a

** literal NULL, then set pDflt to 0. This simplifies checking

** for an SQL NULL default below.

*/

assert( pDflt==0 || pDflt->op==TK_SPAN );

if( pDflt && pDflt->pLeft->op==TK_NULL ){

pDflt = 0;

}

assert( IsOrdinaryTable(pNew) );

if( (db->flags&SQLITE_ForeignKeys) && pNew->u.tab.pFKey && pDflt ){

sqlite3ErrorIfNotEmpty(pParse, zDb, zTab,

"Cannot add a REFERENCES column with non-NULL default value");

}

if( pCol->notNull && !pDflt ){

sqlite3ErrorIfNotEmpty(pParse, zDb, zTab,

"Cannot add a NOT NULL column with default value NULL");

}

/* Ensure the default expression is something that sqlite3ValueFromExpr()

** can handle (i.e. not CURRENT_TIME etc.)

*/

if( pDflt ){

sqlite3_value *pVal = 0;

int rc;

rc = sqlite3ValueFromExpr(db, pDflt, SQLITE_UTF8, SQLITE_AFF_BLOB, &pVal);

assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );

if( rc!=SQLITE_OK ){

assert( db->mallocFailed == 1 );

return;

}

if( !pVal ){

sqlite3ErrorIfNotEmpty(pParse, zDb, zTab,

"Cannot add a column with non-constant default");

}

sqlite3ValueFree(pVal);

}

}else if( pCol->colFlags & COLFLAG_STORED ){

sqlite3ErrorIfNotEmpty(pParse, zDb, zTab, "cannot add a STORED column");

}

/* Modify the CREATE TABLE statement. */

zCol = sqlite3DbStrNDup(db, (char*)pColDef->z, pColDef->n);

if( zCol ){

char *zEnd = &zCol[pColDef->n-1];

while( zEnd>zCol && (*zEnd==';' || sqlite3Isspace(*zEnd)) ){

*zEnd-- = '\0';

}

/* substr() operations on characters, but addColOffset is in bytes. So we

** have to use printf() to translate between these units: */

assert( IsOrdinaryTable(pTab) );

assert( IsOrdinaryTable(pNew) );

sqlite3NestedParse(pParse,

"UPDATE \"%w\"." LEGACY_SCHEMA_TABLE " SET "

"sql = printf('%%.%ds, ',sql) || %Q"

" || substr(sql,1+length(printf('%%.%ds',sql))) "

"WHERE type = 'table' AND name = %Q",

zDb, pNew->u.tab.addColOffset, zCol, pNew->u.tab.addColOffset,

zTab

);

sqlite3DbFree(db, zCol);

}

v = sqlite3GetVdbe(pParse);

if( v ){

/* Make sure the schema version is at least 3. But do not upgrade

** from less than 3 to 4, as that will corrupt any preexisting DESC

** index.

*/

r1 = sqlite3GetTempReg(pParse);

sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT);

sqlite3VdbeUsesBtree(v, iDb);

sqlite3VdbeAddOp2(v, OP_AddImm, r1, -2);

sqlite3VdbeAddOp2(v, OP_IfPos, r1, sqlite3VdbeCurrentAddr(v)+2);

VdbeCoverage(v);

sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, 3);

sqlite3ReleaseTempReg(pParse, r1);

/* Reload the table definition */

renameReloadSchema(pParse, iDb, INITFLAG_AlterAdd);

/* Verify that constraints are still satisfied */

if( pNew->pCheck!=0

|| (pCol->notNull && (pCol->colFlags & COLFLAG_GENERATED)!=0)

){

sqlite3NestedParse(pParse,

"SELECT CASE WHEN quick_check GLOB 'CHECK*'"

" THEN raise(ABORT,'CHECK constraint failed')"

" ELSE raise(ABORT,'NOT NULL constraint failed')"

" END"

" FROM pragma_quick_check(\"%w\",\"%w\")"

" WHERE quick_check GLOB 'CHECK*' OR quick_check GLOB 'NULL*'",

zTab, zDb

);

}

}

}

/*

** This function is called by the parser after the table-name in

** an "ALTER TABLE <table-name> ADD" statement is parsed. Argument

** pSrc is the full-name of the table being altered.

**

** This routine makes a (partial) copy of the Table structure

** for the table being altered and sets Parse.pNewTable to point

** to it. Routines called by the parser as the column definition

** is parsed (i.e. sqlite3AddColumn()) add the new Column data to

** the copy. The copy of the Table structure is deleted by tokenize.c

** after parsing is finished.

**

** Routine sqlite3AlterFinishAddColumn() will be called to complete

** coding the "ALTER TABLE ... ADD" statement.

*/

void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){

Table *pNew;

Table *pTab;

int iDb;

int i;

int nAlloc;

sqlite3 *db = pParse->db;

/* Look up the table being altered. */

assert( pParse->pNewTable==0 );

assert( sqlite3BtreeHoldsAllMutexes(db) );

if( db->mallocFailed ) goto exit_begin_add_column;

pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);

if( !pTab ) goto exit_begin_add_column;

#ifndef SQLITE_OMIT_VIRTUALTABLE

if( IsVirtual(pTab) ){

sqlite3ErrorMsg(pParse, "virtual tables may not be altered");

goto exit_begin_add_column;

}

#endif

/* Make sure this is not an attempt to ALTER a view. */

if( IsView(pTab) ){

sqlite3ErrorMsg(pParse, "Cannot add a column to a view");

goto exit_begin_add_column;

}

if( SQLITE_OK!=isAlterableTable(pParse, pTab) ){

goto exit_begin_add_column;

}

sqlite3MayAbort(pParse);

assert( IsOrdinaryTable(pTab) );

assert( pTab->u.tab.addColOffset>0 );

iDb = sqlite3SchemaToIndex(db, pTab->pSchema);

/* Put a copy of the Table struct in Parse.pNewTable for the

** sqlite3AddColumn() function and friends to modify. But modify

** the name by adding an "sqlite_altertab_" prefix. By adding this

** prefix, we insure that the name will not collide with an existing

** table because user table are not allowed to have the "sqlite_"

** prefix on their name.

*/

pNew = (Table*)sqlite3DbMallocZero(db, sizeof(Table));

if( !pNew ) goto exit_begin_add_column;

pParse->pNewTable = pNew;

pNew->nTabRef = 1;

pNew->nCol = pTab->nCol;

assert( pNew->nCol>0 );

nAlloc = (((pNew->nCol-1)/8)*8)+8;

assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );

pNew->aCol = (Column*)sqlite3DbMallocZero(db, sizeof(Column)*nAlloc);

pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);

if( !pNew->aCol || !pNew->zName ){

assert( db->mallocFailed );

goto exit_begin_add_column;

}

memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);

for(i=0; i<pNew->nCol; i++){

Column *pCol = &pNew->aCol[i];

pCol->zCnName = sqlite3DbStrDup(db, pCol->zCnName);

pCol->hName = sqlite3StrIHash(pCol->zCnName);

}

assert( IsOrdinaryTable(pNew) );

pNew->u.tab.pDfltList = sqlite3ExprListDup(db, pTab->u.tab.pDfltList, 0);

pNew->pSchema = db->aDb[iDb].pSchema;

pNew->u.tab.addColOffset = pTab->u.tab.addColOffset;

pNew->nTabRef = 1;

exit_begin_add_column:

sqlite3SrcListDelete(db, pSrc);

return;

}

/*

** Parameter pTab is the subject of an ALTER TABLE ... RENAME COLUMN

** command. This function checks if the table is a view or virtual

** table (columns of views or virtual tables may not be renamed). If so,

** it loads an error message into pParse and returns non-zero.

**

** Or, if pTab is not a view or virtual table, zero is returned.

*/

#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)

static int isRealTable(Parse *pParse, Table *pTab, int bDrop){

const char *zType = 0;

#ifndef SQLITE_OMIT_VIEW

if( IsView(pTab) ){

zType = "view";

}

#endif

#ifndef SQLITE_OMIT_VIRTUALTABLE

if( IsVirtual(pTab) ){

zType = "virtual table";

}

#endif

if( zType ){

sqlite3ErrorMsg(pParse, "cannot %s %s \"%s\"",

(bDrop ? "drop column from" : "rename columns of"),

zType, pTab->zName

);

return 1;

}

return 0;

}

#else /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */

# define isRealTable(x,y,z) (0)

#endif

/*

** Handles the following parser reduction:

**

** cmd ::= ALTER TABLE pSrc RENAME COLUMN pOld TO pNew

*/

void sqlite3AlterRenameColumn(

Parse *pParse, /* Parsing context */

SrcList *pSrc, /* Table being altered. pSrc->nSrc==1 */

Token *pOld, /* Name of column being changed */

Token *pNew /* New column name */

){

sqlite3 *db = pParse->db; /* Database connection */

Table *pTab; /* Table being updated */

int iCol; /* Index of column being renamed */

char *zOld = 0; /* Old column name */

char *zNew = 0; /* New column name */

const char *zDb; /* Name of schema containing the table */

int iSchema; /* Index of the schema */

int bQuote; /* True to quote the new name */

/* Locate the table to be altered */

pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);

if( !pTab ) goto exit_rename_column;

/* Cannot alter a system table */

if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_rename_column;

if( SQLITE_OK!=isRealTable(pParse, pTab, 0) ) goto exit_rename_column;

/* Which schema holds the table to be altered */

iSchema = sqlite3SchemaToIndex(db, pTab->pSchema);

assert( iSchema>=0 );

zDb = db->aDb[iSchema].zDbSName;

#ifndef SQLITE_OMIT_AUTHORIZATION

/* Invoke the authorization callback. */

if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){

goto exit_rename_column;

}

#endif

/* Make sure the old name really is a column name in the table to be

** altered. Set iCol to be the index of the column being renamed */

zOld = sqlite3NameFromToken(db, pOld);

if( !zOld ) goto exit_rename_column;

for(iCol=0; iCol<pTab->nCol; iCol++){

if( 0==sqlite3StrICmp(pTab->aCol[iCol].zCnName, zOld) ) break;

}

if( iCol==pTab->nCol ){

sqlite3ErrorMsg(pParse, "no such column: \"%s\"", zOld);

goto exit_rename_column;

}

/* Ensure the schema contains no double-quoted strings */

renameTestSchema(pParse, zDb, iSchema==1, "", 0);

renameFixQuotes(pParse, zDb, iSchema==1);

/* Do the rename operation using a recursive UPDATE statement that

** uses the sqlite_rename_column() SQL function to compute the new

** CREATE statement text for the sqlite_schema table.

*/

sqlite3MayAbort(pParse);

zNew = sqlite3NameFromToken(db, pNew);

if( !zNew ) goto exit_rename_column;

assert( pNew->n>0 );

bQuote = sqlite3Isquote(pNew->z[0]);

sqlite3NestedParse(pParse,

"UPDATE \"%w\"." LEGACY_SCHEMA_TABLE " SET "

"sql = sqlite_rename_column(sql, type, name, %Q, %Q, %d, %Q, %d, %d) "

"WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X' "

" AND (type != 'index' OR tbl_name = %Q)",

zDb,

zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1,

pTab->zName

);

sqlite3NestedParse(pParse,

"UPDATE temp." LEGACY_SCHEMA_TABLE " SET "

"sql = sqlite_rename_column(sql, type, name, %Q, %Q, %d, %Q, %d, 1) "

"WHERE type IN ('trigger', 'view')",

zDb, pTab->zName, iCol, zNew, bQuote

);

/* Drop and reload the database schema. */

renameReloadSchema(pParse, iSchema, INITFLAG_AlterRename);

renameTestSchema(pParse, zDb, iSchema==1, "after rename", 1);

exit_rename_column:

sqlite3SrcListDelete(db, pSrc);

sqlite3DbFree(db, zOld);

sqlite3DbFree(db, zNew);

return;

}

/*

** Each RenameToken object maps an element of the parse tree into

** the token that generated that element. The parse tree element

** might be one of:

**

** * A pointer to an Expr that represents an ID

** * The name of a table column in Column.zName

**

** A list of RenameToken objects can be constructed during parsing.

** Each new object is created by sqlite3RenameTokenMap().

** As the parse tree is transformed, the sqlite3RenameTokenRemap()

** routine is used to keep the mapping current.

**

** After the parse finishes, renameTokenFind() routine can be used

** to look up the actual token value that created some element in

** the parse tree.

*/

struct RenameToken {

const void *p; /* Parse tree element created by token t */

Token t; /* The token that created parse tree element p */

RenameToken *pNext; /* Next is a list of all RenameToken objects */

};

/*

** The context of an ALTER TABLE RENAME COLUMN operation that gets passed

** down into the Walker.

*/

typedef struct RenameCtx RenameCtx;

struct RenameCtx {

RenameToken *pList; /* List of tokens to overwrite */

int nList; /* Number of tokens in pList */

int iCol; /* Index of column being renamed */

Table *pTab; /* Table being ALTERed */

const char *zOld; /* Old column name */

};

#ifdef SQLITE_DEBUG

/*

** This function is only for debugging. It performs two tasks:

**

** 1. Checks that pointer pPtr does not already appear in the

** rename-token list.

**

** 2. Dereferences each pointer in the rename-token list.

**

** The second is most effective when debugging under valgrind or

** address-sanitizer or similar. If any of these pointers no longer

** point to valid objects, an exception is raised by the memory-checking

** tool.

**

** The point of this is to prevent comparisons of invalid pointer values.

** Even though this always seems to work, it is undefined according to the

** C standard. Example of undefined comparison:

**

** sqlite3_free(x);

** if( x==y ) ...

**

** Technically, as x no longer points into a valid object or to the byte

** following a valid object, it may not be used in comparison operations.

*/

static void renameTokenCheckAll(Parse *pParse, const void *pPtr){

if( pParse->nErr==0 && pParse->db->mallocFailed==0 ){

const RenameToken *p;

u8 i = 0;

for(p=pParse->pRename; p; p=p->pNext){

if( p->p ){

assert( p->p!=pPtr );

i += *(u8*)(p->p);

}

}

}

}

#else

# define renameTokenCheckAll(x,y)

#endif

/*

** Remember that the parser tree element pPtr was created using

** the token pToken.

**

** In other words, construct a new RenameToken object and add it

** to the list of RenameToken objects currently being built up

** in pParse->pRename.

**

** The pPtr argument is returned so that this routine can be used

** with tail recursion in tokenExpr() routine, for a small performance

** improvement.

*/

const void *sqlite3RenameTokenMap(

Parse *pParse,

const void *pPtr,

const Token *pToken

){

RenameToken *pNew;

assert( pPtr || pParse->db->mallocFailed );

renameTokenCheckAll(pParse, pPtr);

if( ALWAYS(pParse->eParseMode!=PARSE_MODE_UNMAP) ){

pNew = sqlite3DbMallocZero(pParse->db, sizeof(RenameToken));

if( pNew ){

pNew->p = pPtr;

pNew->t = *pToken;

pNew->pNext = pParse->pRename;

pParse->pRename = pNew;

}

}

return pPtr;

}

/*

** It is assumed that there is already a RenameToken object associated

** with parse tree element pFrom. This function remaps the associated token

** to parse tree element pTo.

*/

void sqlite3RenameTokenRemap(Parse *pParse, const void *pTo, const void *pFrom){

RenameToken *p;

renameTokenCheckAll(pParse, pTo);

for(p=pParse->pRename; p; p=p->pNext){

if( p->p==pFrom ){

p->p = pTo;

break;

}

}

}

/*

** Walker callback used by sqlite3RenameExprUnmap().

*/

static int renameUnmapExprCb(Walker *pWalker, Expr *pExpr){

Parse *pParse = pWalker->pParse;

sqlite3RenameTokenRemap(pParse, 0, (const void*)pExpr);

if( ExprUseYTab(pExpr) ){

sqlite3RenameTokenRemap(pParse, 0, (const void*)&pExpr->y.pTab);

}

return WRC_Continue;

}

/*

** Iterate through the Select objects that are part of WITH clauses attached

** to select statement pSelect.

*/

static void renameWalkWith(Walker *pWalker, Select *pSelect){

With *pWith = pSelect->pWith;

if( pWith ){

Parse *pParse = pWalker->pParse;

int i;

With *pCopy = 0;

assert( pWith->nCte>0 );

if( (pWith->a[0].pSelect->selFlags & SF_Expanded)==0 ){

/* Push a copy of the With object onto the with-stack. We use a copy

** here as the original will be expanded and resolved (flags SF_Expanded

** and SF_Resolved) below. And the parser code that uses the with-stack

** fails if the Select objects on it have already been expanded and

** resolved. */

pCopy = sqlite3WithDup(pParse->db, pWith);

pCopy = sqlite3WithPush(pParse, pCopy, 1);

}

for(i=0; i<pWith->nCte; i++){

Select *p = pWith->a[i].pSelect;

NameContext sNC;

memset(&sNC, 0, sizeof(sNC));

sNC.pParse = pParse;

if( pCopy ) sqlite3SelectPrep(sNC.pParse, p, &sNC);

if( sNC.pParse->db->mallocFailed ) return;

sqlite3WalkSelect(pWalker, p);

sqlite3RenameExprlistUnmap(pParse, pWith->a[i].pCols);

}

if( pCopy && pParse->pWith==pCopy ){

pParse->pWith = pCopy->pOuter;

}

}

}

/*

** Unmap all tokens in the IdList object passed as the second argument.

*/

static void unmapColumnIdlistNames(

Parse *pParse,

const IdList *pIdList

){

if( pIdList ){

int ii;

for(ii=0; ii<pIdList->nId; ii++){

sqlite3RenameTokenRemap(pParse, 0, (const void*)pIdList->a[ii].zName);

}

}

}

/*

** Walker callback used by sqlite3RenameExprUnmap().

*/

static int renameUnmapSelectCb(Walker *pWalker, Select *p){

Parse *pParse = pWalker->pParse;

int i;

if( pParse->nErr ) return WRC_Abort;

testcase( p->selFlags & SF_View );

testcase( p->selFlags & SF_CopyCte );

if( p->selFlags & (SF_View|SF_CopyCte) ){

return WRC_Prune;

}

if( ALWAYS(p->pEList) ){

ExprList *pList = p->pEList;

for(i=0; i<pList->nExpr; i++){

if( pList->a[i].zEName && pList->a[i].eEName==ENAME_NAME ){

sqlite3RenameTokenRemap(pParse, 0, (void*)pList->a[i].zEName);

}

}

}

if( ALWAYS(p->pSrc) ){ /* Every Select as a SrcList, even if it is empty */

SrcList *pSrc = p->pSrc;

for(i=0; i<pSrc->nSrc; i++){

sqlite3RenameTokenRemap(pParse, 0, (void*)pSrc->a[i].zName);

sqlite3WalkExpr(pWalker, pSrc->a[i].pOn);

unmapColumnIdlistNames(pParse, pSrc->a[i].pUsing);

}

}

renameWalkWith(pWalker, p);

return WRC_Continue;

}

/*

** Remove all nodes that are part of expression pExpr from the rename list.

*/

void sqlite3RenameExprUnmap(Parse *pParse, Expr *pExpr){

u8 eMode = pParse->eParseMode;

Walker sWalker;

memset(&sWalker, 0, sizeof(Walker));

sWalker.pParse = pParse;

sWalker.xExprCallback = renameUnmapExprCb;

sWalker.xSelectCallback = renameUnmapSelectCb;

pParse->eParseMode = PARSE_MODE_UNMAP;

sqlite3WalkExpr(&sWalker, pExpr);

pParse->eParseMode = eMode;

}

/*

** Remove all nodes that are part of expression-list pEList from the

** rename list.

*/

void sqlite3RenameExprlistUnmap(Parse *pParse, ExprList *pEList){

if( pEList ){

int i;

Walker sWalker;

memset(&sWalker, 0, sizeof(Walker));

sWalker.pParse = pParse;

sWalker.xExprCallback = renameUnmapExprCb;

sqlite3WalkExprList(&sWalker, pEList);

for(i=0; i<pEList->nExpr; i++){

if( ALWAYS(pEList->a[i].eEName==ENAME_NAME) ){

sqlite3RenameTokenRemap(pParse, 0, (void*)pEList->a[i].zEName);

}

}

}

}

/*

** Free the list of RenameToken objects given in the second argument

*/

static void renameTokenFree(sqlite3 *db, RenameToken *pToken){

RenameToken *pNext;

RenameToken *p;

for(p=pToken; p; p=pNext){

pNext = p->pNext;

sqlite3DbFree(db, p);

}

}

/*

** Search the Parse object passed as the first argument for a RenameToken

** object associated with parse tree element pPtr. If found, return a pointer

** to it. Otherwise, return NULL.

**

** If the second argument passed to this function is not NULL and a matching

** RenameToken object is found, remove it from the Parse object and add it to

** the list maintained by the RenameCtx object.

*/

static RenameToken *renameTokenFind(

Parse *pParse,

struct RenameCtx *pCtx,

const void *pPtr

){

RenameToken **pp;

if( NEVER(pPtr==0) ){

return 0;

}

for(pp=&pParse->pRename; (*pp); pp=&(*pp)->pNext){

if( (*pp)->p==pPtr ){

RenameToken *pToken = *pp;

if( pCtx ){

*pp = pToken->pNext;

pToken->pNext = pCtx->pList;

pCtx->pList = pToken;

pCtx->nList++;

}

return pToken;

}

}

return 0;

}

/*

** This is a Walker select callback. It does nothing. It is only required

** because without a dummy callback, sqlite3WalkExpr() and similar do not

** descend into sub-select statements.

*/

static int renameColumnSelectCb(Walker *pWalker, Select *p){

if( p->selFlags & (SF_View|SF_CopyCte) ){

testcase( p->selFlags & SF_View );

testcase( p->selFlags & SF_CopyCte );

return WRC_Prune;

}

renameWalkWith(pWalker, p);

return WRC_Continue;

}

/*

** This is a Walker expression callback.

**

** For every TK_COLUMN node in the expression tree, search to see

** if the column being references is the column being renamed by an

** ALTER TABLE statement. If it is, then attach its associated

** RenameToken object to the list of RenameToken objects being

** constructed in RenameCtx object at pWalker->u.pRename.