blob: 2b043ef158b87bb47fb96a0f089e760eeebf839a [file] [log] [blame]
drhd0e4a6c2005-02-15 20:47:57 +00001/*
2** 2005 February 15
3**
4** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
6**
7** May you do good and not evil.
8** May you find forgiveness for yourself and forgive others.
9** May you share freely, never taking more than you give.
10**
11*************************************************************************
12** This file contains C code routines that used to generate VDBE code
13** that implements the ALTER TABLE command.
drhd0e4a6c2005-02-15 20:47:57 +000014*/
15#include "sqliteInt.h"
16
drh1f01ec12005-02-15 21:36:18 +000017/*
18** The code in this file only exists if we are not omitting the
19** ALTER TABLE logic from the build.
20*/
drhd0e4a6c2005-02-15 20:47:57 +000021#ifndef SQLITE_OMIT_ALTERTABLE
drh1f01ec12005-02-15 21:36:18 +000022
23
24/*
25** This function is used by SQL generated to implement the
26** ALTER TABLE command. The first argument is the text of a CREATE TABLE or
27** CREATE INDEX command. The second is a table name. The table name in
drhf11c34d2006-09-08 12:27:36 +000028** the CREATE TABLE or CREATE INDEX statement is replaced with the third
drh1f01ec12005-02-15 21:36:18 +000029** argument and the result returned. Examples:
30**
31** sqlite_rename_table('CREATE TABLE abc(a, b, c)', 'def')
32** -> 'CREATE TABLE def(a, b, c)'
33**
34** sqlite_rename_table('CREATE INDEX i ON abc(a)', 'def')
35** -> 'CREATE INDEX i ON def(a, b, c)'
36*/
37static void renameTableFunc(
38 sqlite3_context *context,
danielk197762c14b32008-11-19 09:05:26 +000039 int NotUsed,
drh1f01ec12005-02-15 21:36:18 +000040 sqlite3_value **argv
41){
42 unsigned char const *zSql = sqlite3_value_text(argv[0]);
43 unsigned char const *zTableName = sqlite3_value_text(argv[1]);
44
45 int token;
46 Token tname;
drh2646da72005-12-09 20:02:05 +000047 unsigned char const *zCsr = zSql;
drh1f01ec12005-02-15 21:36:18 +000048 int len = 0;
49 char *zRet;
50
drhfa4a4b92008-03-19 21:45:51 +000051 sqlite3 *db = sqlite3_context_db_handle(context);
danielk19771e536952007-08-16 10:09:01 +000052
danielk197762c14b32008-11-19 09:05:26 +000053 UNUSED_PARAMETER(NotUsed);
54
drh1f01ec12005-02-15 21:36:18 +000055 /* The principle used to locate the table name in the CREATE TABLE
drh73829452008-05-09 14:17:51 +000056 ** statement is that the table name is the first non-space token that
drh6aa1edc2008-07-07 12:44:58 +000057 ** is immediately followed by a TK_LP or TK_USING token.
drh1f01ec12005-02-15 21:36:18 +000058 */
59 if( zSql ){
60 do {
danielk1977dce872b2007-05-08 12:37:45 +000061 if( !*zCsr ){
62 /* Ran out of input before finding an opening bracket. Return NULL. */
63 return;
64 }
65
drh1f01ec12005-02-15 21:36:18 +000066 /* Store the token that zCsr points to in tname. */
drhb7916a72009-05-27 10:31:29 +000067 tname.z = (char*)zCsr;
drh1f01ec12005-02-15 21:36:18 +000068 tname.n = len;
69
70 /* Advance zCsr to the next token. Store that token type in 'token',
drh85b623f2007-12-13 21:54:09 +000071 ** and its length in 'len' (to be used next iteration of this loop).
drh1f01ec12005-02-15 21:36:18 +000072 */
73 do {
74 zCsr += len;
75 len = sqlite3GetToken(zCsr, &token);
drh200a81d2008-08-08 14:19:41 +000076 } while( token==TK_SPACE );
drh1f01ec12005-02-15 21:36:18 +000077 assert( len>0 );
danielk1977182c4ba2007-06-27 15:53:34 +000078 } while( token!=TK_LP && token!=TK_USING );
drh1f01ec12005-02-15 21:36:18 +000079
drh4300c1a2014-02-20 19:23:15 +000080 zRet = sqlite3MPrintf(db, "%.*s\"%w\"%s", (int)(((u8*)tname.z) - zSql),
81 zSql, zTableName, tname.z+tname.n);
drh633e6d52008-07-28 19:34:53 +000082 sqlite3_result_text(context, zRet, -1, SQLITE_DYNAMIC);
drh1f01ec12005-02-15 21:36:18 +000083 }
84}
85
dan432cc5b2009-09-26 17:51:48 +000086/*
87** This C function implements an SQL user function that is used by SQL code
88** generated by the ALTER TABLE ... RENAME command to modify the definition
89** of any foreign key constraints that use the table being renamed as the
90** parent table. It is passed three arguments:
91**
92** 1) The complete text of the CREATE TABLE statement being modified,
93** 2) The old name of the table being renamed, and
94** 3) The new name of the table being renamed.
95**
96** It returns the new CREATE TABLE statement. For example:
97**
98** sqlite_rename_parent('CREATE TABLE t1(a REFERENCES t2)', 't2', 't3')
99** -> 'CREATE TABLE t1(a REFERENCES t3)'
100*/
101#ifndef SQLITE_OMIT_FOREIGN_KEY
102static void renameParentFunc(
103 sqlite3_context *context,
104 int NotUsed,
105 sqlite3_value **argv
106){
107 sqlite3 *db = sqlite3_context_db_handle(context);
108 char *zOutput = 0;
109 char *zResult;
110 unsigned char const *zInput = sqlite3_value_text(argv[0]);
111 unsigned char const *zOld = sqlite3_value_text(argv[1]);
112 unsigned char const *zNew = sqlite3_value_text(argv[2]);
113
114 unsigned const char *z; /* Pointer to token */
115 int n; /* Length of token z */
116 int token; /* Type of token */
117
drhd3ceeb52009-10-13 13:08:19 +0000118 UNUSED_PARAMETER(NotUsed);
drh65b9ac52014-04-14 19:48:25 +0000119 if( zInput==0 || zOld==0 ) return;
dan432cc5b2009-09-26 17:51:48 +0000120 for(z=zInput; *z; z=z+n){
121 n = sqlite3GetToken(z, &token);
122 if( token==TK_REFERENCES ){
123 char *zParent;
124 do {
125 z += n;
126 n = sqlite3GetToken(z, &token);
127 }while( token==TK_SPACE );
128
dand68d1f42015-04-28 14:07:02 +0000129 if( token==TK_ILLEGAL ) break;
dan432cc5b2009-09-26 17:51:48 +0000130 zParent = sqlite3DbStrNDup(db, (const char *)z, n);
drha172c342009-10-08 01:43:55 +0000131 if( zParent==0 ) break;
dan432cc5b2009-09-26 17:51:48 +0000132 sqlite3Dequote(zParent);
133 if( 0==sqlite3StrICmp((const char *)zOld, zParent) ){
134 char *zOut = sqlite3MPrintf(db, "%s%.*s\"%w\"",
drh4300c1a2014-02-20 19:23:15 +0000135 (zOutput?zOutput:""), (int)(z-zInput), zInput, (const char *)zNew
dan432cc5b2009-09-26 17:51:48 +0000136 );
137 sqlite3DbFree(db, zOutput);
138 zOutput = zOut;
139 zInput = &z[n];
140 }
141 sqlite3DbFree(db, zParent);
142 }
143 }
144
145 zResult = sqlite3MPrintf(db, "%s%s", (zOutput?zOutput:""), zInput),
146 sqlite3_result_text(context, zResult, -1, SQLITE_DYNAMIC);
147 sqlite3DbFree(db, zOutput);
148}
149#endif
150
drh1f01ec12005-02-15 21:36:18 +0000151#ifndef SQLITE_OMIT_TRIGGER
drhf11c34d2006-09-08 12:27:36 +0000152/* This function is used by SQL generated to implement the
drh1f01ec12005-02-15 21:36:18 +0000153** ALTER TABLE command. The first argument is the text of a CREATE TRIGGER
154** statement. The second is a table name. The table name in the CREATE
drhf11c34d2006-09-08 12:27:36 +0000155** TRIGGER statement is replaced with the third argument and the result
drh1f01ec12005-02-15 21:36:18 +0000156** returned. This is analagous to renameTableFunc() above, except for CREATE
157** TRIGGER, not CREATE INDEX and CREATE TABLE.
158*/
159static void renameTriggerFunc(
160 sqlite3_context *context,
danielk197762c14b32008-11-19 09:05:26 +0000161 int NotUsed,
drh1f01ec12005-02-15 21:36:18 +0000162 sqlite3_value **argv
163){
164 unsigned char const *zSql = sqlite3_value_text(argv[0]);
165 unsigned char const *zTableName = sqlite3_value_text(argv[1]);
166
167 int token;
168 Token tname;
169 int dist = 3;
drh2646da72005-12-09 20:02:05 +0000170 unsigned char const *zCsr = zSql;
drh1f01ec12005-02-15 21:36:18 +0000171 int len = 0;
172 char *zRet;
drhfa4a4b92008-03-19 21:45:51 +0000173 sqlite3 *db = sqlite3_context_db_handle(context);
danielk19771e536952007-08-16 10:09:01 +0000174
danielk197762c14b32008-11-19 09:05:26 +0000175 UNUSED_PARAMETER(NotUsed);
176
drh1f01ec12005-02-15 21:36:18 +0000177 /* The principle used to locate the table name in the CREATE TRIGGER
peter.d.reid60ec9142014-09-06 16:39:46 +0000178 ** statement is that the table name is the first token that is immediately
179 ** preceded by either TK_ON or TK_DOT and immediately followed by one
drh1f01ec12005-02-15 21:36:18 +0000180 ** of TK_WHEN, TK_BEGIN or TK_FOR.
181 */
182 if( zSql ){
183 do {
danielk1977dce872b2007-05-08 12:37:45 +0000184
185 if( !*zCsr ){
186 /* Ran out of input before finding the table name. Return NULL. */
187 return;
188 }
189
drh1f01ec12005-02-15 21:36:18 +0000190 /* Store the token that zCsr points to in tname. */
drhb7916a72009-05-27 10:31:29 +0000191 tname.z = (char*)zCsr;
drh1f01ec12005-02-15 21:36:18 +0000192 tname.n = len;
193
194 /* Advance zCsr to the next token. Store that token type in 'token',
drh85b623f2007-12-13 21:54:09 +0000195 ** and its length in 'len' (to be used next iteration of this loop).
drh1f01ec12005-02-15 21:36:18 +0000196 */
197 do {
198 zCsr += len;
199 len = sqlite3GetToken(zCsr, &token);
200 }while( token==TK_SPACE );
201 assert( len>0 );
202
203 /* Variable 'dist' stores the number of tokens read since the most
204 ** recent TK_DOT or TK_ON. This means that when a WHEN, FOR or BEGIN
205 ** token is read and 'dist' equals 2, the condition stated above
206 ** to be met.
207 **
208 ** Note that ON cannot be a database, table or column name, so
209 ** there is no need to worry about syntax like
210 ** "CREATE TRIGGER ... ON ON.ON BEGIN ..." etc.
211 */
212 dist++;
213 if( token==TK_DOT || token==TK_ON ){
214 dist = 0;
215 }
216 } while( dist!=2 || (token!=TK_WHEN && token!=TK_FOR && token!=TK_BEGIN) );
217
218 /* Variable tname now contains the token that is the old table-name
219 ** in the CREATE TRIGGER statement.
220 */
drh4300c1a2014-02-20 19:23:15 +0000221 zRet = sqlite3MPrintf(db, "%.*s\"%w\"%s", (int)(((u8*)tname.z) - zSql),
222 zSql, zTableName, tname.z+tname.n);
drh633e6d52008-07-28 19:34:53 +0000223 sqlite3_result_text(context, zRet, -1, SQLITE_DYNAMIC);
drh1f01ec12005-02-15 21:36:18 +0000224 }
225}
226#endif /* !SQLITE_OMIT_TRIGGER */
227
228/*
229** Register built-in functions used to help implement ALTER TABLE
230*/
drh545f5872010-04-24 14:02:59 +0000231void sqlite3AlterFunctions(void){
232 static SQLITE_WSD FuncDef aAlterTableFuncs[] = {
233 FUNCTION(sqlite_rename_table, 2, 0, 0, renameTableFunc),
drh1f01ec12005-02-15 21:36:18 +0000234#ifndef SQLITE_OMIT_TRIGGER
drh545f5872010-04-24 14:02:59 +0000235 FUNCTION(sqlite_rename_trigger, 2, 0, 0, renameTriggerFunc),
drh1f01ec12005-02-15 21:36:18 +0000236#endif
dan432cc5b2009-09-26 17:51:48 +0000237#ifndef SQLITE_OMIT_FOREIGN_KEY
drh545f5872010-04-24 14:02:59 +0000238 FUNCTION(sqlite_rename_parent, 3, 0, 0, renameParentFunc),
dan432cc5b2009-09-26 17:51:48 +0000239#endif
drh545f5872010-04-24 14:02:59 +0000240 };
241 int i;
242 FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions);
243 FuncDef *aFunc = (FuncDef*)&GLOBAL(FuncDef, aAlterTableFuncs);
244
245 for(i=0; i<ArraySize(aAlterTableFuncs); i++){
246 sqlite3FuncDefInsert(pHash, &aFunc[i]);
247 }
dan432cc5b2009-09-26 17:51:48 +0000248}
249
250/*
251** This function is used to create the text of expressions of the form:
252**
253** name=<constant1> OR name=<constant2> OR ...
254**
255** If argument zWhere is NULL, then a pointer string containing the text
256** "name=<constant>" is returned, where <constant> is the quoted version
257** of the string passed as argument zConstant. The returned buffer is
258** allocated using sqlite3DbMalloc(). It is the responsibility of the
259** caller to ensure that it is eventually freed.
260**
261** If argument zWhere is not NULL, then the string returned is
262** "<where> OR name=<constant>", where <where> is the contents of zWhere.
263** In this case zWhere is passed to sqlite3DbFree() before returning.
264**
265*/
266static char *whereOrName(sqlite3 *db, char *zWhere, char *zConstant){
267 char *zNew;
268 if( !zWhere ){
269 zNew = sqlite3MPrintf(db, "name=%Q", zConstant);
270 }else{
271 zNew = sqlite3MPrintf(db, "%s OR name=%Q", zWhere, zConstant);
272 sqlite3DbFree(db, zWhere);
273 }
274 return zNew;
275}
276
dan856ef1a2009-09-29 06:33:23 +0000277#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
dan432cc5b2009-09-26 17:51:48 +0000278/*
279** Generate the text of a WHERE expression which can be used to select all
280** tables that have foreign key constraints that refer to table pTab (i.e.
281** constraints for which pTab is the parent table) from the sqlite_master
282** table.
283*/
284static char *whereForeignKeys(Parse *pParse, Table *pTab){
285 FKey *p;
286 char *zWhere = 0;
287 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
288 zWhere = whereOrName(pParse->db, zWhere, p->pFrom->zName);
289 }
290 return zWhere;
drh1f01ec12005-02-15 21:36:18 +0000291}
dan856ef1a2009-09-29 06:33:23 +0000292#endif
drh1f01ec12005-02-15 21:36:18 +0000293
drhd0e4a6c2005-02-15 20:47:57 +0000294/*
danielk197719a8e7e2005-03-17 05:03:38 +0000295** Generate the text of a WHERE expression which can be used to select all
296** temporary triggers on table pTab from the sqlite_temp_master table. If
297** table pTab has no temporary triggers, or is itself stored in the
298** temporary database, NULL is returned.
299*/
300static char *whereTempTriggers(Parse *pParse, Table *pTab){
301 Trigger *pTrig;
302 char *zWhere = 0;
danielk1977e501b892006-01-09 06:29:47 +0000303 const Schema *pTempSchema = pParse->db->aDb[1].pSchema; /* Temp db schema */
danielk1977da184232006-01-05 11:34:32 +0000304
305 /* If the table is not located in the temp-db (in which case NULL is
306 ** returned, loop through the tables list of triggers. For each trigger
307 ** that is not part of the temp-db schema, add a clause to the WHERE
308 ** expression being built up in zWhere.
309 */
310 if( pTab->pSchema!=pTempSchema ){
danielk19771e536952007-08-16 10:09:01 +0000311 sqlite3 *db = pParse->db;
danielk19772f886d12009-02-28 10:47:41 +0000312 for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
danielk1977da184232006-01-05 11:34:32 +0000313 if( pTrig->pSchema==pTempSchema ){
dan432cc5b2009-09-26 17:51:48 +0000314 zWhere = whereOrName(db, zWhere, pTrig->zName);
danielk197719a8e7e2005-03-17 05:03:38 +0000315 }
316 }
317 }
dan39f1bcb2010-09-29 07:16:46 +0000318 if( zWhere ){
319 char *zNew = sqlite3MPrintf(pParse->db, "type='trigger' AND (%s)", zWhere);
320 sqlite3DbFree(pParse->db, zWhere);
321 zWhere = zNew;
322 }
danielk197719a8e7e2005-03-17 05:03:38 +0000323 return zWhere;
324}
325
326/*
327** Generate code to drop and reload the internal representation of table
328** pTab from the database, including triggers and temporary triggers.
329** Argument zName is the name of the table in the database schema at
330** the time the generated code is executed. This can be different from
331** pTab->zName if this function is being called to code part of an
332** "ALTER TABLE RENAME TO" statement.
333*/
334static void reloadTableSchema(Parse *pParse, Table *pTab, const char *zName){
335 Vdbe *v;
336 char *zWhere;
danielk1977da184232006-01-05 11:34:32 +0000337 int iDb; /* Index of database containing pTab */
danielk197719a8e7e2005-03-17 05:03:38 +0000338#ifndef SQLITE_OMIT_TRIGGER
339 Trigger *pTrig;
340#endif
341
342 v = sqlite3GetVdbe(pParse);
drhd3264c72009-04-15 13:39:47 +0000343 if( NEVER(v==0) ) return;
drh1fee73e2007-08-29 04:00:57 +0000344 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
danielk1977da184232006-01-05 11:34:32 +0000345 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
346 assert( iDb>=0 );
danielk197719a8e7e2005-03-17 05:03:38 +0000347
348#ifndef SQLITE_OMIT_TRIGGER
349 /* Drop any table triggers from the internal schema. */
danielk19772f886d12009-02-28 10:47:41 +0000350 for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
danielk1977da184232006-01-05 11:34:32 +0000351 int iTrigDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
352 assert( iTrigDb==iDb || iTrigDb==1 );
dan165921a2009-08-28 18:53:45 +0000353 sqlite3VdbeAddOp4(v, OP_DropTrigger, iTrigDb, 0, 0, pTrig->zName, 0);
danielk197719a8e7e2005-03-17 05:03:38 +0000354 }
355#endif
356
dan432cc5b2009-09-26 17:51:48 +0000357 /* Drop the table and index from the internal schema. */
drh66a51672008-01-03 00:01:23 +0000358 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
danielk197719a8e7e2005-03-17 05:03:38 +0000359
360 /* Reload the table, index and permanent trigger schemas. */
danielk19771e536952007-08-16 10:09:01 +0000361 zWhere = sqlite3MPrintf(pParse->db, "tbl_name=%Q", zName);
danielk197719a8e7e2005-03-17 05:03:38 +0000362 if( !zWhere ) return;
drh5d9c9da2011-06-03 20:11:17 +0000363 sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere);
danielk197719a8e7e2005-03-17 05:03:38 +0000364
365#ifndef SQLITE_OMIT_TRIGGER
366 /* Now, if the table is not stored in the temp database, reload any temp
367 ** triggers. Don't use IN(...) in case SQLITE_OMIT_SUBQUERY is defined.
368 */
drhd9cb6ac2005-10-20 07:28:17 +0000369 if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){
drh5d9c9da2011-06-03 20:11:17 +0000370 sqlite3VdbeAddParseSchemaOp(v, 1, zWhere);
danielk197719a8e7e2005-03-17 05:03:38 +0000371 }
372#endif
373}
374
375/*
danbe535002011-04-01 15:15:58 +0000376** Parameter zName is the name of a table that is about to be altered
377** (either with ALTER TABLE ... RENAME TO or ALTER TABLE ... ADD COLUMN).
378** If the table is a system table, this function leaves an error message
379** in pParse->zErr (system tables may not be altered) and returns non-zero.
380**
381** Or, if zName is not a system table, zero is returned.
382*/
383static int isSystemTable(Parse *pParse, const char *zName){
384 if( sqlite3Strlen30(zName)>6 && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){
385 sqlite3ErrorMsg(pParse, "table %s may not be altered", zName);
386 return 1;
387 }
388 return 0;
389}
390
391/*
drhd0e4a6c2005-02-15 20:47:57 +0000392** Generate code to implement the "ALTER TABLE xxx RENAME TO yyy"
393** command.
394*/
395void sqlite3AlterRenameTable(
396 Parse *pParse, /* Parser context. */
397 SrcList *pSrc, /* The table to rename. */
398 Token *pName /* The new table name. */
399){
400 int iDb; /* Database that contains the table */
401 char *zDb; /* Name of database iDb */
402 Table *pTab; /* Table being renamed */
403 char *zName = 0; /* NULL-terminated version of pName */
drhd0e4a6c2005-02-15 20:47:57 +0000404 sqlite3 *db = pParse->db; /* Database connection */
drh4e5dd852007-05-15 03:56:49 +0000405 int nTabName; /* Number of UTF-8 characters in zTabName */
406 const char *zTabName; /* Original name of the table */
drhd0e4a6c2005-02-15 20:47:57 +0000407 Vdbe *v;
408#ifndef SQLITE_OMIT_TRIGGER
danielk197719a8e7e2005-03-17 05:03:38 +0000409 char *zWhere = 0; /* Where clause to locate temp triggers */
drhd0e4a6c2005-02-15 20:47:57 +0000410#endif
danielk1977595a5232009-07-24 17:58:53 +0000411 VTable *pVTab = 0; /* Non-zero if this is a v-tab with an xRename() */
drh545f5872010-04-24 14:02:59 +0000412 int savedDbFlags; /* Saved value of db->flags */
413
414 savedDbFlags = db->flags;
drh56d56f72009-04-16 16:30:17 +0000415 if( NEVER(db->mallocFailed) ) goto exit_rename_table;
drhd0e4a6c2005-02-15 20:47:57 +0000416 assert( pSrc->nSrc==1 );
drh1fee73e2007-08-29 04:00:57 +0000417 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
drhd0e4a6c2005-02-15 20:47:57 +0000418
dan41fb5cd2012-10-04 19:33:00 +0000419 pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
drhd0e4a6c2005-02-15 20:47:57 +0000420 if( !pTab ) goto exit_rename_table;
danielk1977da184232006-01-05 11:34:32 +0000421 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
drhd0e4a6c2005-02-15 20:47:57 +0000422 zDb = db->aDb[iDb].zName;
drh545f5872010-04-24 14:02:59 +0000423 db->flags |= SQLITE_PreferBuiltin;
drhd0e4a6c2005-02-15 20:47:57 +0000424
425 /* Get a NULL terminated version of the new table name. */
drh17435752007-08-16 04:30:38 +0000426 zName = sqlite3NameFromToken(db, pName);
drhd0e4a6c2005-02-15 20:47:57 +0000427 if( !zName ) goto exit_rename_table;
428
429 /* Check that a table or index named 'zName' does not already exist
430 ** in database iDb. If so, this is an error.
431 */
432 if( sqlite3FindTable(db, zName, zDb) || sqlite3FindIndex(db, zName, zDb) ){
433 sqlite3ErrorMsg(pParse,
434 "there is already another table or index with this name: %s", zName);
435 goto exit_rename_table;
436 }
437
438 /* Make sure it is not a system table being altered, or a reserved name
439 ** that the table is being renamed to.
440 */
danbe535002011-04-01 15:15:58 +0000441 if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
drhd0e4a6c2005-02-15 20:47:57 +0000442 goto exit_rename_table;
443 }
danbe535002011-04-01 15:15:58 +0000444 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ goto
445 exit_rename_table;
drhd0e4a6c2005-02-15 20:47:57 +0000446 }
447
danielk197761116ae2007-12-13 08:15:30 +0000448#ifndef SQLITE_OMIT_VIEW
449 if( pTab->pSelect ){
450 sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
451 goto exit_rename_table;
452 }
453#endif
454
drhd0e4a6c2005-02-15 20:47:57 +0000455#ifndef SQLITE_OMIT_AUTHORIZATION
456 /* Invoke the authorization callback. */
457 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
458 goto exit_rename_table;
459 }
460#endif
461
danielk1977182c4ba2007-06-27 15:53:34 +0000462#ifndef SQLITE_OMIT_VIRTUALTABLE
danielk19775c558862007-06-27 17:09:24 +0000463 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
464 goto exit_rename_table;
465 }
danielk1977595a5232009-07-24 17:58:53 +0000466 if( IsVirtual(pTab) ){
467 pVTab = sqlite3GetVTable(db, pTab);
468 if( pVTab->pVtab->pModule->xRename==0 ){
469 pVTab = 0;
470 }
danielk1977182c4ba2007-06-27 15:53:34 +0000471 }
472#endif
473
drhb22f7c82014-02-06 23:56:27 +0000474 /* Begin a transaction for database iDb.
drhd0e4a6c2005-02-15 20:47:57 +0000475 ** Then modify the schema cookie (since the ALTER TABLE modifies the
danielk1977182c4ba2007-06-27 15:53:34 +0000476 ** schema). Open a statement transaction if the table is a virtual
477 ** table.
drhd0e4a6c2005-02-15 20:47:57 +0000478 */
479 v = sqlite3GetVdbe(pParse);
480 if( v==0 ){
481 goto exit_rename_table;
482 }
danielk1977595a5232009-07-24 17:58:53 +0000483 sqlite3BeginWriteOperation(pParse, pVTab!=0, iDb);
drh9cbf3422008-01-17 16:22:13 +0000484 sqlite3ChangeCookie(pParse, iDb);
drhd0e4a6c2005-02-15 20:47:57 +0000485
danielk1977182c4ba2007-06-27 15:53:34 +0000486 /* If this is a virtual table, invoke the xRename() function if
487 ** one is defined. The xRename() callback will modify the names
488 ** of any resources used by the v-table implementation (including other
489 ** SQLite tables) that are identified by the name of the virtual table.
490 */
491#ifndef SQLITE_OMIT_VIRTUALTABLE
danielk1977595a5232009-07-24 17:58:53 +0000492 if( pVTab ){
danielk1977a29f18c2008-01-04 11:01:03 +0000493 int i = ++pParse->nMem;
drh076e85f2015-09-03 13:46:12 +0000494 sqlite3VdbeLoadString(v, i, zName);
danielk1977595a5232009-07-24 17:58:53 +0000495 sqlite3VdbeAddOp4(v, OP_VRename, i, 0, 0,(const char*)pVTab, P4_VTAB);
dane0af83a2009-09-08 19:15:01 +0000496 sqlite3MayAbort(pParse);
danielk1977182c4ba2007-06-27 15:53:34 +0000497 }
498#endif
499
drh4e5dd852007-05-15 03:56:49 +0000500 /* figure out how many UTF-8 characters are in zName */
501 zTabName = pTab->zName;
drh9a087a92007-05-15 14:34:32 +0000502 nTabName = sqlite3Utf8CharLen(zTabName, -1);
drh4e5dd852007-05-15 03:56:49 +0000503
dan856ef1a2009-09-29 06:33:23 +0000504#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
dan432cc5b2009-09-26 17:51:48 +0000505 if( db->flags&SQLITE_ForeignKeys ){
506 /* If foreign-key support is enabled, rewrite the CREATE TABLE
507 ** statements corresponding to all child tables of foreign key constraints
508 ** for which the renamed table is the parent table. */
509 if( (zWhere=whereForeignKeys(pParse, pTab))!=0 ){
510 sqlite3NestedParse(pParse,
drh9a6ffc82010-02-15 18:03:20 +0000511 "UPDATE \"%w\".%s SET "
dan432cc5b2009-09-26 17:51:48 +0000512 "sql = sqlite_rename_parent(sql, %Q, %Q) "
drh9a6ffc82010-02-15 18:03:20 +0000513 "WHERE %s;", zDb, SCHEMA_TABLE(iDb), zTabName, zName, zWhere);
dan432cc5b2009-09-26 17:51:48 +0000514 sqlite3DbFree(db, zWhere);
515 }
516 }
517#endif
518
drhd0e4a6c2005-02-15 20:47:57 +0000519 /* Modify the sqlite_master table to use the new table name. */
520 sqlite3NestedParse(pParse,
521 "UPDATE %Q.%s SET "
522#ifdef SQLITE_OMIT_TRIGGER
523 "sql = sqlite_rename_table(sql, %Q), "
524#else
525 "sql = CASE "
526 "WHEN type = 'trigger' THEN sqlite_rename_trigger(sql, %Q)"
527 "ELSE sqlite_rename_table(sql, %Q) END, "
528#endif
529 "tbl_name = %Q, "
530 "name = CASE "
531 "WHEN type='table' THEN %Q "
532 "WHEN name LIKE 'sqlite_autoindex%%' AND type='index' THEN "
drha21a9292007-10-20 20:58:57 +0000533 "'sqlite_autoindex_' || %Q || substr(name,%d+18) "
drhd0e4a6c2005-02-15 20:47:57 +0000534 "ELSE name END "
drh01522682012-02-01 01:13:10 +0000535 "WHERE tbl_name=%Q COLLATE nocase AND "
drhd0e4a6c2005-02-15 20:47:57 +0000536 "(type='table' OR type='index' OR type='trigger');",
537 zDb, SCHEMA_TABLE(iDb), zName, zName, zName,
538#ifndef SQLITE_OMIT_TRIGGER
danielk197719a8e7e2005-03-17 05:03:38 +0000539 zName,
drhd0e4a6c2005-02-15 20:47:57 +0000540#endif
drh4e5dd852007-05-15 03:56:49 +0000541 zName, nTabName, zTabName
drhd0e4a6c2005-02-15 20:47:57 +0000542 );
543
544#ifndef SQLITE_OMIT_AUTOINCREMENT
545 /* If the sqlite_sequence table exists in this database, then update
546 ** it with the new table name.
547 */
548 if( sqlite3FindTable(db, "sqlite_sequence", zDb) ){
549 sqlite3NestedParse(pParse,
drh8e5b5f82008-02-09 14:30:29 +0000550 "UPDATE \"%w\".sqlite_sequence set name = %Q WHERE name = %Q",
drhd0e4a6c2005-02-15 20:47:57 +0000551 zDb, zName, pTab->zName);
552 }
553#endif
554
555#ifndef SQLITE_OMIT_TRIGGER
556 /* If there are TEMP triggers on this table, modify the sqlite_temp_master
557 ** table. Don't do this if the table being ALTERed is itself located in
558 ** the temp database.
559 */
drhd9cb6ac2005-10-20 07:28:17 +0000560 if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){
danielk197719a8e7e2005-03-17 05:03:38 +0000561 sqlite3NestedParse(pParse,
562 "UPDATE sqlite_temp_master SET "
563 "sql = sqlite_rename_trigger(sql, %Q), "
564 "tbl_name = %Q "
565 "WHERE %s;", zName, zName, zWhere);
drh633e6d52008-07-28 19:34:53 +0000566 sqlite3DbFree(db, zWhere);
drhd0e4a6c2005-02-15 20:47:57 +0000567 }
568#endif
569
dan856ef1a2009-09-29 06:33:23 +0000570#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
dan432cc5b2009-09-26 17:51:48 +0000571 if( db->flags&SQLITE_ForeignKeys ){
572 FKey *p;
573 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
574 Table *pFrom = p->pFrom;
575 if( pFrom!=pTab ){
576 reloadTableSchema(pParse, p->pFrom, pFrom->zName);
577 }
578 }
579 }
580#endif
581
danielk197719a8e7e2005-03-17 05:03:38 +0000582 /* Drop and reload the internal table schema. */
583 reloadTableSchema(pParse, pTab, zName);
drhd0e4a6c2005-02-15 20:47:57 +0000584
585exit_rename_table:
drh633e6d52008-07-28 19:34:53 +0000586 sqlite3SrcListDelete(db, pSrc);
587 sqlite3DbFree(db, zName);
drh545f5872010-04-24 14:02:59 +0000588 db->flags = savedDbFlags;
drhd0e4a6c2005-02-15 20:47:57 +0000589}
danielk197719a8e7e2005-03-17 05:03:38 +0000590
591
592/*
drhd3001712009-05-12 17:46:53 +0000593** Generate code to make sure the file format number is at least minFormat.
594** The generated code will increase the file format number if necessary.
595*/
596void sqlite3MinimumFileFormat(Parse *pParse, int iDb, int minFormat){
597 Vdbe *v;
598 v = sqlite3GetVdbe(pParse);
599 /* The VDBE should have been allocated before this routine is called.
600 ** If that allocation failed, we would have quit before reaching this
601 ** point */
602 if( ALWAYS(v) ){
603 int r1 = sqlite3GetTempReg(pParse);
604 int r2 = sqlite3GetTempReg(pParse);
drh728e0f92015-10-10 14:41:28 +0000605 int addr1;
danielk19770d19f7a2009-06-03 11:25:07 +0000606 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT);
drhd3001712009-05-12 17:46:53 +0000607 sqlite3VdbeUsesBtree(v, iDb);
608 sqlite3VdbeAddOp2(v, OP_Integer, minFormat, r2);
drh728e0f92015-10-10 14:41:28 +0000609 addr1 = sqlite3VdbeAddOp3(v, OP_Ge, r2, 0, r1);
drh3d77dee2014-02-19 14:20:49 +0000610 sqlite3VdbeChangeP5(v, SQLITE_NOTNULL); VdbeCoverage(v);
danielk19770d19f7a2009-06-03 11:25:07 +0000611 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, r2);
drh728e0f92015-10-10 14:41:28 +0000612 sqlite3VdbeJumpHere(v, addr1);
drhd3001712009-05-12 17:46:53 +0000613 sqlite3ReleaseTempReg(pParse, r1);
614 sqlite3ReleaseTempReg(pParse, r2);
615 }
616}
617
618/*
danielk197719a8e7e2005-03-17 05:03:38 +0000619** This function is called after an "ALTER TABLE ... ADD" statement
620** has been parsed. Argument pColDef contains the text of the new
621** column definition.
622**
623** The Table structure pParse->pNewTable was extended to include
624** the new column during parsing.
625*/
626void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
627 Table *pNew; /* Copy of pParse->pNewTable */
628 Table *pTab; /* Table being altered */
629 int iDb; /* Database number */
630 const char *zDb; /* Database name */
631 const char *zTab; /* Table name */
632 char *zCol; /* Null-terminated column definition */
633 Column *pCol; /* The new column */
634 Expr *pDflt; /* Default value for the new column */
drh17435752007-08-16 04:30:38 +0000635 sqlite3 *db; /* The database connection; */
danielk197719a8e7e2005-03-17 05:03:38 +0000636
danielk1977f150c9d2008-10-30 17:21:12 +0000637 db = pParse->db;
638 if( pParse->nErr || db->mallocFailed ) return;
danielk197719a8e7e2005-03-17 05:03:38 +0000639 pNew = pParse->pNewTable;
640 assert( pNew );
641
drh1fee73e2007-08-29 04:00:57 +0000642 assert( sqlite3BtreeHoldsAllMutexes(db) );
drh17435752007-08-16 04:30:38 +0000643 iDb = sqlite3SchemaToIndex(db, pNew->pSchema);
644 zDb = db->aDb[iDb].zName;
drh03881232009-02-13 03:43:31 +0000645 zTab = &pNew->zName[16]; /* Skip the "sqlite_altertab_" prefix on the name */
danielk197719a8e7e2005-03-17 05:03:38 +0000646 pCol = &pNew->aCol[pNew->nCol-1];
647 pDflt = pCol->pDflt;
drh17435752007-08-16 04:30:38 +0000648 pTab = sqlite3FindTable(db, zTab, zDb);
danielk197719a8e7e2005-03-17 05:03:38 +0000649 assert( pTab );
650
drh81f2ccd2006-01-31 14:28:44 +0000651#ifndef SQLITE_OMIT_AUTHORIZATION
652 /* Invoke the authorization callback. */
653 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
654 return;
655 }
656#endif
657
danielk197719a8e7e2005-03-17 05:03:38 +0000658 /* If the default value for the new column was specified with a
659 ** literal NULL, then set pDflt to 0. This simplifies checking
660 ** for an SQL NULL default below.
661 */
662 if( pDflt && pDflt->op==TK_NULL ){
663 pDflt = 0;
664 }
665
666 /* Check that the new column is not specified as PRIMARY KEY or UNIQUE.
667 ** If there is a NOT NULL constraint, then the default value for the
668 ** column must not be NULL.
669 */
drha371ace2012-09-13 14:22:47 +0000670 if( pCol->colFlags & COLFLAG_PRIMKEY ){
danielk197719a8e7e2005-03-17 05:03:38 +0000671 sqlite3ErrorMsg(pParse, "Cannot add a PRIMARY KEY column");
672 return;
673 }
674 if( pNew->pIndex ){
675 sqlite3ErrorMsg(pParse, "Cannot add a UNIQUE column");
676 return;
677 }
dan53c3fa82009-09-25 11:26:54 +0000678 if( (db->flags&SQLITE_ForeignKeys) && pNew->pFKey && pDflt ){
679 sqlite3ErrorMsg(pParse,
680 "Cannot add a REFERENCES column with non-NULL default value");
681 return;
682 }
danielk197719a8e7e2005-03-17 05:03:38 +0000683 if( pCol->notNull && !pDflt ){
684 sqlite3ErrorMsg(pParse,
685 "Cannot add a NOT NULL column with default value NULL");
686 return;
687 }
688
689 /* Ensure the default expression is something that sqlite3ValueFromExpr()
690 ** can handle (i.e. not CURRENT_TIME etc.)
691 */
692 if( pDflt ){
dan7a419232013-08-06 20:01:43 +0000693 sqlite3_value *pVal = 0;
drh96f4ad22015-03-12 21:02:36 +0000694 int rc;
drh05883a32015-06-02 15:32:08 +0000695 rc = sqlite3ValueFromExpr(db, pDflt, SQLITE_UTF8, SQLITE_AFF_BLOB, &pVal);
drh96f4ad22015-03-12 21:02:36 +0000696 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
697 if( rc!=SQLITE_OK ){
drh17435752007-08-16 04:30:38 +0000698 db->mallocFailed = 1;
danielk197719a8e7e2005-03-17 05:03:38 +0000699 return;
700 }
701 if( !pVal ){
702 sqlite3ErrorMsg(pParse, "Cannot add a column with non-constant default");
703 return;
704 }
705 sqlite3ValueFree(pVal);
706 }
707
708 /* Modify the CREATE TABLE statement. */
drh17435752007-08-16 04:30:38 +0000709 zCol = sqlite3DbStrNDup(db, (char*)pColDef->z, pColDef->n);
danielk197719a8e7e2005-03-17 05:03:38 +0000710 if( zCol ){
711 char *zEnd = &zCol[pColDef->n-1];
drh545f5872010-04-24 14:02:59 +0000712 int savedDbFlags = db->flags;
drh56d56f72009-04-16 16:30:17 +0000713 while( zEnd>zCol && (*zEnd==';' || sqlite3Isspace(*zEnd)) ){
danielk197719a8e7e2005-03-17 05:03:38 +0000714 *zEnd-- = '\0';
715 }
drh545f5872010-04-24 14:02:59 +0000716 db->flags |= SQLITE_PreferBuiltin;
danielk197719a8e7e2005-03-17 05:03:38 +0000717 sqlite3NestedParse(pParse,
drh8e5b5f82008-02-09 14:30:29 +0000718 "UPDATE \"%w\".%s SET "
drha21a9292007-10-20 20:58:57 +0000719 "sql = substr(sql,1,%d) || ', ' || %Q || substr(sql,%d) "
danielk197719a8e7e2005-03-17 05:03:38 +0000720 "WHERE type = 'table' AND name = %Q",
721 zDb, SCHEMA_TABLE(iDb), pNew->addColOffset, zCol, pNew->addColOffset+1,
722 zTab
723 );
drh633e6d52008-07-28 19:34:53 +0000724 sqlite3DbFree(db, zCol);
drh545f5872010-04-24 14:02:59 +0000725 db->flags = savedDbFlags;
danielk197719a8e7e2005-03-17 05:03:38 +0000726 }
727
728 /* If the default value of the new column is NULL, then set the file
729 ** format to 2. If the default value of the new column is not NULL,
730 ** the file format becomes 3.
731 */
drhfdd6e852005-12-16 01:06:16 +0000732 sqlite3MinimumFileFormat(pParse, iDb, pDflt ? 3 : 2);
danielk197719a8e7e2005-03-17 05:03:38 +0000733
734 /* Reload the schema of the modified table. */
735 reloadTableSchema(pParse, pTab, pTab->zName);
736}
737
drhfdd6e852005-12-16 01:06:16 +0000738/*
danielk197719a8e7e2005-03-17 05:03:38 +0000739** This function is called by the parser after the table-name in
740** an "ALTER TABLE <table-name> ADD" statement is parsed. Argument
741** pSrc is the full-name of the table being altered.
742**
743** This routine makes a (partial) copy of the Table structure
744** for the table being altered and sets Parse.pNewTable to point
745** to it. Routines called by the parser as the column definition
746** is parsed (i.e. sqlite3AddColumn()) add the new Column data to
747** the copy. The copy of the Table structure is deleted by tokenize.c
748** after parsing is finished.
749**
750** Routine sqlite3AlterFinishAddColumn() will be called to complete
751** coding the "ALTER TABLE ... ADD" statement.
752*/
753void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){
754 Table *pNew;
755 Table *pTab;
756 Vdbe *v;
757 int iDb;
758 int i;
759 int nAlloc;
drh17435752007-08-16 04:30:38 +0000760 sqlite3 *db = pParse->db;
danielk197719a8e7e2005-03-17 05:03:38 +0000761
762 /* Look up the table being altered. */
drh0bbaa1b2005-08-19 19:14:12 +0000763 assert( pParse->pNewTable==0 );
drh1fee73e2007-08-29 04:00:57 +0000764 assert( sqlite3BtreeHoldsAllMutexes(db) );
drh17435752007-08-16 04:30:38 +0000765 if( db->mallocFailed ) goto exit_begin_add_column;
dan41fb5cd2012-10-04 19:33:00 +0000766 pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
danielk197719a8e7e2005-03-17 05:03:38 +0000767 if( !pTab ) goto exit_begin_add_column;
768
danielk19775ee9d692006-06-21 12:36:25 +0000769#ifndef SQLITE_OMIT_VIRTUALTABLE
770 if( IsVirtual(pTab) ){
771 sqlite3ErrorMsg(pParse, "virtual tables may not be altered");
772 goto exit_begin_add_column;
773 }
774#endif
775
danielk197719a8e7e2005-03-17 05:03:38 +0000776 /* Make sure this is not an attempt to ALTER a view. */
777 if( pTab->pSelect ){
778 sqlite3ErrorMsg(pParse, "Cannot add a column to a view");
779 goto exit_begin_add_column;
780 }
danbe535002011-04-01 15:15:58 +0000781 if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
782 goto exit_begin_add_column;
783 }
danielk197719a8e7e2005-03-17 05:03:38 +0000784
785 assert( pTab->addColOffset>0 );
drh17435752007-08-16 04:30:38 +0000786 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
danielk197719a8e7e2005-03-17 05:03:38 +0000787
788 /* Put a copy of the Table struct in Parse.pNewTable for the
drh03881232009-02-13 03:43:31 +0000789 ** sqlite3AddColumn() function and friends to modify. But modify
790 ** the name by adding an "sqlite_altertab_" prefix. By adding this
791 ** prefix, we insure that the name will not collide with an existing
792 ** table because user table are not allowed to have the "sqlite_"
793 ** prefix on their name.
danielk197719a8e7e2005-03-17 05:03:38 +0000794 */
drh17435752007-08-16 04:30:38 +0000795 pNew = (Table*)sqlite3DbMallocZero(db, sizeof(Table));
danielk197719a8e7e2005-03-17 05:03:38 +0000796 if( !pNew ) goto exit_begin_add_column;
797 pParse->pNewTable = pNew;
drh0bbaa1b2005-08-19 19:14:12 +0000798 pNew->nRef = 1;
danielk197719a8e7e2005-03-17 05:03:38 +0000799 pNew->nCol = pTab->nCol;
danielk1977b3a2cce2005-03-27 01:56:30 +0000800 assert( pNew->nCol>0 );
801 nAlloc = (((pNew->nCol-1)/8)*8)+8;
802 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
danielk197726783a52007-08-29 14:06:22 +0000803 pNew->aCol = (Column*)sqlite3DbMallocZero(db, sizeof(Column)*nAlloc);
drh03881232009-02-13 03:43:31 +0000804 pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
danielk197719a8e7e2005-03-17 05:03:38 +0000805 if( !pNew->aCol || !pNew->zName ){
drh17435752007-08-16 04:30:38 +0000806 db->mallocFailed = 1;
danielk197719a8e7e2005-03-17 05:03:38 +0000807 goto exit_begin_add_column;
808 }
809 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
810 for(i=0; i<pNew->nCol; i++){
811 Column *pCol = &pNew->aCol[i];
drh17435752007-08-16 04:30:38 +0000812 pCol->zName = sqlite3DbStrDup(db, pCol->zName);
drhff22e182006-02-09 02:56:02 +0000813 pCol->zColl = 0;
danielk197719a8e7e2005-03-17 05:03:38 +0000814 pCol->zType = 0;
815 pCol->pDflt = 0;
drhb7916a72009-05-27 10:31:29 +0000816 pCol->zDflt = 0;
danielk197719a8e7e2005-03-17 05:03:38 +0000817 }
drh17435752007-08-16 04:30:38 +0000818 pNew->pSchema = db->aDb[iDb].pSchema;
danielk197719a8e7e2005-03-17 05:03:38 +0000819 pNew->addColOffset = pTab->addColOffset;
drhed8a3bb2005-06-06 21:19:56 +0000820 pNew->nRef = 1;
danielk197719a8e7e2005-03-17 05:03:38 +0000821
822 /* Begin a transaction and increment the schema cookie. */
823 sqlite3BeginWriteOperation(pParse, 0, iDb);
824 v = sqlite3GetVdbe(pParse);
825 if( !v ) goto exit_begin_add_column;
drh9cbf3422008-01-17 16:22:13 +0000826 sqlite3ChangeCookie(pParse, iDb);
danielk197719a8e7e2005-03-17 05:03:38 +0000827
828exit_begin_add_column:
drh633e6d52008-07-28 19:34:53 +0000829 sqlite3SrcListDelete(db, pSrc);
danielk197719a8e7e2005-03-17 05:03:38 +0000830 return;
831}
drhd0e4a6c2005-02-15 20:47:57 +0000832#endif /* SQLITE_ALTER_TABLE */