/*

** 2001 September 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 are called by the SQLite parser

** when syntax rules are reduced. The routines in this file handle the

** following kinds of SQL syntax:

**

** CREATE TABLE

** DROP TABLE

** CREATE INDEX

** DROP INDEX

** creating ID lists

** BEGIN TRANSACTION

** COMMIT

** ROLLBACK

*/

#include "sqliteInt.h"

#ifndef SQLITE_OMIT_SHARED_CACHE

/*

** The TableLock structure is only used by the sqlite3TableLock() and

** codeTableLocks() functions.

*/

struct TableLock {

int iDb; /* The database containing the table to be locked */

int iTab; /* The root page of the table to be locked */

u8 isWriteLock; /* True for write lock. False for a read lock */

const char *zLockName; /* Name of the table */

};

/*

** Record the fact that we want to lock a table at run-time.

**

** The table to be locked has root page iTab and is found in database iDb.

** A read or a write lock can be taken depending on isWritelock.

**

** This routine just records the fact that the lock is desired. The

** code to make the lock occur is generated by a later call to

** codeTableLocks() which occurs during sqlite3FinishCoding().

*/

void sqlite3TableLock(

Parse *pParse, /* Parsing context */

int iDb, /* Index of the database containing the table to lock */

int iTab, /* Root page number of the table to be locked */

u8 isWriteLock, /* True for a write lock */

const char *zName /* Name of the table to be locked */

){

Parse *pToplevel = sqlite3ParseToplevel(pParse);

int i;

int nBytes;

TableLock *p;

assert( iDb>=0 );

if( iDb==1 ) return;

if( !sqlite3BtreeSharable(pParse->db->aDb[iDb].pBt) ) return;

for(i=0; i<pToplevel->nTableLock; i++){

p = &pToplevel->aTableLock[i];

if( p->iDb==iDb && p->iTab==iTab ){

p->isWriteLock = (p->isWriteLock || isWriteLock);

return;

}

}

nBytes = sizeof(TableLock) * (pToplevel->nTableLock+1);

pToplevel->aTableLock =

sqlite3DbReallocOrFree(pToplevel->db, pToplevel->aTableLock, nBytes);

if( pToplevel->aTableLock ){

p = &pToplevel->aTableLock[pToplevel->nTableLock++];

p->iDb = iDb;

p->iTab = iTab;

p->isWriteLock = isWriteLock;

p->zLockName = zName;

}else{

pToplevel->nTableLock = 0;

sqlite3OomFault(pToplevel->db);

}

}

/*

** Code an OP_TableLock instruction for each table locked by the

** statement (configured by calls to sqlite3TableLock()).

*/

static void codeTableLocks(Parse *pParse){

int i;

Vdbe *pVdbe;

pVdbe = sqlite3GetVdbe(pParse);

assert( pVdbe!=0 ); /* sqlite3GetVdbe cannot fail: VDBE already allocated */

for(i=0; i<pParse->nTableLock; i++){

TableLock *p = &pParse->aTableLock[i];

int p1 = p->iDb;

sqlite3VdbeAddOp4(pVdbe, OP_TableLock, p1, p->iTab, p->isWriteLock,

p->zLockName, P4_STATIC);

}

}

#else

#define codeTableLocks(x)

#endif

/*

** Return TRUE if the given yDbMask object is empty - if it contains no

** 1 bits. This routine is used by the DbMaskAllZero() and DbMaskNotZero()

** macros when SQLITE_MAX_ATTACHED is greater than 30.

*/

#if SQLITE_MAX_ATTACHED>30

int sqlite3DbMaskAllZero(yDbMask m){

int i;

for(i=0; i<sizeof(yDbMask); i++) if( m[i] ) return 0;

return 1;

}

#endif

/*

** This routine is called after a single SQL statement has been

** parsed and a VDBE program to execute that statement has been

** prepared. This routine puts the finishing touches on the

** VDBE program and resets the pParse structure for the next

** parse.

**

** Note that if an error occurred, it might be the case that

** no VDBE code was generated.

*/

