/*

** 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 */

Pgno 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().

*/

static SQLITE_NOINLINE void lockTable(

Parse *pParse, /* Parsing context */

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

Pgno 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;

int i;

int nBytes;

TableLock *p;

assert( iDb>=0 );

pToplevel = sqlite3ParseToplevel(pParse);

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);

}

}

void sqlite3TableLock(

Parse *pParse, /* Parsing context */

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

Pgno 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 */

){

if( iDb==1 ) return;

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

lockTable(pParse, iDb, iTab, isWriteLock, zName);

}

/*

** 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 = pParse->pVdbe;

assert( pVdbe!=0 );

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;

int iDb, i;

assert( pParse->pToplevel==0 );

db = pParse->db;

assert( db->pParse==pParse );

if( pParse->nested ) return;

if( pParse->nErr ){

if( db->mallocFailed ) pParse->rc = SQLITE_NOMEM;

return;

}

assert( db->mallocFailed==0 );

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

** vdbe program

*/

v = pParse->pVdbe;

if( v==0 ){

if( db->init.busy ){

pParse->rc = SQLITE_DONE;

return;

}

v = sqlite3GetVdbe(pParse);

if( v==0 ) pParse->rc = SQLITE_ERROR;

}

assert( !pParse->isMultiWrite

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

if( v ){

if( pParse->bReturning ){

Returning *pReturning = pParse->u1.pReturning;

int addrRewind;

int reg;

if( pReturning->nRetCol ){

sqlite3VdbeAddOp0(v, OP_FkCheck);

addrRewind =

sqlite3VdbeAddOp1(v, OP_Rewind, pReturning->iRetCur);

VdbeCoverage(v);

reg = pReturning->iRetReg;

for(i=0; i<pReturning->nRetCol; i++){

sqlite3VdbeAddOp3(v, OP_Column, pReturning->iRetCur, i, reg+i);

}

sqlite3VdbeAddOp2(v, OP_ResultRow, reg, i);

sqlite3VdbeAddOp2(v, OP_Next, pReturning->iRetCur, addrRewind+1);

VdbeCoverage(v);

sqlite3VdbeJumpHere(v, addrRewind);

}

}

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.

*/

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

sqlite3VdbeJumpHere(v, 0);

assert( db->nDb>0 );

iDb = 0;

do{

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));

}while( ++iDb<db->nDb );

#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.

**

** The pConstExpr list might also contain expressions that we simply

** want to keep around until the Parse object is deleted. Such

** expressions have iConstExprReg==0. Do not generate code for

** those expressions, of course.

*/

if( pParse->pConstExpr ){

ExprList *pEL = pParse->pConstExpr;

pParse->okConstFactor = 0;

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

int iReg = pEL->a[i].u.iConstExprReg;

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

}

}

if( pParse->bReturning ){

Returning *pRet = pParse->u1.pReturning;

if( pRet->nRetCol ){

sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pRet->iRetCur, pRet->nRetCol);

}

}

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

sqlite3VdbeGoto(v, 1);

}

/* Get the VDBE program ready for execution

*/

assert( v!=0 || pParse->nErr );

assert( db->mallocFailed==0 || pParse->nErr );

if( pParse->nErr==0 ){

/* 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. Notes:

**

** * The final OP_Halt is not appended and other initialization

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

** outermost parser.

**

** * Built-in SQL functions always take precedence over application-defined

** SQL functions. In other words, it is not possible to override a

** built-in function.

*/

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

va_list ap;

char *zSql;

sqlite3 *db = pParse->db;

u32 savedDbFlags = db->mDbFlags;

char saveBuf[PARSE_TAIL_SZ];

if( pParse->nErr ) return;

if( pParse->eParseMode ) 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);

db->mDbFlags |= DBFLAG_PreferBuiltin;

sqlite3RunParser(pParse, zSql);

db->mDbFlags = savedDbFlags;

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

if( zDatabase ){

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

if( sqlite3StrICmp(zDatabase, db->aDb[i].zDbSName)==0 ) break;

}

if( i>=db->nDb ){

/* No match against the official names. But always match "main"

** to schema 0 as a legacy fallback. */

if( sqlite3StrICmp(zDatabase,"main")==0 ){

i = 0;

}else{

return 0;

}

}

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

if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){

if( i==1 ){

if( sqlite3StrICmp(zName+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0

|| sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0

|| sqlite3StrICmp(zName+7, &LEGACY_SCHEMA_TABLE[7])==0

){

p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash,

LEGACY_TEMP_SCHEMA_TABLE);

}

}else{

if( sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0 ){

p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash,

LEGACY_SCHEMA_TABLE);

}

}

}

}else{

/* Match against TEMP first */

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

if( p ) return p;

/* The main database is second */

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

if( p ) return p;

/* Attached databases are in order of attachment */

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

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

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

if( p ) break;

}

if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){

if( sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0 ){

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

}else if( sqlite3StrICmp(zName+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0 ){

p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash,

LEGACY_TEMP_SCHEMA_TABLE);

}

}

}

return p;

}

/*

** 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->prepFlags & SQLITE_PREPARE_NO_VTAB)==0 && db->init.busy==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) ){

testcase( pMod->pEpoTab==0 );

return pMod->pEpoTab;

}

}

#endif

if( flags & LOCATE_NOERR ) return 0;

pParse->checkSchema = 1;

}else if( IsVirtual(p) && (pParse->prepFlags & SQLITE_PREPARE_NO_VTAB)!=0 ){

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);

}

}else{

assert( HasRowid(p) || p->iPKey<0 );

}

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,

SrcItem *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);

}

/*

** Return the preferred table name for system tables. Translate legacy

** names into the new preferred names, as appropriate.

*/

