sl@0: /*
sl@0: ** 2005 February 15
sl@0: **
sl@0: ** The author disclaims copyright to this source code.  In place of
sl@0: ** a legal notice, here is a blessing:
sl@0: **
sl@0: **    May you do good and not evil.
sl@0: **    May you find forgiveness for yourself and forgive others.
sl@0: **    May you share freely, never taking more than you give.
sl@0: **
sl@0: *************************************************************************
sl@0: ** This file contains C code routines that used to generate VDBE code
sl@0: ** that implements the ALTER TABLE command.
sl@0: **
sl@0: ** $Id: alter.c,v 1.48 2008/08/08 14:19:41 drh Exp $
sl@0: */
sl@0: #include "sqliteInt.h"
sl@0: #include <ctype.h>
sl@0: 
sl@0: /*
sl@0: ** The code in this file only exists if we are not omitting the
sl@0: ** ALTER TABLE logic from the build.
sl@0: */
sl@0: #ifndef SQLITE_OMIT_ALTERTABLE
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** This function is used by SQL generated to implement the 
sl@0: ** ALTER TABLE command. The first argument is the text of a CREATE TABLE or
sl@0: ** CREATE INDEX command. The second is a table name. The table name in 
sl@0: ** the CREATE TABLE or CREATE INDEX statement is replaced with the third
sl@0: ** argument and the result returned. Examples:
sl@0: **
sl@0: ** sqlite_rename_table('CREATE TABLE abc(a, b, c)', 'def')
sl@0: **     -> 'CREATE TABLE def(a, b, c)'
sl@0: **
sl@0: ** sqlite_rename_table('CREATE INDEX i ON abc(a)', 'def')
sl@0: **     -> 'CREATE INDEX i ON def(a, b, c)'
sl@0: */
sl@0: static void renameTableFunc(
sl@0:   sqlite3_context *context,
sl@0:   int argc,
sl@0:   sqlite3_value **argv
sl@0: ){
sl@0:   unsigned char const *zSql = sqlite3_value_text(argv[0]);
sl@0:   unsigned char const *zTableName = sqlite3_value_text(argv[1]);
sl@0: 
sl@0:   int token;
sl@0:   Token tname;
sl@0:   unsigned char const *zCsr = zSql;
sl@0:   int len = 0;
sl@0:   char *zRet;
sl@0: 
sl@0:   sqlite3 *db = sqlite3_context_db_handle(context);
sl@0: 
sl@0:   /* The principle used to locate the table name in the CREATE TABLE 
sl@0:   ** statement is that the table name is the first non-space token that
sl@0:   ** is immediately followed by a TK_LP or TK_USING token.
sl@0:   */
sl@0:   if( zSql ){
sl@0:     do {
sl@0:       if( !*zCsr ){
sl@0:         /* Ran out of input before finding an opening bracket. Return NULL. */
sl@0:         return;
sl@0:       }
sl@0: 
sl@0:       /* Store the token that zCsr points to in tname. */
sl@0:       tname.z = zCsr;
sl@0:       tname.n = len;
sl@0: 
sl@0:       /* Advance zCsr to the next token. Store that token type in 'token',
sl@0:       ** and its length in 'len' (to be used next iteration of this loop).
sl@0:       */
sl@0:       do {
sl@0:         zCsr += len;
sl@0:         len = sqlite3GetToken(zCsr, &token);
sl@0:       } while( token==TK_SPACE );
sl@0:       assert( len>0 );
sl@0:     } while( token!=TK_LP && token!=TK_USING );
sl@0: 
sl@0:     zRet = sqlite3MPrintf(db, "%.*s\"%w\"%s", tname.z - zSql, zSql, 
sl@0:        zTableName, tname.z+tname.n);
sl@0:     sqlite3_result_text(context, zRet, -1, SQLITE_DYNAMIC);
sl@0:   }
sl@0: }
sl@0: 
sl@0: #ifndef SQLITE_OMIT_TRIGGER
sl@0: /* This function is used by SQL generated to implement the
sl@0: ** ALTER TABLE command. The first argument is the text of a CREATE TRIGGER 
sl@0: ** statement. The second is a table name. The table name in the CREATE 
sl@0: ** TRIGGER statement is replaced with the third argument and the result 
sl@0: ** returned. This is analagous to renameTableFunc() above, except for CREATE
sl@0: ** TRIGGER, not CREATE INDEX and CREATE TABLE.
sl@0: */
sl@0: static void renameTriggerFunc(
sl@0:   sqlite3_context *context,
sl@0:   int argc,
sl@0:   sqlite3_value **argv
sl@0: ){
sl@0:   unsigned char const *zSql = sqlite3_value_text(argv[0]);
sl@0:   unsigned char const *zTableName = sqlite3_value_text(argv[1]);
sl@0: 
sl@0:   int token;
sl@0:   Token tname;
sl@0:   int dist = 3;
sl@0:   unsigned char const *zCsr = zSql;
sl@0:   int len = 0;
sl@0:   char *zRet;
sl@0: 
sl@0:   sqlite3 *db = sqlite3_context_db_handle(context);
sl@0: 
sl@0:   /* The principle used to locate the table name in the CREATE TRIGGER 
sl@0:   ** statement is that the table name is the first token that is immediatedly
sl@0:   ** preceded by either TK_ON or TK_DOT and immediatedly followed by one
sl@0:   ** of TK_WHEN, TK_BEGIN or TK_FOR.
sl@0:   */
sl@0:   if( zSql ){
sl@0:     do {
sl@0: 
sl@0:       if( !*zCsr ){
sl@0:         /* Ran out of input before finding the table name. Return NULL. */
sl@0:         return;
sl@0:       }
sl@0: 
sl@0:       /* Store the token that zCsr points to in tname. */
sl@0:       tname.z = zCsr;
sl@0:       tname.n = len;
sl@0: 
sl@0:       /* Advance zCsr to the next token. Store that token type in 'token',
sl@0:       ** and its length in 'len' (to be used next iteration of this loop).
sl@0:       */
sl@0:       do {
sl@0:         zCsr += len;
sl@0:         len = sqlite3GetToken(zCsr, &token);
sl@0:       }while( token==TK_SPACE );
sl@0:       assert( len>0 );
sl@0: 
sl@0:       /* Variable 'dist' stores the number of tokens read since the most
sl@0:       ** recent TK_DOT or TK_ON. This means that when a WHEN, FOR or BEGIN 
sl@0:       ** token is read and 'dist' equals 2, the condition stated above
sl@0:       ** to be met.
sl@0:       **
sl@0:       ** Note that ON cannot be a database, table or column name, so
sl@0:       ** there is no need to worry about syntax like 
sl@0:       ** "CREATE TRIGGER ... ON ON.ON BEGIN ..." etc.
sl@0:       */
sl@0:       dist++;
sl@0:       if( token==TK_DOT || token==TK_ON ){
sl@0:         dist = 0;
sl@0:       }
sl@0:     } while( dist!=2 || (token!=TK_WHEN && token!=TK_FOR && token!=TK_BEGIN) );
sl@0: 
sl@0:     /* Variable tname now contains the token that is the old table-name
sl@0:     ** in the CREATE TRIGGER statement.
sl@0:     */
sl@0:     zRet = sqlite3MPrintf(db, "%.*s\"%w\"%s", tname.z - zSql, zSql, 
sl@0:        zTableName, tname.z+tname.n);
sl@0:     sqlite3_result_text(context, zRet, -1, SQLITE_DYNAMIC);
sl@0:   }
sl@0: }
sl@0: #endif   /* !SQLITE_OMIT_TRIGGER */
sl@0: 
sl@0: /*
sl@0: ** Register built-in functions used to help implement ALTER TABLE
sl@0: */
sl@0: void sqlite3AlterFunctions(sqlite3 *db){
sl@0:   sqlite3CreateFunc(db, "sqlite_rename_table", 2, SQLITE_UTF8, 0,
sl@0:                          renameTableFunc, 0, 0);
sl@0: #ifndef SQLITE_OMIT_TRIGGER
sl@0:   sqlite3CreateFunc(db, "sqlite_rename_trigger", 2, SQLITE_UTF8, 0,
sl@0:                          renameTriggerFunc, 0, 0);
sl@0: #endif
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Generate the text of a WHERE expression which can be used to select all
sl@0: ** temporary triggers on table pTab from the sqlite_temp_master table. If
sl@0: ** table pTab has no temporary triggers, or is itself stored in the 
sl@0: ** temporary database, NULL is returned.
sl@0: */
sl@0: static char *whereTempTriggers(Parse *pParse, Table *pTab){
sl@0:   Trigger *pTrig;
sl@0:   char *zWhere = 0;
sl@0:   char *tmp = 0;
sl@0:   const Schema *pTempSchema = pParse->db->aDb[1].pSchema; /* Temp db schema */
sl@0: 
sl@0:   /* If the table is not located in the temp-db (in which case NULL is 
sl@0:   ** returned, loop through the tables list of triggers. For each trigger
sl@0:   ** that is not part of the temp-db schema, add a clause to the WHERE 
sl@0:   ** expression being built up in zWhere.
sl@0:   */
sl@0:   if( pTab->pSchema!=pTempSchema ){
sl@0:     sqlite3 *db = pParse->db;
sl@0:     for( pTrig=pTab->pTrigger; pTrig; pTrig=pTrig->pNext ){
sl@0:       if( pTrig->pSchema==pTempSchema ){
sl@0:         if( !zWhere ){
sl@0:           zWhere = sqlite3MPrintf(db, "name=%Q", pTrig->name);
sl@0:         }else{
sl@0:           tmp = zWhere;
sl@0:           zWhere = sqlite3MPrintf(db, "%s OR name=%Q", zWhere, pTrig->name);
sl@0:           sqlite3DbFree(db, tmp);
sl@0:         }
sl@0:       }
sl@0:     }
sl@0:   }
sl@0:   return zWhere;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Generate code to drop and reload the internal representation of table
sl@0: ** pTab from the database, including triggers and temporary triggers.
sl@0: ** Argument zName is the name of the table in the database schema at
sl@0: ** the time the generated code is executed. This can be different from
sl@0: ** pTab->zName if this function is being called to code part of an 
sl@0: ** "ALTER TABLE RENAME TO" statement.
sl@0: */
sl@0: static void reloadTableSchema(Parse *pParse, Table *pTab, const char *zName){
sl@0:   Vdbe *v;
sl@0:   char *zWhere;
sl@0:   int iDb;                   /* Index of database containing pTab */
sl@0: #ifndef SQLITE_OMIT_TRIGGER
sl@0:   Trigger *pTrig;
sl@0: #endif
sl@0: 
sl@0:   v = sqlite3GetVdbe(pParse);
sl@0:   if( !v ) return;
sl@0:   assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
sl@0:   iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
sl@0:   assert( iDb>=0 );
sl@0: 
sl@0: #ifndef SQLITE_OMIT_TRIGGER
sl@0:   /* Drop any table triggers from the internal schema. */
sl@0:   for(pTrig=pTab->pTrigger; pTrig; pTrig=pTrig->pNext){
sl@0:     int iTrigDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
sl@0:     assert( iTrigDb==iDb || iTrigDb==1 );
sl@0:     sqlite3VdbeAddOp4(v, OP_DropTrigger, iTrigDb, 0, 0, pTrig->name, 0);
sl@0:   }
sl@0: #endif
sl@0: 
sl@0:   /* Drop the table and index from the internal schema */
sl@0:   sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
sl@0: 
sl@0:   /* Reload the table, index and permanent trigger schemas. */
sl@0:   zWhere = sqlite3MPrintf(pParse->db, "tbl_name=%Q", zName);
sl@0:   if( !zWhere ) return;
sl@0:   sqlite3VdbeAddOp4(v, OP_ParseSchema, iDb, 0, 0, zWhere, P4_DYNAMIC);
sl@0: 
sl@0: #ifndef SQLITE_OMIT_TRIGGER
sl@0:   /* Now, if the table is not stored in the temp database, reload any temp 
sl@0:   ** triggers. Don't use IN(...) in case SQLITE_OMIT_SUBQUERY is defined. 
sl@0:   */
sl@0:   if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){
sl@0:     sqlite3VdbeAddOp4(v, OP_ParseSchema, 1, 0, 0, zWhere, P4_DYNAMIC);
sl@0:   }
sl@0: #endif
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Generate code to implement the "ALTER TABLE xxx RENAME TO yyy" 
sl@0: ** command. 
sl@0: */
sl@0: void sqlite3AlterRenameTable(
sl@0:   Parse *pParse,            /* Parser context. */
sl@0:   SrcList *pSrc,            /* The table to rename. */
sl@0:   Token *pName              /* The new table name. */
sl@0: ){
sl@0:   int iDb;                  /* Database that contains the table */
sl@0:   char *zDb;                /* Name of database iDb */
sl@0:   Table *pTab;              /* Table being renamed */
sl@0:   char *zName = 0;          /* NULL-terminated version of pName */ 
sl@0:   sqlite3 *db = pParse->db; /* Database connection */
sl@0:   int nTabName;             /* Number of UTF-8 characters in zTabName */
sl@0:   const char *zTabName;     /* Original name of the table */
sl@0:   Vdbe *v;
sl@0: #ifndef SQLITE_OMIT_TRIGGER
sl@0:   char *zWhere = 0;         /* Where clause to locate temp triggers */
sl@0: #endif
sl@0:   int isVirtualRename = 0;  /* True if this is a v-table with an xRename() */
sl@0:   
sl@0:   if( db->mallocFailed ) goto exit_rename_table;
sl@0:   assert( pSrc->nSrc==1 );
sl@0:   assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
sl@0: 
sl@0:   pTab = sqlite3LocateTable(pParse, 0, pSrc->a[0].zName, pSrc->a[0].zDatabase);
sl@0:   if( !pTab ) goto exit_rename_table;
sl@0:   iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
sl@0:   zDb = db->aDb[iDb].zName;
sl@0: 
sl@0:   /* Get a NULL terminated version of the new table name. */
sl@0:   zName = sqlite3NameFromToken(db, pName);
sl@0:   if( !zName ) goto exit_rename_table;
sl@0: 
sl@0:   /* Check that a table or index named 'zName' does not already exist
sl@0:   ** in database iDb. If so, this is an error.
sl@0:   */
sl@0:   if( sqlite3FindTable(db, zName, zDb) || sqlite3FindIndex(db, zName, zDb) ){
sl@0:     sqlite3ErrorMsg(pParse, 
sl@0:         "there is already another table or index with this name: %s", zName);
sl@0:     goto exit_rename_table;
sl@0:   }
sl@0: 
sl@0:   /* Make sure it is not a system table being altered, or a reserved name
sl@0:   ** that the table is being renamed to.
sl@0:   */
sl@0:   if( strlen(pTab->zName)>6 && 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7) ){
sl@0:     sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName);
sl@0:     goto exit_rename_table;
sl@0:   }
sl@0:   if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
sl@0:     goto exit_rename_table;
sl@0:   }
sl@0: 
sl@0: #ifndef SQLITE_OMIT_VIEW
sl@0:   if( pTab->pSelect ){
sl@0:     sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
sl@0:     goto exit_rename_table;
sl@0:   }
sl@0: #endif
sl@0: 
sl@0: #ifndef SQLITE_OMIT_AUTHORIZATION
sl@0:   /* Invoke the authorization callback. */
sl@0:   if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
sl@0:     goto exit_rename_table;
sl@0:   }
sl@0: #endif
sl@0: 
sl@0: #ifndef SQLITE_OMIT_VIRTUALTABLE
sl@0:   if( sqlite3ViewGetColumnNames(pParse, pTab) ){
sl@0:     goto exit_rename_table;
sl@0:   }
sl@0:   if( IsVirtual(pTab) && pTab->pMod->pModule->xRename ){
sl@0:     isVirtualRename = 1;
sl@0:   }
sl@0: #endif
sl@0: 
sl@0:   /* Begin a transaction and code the VerifyCookie for database iDb. 
sl@0:   ** Then modify the schema cookie (since the ALTER TABLE modifies the
sl@0:   ** schema). Open a statement transaction if the table is a virtual
sl@0:   ** table.
sl@0:   */
sl@0:   v = sqlite3GetVdbe(pParse);
sl@0:   if( v==0 ){
sl@0:     goto exit_rename_table;
sl@0:   }
sl@0:   sqlite3BeginWriteOperation(pParse, isVirtualRename, iDb);
sl@0:   sqlite3ChangeCookie(pParse, iDb);
sl@0: 
sl@0:   /* If this is a virtual table, invoke the xRename() function if
sl@0:   ** one is defined. The xRename() callback will modify the names
sl@0:   ** of any resources used by the v-table implementation (including other
sl@0:   ** SQLite tables) that are identified by the name of the virtual table.
sl@0:   */
sl@0: #ifndef SQLITE_OMIT_VIRTUALTABLE
sl@0:   if( isVirtualRename ){
sl@0:     int i = ++pParse->nMem;
sl@0:     sqlite3VdbeAddOp4(v, OP_String8, 0, i, 0, zName, 0);
sl@0:     sqlite3VdbeAddOp4(v, OP_VRename, i, 0, 0,(const char*)pTab->pVtab, P4_VTAB);
sl@0:   }
sl@0: #endif
sl@0: 
sl@0:   /* figure out how many UTF-8 characters are in zName */
sl@0:   zTabName = pTab->zName;
sl@0:   nTabName = sqlite3Utf8CharLen(zTabName, -1);
sl@0: 
sl@0:   /* Modify the sqlite_master table to use the new table name. */
sl@0:   sqlite3NestedParse(pParse,
sl@0:       "UPDATE %Q.%s SET "
sl@0: #ifdef SQLITE_OMIT_TRIGGER
sl@0:           "sql = sqlite_rename_table(sql, %Q), "
sl@0: #else
sl@0:           "sql = CASE "
sl@0:             "WHEN type = 'trigger' THEN sqlite_rename_trigger(sql, %Q)"
sl@0:             "ELSE sqlite_rename_table(sql, %Q) END, "
sl@0: #endif
sl@0:           "tbl_name = %Q, "
sl@0:           "name = CASE "
sl@0:             "WHEN type='table' THEN %Q "
sl@0:             "WHEN name LIKE 'sqlite_autoindex%%' AND type='index' THEN "
sl@0:              "'sqlite_autoindex_' || %Q || substr(name,%d+18) "
sl@0:             "ELSE name END "
sl@0:       "WHERE tbl_name=%Q AND "
sl@0:           "(type='table' OR type='index' OR type='trigger');", 
sl@0:       zDb, SCHEMA_TABLE(iDb), zName, zName, zName, 
sl@0: #ifndef SQLITE_OMIT_TRIGGER
sl@0:       zName,
sl@0: #endif
sl@0:       zName, nTabName, zTabName
sl@0:   );
sl@0: 
sl@0: #ifndef SQLITE_OMIT_AUTOINCREMENT
sl@0:   /* If the sqlite_sequence table exists in this database, then update 
sl@0:   ** it with the new table name.
sl@0:   */
sl@0:   if( sqlite3FindTable(db, "sqlite_sequence", zDb) ){
sl@0:     sqlite3NestedParse(pParse,
sl@0:         "UPDATE \"%w\".sqlite_sequence set name = %Q WHERE name = %Q",
sl@0:         zDb, zName, pTab->zName);
sl@0:   }
sl@0: #endif
sl@0: 
sl@0: #ifndef SQLITE_OMIT_TRIGGER
sl@0:   /* If there are TEMP triggers on this table, modify the sqlite_temp_master
sl@0:   ** table. Don't do this if the table being ALTERed is itself located in
sl@0:   ** the temp database.
sl@0:   */
sl@0:   if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){
sl@0:     sqlite3NestedParse(pParse, 
sl@0:         "UPDATE sqlite_temp_master SET "
sl@0:             "sql = sqlite_rename_trigger(sql, %Q), "
sl@0:             "tbl_name = %Q "
sl@0:             "WHERE %s;", zName, zName, zWhere);
sl@0:     sqlite3DbFree(db, zWhere);
sl@0:   }
sl@0: #endif
sl@0: 
sl@0:   /* Drop and reload the internal table schema. */
sl@0:   reloadTableSchema(pParse, pTab, zName);
sl@0: 
sl@0: exit_rename_table:
sl@0:   sqlite3SrcListDelete(db, pSrc);
sl@0:   sqlite3DbFree(db, zName);
sl@0: }
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** This function is called after an "ALTER TABLE ... ADD" statement
sl@0: ** has been parsed. Argument pColDef contains the text of the new
sl@0: ** column definition.
sl@0: **
sl@0: ** The Table structure pParse->pNewTable was extended to include
sl@0: ** the new column during parsing.
sl@0: */
sl@0: void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
sl@0:   Table *pNew;              /* Copy of pParse->pNewTable */
sl@0:   Table *pTab;              /* Table being altered */
sl@0:   int iDb;                  /* Database number */
sl@0:   const char *zDb;          /* Database name */
sl@0:   const char *zTab;         /* Table name */
sl@0:   char *zCol;               /* Null-terminated column definition */
sl@0:   Column *pCol;             /* The new column */
sl@0:   Expr *pDflt;              /* Default value for the new column */
sl@0:   sqlite3 *db;              /* The database connection; */
sl@0: 
sl@0:   if( pParse->nErr ) return;
sl@0:   pNew = pParse->pNewTable;
sl@0:   assert( pNew );
sl@0: 
sl@0:   db = pParse->db;
sl@0:   assert( sqlite3BtreeHoldsAllMutexes(db) );
sl@0:   iDb = sqlite3SchemaToIndex(db, pNew->pSchema);
sl@0:   zDb = db->aDb[iDb].zName;
sl@0:   zTab = pNew->zName;
sl@0:   pCol = &pNew->aCol[pNew->nCol-1];
sl@0:   pDflt = pCol->pDflt;
sl@0:   pTab = sqlite3FindTable(db, zTab, zDb);
sl@0:   assert( pTab );
sl@0: 
sl@0: #ifndef SQLITE_OMIT_AUTHORIZATION
sl@0:   /* Invoke the authorization callback. */
sl@0:   if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
sl@0:     return;
sl@0:   }
sl@0: #endif
sl@0: 
sl@0:   /* If the default value for the new column was specified with a 
sl@0:   ** literal NULL, then set pDflt to 0. This simplifies checking
sl@0:   ** for an SQL NULL default below.
sl@0:   */
sl@0:   if( pDflt && pDflt->op==TK_NULL ){
sl@0:     pDflt = 0;
sl@0:   }
sl@0: 
sl@0:   /* Check that the new column is not specified as PRIMARY KEY or UNIQUE.
sl@0:   ** If there is a NOT NULL constraint, then the default value for the
sl@0:   ** column must not be NULL.
sl@0:   */
sl@0:   if( pCol->isPrimKey ){
sl@0:     sqlite3ErrorMsg(pParse, "Cannot add a PRIMARY KEY column");
sl@0:     return;
sl@0:   }
sl@0:   if( pNew->pIndex ){
sl@0:     sqlite3ErrorMsg(pParse, "Cannot add a UNIQUE column");
sl@0:     return;
sl@0:   }
sl@0:   if( pCol->notNull && !pDflt ){
sl@0:     sqlite3ErrorMsg(pParse, 
sl@0:         "Cannot add a NOT NULL column with default value NULL");
sl@0:     return;
sl@0:   }
sl@0: 
sl@0:   /* Ensure the default expression is something that sqlite3ValueFromExpr()
sl@0:   ** can handle (i.e. not CURRENT_TIME etc.)
sl@0:   */
sl@0:   if( pDflt ){
sl@0:     sqlite3_value *pVal;
sl@0:     if( sqlite3ValueFromExpr(db, pDflt, SQLITE_UTF8, SQLITE_AFF_NONE, &pVal) ){
sl@0:       db->mallocFailed = 1;
sl@0:       return;
sl@0:     }
sl@0:     if( !pVal ){
sl@0:       sqlite3ErrorMsg(pParse, "Cannot add a column with non-constant default");
sl@0:       return;
sl@0:     }
sl@0:     sqlite3ValueFree(pVal);
sl@0:   }
sl@0: 
sl@0:   /* Modify the CREATE TABLE statement. */
sl@0:   zCol = sqlite3DbStrNDup(db, (char*)pColDef->z, pColDef->n);
sl@0:   if( zCol ){
sl@0:     char *zEnd = &zCol[pColDef->n-1];
sl@0:     while( (zEnd>zCol && *zEnd==';') || isspace(*(unsigned char *)zEnd) ){
sl@0:       *zEnd-- = '\0';
sl@0:     }
sl@0:     sqlite3NestedParse(pParse, 
sl@0:         "UPDATE \"%w\".%s SET "
sl@0:           "sql = substr(sql,1,%d) || ', ' || %Q || substr(sql,%d) "
sl@0:         "WHERE type = 'table' AND name = %Q", 
sl@0:       zDb, SCHEMA_TABLE(iDb), pNew->addColOffset, zCol, pNew->addColOffset+1,
sl@0:       zTab
sl@0:     );
sl@0:     sqlite3DbFree(db, zCol);
sl@0:   }
sl@0: 
sl@0:   /* If the default value of the new column is NULL, then set the file
sl@0:   ** format to 2. If the default value of the new column is not NULL,
sl@0:   ** the file format becomes 3.
sl@0:   */
sl@0:   sqlite3MinimumFileFormat(pParse, iDb, pDflt ? 3 : 2);
sl@0: 
sl@0:   /* Reload the schema of the modified table. */
sl@0:   reloadTableSchema(pParse, pTab, pTab->zName);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** This function is called by the parser after the table-name in
sl@0: ** an "ALTER TABLE <table-name> ADD" statement is parsed. Argument 
sl@0: ** pSrc is the full-name of the table being altered.
sl@0: **
sl@0: ** This routine makes a (partial) copy of the Table structure
sl@0: ** for the table being altered and sets Parse.pNewTable to point
sl@0: ** to it. Routines called by the parser as the column definition
sl@0: ** is parsed (i.e. sqlite3AddColumn()) add the new Column data to 
sl@0: ** the copy. The copy of the Table structure is deleted by tokenize.c 
sl@0: ** after parsing is finished.
sl@0: **
sl@0: ** Routine sqlite3AlterFinishAddColumn() will be called to complete
sl@0: ** coding the "ALTER TABLE ... ADD" statement.
sl@0: */
sl@0: void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){
sl@0:   Table *pNew;
sl@0:   Table *pTab;
sl@0:   Vdbe *v;
sl@0:   int iDb;
sl@0:   int i;
sl@0:   int nAlloc;
sl@0:   sqlite3 *db = pParse->db;
sl@0: 
sl@0:   /* Look up the table being altered. */
sl@0:   assert( pParse->pNewTable==0 );
sl@0:   assert( sqlite3BtreeHoldsAllMutexes(db) );
sl@0:   if( db->mallocFailed ) goto exit_begin_add_column;
sl@0:   pTab = sqlite3LocateTable(pParse, 0, pSrc->a[0].zName, pSrc->a[0].zDatabase);
sl@0:   if( !pTab ) goto exit_begin_add_column;
sl@0: 
sl@0: #ifndef SQLITE_OMIT_VIRTUALTABLE
sl@0:   if( IsVirtual(pTab) ){
sl@0:     sqlite3ErrorMsg(pParse, "virtual tables may not be altered");
sl@0:     goto exit_begin_add_column;
sl@0:   }
sl@0: #endif
sl@0: 
sl@0:   /* Make sure this is not an attempt to ALTER a view. */
sl@0:   if( pTab->pSelect ){
sl@0:     sqlite3ErrorMsg(pParse, "Cannot add a column to a view");
sl@0:     goto exit_begin_add_column;
sl@0:   }
sl@0: 
sl@0:   assert( pTab->addColOffset>0 );
sl@0:   iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
sl@0: 
sl@0:   /* Put a copy of the Table struct in Parse.pNewTable for the
sl@0:   ** sqlite3AddColumn() function and friends to modify.
sl@0:   */
sl@0:   pNew = (Table*)sqlite3DbMallocZero(db, sizeof(Table));
sl@0:   if( !pNew ) goto exit_begin_add_column;
sl@0:   pParse->pNewTable = pNew;
sl@0:   pNew->nRef = 1;
sl@0:   pNew->db = db;
sl@0:   pNew->nCol = pTab->nCol;
sl@0:   assert( pNew->nCol>0 );
sl@0:   nAlloc = (((pNew->nCol-1)/8)*8)+8;
sl@0:   assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
sl@0:   pNew->aCol = (Column*)sqlite3DbMallocZero(db, sizeof(Column)*nAlloc);
sl@0:   pNew->zName = sqlite3DbStrDup(db, pTab->zName);
sl@0:   if( !pNew->aCol || !pNew->zName ){
sl@0:     db->mallocFailed = 1;
sl@0:     goto exit_begin_add_column;
sl@0:   }
sl@0:   memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
sl@0:   for(i=0; i<pNew->nCol; i++){
sl@0:     Column *pCol = &pNew->aCol[i];
sl@0:     pCol->zName = sqlite3DbStrDup(db, pCol->zName);
sl@0:     pCol->zColl = 0;
sl@0:     pCol->zType = 0;
sl@0:     pCol->pDflt = 0;
sl@0:   }
sl@0:   pNew->pSchema = db->aDb[iDb].pSchema;
sl@0:   pNew->addColOffset = pTab->addColOffset;
sl@0:   pNew->nRef = 1;
sl@0: 
sl@0:   /* Begin a transaction and increment the schema cookie.  */
sl@0:   sqlite3BeginWriteOperation(pParse, 0, iDb);
sl@0:   v = sqlite3GetVdbe(pParse);
sl@0:   if( !v ) goto exit_begin_add_column;
sl@0:   sqlite3ChangeCookie(pParse, iDb);
sl@0: 
sl@0: exit_begin_add_column:
sl@0:   sqlite3SrcListDelete(db, pSrc);
sl@0:   return;
sl@0: }
sl@0: #endif  /* SQLITE_ALTER_TABLE */