void sqlite3FinishCoding(Parse *pParse){

sqlite3 *db;

Vdbe *v;

assert( pParse->pToplevel==0 );

db = pParse->db;

if( pParse->nested ) return;

if( db->mallocFailed || pParse->nErr ){

if( pParse->rc==SQLITE_OK ) pParse->rc = SQLITE_ERROR;

return;

}

/* Begin by generating some termination code at the end of the

** vdbe program

*/

v = sqlite3GetVdbe(pParse);

assert( !pParse->isMultiWrite

|| sqlite3VdbeAssertMayAbort(v, pParse->mayAbort));

if( v ){

sqlite3VdbeAddOp0(v, OP_Halt);

#if SQLITE_USER_AUTHENTICATION

if( pParse->nTableLock>0 && db->init.busy==0 ){

sqlite3UserAuthInit(db);

if( db->auth.authLevel<UAUTH_User ){

sqlite3ErrorMsg(pParse, "user not authenticated");

pParse->rc = SQLITE_AUTH_USER;

return;

}

}

#endif

/* The cookie mask contains one bit for each database file open.

** (Bit 0 is for main, bit 1 is for temp, and so forth.) Bits are

** set for each database that is used. Generate code to start a

** transaction on each used database and to verify the schema cookie

** on each used database.

*/

if( db->mallocFailed==0

&& (DbMaskNonZero(pParse->cookieMask) || pParse->pConstExpr)

){

int iDb, i;

assert( sqlite3VdbeGetOp(v, 0)->opcode==OP_Init );

sqlite3VdbeJumpHere(v, 0);

for(iDb=0; iDb<db->nDb; iDb++){

Schema *pSchema;

if( DbMaskTest(pParse->cookieMask, iDb)==0 ) continue;

sqlite3VdbeUsesBtree(v, iDb);

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

sqlite3VdbeAddOp4Int(v,

OP_Transaction, /* Opcode */

iDb, /* P1 */

DbMaskTest(pParse->writeMask,iDb), /* P2 */

pSchema->schema_cookie, /* P3 */

pSchema->iGeneration /* P4 */

);

if( db->init.busy==0 ) sqlite3VdbeChangeP5(v, 1);

VdbeComment((v,

"usesStmtJournal=%d", pParse->mayAbort && pParse->isMultiWrite));

}

#ifndef SQLITE_OMIT_VIRTUALTABLE

for(i=0; i<pParse->nVtabLock; i++){

char *vtab = (char *)sqlite3GetVTable(db, pParse->apVtabLock[i]);

sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB);

}

pParse->nVtabLock = 0;

#endif

/* Once all the cookies have been verified and transactions opened,

** obtain the required table-locks. This is a no-op unless the

** shared-cache feature is enabled.

*/

codeTableLocks(pParse);

/* Initialize any AUTOINCREMENT data structures required.

*/

sqlite3AutoincrementBegin(pParse);

/* Code constant expressions that where factored out of inner loops */

if( pParse->pConstExpr ){

ExprList *pEL = pParse->pConstExpr;

pParse->okConstFactor = 0;

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

sqlite3ExprCode(pParse, pEL->a[i].pExpr, pEL->a[i].u.iConstExprReg);

}

}

/* Finally, jump back to the beginning of the executable code. */

sqlite3VdbeGoto(v, 1);

}

}

/* Get the VDBE program ready for execution

*/

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

/* A minimum of one cursor is required if autoincrement is used

* See ticket [a696379c1f08866] */

assert( pParse->pAinc==0 || pParse->nTab>0 );

sqlite3VdbeMakeReady(v, pParse);

pParse->rc = SQLITE_DONE;

}else{

pParse->rc = SQLITE_ERROR;

}

}

/*

** Run the parser and code generator recursively in order to generate

** code for the SQL statement given onto the end of the pParse context

** currently under construction. When the parser is run recursively

** this way, the final OP_Halt is not appended and other initialization

** and finalization steps are omitted because those are handling by the

** outermost parser.

**

** Not everything is nestable. This facility is designed to permit

** INSERT, UPDATE, and DELETE operations against SQLITE_MASTER. Use

** care if you decide to try to use this routine for some other purposes.

*/