const char *sqlite3PreferredTableName(const char *zName){

if( sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){

if( sqlite3StrICmp(zName+7, &LEGACY_SCHEMA_TABLE[7])==0 ){

return PREFERRED_SCHEMA_TABLE;

}

if( sqlite3StrICmp(zName+7, &LEGACY_TEMP_SCHEMA_TABLE[7])==0 ){

return PREFERRED_TEMP_SCHEMA_TABLE;

}

}

return zName;

}

/*

** 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 && sqlite3DbIsNamed(db, j, zDb)==0 ) 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;

}

/*

** Set the expression associated with a column. This is usually

** the DEFAULT value, but might also be the expression that computes

** the value for a generated column.

*/

void sqlite3ColumnSetExpr(

Parse *pParse, /* Parsing context */

Table *pTab, /* The table containing the column */

Column *pCol, /* The column to receive the new DEFAULT expression */

Expr *pExpr /* The new default expression */

){

ExprList *pList;

assert( IsOrdinaryTable(pTab) );

pList = pTab->u.tab.pDfltList;

if( pCol->iDflt==0

|| NEVER(pList==0)

|| NEVER(pList->nExpr<pCol->iDflt)

){

pCol->iDflt = pList==0 ? 1 : pList->nExpr+1;

pTab->u.tab.pDfltList = sqlite3ExprListAppend(pParse, pList, pExpr);

}else{

sqlite3ExprDelete(pParse->db, pList->a[pCol->iDflt-1].pExpr);

pList->a[pCol->iDflt-1].pExpr = pExpr;

}

}

/*

** Return the expression associated with a column. The expression might be

** the DEFAULT clause or the AS clause of a generated column.

** Return NULL if the column has no associated expression.

*/

Expr *sqlite3ColumnExpr(Table *pTab, Column *pCol){

if( pCol->iDflt==0 ) return 0;

if( NEVER(!IsOrdinaryTable(pTab)) ) return 0;

if( NEVER(pTab->u.tab.pDfltList==0) ) return 0;

if( NEVER(pTab->u.tab.pDfltList->nExpr<pCol->iDflt) ) return 0;

return pTab->u.tab.pDfltList->a[pCol->iDflt-1].pExpr;

}

/*

** Set the collating sequence name for a column.

*/

void sqlite3ColumnSetColl(

sqlite3 *db,

Column *pCol,

const char *zColl

){

i64 nColl;

i64 n;

char *zNew;

assert( zColl!=0 );

n = sqlite3Strlen30(pCol->zCnName) + 1;

if( pCol->colFlags & COLFLAG_HASTYPE ){

n += sqlite3Strlen30(pCol->zCnName+n) + 1;

}

nColl = sqlite3Strlen30(zColl) + 1;

zNew = sqlite3DbRealloc(db, pCol->zCnName, nColl+n);

if( zNew ){

pCol->zCnName = zNew;

memcpy(pCol->zCnName + n, zColl, nColl);

pCol->colFlags |= COLFLAG_HASCOLL;

}

}

/*

** Return the collating squence name for a column

*/

const char *sqlite3ColumnColl(Column *pCol){

const char *z;

if( (pCol->colFlags & COLFLAG_HASCOLL)==0 ) return 0;

z = pCol->zCnName;

while( *z ){ z++; }

if( pCol->colFlags & COLFLAG_HASTYPE ){

do{ z++; }while( *z );

}

return z+1;

}

/*

** 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 );

assert( db!=0 );

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

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

assert( pCol->zCnName==0 || pCol->hName==sqlite3StrIHash(pCol->zCnName) );

sqlite3DbFree(db, pCol->zCnName);

}

sqlite3DbNNFreeNN(db, pTable->aCol);

if( IsOrdinaryTable(pTable) ){

sqlite3ExprListDelete(db, pTable->u.tab.pDfltList);

}

if( db->pnBytesFreed==0 ){

pTable->aCol = 0;

pTable->nCol = 0;

if( IsOrdinaryTable(pTable) ){

pTable->u.tab.pDfltList = 0;

}

}

}

}

/*

** 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;

assert( db!=0 );

if( !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->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);

}

if( IsOrdinaryTable(pTable) ){

sqlite3FkDelete(db, pTable);

}

#ifndef SQLITE_OMIT_VIRTUALTABLE

else if( IsVirtual(pTable) ){

sqlite3VtabClear(db, pTable);

}

#endif

else{

assert( IsView(pTable) );

sqlite3SelectDelete(db, pTable->u.view.pSelect);

}

/* Delete the Table structure itself.

*/

sqlite3DeleteColumnNames(db, pTable);

sqlite3DbFree(db, pTable->zName);

sqlite3DbFree(db, pTable->zColAff);

sqlite3ExprListDelete(db, pTable->pCheck);

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. */

assert( db!=0 );

if( !pTable ) return;

if( 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, const Token *pName){

char *zName;

if( pName ){

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

sqlite3Dequote(zName);

}else{

zName = 0;

}

return zName;

}

/*

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

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

*/

void sqlite3OpenSchemaTable(Parse *p, int iDb){

Vdbe *v = sqlite3GetVdbe(p);

sqlite3TableLock(p, iDb, SCHEMA_ROOT, 1, LEGACY_SCHEMA_TABLE);

sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, SCHEMA_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");