void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){

va_list ap;

char *zSql;

char *zErrMsg = 0;

sqlite3 *db = pParse->db;

char saveBuf[PARSE_TAIL_SZ];

if( pParse->nErr ) return;

assert( pParse->nested<10 ); /* Nesting should only be of limited depth */

va_start(ap, zFormat);

zSql = sqlite3VMPrintf(db, zFormat, ap);

va_end(ap);

if( zSql==0 ){

/* This can result either from an OOM or because the formatted string

** exceeds SQLITE_LIMIT_LENGTH. In the latter case, we need to set

** an error */

if( !db->mallocFailed ) pParse->rc = SQLITE_TOOBIG;

pParse->nErr++;

return;

}

pParse->nested++;

memcpy(saveBuf, PARSE_TAIL(pParse), PARSE_TAIL_SZ);

memset(PARSE_TAIL(pParse), 0, PARSE_TAIL_SZ);

sqlite3RunParser(pParse, zSql, &zErrMsg);

sqlite3DbFree(db, zErrMsg);

sqlite3DbFree(db, zSql);

memcpy(PARSE_TAIL(pParse), saveBuf, PARSE_TAIL_SZ);

pParse->nested--;

}

#if SQLITE_USER_AUTHENTICATION

/*

** Return TRUE if zTable is the name of the system table that stores the

** list of users and their access credentials.

*/

int sqlite3UserAuthTable(const char *zTable){

return sqlite3_stricmp(zTable, "sqlite_user")==0;

}

#endif

/*

** Locate the in-memory structure that describes a particular database

** table given the name of that table and (optionally) the name of the

** database containing the table. Return NULL if not found.

**

** If zDatabase is 0, all databases are searched for the table and the

** first matching table is returned. (No checking for duplicate table

** names is done.) The search order is TEMP first, then MAIN, then any

** auxiliary databases added using the ATTACH command.

**

** See also sqlite3LocateTable().

*/

Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){

Table *p = 0;

int i;

/* All mutexes are required for schema access. Make sure we hold them. */

assert( zDatabase!=0 || sqlite3BtreeHoldsAllMutexes(db) );

#if SQLITE_USER_AUTHENTICATION

/* Only the admin user is allowed to know that the sqlite_user table

** exists */

if( db->auth.authLevel<UAUTH_Admin && sqlite3UserAuthTable(zName)!=0 ){

return 0;

}

#endif

while(1){

for(i=OMIT_TEMPDB; i<db->nDb; i++){

int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */

if( zDatabase==0 || sqlite3StrICmp(zDatabase, db->aDb[j].zDbSName)==0 ){

assert( sqlite3SchemaMutexHeld(db, j, 0) );

p = sqlite3HashFind(&db->aDb[j].pSchema->tblHash, zName);

if( p ) return p;

}

}

/* Not found. If the name we were looking for was temp.sqlite_master

** then change the name to sqlite_temp_master and try again. */

if( sqlite3StrICmp(zName, MASTER_NAME)!=0 ) break;

if( sqlite3_stricmp(zDatabase, db->aDb[1].zDbSName)!=0 ) break;

zName = TEMP_MASTER_NAME;

}

return 0;

}

/*

** Locate the in-memory structure that describes a particular database

** table given the name of that table and (optionally) the name of the

** database containing the table. Return NULL if not found. Also leave an

** error message in pParse->zErrMsg.

**

** The difference between this routine and sqlite3FindTable() is that this

** routine leaves an error message in pParse->zErrMsg where

** sqlite3FindTable() does not.

*/

Table *sqlite3LocateTable(

Parse *pParse, /* context in which to report errors */

u32 flags, /* LOCATE_VIEW or LOCATE_NOERR */

const char *zName, /* Name of the table we are looking for */

const char *zDbase /* Name of the database. Might be NULL */

){

Table *p;

sqlite3 *db = pParse->db;

/* Read the database schema. If an error occurs, leave an error message

** and code in pParse and return NULL. */

if( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0

&& SQLITE_OK!=sqlite3ReadSchema(pParse)

){

return 0;

}

p = sqlite3FindTable(db, zName, zDbase);

if( p==0 ){

#ifndef SQLITE_OMIT_VIRTUALTABLE

/* If zName is the not the name of a table in the schema created using

** CREATE, then check to see if it is the name of an virtual table that

** can be an eponymous virtual table. */

if( pParse->disableVtab==0 ){

Module *pMod = (Module*)sqlite3HashFind(&db->aModule, zName);

if( pMod==0 && sqlite3_strnicmp(zName, "pragma_", 7)==0 ){

pMod = sqlite3PragmaVtabRegister(db, zName);

}

if( pMod && sqlite3VtabEponymousTableInit(pParse, pMod) ){

return pMod->pEpoTab;

}

}

#endif

if( flags & LOCATE_NOERR ) return 0;

pParse->checkSchema = 1;

}else if( IsVirtual(p) && pParse->disableVtab ){

p = 0;

}

if( p==0 ){

const char *zMsg = flags & LOCATE_VIEW ? "no such view" : "no such table";

if( zDbase ){

sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);

}else{

sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);

}

}

return p;

}

/*

** Locate the table identified by *p.

**

** This is a wrapper around sqlite3LocateTable(). The difference between

** sqlite3LocateTable() and this function is that this function restricts

** the search to schema (p->pSchema) if it is not NULL. p->pSchema may be

** non-NULL if it is part of a view or trigger program definition. See

** sqlite3FixSrcList() for details.

*/

Table *sqlite3LocateTableItem(

Parse *pParse,

u32 flags,

struct SrcList_item *p

){

const char *zDb;

assert( p->pSchema==0 || p->zDatabase==0 );

if( p->pSchema ){

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

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

}else{

zDb = p->zDatabase;

}

return sqlite3LocateTable(pParse, flags, p->zName, zDb);

}

/*

** Locate the in-memory structure that describes

** a particular index given the name of that index

** and the name of the database that contains the index.

** Return NULL if not found.

**

** If zDatabase is 0, all databases are searched for the

** table and the first matching index is returned. (No checking

** for duplicate index names is done.) The search order is

** TEMP first, then MAIN, then any auxiliary databases added

** using the ATTACH command.

*/

Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){

Index *p = 0;

int i;

/* All mutexes are required for schema access. Make sure we hold them. */

assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );

for(i=OMIT_TEMPDB; i<db->nDb; i++){

int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */

Schema *pSchema = db->aDb[j].pSchema;

assert( pSchema );

if( zDb && sqlite3StrICmp(zDb, db->aDb[j].zDbSName) ) continue;

assert( sqlite3SchemaMutexHeld(db, j, 0) );

p = sqlite3HashFind(&pSchema->idxHash, zName);

if( p ) break;

}

return p;

}

/*

** Reclaim the memory used by an index

*/

void sqlite3FreeIndex(sqlite3 *db, Index *p){

#ifndef SQLITE_OMIT_ANALYZE

sqlite3DeleteIndexSamples(db, p);

#endif

sqlite3ExprDelete(db, p->pPartIdxWhere);

sqlite3ExprListDelete(db, p->aColExpr);

sqlite3DbFree(db, p->zColAff);

if( p->isResized ) sqlite3DbFree(db, (void *)p->azColl);

#ifdef SQLITE_ENABLE_STAT4

sqlite3_free(p->aiRowEst);

#endif

sqlite3DbFree(db, p);

}

/*

** For the index called zIdxName which is found in the database iDb,

** unlike that index from its Table then remove the index from

** the index hash table and free all memory structures associated

** with the index.

*/

void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){

Index *pIndex;

Hash *pHash;

assert( sqlite3SchemaMutexHeld(db, iDb, 0) );

pHash = &db->aDb[iDb].pSchema->idxHash;

pIndex = sqlite3HashInsert(pHash, zIdxName, 0);

if( ALWAYS(pIndex) ){

if( pIndex->pTable->pIndex==pIndex ){

pIndex->pTable->pIndex = pIndex->pNext;

}else{

Index *p;

/* Justification of ALWAYS(); The index must be on the list of

** indices. */

p = pIndex->pTable->pIndex;

while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; }

if( ALWAYS(p && p->pNext==pIndex) ){

p->pNext = pIndex->pNext;

}

}

sqlite3FreeIndex(db, pIndex);

}

db->mDbFlags |= DBFLAG_SchemaChange;

}

/*

** Look through the list of open database files in db->aDb[] and if

** any have been closed, remove them from the list. Reallocate the

** db->aDb[] structure to a smaller size, if possible.

**

** Entry 0 (the "main" database) and entry 1 (the "temp" database)

** are never candidates for being collapsed.

*/

void sqlite3CollapseDatabaseArray(sqlite3 *db){

int i, j;

for(i=j=2; i<db->nDb; i++){

struct Db *pDb = &db->aDb[i];

if( pDb->pBt==0 ){

sqlite3DbFree(db, pDb->zDbSName);

pDb->zDbSName = 0;

continue;

}

if( j<i ){

db->aDb[j] = db->aDb[i];

}

j++;

}

db->nDb = j;

if( db->nDb<=2 && db->aDb!=db->aDbStatic ){

memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));

sqlite3DbFree(db, db->aDb);

db->aDb = db->aDbStatic;

}

}

/*

** Reset the schema for the database at index iDb. Also reset the

** TEMP schema. The reset is deferred if db->nSchemaLock is not zero.

** Deferred resets may be run by calling with iDb<0.

*/

void sqlite3ResetOneSchema(sqlite3 *db, int iDb){

int i;

assert( iDb<db->nDb );

if( iDb>=0 ){

assert( sqlite3SchemaMutexHeld(db, iDb, 0) );

DbSetProperty(db, iDb, DB_ResetWanted);

DbSetProperty(db, 1, DB_ResetWanted);

db->mDbFlags &= ~DBFLAG_SchemaKnownOk;

}

if( db->nSchemaLock==0 ){

for(i=0; i<db->nDb; i++){

if( DbHasProperty(db, i, DB_ResetWanted) ){

sqlite3SchemaClear(db->aDb[i].pSchema);

}

}

}

}

/*

** Erase all schema information from all attached databases (including

** "main" and "temp") for a single database connection.

*/

void sqlite3ResetAllSchemasOfConnection(sqlite3 *db){

int i;

sqlite3BtreeEnterAll(db);

for(i=0; i<db->nDb; i++){

Db *pDb = &db->aDb[i];

if( pDb->pSchema ){

if( db->nSchemaLock==0 ){

sqlite3SchemaClear(pDb->pSchema);

}else{

DbSetProperty(db, i, DB_ResetWanted);

}

}

}

db->mDbFlags &= ~(DBFLAG_SchemaChange|DBFLAG_SchemaKnownOk);

sqlite3VtabUnlockList(db);

sqlite3BtreeLeaveAll(db);

if( db->nSchemaLock==0 ){

sqlite3CollapseDatabaseArray(db);

}

}

/*

** This routine is called when a commit occurs.

*/

void sqlite3CommitInternalChanges(sqlite3 *db){

db->mDbFlags &= ~DBFLAG_SchemaChange;

}

/*

** Delete memory allocated for the column names of a table or view (the

** Table.aCol[] array).

*/

void sqlite3DeleteColumnNames(sqlite3 *db, Table *pTable){

int i;

Column *pCol;

assert( pTable!=0 );

if( (pCol = pTable->aCol)!=0 ){

for(i=0; i<pTable->nCol; i++, pCol++){

sqlite3DbFree(db, pCol->zName);

sqlite3ExprDelete(db, pCol->pDflt);

sqlite3DbFree(db, pCol->zColl);

}

sqlite3DbFree(db, pTable->aCol);

}

}

/*

** Remove the memory data structures associated with the given

** Table. No changes are made to disk by this routine.

**

** This routine just deletes the data structure. It does not unlink

** the table data structure from the hash table. But it does destroy

** memory structures of the indices and foreign keys associated with

** the table.

**

** The db parameter is optional. It is needed if the Table object

** contains lookaside memory. (Table objects in the schema do not use

** lookaside memory, but some ephemeral Table objects do.) Or the

** db parameter can be used with db->pnBytesFreed to measure the memory

** used by the Table object.

*/

static void SQLITE_NOINLINE deleteTable(sqlite3 *db, Table *pTable){

Index *pIndex, *pNext;

#ifdef SQLITE_DEBUG

/* Record the number of outstanding lookaside allocations in schema Tables

** prior to doing any free() operations. Since schema Tables do not use

** lookaside, this number should not change.

**

** If malloc has already failed, it may be that it failed while allocating

** a Table object that was going to be marked ephemeral. So do not check

** that no lookaside memory is used in this case either. */

int nLookaside = 0;

if( db && !db->mallocFailed && (pTable->tabFlags & TF_Ephemeral)==0 ){

nLookaside = sqlite3LookasideUsed(db, 0);

}

#endif

/* Delete all indices associated with this table. */

for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){

pNext = pIndex->pNext;

assert( pIndex->pSchema==pTable->pSchema

|| (IsVirtual(pTable) && pIndex->idxType!=SQLITE_IDXTYPE_APPDEF) );

if( (db==0 || db->pnBytesFreed==0) && !IsVirtual(pTable) ){

char *zName = pIndex->zName;

TESTONLY ( Index *pOld = ) sqlite3HashInsert(

&pIndex->pSchema->idxHash, zName, 0

);

assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );

assert( pOld==pIndex || pOld==0 );

}

sqlite3FreeIndex(db, pIndex);

}

/* Delete any foreign keys attached to this table. */

sqlite3FkDelete(db, pTable);

/* Delete the Table structure itself.

*/

sqlite3DeleteColumnNames(db, pTable);

sqlite3DbFree(db, pTable->zName);

sqlite3DbFree(db, pTable->zColAff);

sqlite3SelectDelete(db, pTable->pSelect);

sqlite3ExprListDelete(db, pTable->pCheck);

#ifndef SQLITE_OMIT_VIRTUALTABLE

sqlite3VtabClear(db, pTable);

#endif

sqlite3DbFree(db, pTable);

/* Verify that no lookaside memory was used by schema tables */

assert( nLookaside==0 || nLookaside==sqlite3LookasideUsed(db,0) );

}

void sqlite3DeleteTable(sqlite3 *db, Table *pTable){

/* Do not delete the table until the reference count reaches zero. */

if( !pTable ) return;

if( ((!db || db->pnBytesFreed==0) && (--pTable->nTabRef)>0) ) return;

deleteTable(db, pTable);

}

/*

** Unlink the given table from the hash tables and the delete the

** table structure with all its indices and foreign keys.

*/

void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){

Table *p;

Db *pDb;

assert( db!=0 );

assert( iDb>=0 && iDb<db->nDb );

assert( zTabName );

assert( sqlite3SchemaMutexHeld(db, iDb, 0) );

testcase( zTabName[0]==0 ); /* Zero-length table names are allowed */

pDb = &db->aDb[iDb];

p = sqlite3HashInsert(&pDb->pSchema->tblHash, zTabName, 0);

sqlite3DeleteTable(db, p);

db->mDbFlags |= DBFLAG_SchemaChange;

}

/*

** Given a token, return a string that consists of the text of that

** token. Space to hold the returned string

** is obtained from sqliteMalloc() and must be freed by the calling

** function.

**

** Any quotation marks (ex: "name", 'name', [name], or `name`) that

** surround the body of the token are removed.

**

** Tokens are often just pointers into the original SQL text and so

** are not \000 terminated and are not persistent. The returned string

** is \000 terminated and is persistent.

*/

char *sqlite3NameFromToken(sqlite3 *db, Token *pName){

char *zName;

if( pName ){

zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n);

sqlite3Dequote(zName);

}else{

zName = 0;

}

return zName;

}

/*

** Open the sqlite_master table stored in database number iDb for

** writing. The table is opened using cursor 0.

*/

void sqlite3OpenMasterTable(Parse *p, int iDb){

Vdbe *v = sqlite3GetVdbe(p);

sqlite3TableLock(p, iDb, MASTER_ROOT, 1, MASTER_NAME);

sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, MASTER_ROOT, iDb, 5);

if( p->nTab==0 ){

p->nTab = 1;

}

}

/*

** Parameter zName points to a nul-terminated buffer containing the name

** of a database ("main", "temp" or the name of an attached db). This

** function returns the index of the named database in db->aDb[], or

** -1 if the named db cannot be found.

*/

int sqlite3FindDbName(sqlite3 *db, const char *zName){

int i = -1; /* Database number */

if( zName ){

Db *pDb;

for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){

if( 0==sqlite3_stricmp(pDb->zDbSName, zName) ) break;

/* "main" is always an acceptable alias for the primary database

** even if it has been renamed using SQLITE_DBCONFIG_MAINDBNAME. */

if( i==0 && 0==sqlite3_stricmp("main", zName) ) break;

}

}

return i;

}

/*

** The token *pName contains the name of a database (either "main" or

** "temp" or the name of an attached db). This routine returns the

** index of the named database in db->aDb[], or -1 if the named db

** does not exist.

*/

int sqlite3FindDb(sqlite3 *db, Token *pName){

int i; /* Database number */

char *zName; /* Name we are searching for */

zName = sqlite3NameFromToken(db, pName);

i = sqlite3FindDbName(db, zName);

sqlite3DbFree(db, zName);

return i;

}

/* The table or view or trigger name is passed to this routine via tokens

** pName1 and pName2. If the table name was fully qualified, for example:

**

** CREATE TABLE xxx.yyy (...);

**

** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if

** the table name is not fully qualified, i.e.:

**

** CREATE TABLE yyy(...);

**

** Then pName1 is set to "yyy" and pName2 is "".

**

** This routine sets the *ppUnqual pointer to point at the token (pName1 or

** pName2) that stores the unqualified table name. The index of the

** database "xxx" is returned.

*/

int sqlite3TwoPartName(

Parse *pParse, /* Parsing and code generating context */

Token *pName1, /* The "xxx" in the name "xxx.yyy" or "xxx" */

Token *pName2, /* The "yyy" in the name "xxx.yyy" */

Token **pUnqual /* Write the unqualified object name here */

){

int iDb; /* Database holding the object */

sqlite3 *db = pParse->db;

assert( pName2!=0 );

if( pName2->n>0 ){

if( db->init.busy ) {

sqlite3ErrorMsg(pParse, "corrupt database");

return -1;

}

*pUnqual = pName2;

iDb = sqlite3FindDb(db, pName1);

if( iDb<0 ){

sqlite3ErrorMsg(pParse, "unknown database %T", pName1);

return -1;

}

}else{

assert( db->init.iDb==0 || db->init.busy || IN_RENAME_OBJECT

|| (db->mDbFlags & DBFLAG_Vacuum)!=0);

iDb = db->init.iDb;

*pUnqual = pName1;

}

return iDb;

}

/*

** True if PRAGMA writable_schema is ON

*/

int sqlite3WritableSchema(sqlite3 *db){

testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==0 );

testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==

SQLITE_WriteSchema );

testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==

SQLITE_Defensive );

testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==

(SQLITE_WriteSchema|SQLITE_Defensive) );

return (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==SQLITE_WriteSchema;

}

/*

** This routine is used to check if the UTF-8 string zName is a legal

** unqualified name for a new schema object (table, index, view or

** trigger). All names are legal except those that begin with the string

** "sqlite_" (in upper, lower or mixed case). This portion of the namespace

** is reserved for internal use.

**

** When parsing the sqlite_master table, this routine also checks to

** make sure the "type", "name", and "tbl_name" columns are consistent

** with the SQL.

*/

int sqlite3CheckObjectName(

Parse *pParse, /* Parsing context */

const char *zName, /* Name of the object to check */

const char *zType, /* Type of this object */

const char *zTblName /* Parent table name for triggers and indexes */

){

sqlite3 *db = pParse->db;

if( sqlite3WritableSchema(db) || db->init.imposterTable ){

/* Skip these error checks for writable_schema=ON */

return SQLITE_OK;

}

if( db->init.busy ){

if( sqlite3_stricmp(zType, db->init.azInit[0])

|| sqlite3_stricmp(zName, db->init.azInit[1])

|| sqlite3_stricmp(zTblName, db->init.azInit[2])

){

if( sqlite3Config.bExtraSchemaChecks ){

sqlite3ErrorMsg(pParse, ""); /* corruptSchema() will supply the error */

return SQLITE_ERROR;

}

}

}else{

if( (pParse->nested==0 && 0==sqlite3StrNICmp(zName, "sqlite_", 7))

|| (sqlite3ReadOnlyShadowTables(db) && sqlite3ShadowTableName(db, zName))

){

sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s",

zName);

return SQLITE_ERROR;

}

}

return SQLITE_OK;

}

/*

** Return the PRIMARY KEY index of a table

*/

Index *sqlite3PrimaryKeyIndex(Table *pTab){

Index *p;

for(p=pTab->pIndex; p && !IsPrimaryKeyIndex(p); p=p->pNext){}

return p;

}

/*

** Convert an table column number into a index column number. That is,

** for the column iCol in the table (as defined by the CREATE TABLE statement)

** find the (first) offset of that column in index pIdx. Or return -1

** if column iCol is not used in index pIdx.

*/

i16 sqlite3TableColumnToIndex(Index *pIdx, i16 iCol){

int i;

for(i=0; i<pIdx->nColumn; i++){

if( iCol==pIdx->aiColumn[i] ) return i;

}

return -1;

}

#ifndef SQLITE_OMIT_GENERATED_COLUMNS

/* Convert a storage column number into a table column number.

**

** The storage column number (0,1,2,....) is the index of the value

** as it appears in the record on disk. The true column number

** is the index (0,1,2,...) of the column in the CREATE TABLE statement.

**

** The storage column number is less than the table column number if

** and only there are VIRTUAL columns to the left.

**

** If SQLITE_OMIT_GENERATED_COLUMNS, this routine is a no-op macro.

*/

i16 sqlite3StorageColumnToTable(Table *pTab, i16 iCol){

if( pTab->tabFlags & TF_HasVirtual ){

int i;

for(i=0; i<=iCol; i++){

if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) iCol++;

}

}

return iCol;

}

#endif

#ifndef SQLITE_OMIT_GENERATED_COLUMNS

/* Convert a table column number into a storage column number.

**

** The storage column number (0,1,2,....) is the index of the value

** as it appears in the record on disk. Or, if the input column is

** the N-th virtual column (zero-based) then the storage number is

** the number of non-virtual columns in the table plus N.

**

** The true column number is the index (0,1,2,...) of the column in

** the CREATE TABLE statement.

**

** If the input column is a VIRTUAL column, then it should not appear

** in storage. But the value sometimes is cached in registers that

** follow the range of registers used to construct storage. This

** avoids computing the same VIRTUAL column multiple times, and provides

** values for use by OP_Param opcodes in triggers. Hence, if the

** input column is a VIRTUAL table, put it after all the other columns.

**

** In the following, N means "normal column", S means STORED, and

** V means VIRTUAL. Suppose the CREATE TABLE has columns like this:

**

** CREATE TABLE ex(N,S,V,N,S,V,N,S,V);

** -- 0 1 2 3 4 5 6 7 8

**

** Then the mapping from this function is as follows:

**

** INPUTS: 0 1 2 3 4 5 6 7 8

** OUTPUTS: 0 1 6 2 3 7 4 5 8

**

** So, in other words, this routine shifts all the virtual columns to

** the end.

**

** If SQLITE_OMIT_GENERATED_COLUMNS then there are no virtual columns and

** this routine is a no-op macro. If the pTab does not have any virtual

** columns, then this routine is no-op that always return iCol. If iCol

** is negative (indicating the ROWID column) then this routine return iCol.

*/

i16 sqlite3TableColumnToStorage(Table *pTab, i16 iCol){

int i;

i16 n;

assert( iCol<pTab->nCol );

if( (pTab->tabFlags & TF_HasVirtual)==0 || iCol<0 ) return iCol;

for(i=0, n=0; i<iCol; i++){

if( (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) n++;

}

if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ){

/* iCol is a virtual column itself */

return pTab->nNVCol + i - n;

}else{

/* iCol is a normal or stored column */

return n;

}

}

#endif

/*

** Begin constructing a new table representation in memory. This is

** the first of several action routines that get called in response

** to a CREATE TABLE statement. In particular, this routine is called

** after seeing tokens "CREATE" and "TABLE" and the table name. The isTemp

** flag is true if the table should be stored in the auxiliary database

** file instead of in the main database file. This is normally the case

** when the "TEMP" or "TEMPORARY" keyword occurs in between

** CREATE and TABLE.

**

** The new table record is initialized and put in pParse->pNewTable.

** As more of the CREATE TABLE statement is parsed, additional action

** routines will be called to add more information to this record.

** At the end of the CREATE TABLE statement, the sqlite3EndTable() routine

** is called to complete the construction of the new table record.

*/

void sqlite3StartTable(

Parse *pParse, /* Parser context */

Token *pName1, /* First part of the name of the table or view */

Token *pName2, /* Second part of the name of the table or view */

int isTemp, /* True if this is a TEMP table */

int isView, /* True if this is a VIEW */

int isVirtual, /* True if this is a VIRTUAL table */

int noErr /* Do nothing if table already exists */

){

Table *pTable;

char *zName = 0; /* The name of the new table */

sqlite3 *db = pParse->db;

Vdbe *v;