mirror of
https://github.com/sqlite/sqlite.git
synced 2025-07-24 22:22:08 +03:00
cc803b209f
But the actual number of columns in the implementation might need to be twice as much to account for the primary key at the end. Ensure that the code is able to deal with this. This is a correction to check-in [d7729dbbf231d57c]. FossilOrigin-Name: 5822feec43be9352fd87bf9968c39c0218e01ab5fe3ba50431ae21cba79e6c89
5795 lines
190 KiB
C
5795 lines
190 KiB
C
/*
|
|
** 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;
|
|
}
|
|
}
|
|
|
|
assert( pToplevel->nTableLock < 0x7fff0000 );
|
|
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;
|
|
int addrRewind;
|
|
int reg;
|
|
|
|
assert( !pParse->isCreate );
|
|
pReturning = pParse->u1.d.pReturning;
|
|
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);
|
|
|
|
/* 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
|
|
|
|
#ifndef SQLITE_OMIT_SHARED_CACHE
|
|
/* 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.
|
|
*/
|
|
if( pParse->nTableLock ) codeTableLocks(pParse);
|
|
#endif
|
|
|
|
/* Initialize any AUTOINCREMENT data structures required.
|
|
*/
|
|
if( pParse->pAinc ) sqlite3AutoincrementBegin(pParse);
|
|
|
|
/* Code constant expressions that were factored out of inner loops.
|
|
*/
|
|
if( pParse->pConstExpr ){
|
|
ExprList *pEL = pParse->pConstExpr;
|
|
pParse->okConstFactor = 0;
|
|
for(i=0; i<pEL->nExpr; i++){
|
|
assert( pEL->a[i].u.iConstExprReg>0 );
|
|
sqlite3ExprCode(pParse, pEL->a[i].pExpr, pEL->a[i].u.iConstExprReg);
|
|
}
|
|
}
|
|
|
|
if( pParse->bReturning ){
|
|
Returning *pRet;
|
|
assert( !pParse->isCreate );
|
|
pRet = pParse->u1.d.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--;
|
|
}
|
|
|
|
/*
|
|
** 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( 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;
|
|
if( p->fg.fixedSchema ){
|
|
int iDb = sqlite3SchemaToIndex(pParse->db, p->u4.pSchema);
|
|
zDb = pParse->db->aDb[iDb].zDbSName;
|
|
}else{
|
|
assert( !p->fg.isSubquery );
|
|
zDb = p->u4.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( !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 sequence 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);
|
|
}
|
|
void sqlite3DeleteTableGeneric(sqlite3 *db, void *pTable){
|
|
sqlite3DeleteTable(db, (Table*)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");
|
|
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_SPECIAL_PARSE
|
|
|| (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_schema 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
|
|
|| !sqlite3Config.bExtraSchemaChecks
|
|
){
|
|
/* 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])
|
|
){
|
|
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.
|
|
*/
|
|
int sqlite3TableColumnToIndex(Index *pIdx, int iCol){
|
|
int i;
|
|
i16 iCol16;
|
|
assert( iCol>=(-1) && iCol<=SQLITE_MAX_COLUMN );
|
|
assert( pIdx->nColumn<=SQLITE_MAX_COLUMN );
|
|
iCol16 = iCol;
|
|
for(i=0; i<pIdx->nColumn; i++){
|
|
if( iCol16==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
|
|
|
|
/*
|
|
** Insert a single OP_JournalMode query opcode in order to force the
|
|
** prepared statement to return false for sqlite3_stmt_readonly(). This
|
|
** is used by CREATE TABLE IF NOT EXISTS and similar if the table already
|
|
** exists, so that the prepared statement for CREATE TABLE IF NOT EXISTS
|
|
** will return false for sqlite3_stmt_readonly() even if that statement
|
|
** is a read-only no-op.
|
|
*/
|
|
static void sqlite3ForceNotReadOnly(Parse *pParse){
|
|
int iReg = ++pParse->nMem;
|
|
Vdbe *v = sqlite3GetVdbe(pParse);
|
|
if( v ){
|
|
sqlite3VdbeAddOp3(v, OP_JournalMode, 0, iReg, PAGER_JOURNALMODE_QUERY);
|
|
sqlite3VdbeUsesBtree(v, 0);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** 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;
|
|
int iDb; /* Database number to create the table in */
|
|
Token *pName; /* Unqualified name of the table to create */
|
|
|
|
if( db->init.busy && db->init.newTnum==1 ){
|
|
/* Special case: Parsing the sqlite_schema or sqlite_temp_schema schema */
|
|
iDb = db->init.iDb;
|
|
zName = sqlite3DbStrDup(db, SCHEMA_TABLE(iDb));
|
|
pName = pName1;
|
|
}else{
|
|
/* The common case */
|
|
iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
|
|
if( iDb<0 ) return;
|
|
if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){
|
|
/* If creating a temp table, the name may not be qualified. Unless
|
|
** the database name is "temp" anyway. */
|
|
sqlite3ErrorMsg(pParse, "temporary table name must be unqualified");
|
|
return;
|
|
}
|
|
if( !OMIT_TEMPDB && isTemp ) iDb = 1;
|
|
zName = sqlite3NameFromToken(db, pName);
|
|
if( IN_RENAME_OBJECT ){
|
|
sqlite3RenameTokenMap(pParse, (void*)zName, pName);
|
|
}
|
|
}
|
|
pParse->sNameToken = *pName;
|
|
if( zName==0 ) return;
|
|
if( sqlite3CheckObjectName(pParse, zName, isView?"view":"table", zName) ){
|
|
goto begin_table_error;
|
|
}
|
|
if( db->init.iDb==1 ) isTemp = 1;
|
|
#ifndef SQLITE_OMIT_AUTHORIZATION
|
|
assert( isTemp==0 || isTemp==1 );
|
|
assert( isView==0 || isView==1 );
|
|
{
|
|
static const u8 aCode[] = {
|
|
SQLITE_CREATE_TABLE,
|
|
SQLITE_CREATE_TEMP_TABLE,
|
|
SQLITE_CREATE_VIEW,
|
|
SQLITE_CREATE_TEMP_VIEW
|
|
};
|
|
char *zDb = db->aDb[iDb].zDbSName;
|
|
if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){
|
|
goto begin_table_error;
|
|
}
|
|
if( !isVirtual && sqlite3AuthCheck(pParse, (int)aCode[isTemp+2*isView],
|
|
zName, 0, zDb) ){
|
|
goto begin_table_error;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* Make sure the new table name does not collide with an existing
|
|
** index or table name in the same database. Issue an error message if
|
|
** it does. The exception is if the statement being parsed was passed
|
|
** to an sqlite3_declare_vtab() call. In that case only the column names
|
|
** and types will be used, so there is no need to test for namespace
|
|
** collisions.
|
|
*/
|
|
if( !IN_SPECIAL_PARSE ){
|
|
char *zDb = db->aDb[iDb].zDbSName;
|
|
if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
|
|
goto begin_table_error;
|
|
}
|
|
pTable = sqlite3FindTable(db, zName, zDb);
|
|
if( pTable ){
|
|
if( !noErr ){
|
|
sqlite3ErrorMsg(pParse, "%s %T already exists",
|
|
(IsView(pTable)? "view" : "table"), pName);
|
|
}else{
|
|
assert( !db->init.busy || CORRUPT_DB );
|
|
sqlite3CodeVerifySchema(pParse, iDb);
|
|
sqlite3ForceNotReadOnly(pParse);
|
|
}
|
|
goto begin_table_error;
|
|
}
|
|
if( sqlite3FindIndex(db, zName, zDb)!=0 ){
|
|
sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
|
|
goto begin_table_error;
|
|
}
|
|
}
|
|
|
|
pTable = sqlite3DbMallocZero(db, sizeof(Table));
|
|
if( pTable==0 ){
|
|
assert( db->mallocFailed );
|
|
pParse->rc = SQLITE_NOMEM_BKPT;
|
|
pParse->nErr++;
|
|
goto begin_table_error;
|
|
}
|
|
pTable->zName = zName;
|
|
pTable->iPKey = -1;
|
|
pTable->pSchema = db->aDb[iDb].pSchema;
|
|
pTable->nTabRef = 1;
|
|
#ifdef SQLITE_DEFAULT_ROWEST
|
|
pTable->nRowLogEst = sqlite3LogEst(SQLITE_DEFAULT_ROWEST);
|
|
#else
|
|
pTable->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
|
|
#endif
|
|
assert( pParse->pNewTable==0 );
|
|
pParse->pNewTable = pTable;
|
|
|
|
/* Begin generating the code that will insert the table record into
|
|
** the schema table. Note in particular that we must go ahead
|
|
** and allocate the record number for the table entry now. Before any
|
|
** PRIMARY KEY or UNIQUE keywords are parsed. Those keywords will cause
|
|
** indices to be created and the table record must come before the
|
|
** indices. Hence, the record number for the table must be allocated
|
|
** now.
|
|
*/
|
|
if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){
|
|
int addr1;
|
|
int fileFormat;
|
|
int reg1, reg2, reg3;
|
|
/* nullRow[] is an OP_Record encoding of a row containing 5 NULLs */
|
|
static const char nullRow[] = { 6, 0, 0, 0, 0, 0 };
|
|
sqlite3BeginWriteOperation(pParse, 1, iDb);
|
|
|
|
#ifndef SQLITE_OMIT_VIRTUALTABLE
|
|
if( isVirtual ){
|
|
sqlite3VdbeAddOp0(v, OP_VBegin);
|
|
}
|
|
#endif
|
|
|
|
/* If the file format and encoding in the database have not been set,
|
|
** set them now.
|
|
*/
|
|
assert( pParse->isCreate );
|
|
reg1 = pParse->u1.cr.regRowid = ++pParse->nMem;
|
|
reg2 = pParse->u1.cr.regRoot = ++pParse->nMem;
|
|
reg3 = ++pParse->nMem;
|
|
sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT);
|
|
sqlite3VdbeUsesBtree(v, iDb);
|
|
addr1 = sqlite3VdbeAddOp1(v, OP_If, reg3); VdbeCoverage(v);
|
|
fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ?
|
|
1 : SQLITE_MAX_FILE_FORMAT;
|
|
sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, fileFormat);
|
|
sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, ENC(db));
|
|
sqlite3VdbeJumpHere(v, addr1);
|
|
|
|
/* This just creates a place-holder record in the sqlite_schema table.
|
|
** The record created does not contain anything yet. It will be replaced
|
|
** by the real entry in code generated at sqlite3EndTable().
|
|
**
|
|
** The rowid for the new entry is left in register pParse->u1.cr.regRowid.
|
|
** The root page of the new table is left in reg pParse->u1.cr.regRoot.
|
|
** The rowid and root page number values are needed by the code that
|
|
** sqlite3EndTable will generate.
|
|
*/
|
|
#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
|
|
if( isView || isVirtual ){
|
|
sqlite3VdbeAddOp2(v, OP_Integer, 0, reg2);
|
|
}else
|
|
#endif
|
|
{
|
|
assert( !pParse->bReturning );
|
|
pParse->u1.cr.addrCrTab =
|
|
sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, reg2, BTREE_INTKEY);
|
|
}
|
|
sqlite3OpenSchemaTable(pParse, iDb);
|
|
sqlite3VdbeAddOp2(v, OP_NewRowid, 0, reg1);
|
|
sqlite3VdbeAddOp4(v, OP_Blob, 6, reg3, 0, nullRow, P4_STATIC);
|
|
sqlite3VdbeAddOp3(v, OP_Insert, 0, reg3, reg1);
|
|
sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
|
|
sqlite3VdbeAddOp0(v, OP_Close);
|
|
}
|
|
|
|
/* Normal (non-error) return. */
|
|
return;
|
|
|
|
/* If an error occurs, we jump here */
|
|
begin_table_error:
|
|
pParse->checkSchema = 1;
|
|
sqlite3DbFree(db, zName);
|
|
return;
|
|
}
|
|
|
|
/* Set properties of a table column based on the (magical)
|
|
** name of the column.
|
|
*/
|
|
#if SQLITE_ENABLE_HIDDEN_COLUMNS
|
|
void sqlite3ColumnPropertiesFromName(Table *pTab, Column *pCol){
|
|
if( sqlite3_strnicmp(pCol->zCnName, "__hidden__", 10)==0 ){
|
|
pCol->colFlags |= COLFLAG_HIDDEN;
|
|
if( pTab ) pTab->tabFlags |= TF_HasHidden;
|
|
}else if( pTab && pCol!=pTab->aCol && (pCol[-1].colFlags & COLFLAG_HIDDEN) ){
|
|
pTab->tabFlags |= TF_OOOHidden;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
** Clean up the data structures associated with the RETURNING clause.
|
|
*/
|
|
static void sqlite3DeleteReturning(sqlite3 *db, void *pArg){
|
|
Returning *pRet = (Returning*)pArg;
|
|
Hash *pHash;
|
|
pHash = &(db->aDb[1].pSchema->trigHash);
|
|
sqlite3HashInsert(pHash, pRet->zName, 0);
|
|
sqlite3ExprListDelete(db, pRet->pReturnEL);
|
|
sqlite3DbFree(db, pRet);
|
|
}
|
|
|
|
/*
|
|
** Add the RETURNING clause to the parse currently underway.
|
|
**
|
|
** This routine creates a special TEMP trigger that will fire for each row
|
|
** of the DML statement. That TEMP trigger contains a single SELECT
|
|
** statement with a result set that is the argument of the RETURNING clause.
|
|
** The trigger has the Trigger.bReturning flag and an opcode of
|
|
** TK_RETURNING instead of TK_SELECT, so that the trigger code generator
|
|
** knows to handle it specially. The TEMP trigger is automatically
|
|
** removed at the end of the parse.
|
|
**
|
|
** When this routine is called, we do not yet know if the RETURNING clause
|
|
** is attached to a DELETE, INSERT, or UPDATE, so construct it as a
|
|
** RETURNING trigger instead. It will then be converted into the appropriate
|
|
** type on the first call to sqlite3TriggersExist().
|
|
*/
|
|
void sqlite3AddReturning(Parse *pParse, ExprList *pList){
|
|
Returning *pRet;
|
|
Hash *pHash;
|
|
sqlite3 *db = pParse->db;
|
|
if( pParse->pNewTrigger ){
|
|
sqlite3ErrorMsg(pParse, "cannot use RETURNING in a trigger");
|
|
}else{
|
|
assert( pParse->bReturning==0 || pParse->ifNotExists );
|
|
}
|
|
pParse->bReturning = 1;
|
|
pRet = sqlite3DbMallocZero(db, sizeof(*pRet));
|
|
if( pRet==0 ){
|
|
sqlite3ExprListDelete(db, pList);
|
|
return;
|
|
}
|
|
assert( !pParse->isCreate );
|
|
pParse->u1.d.pReturning = pRet;
|
|
pRet->pParse = pParse;
|
|
pRet->pReturnEL = pList;
|
|
sqlite3ParserAddCleanup(pParse, sqlite3DeleteReturning, pRet);
|
|
testcase( pParse->earlyCleanup );
|
|
if( db->mallocFailed ) return;
|
|
sqlite3_snprintf(sizeof(pRet->zName), pRet->zName,
|
|
"sqlite_returning_%p", pParse);
|
|
pRet->retTrig.zName = pRet->zName;
|
|
pRet->retTrig.op = TK_RETURNING;
|
|
pRet->retTrig.tr_tm = TRIGGER_AFTER;
|
|
pRet->retTrig.bReturning = 1;
|
|
pRet->retTrig.pSchema = db->aDb[1].pSchema;
|
|
pRet->retTrig.pTabSchema = db->aDb[1].pSchema;
|
|
pRet->retTrig.step_list = &pRet->retTStep;
|
|
pRet->retTStep.op = TK_RETURNING;
|
|
pRet->retTStep.pTrig = &pRet->retTrig;
|
|
pRet->retTStep.pExprList = pList;
|
|
pHash = &(db->aDb[1].pSchema->trigHash);
|
|
assert( sqlite3HashFind(pHash, pRet->zName)==0
|
|
|| pParse->nErr || pParse->ifNotExists );
|
|
if( sqlite3HashInsert(pHash, pRet->zName, &pRet->retTrig)
|
|
==&pRet->retTrig ){
|
|
sqlite3OomFault(db);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Add a new column to the table currently being constructed.
|
|
**
|
|
** The parser calls this routine once for each column declaration
|
|
** in a CREATE TABLE statement. sqlite3StartTable() gets called
|
|
** first to get things going. Then this routine is called for each
|
|
** column.
|
|
*/
|
|
void sqlite3AddColumn(Parse *pParse, Token sName, Token sType){
|
|
Table *p;
|
|
int i;
|
|
char *z;
|
|
char *zType;
|
|
Column *pCol;
|
|
sqlite3 *db = pParse->db;
|
|
Column *aNew;
|
|
u8 eType = COLTYPE_CUSTOM;
|
|
u8 szEst = 1;
|
|
char affinity = SQLITE_AFF_BLOB;
|
|
|
|
if( (p = pParse->pNewTable)==0 ) return;
|
|
if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
|
|
sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
|
|
return;
|
|
}
|
|
if( !IN_RENAME_OBJECT ) sqlite3DequoteToken(&sName);
|
|
|
|
/* Because keywords GENERATE ALWAYS can be converted into identifiers
|
|
** by the parser, we can sometimes end up with a typename that ends
|
|
** with "generated always". Check for this case and omit the surplus
|
|
** text. */
|
|
if( sType.n>=16
|
|
&& sqlite3_strnicmp(sType.z+(sType.n-6),"always",6)==0
|
|
){
|
|
sType.n -= 6;
|
|
while( ALWAYS(sType.n>0) && sqlite3Isspace(sType.z[sType.n-1]) ) sType.n--;
|
|
if( sType.n>=9
|
|
&& sqlite3_strnicmp(sType.z+(sType.n-9),"generated",9)==0
|
|
){
|
|
sType.n -= 9;
|
|
while( sType.n>0 && sqlite3Isspace(sType.z[sType.n-1]) ) sType.n--;
|
|
}
|
|
}
|
|
|
|
/* Check for standard typenames. For standard typenames we will
|
|
** set the Column.eType field rather than storing the typename after
|
|
** the column name, in order to save space. */
|
|
if( sType.n>=3 ){
|
|
sqlite3DequoteToken(&sType);
|
|
for(i=0; i<SQLITE_N_STDTYPE; i++){
|
|
if( sType.n==sqlite3StdTypeLen[i]
|
|
&& sqlite3_strnicmp(sType.z, sqlite3StdType[i], sType.n)==0
|
|
){
|
|
sType.n = 0;
|
|
eType = i+1;
|
|
affinity = sqlite3StdTypeAffinity[i];
|
|
if( affinity<=SQLITE_AFF_TEXT ) szEst = 5;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
z = sqlite3DbMallocRaw(db, (i64)sName.n + 1 + (i64)sType.n + (sType.n>0) );
|
|
if( z==0 ) return;
|
|
if( IN_RENAME_OBJECT ) sqlite3RenameTokenMap(pParse, (void*)z, &sName);
|
|
memcpy(z, sName.z, sName.n);
|
|
z[sName.n] = 0;
|
|
sqlite3Dequote(z);
|
|
if( p->nCol && sqlite3ColumnIndex(p, z)>=0 ){
|
|
sqlite3ErrorMsg(pParse, "duplicate column name: %s", z);
|
|
sqlite3DbFree(db, z);
|
|
return;
|
|
}
|
|
aNew = sqlite3DbRealloc(db,p->aCol,((i64)p->nCol+1)*sizeof(p->aCol[0]));
|
|
if( aNew==0 ){
|
|
sqlite3DbFree(db, z);
|
|
return;
|
|
}
|
|
p->aCol = aNew;
|
|
pCol = &p->aCol[p->nCol];
|
|
memset(pCol, 0, sizeof(p->aCol[0]));
|
|
pCol->zCnName = z;
|
|
pCol->hName = sqlite3StrIHash(z);
|
|
sqlite3ColumnPropertiesFromName(p, pCol);
|
|
|
|
if( sType.n==0 ){
|
|
/* If there is no type specified, columns have the default affinity
|
|
** 'BLOB' with a default size of 4 bytes. */
|
|
pCol->affinity = affinity;
|
|
pCol->eCType = eType;
|
|
pCol->szEst = szEst;
|
|
#ifdef SQLITE_ENABLE_SORTER_REFERENCES
|
|
if( affinity==SQLITE_AFF_BLOB ){
|
|
if( 4>=sqlite3GlobalConfig.szSorterRef ){
|
|
pCol->colFlags |= COLFLAG_SORTERREF;
|
|
}
|
|
}
|
|
#endif
|
|
}else{
|
|
zType = z + sqlite3Strlen30(z) + 1;
|
|
memcpy(zType, sType.z, sType.n);
|
|
zType[sType.n] = 0;
|
|
sqlite3Dequote(zType);
|
|
pCol->affinity = sqlite3AffinityType(zType, pCol);
|
|
pCol->colFlags |= COLFLAG_HASTYPE;
|
|
}
|
|
if( p->nCol<=0xff ){
|
|
u8 h = pCol->hName % sizeof(p->aHx);
|
|
p->aHx[h] = p->nCol;
|
|
}
|
|
p->nCol++;
|
|
p->nNVCol++;
|
|
assert( pParse->isCreate );
|
|
pParse->u1.cr.constraintName.n = 0;
|
|
}
|
|
|
|
/*
|
|
** This routine is called by the parser while in the middle of
|
|
** parsing a CREATE TABLE statement. A "NOT NULL" constraint has
|
|
** been seen on a column. This routine sets the notNull flag on
|
|
** the column currently under construction.
|
|
*/
|
|
void sqlite3AddNotNull(Parse *pParse, int onError){
|
|
Table *p;
|
|
Column *pCol;
|
|
p = pParse->pNewTable;
|
|
if( p==0 || NEVER(p->nCol<1) ) return;
|
|
pCol = &p->aCol[p->nCol-1];
|
|
pCol->notNull = (u8)onError;
|
|
p->tabFlags |= TF_HasNotNull;
|
|
|
|
/* Set the uniqNotNull flag on any UNIQUE or PK indexes already created
|
|
** on this column. */
|
|
if( pCol->colFlags & COLFLAG_UNIQUE ){
|
|
Index *pIdx;
|
|
for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
|
|
assert( pIdx->nKeyCol==1 && pIdx->onError!=OE_None );
|
|
if( pIdx->aiColumn[0]==p->nCol-1 ){
|
|
pIdx->uniqNotNull = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Scan the column type name zType (length nType) and return the
|
|
** associated affinity type.
|
|
**
|
|
** This routine does a case-independent search of zType for the
|
|
** substrings in the following table. If one of the substrings is
|
|
** found, the corresponding affinity is returned. If zType contains
|
|
** more than one of the substrings, entries toward the top of
|
|
** the table take priority. For example, if zType is 'BLOBINT',
|
|
** SQLITE_AFF_INTEGER is returned.
|
|
**
|
|
** Substring | Affinity
|
|
** --------------------------------
|
|
** 'INT' | SQLITE_AFF_INTEGER
|
|
** 'CHAR' | SQLITE_AFF_TEXT
|
|
** 'CLOB' | SQLITE_AFF_TEXT
|
|
** 'TEXT' | SQLITE_AFF_TEXT
|
|
** 'BLOB' | SQLITE_AFF_BLOB
|
|
** 'REAL' | SQLITE_AFF_REAL
|
|
** 'FLOA' | SQLITE_AFF_REAL
|
|
** 'DOUB' | SQLITE_AFF_REAL
|
|
**
|
|
** If none of the substrings in the above table are found,
|
|
** SQLITE_AFF_NUMERIC is returned.
|
|
*/
|
|
char sqlite3AffinityType(const char *zIn, Column *pCol){
|
|
u32 h = 0;
|
|
char aff = SQLITE_AFF_NUMERIC;
|
|
const char *zChar = 0;
|
|
|
|
assert( zIn!=0 );
|
|
while( zIn[0] ){
|
|
u8 x = *(u8*)zIn;
|
|
h = (h<<8) + sqlite3UpperToLower[x];
|
|
zIn++;
|
|
if( h==(('c'<<24)+('h'<<16)+('a'<<8)+'r') ){ /* CHAR */
|
|
aff = SQLITE_AFF_TEXT;
|
|
zChar = zIn;
|
|
}else if( h==(('c'<<24)+('l'<<16)+('o'<<8)+'b') ){ /* CLOB */
|
|
aff = SQLITE_AFF_TEXT;
|
|
}else if( h==(('t'<<24)+('e'<<16)+('x'<<8)+'t') ){ /* TEXT */
|
|
aff = SQLITE_AFF_TEXT;
|
|
}else if( h==(('b'<<24)+('l'<<16)+('o'<<8)+'b') /* BLOB */
|
|
&& (aff==SQLITE_AFF_NUMERIC || aff==SQLITE_AFF_REAL) ){
|
|
aff = SQLITE_AFF_BLOB;
|
|
if( zIn[0]=='(' ) zChar = zIn;
|
|
#ifndef SQLITE_OMIT_FLOATING_POINT
|
|
}else if( h==(('r'<<24)+('e'<<16)+('a'<<8)+'l') /* REAL */
|
|
&& aff==SQLITE_AFF_NUMERIC ){
|
|
aff = SQLITE_AFF_REAL;
|
|
}else if( h==(('f'<<24)+('l'<<16)+('o'<<8)+'a') /* FLOA */
|
|
&& aff==SQLITE_AFF_NUMERIC ){
|
|
aff = SQLITE_AFF_REAL;
|
|
}else if( h==(('d'<<24)+('o'<<16)+('u'<<8)+'b') /* DOUB */
|
|
&& aff==SQLITE_AFF_NUMERIC ){
|
|
aff = SQLITE_AFF_REAL;
|
|
#endif
|
|
}else if( (h&0x00FFFFFF)==(('i'<<16)+('n'<<8)+'t') ){ /* INT */
|
|
aff = SQLITE_AFF_INTEGER;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* If pCol is not NULL, store an estimate of the field size. The
|
|
** estimate is scaled so that the size of an integer is 1. */
|
|
if( pCol ){
|
|
int v = 0; /* default size is approx 4 bytes */
|
|
if( aff<SQLITE_AFF_NUMERIC ){
|
|
if( zChar ){
|
|
while( zChar[0] ){
|
|
if( sqlite3Isdigit(zChar[0]) ){
|
|
/* BLOB(k), VARCHAR(k), CHAR(k) -> r=(k/4+1) */
|
|
sqlite3GetInt32(zChar, &v);
|
|
break;
|
|
}
|
|
zChar++;
|
|
}
|
|
}else{
|
|
v = 16; /* BLOB, TEXT, CLOB -> r=5 (approx 20 bytes)*/
|
|
}
|
|
}
|
|
#ifdef SQLITE_ENABLE_SORTER_REFERENCES
|
|
if( v>=sqlite3GlobalConfig.szSorterRef ){
|
|
pCol->colFlags |= COLFLAG_SORTERREF;
|
|
}
|
|
#endif
|
|
v = v/4 + 1;
|
|
if( v>255 ) v = 255;
|
|
pCol->szEst = v;
|
|
}
|
|
return aff;
|
|
}
|
|
|
|
/*
|
|
** The expression is the default value for the most recently added column
|
|
** of the table currently under construction.
|
|
**
|
|
** Default value expressions must be constant. Raise an exception if this
|
|
** is not the case.
|
|
**
|
|
** This routine is called by the parser while in the middle of
|
|
** parsing a CREATE TABLE statement.
|
|
*/
|
|
void sqlite3AddDefaultValue(
|
|
Parse *pParse, /* Parsing context */
|
|
Expr *pExpr, /* The parsed expression of the default value */
|
|
const char *zStart, /* Start of the default value text */
|
|
const char *zEnd /* First character past end of default value text */
|
|
){
|
|
Table *p;
|
|
Column *pCol;
|
|
sqlite3 *db = pParse->db;
|
|
p = pParse->pNewTable;
|
|
if( p!=0 ){
|
|
int isInit = db->init.busy && db->init.iDb!=1;
|
|
pCol = &(p->aCol[p->nCol-1]);
|
|
if( !sqlite3ExprIsConstantOrFunction(pExpr, isInit) ){
|
|
sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
|
|
pCol->zCnName);
|
|
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
|
|
}else if( pCol->colFlags & COLFLAG_GENERATED ){
|
|
testcase( pCol->colFlags & COLFLAG_VIRTUAL );
|
|
testcase( pCol->colFlags & COLFLAG_STORED );
|
|
sqlite3ErrorMsg(pParse, "cannot use DEFAULT on a generated column");
|
|
#endif
|
|
}else{
|
|
/* A copy of pExpr is used instead of the original, as pExpr contains
|
|
** tokens that point to volatile memory.
|
|
*/
|
|
Expr x, *pDfltExpr;
|
|
memset(&x, 0, sizeof(x));
|
|
x.op = TK_SPAN;
|
|
x.u.zToken = sqlite3DbSpanDup(db, zStart, zEnd);
|
|
x.pLeft = pExpr;
|
|
x.flags = EP_Skip;
|
|
pDfltExpr = sqlite3ExprDup(db, &x, EXPRDUP_REDUCE);
|
|
sqlite3DbFree(db, x.u.zToken);
|
|
sqlite3ColumnSetExpr(pParse, p, pCol, pDfltExpr);
|
|
}
|
|
}
|
|
if( IN_RENAME_OBJECT ){
|
|
sqlite3RenameExprUnmap(pParse, pExpr);
|
|
}
|
|
sqlite3ExprDelete(db, pExpr);
|
|
}
|
|
|
|
/*
|
|
** Backwards Compatibility Hack:
|
|
**
|
|
** Historical versions of SQLite accepted strings as column names in
|
|
** indexes and PRIMARY KEY constraints and in UNIQUE constraints. Example:
|
|
**
|
|
** CREATE TABLE xyz(a,b,c,d,e,PRIMARY KEY('a'),UNIQUE('b','c' COLLATE trim)
|
|
** CREATE INDEX abc ON xyz('c','d' DESC,'e' COLLATE nocase DESC);
|
|
**
|
|
** This is goofy. But to preserve backwards compatibility we continue to
|
|
** accept it. This routine does the necessary conversion. It converts
|
|
** the expression given in its argument from a TK_STRING into a TK_ID
|
|
** if the expression is just a TK_STRING with an optional COLLATE clause.
|
|
** If the expression is anything other than TK_STRING, the expression is
|
|
** unchanged.
|
|
*/
|
|
static void sqlite3StringToId(Expr *p){
|
|
if( p->op==TK_STRING ){
|
|
p->op = TK_ID;
|
|
}else if( p->op==TK_COLLATE && p->pLeft->op==TK_STRING ){
|
|
p->pLeft->op = TK_ID;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Tag the given column as being part of the PRIMARY KEY
|
|
*/
|
|
static void makeColumnPartOfPrimaryKey(Parse *pParse, Column *pCol){
|
|
pCol->colFlags |= COLFLAG_PRIMKEY;
|
|
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
|
|
if( pCol->colFlags & COLFLAG_GENERATED ){
|
|
testcase( pCol->colFlags & COLFLAG_VIRTUAL );
|
|
testcase( pCol->colFlags & COLFLAG_STORED );
|
|
sqlite3ErrorMsg(pParse,
|
|
"generated columns cannot be part of the PRIMARY KEY");
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
** Designate the PRIMARY KEY for the table. pList is a list of names
|
|
** of columns that form the primary key. If pList is NULL, then the
|
|
** most recently added column of the table is the primary key.
|
|
**
|
|
** A table can have at most one primary key. If the table already has
|
|
** a primary key (and this is the second primary key) then create an
|
|
** error.
|
|
**
|
|
** If the PRIMARY KEY is on a single column whose datatype is INTEGER,
|
|
** then we will try to use that column as the rowid. Set the Table.iPKey
|
|
** field of the table under construction to be the index of the
|
|
** INTEGER PRIMARY KEY column. Table.iPKey is set to -1 if there is
|
|
** no INTEGER PRIMARY KEY.
|
|
**
|
|
** If the key is not an INTEGER PRIMARY KEY, then create a unique
|
|
** index for the key. No index is created for INTEGER PRIMARY KEYs.
|
|
*/
|
|
void sqlite3AddPrimaryKey(
|
|
Parse *pParse, /* Parsing context */
|
|
ExprList *pList, /* List of field names to be indexed */
|
|
int onError, /* What to do with a uniqueness conflict */
|
|
int autoInc, /* True if the AUTOINCREMENT keyword is present */
|
|
int sortOrder /* SQLITE_SO_ASC or SQLITE_SO_DESC */
|
|
){
|
|
Table *pTab = pParse->pNewTable;
|
|
Column *pCol = 0;
|
|
int iCol = -1, i;
|
|
int nTerm;
|
|
if( pTab==0 ) goto primary_key_exit;
|
|
if( pTab->tabFlags & TF_HasPrimaryKey ){
|
|
sqlite3ErrorMsg(pParse,
|
|
"table \"%s\" has more than one primary key", pTab->zName);
|
|
goto primary_key_exit;
|
|
}
|
|
pTab->tabFlags |= TF_HasPrimaryKey;
|
|
if( pList==0 ){
|
|
iCol = pTab->nCol - 1;
|
|
pCol = &pTab->aCol[iCol];
|
|
makeColumnPartOfPrimaryKey(pParse, pCol);
|
|
nTerm = 1;
|
|
}else{
|
|
nTerm = pList->nExpr;
|
|
for(i=0; i<nTerm; i++){
|
|
Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[i].pExpr);
|
|
assert( pCExpr!=0 );
|
|
sqlite3StringToId(pCExpr);
|
|
if( pCExpr->op==TK_ID ){
|
|
assert( !ExprHasProperty(pCExpr, EP_IntValue) );
|
|
iCol = sqlite3ColumnIndex(pTab, pCExpr->u.zToken);
|
|
if( iCol>=0 ){
|
|
pCol = &pTab->aCol[iCol];
|
|
makeColumnPartOfPrimaryKey(pParse, pCol);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if( nTerm==1
|
|
&& pCol
|
|
&& pCol->eCType==COLTYPE_INTEGER
|
|
&& sortOrder!=SQLITE_SO_DESC
|
|
){
|
|
if( IN_RENAME_OBJECT && pList ){
|
|
Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[0].pExpr);
|
|
sqlite3RenameTokenRemap(pParse, &pTab->iPKey, pCExpr);
|
|
}
|
|
pTab->iPKey = iCol;
|
|
pTab->keyConf = (u8)onError;
|
|
assert( autoInc==0 || autoInc==1 );
|
|
pTab->tabFlags |= autoInc*TF_Autoincrement;
|
|
if( pList ) pParse->iPkSortOrder = pList->a[0].fg.sortFlags;
|
|
(void)sqlite3HasExplicitNulls(pParse, pList);
|
|
}else if( autoInc ){
|
|
#ifndef SQLITE_OMIT_AUTOINCREMENT
|
|
sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an "
|
|
"INTEGER PRIMARY KEY");
|
|
#endif
|
|
}else{
|
|
sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0,
|
|
0, sortOrder, 0, SQLITE_IDXTYPE_PRIMARYKEY);
|
|
pList = 0;
|
|
}
|
|
|
|
primary_key_exit:
|
|
sqlite3ExprListDelete(pParse->db, pList);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
** Add a new CHECK constraint to the table currently under construction.
|
|
*/
|
|
void sqlite3AddCheckConstraint(
|
|
Parse *pParse, /* Parsing context */
|
|
Expr *pCheckExpr, /* The check expression */
|
|
const char *zStart, /* Opening "(" */
|
|
const char *zEnd /* Closing ")" */
|
|
){
|
|
#ifndef SQLITE_OMIT_CHECK
|
|
Table *pTab = pParse->pNewTable;
|
|
sqlite3 *db = pParse->db;
|
|
if( pTab && !IN_DECLARE_VTAB
|
|
&& !sqlite3BtreeIsReadonly(db->aDb[db->init.iDb].pBt)
|
|
){
|
|
pTab->pCheck = sqlite3ExprListAppend(pParse, pTab->pCheck, pCheckExpr);
|
|
assert( pParse->isCreate );
|
|
if( pParse->u1.cr.constraintName.n ){
|
|
sqlite3ExprListSetName(pParse, pTab->pCheck,
|
|
&pParse->u1.cr.constraintName, 1);
|
|
}else{
|
|
Token t;
|
|
for(zStart++; sqlite3Isspace(zStart[0]); zStart++){}
|
|
while( sqlite3Isspace(zEnd[-1]) ){ zEnd--; }
|
|
t.z = zStart;
|
|
t.n = (int)(zEnd - t.z);
|
|
sqlite3ExprListSetName(pParse, pTab->pCheck, &t, 1);
|
|
}
|
|
}else
|
|
#endif
|
|
{
|
|
sqlite3ExprDelete(pParse->db, pCheckExpr);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Set the collation function of the most recently parsed table column
|
|
** to the CollSeq given.
|
|
*/
|
|
void sqlite3AddCollateType(Parse *pParse, Token *pToken){
|
|
Table *p;
|
|
int i;
|
|
char *zColl; /* Dequoted name of collation sequence */
|
|
sqlite3 *db;
|
|
|
|
if( (p = pParse->pNewTable)==0 || IN_RENAME_OBJECT ) return;
|
|
i = p->nCol-1;
|
|
db = pParse->db;
|
|
zColl = sqlite3NameFromToken(db, pToken);
|
|
if( !zColl ) return;
|
|
|
|
if( sqlite3LocateCollSeq(pParse, zColl) ){
|
|
Index *pIdx;
|
|
sqlite3ColumnSetColl(db, &p->aCol[i], zColl);
|
|
|
|
/* If the column is declared as "<name> PRIMARY KEY COLLATE <type>",
|
|
** then an index may have been created on this column before the
|
|
** collation type was added. Correct this if it is the case.
|
|
*/
|
|
for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
|
|
assert( pIdx->nKeyCol==1 );
|
|
if( pIdx->aiColumn[0]==i ){
|
|
pIdx->azColl[0] = sqlite3ColumnColl(&p->aCol[i]);
|
|
}
|
|
}
|
|
}
|
|
sqlite3DbFree(db, zColl);
|
|
}
|
|
|
|
/* Change the most recently parsed column to be a GENERATED ALWAYS AS
|
|
** column.
|
|
*/
|
|
void sqlite3AddGenerated(Parse *pParse, Expr *pExpr, Token *pType){
|
|
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
|
|
u8 eType = COLFLAG_VIRTUAL;
|
|
Table *pTab = pParse->pNewTable;
|
|
Column *pCol;
|
|
if( pTab==0 ){
|
|
/* generated column in an CREATE TABLE IF NOT EXISTS that already exists */
|
|
goto generated_done;
|
|
}
|
|
pCol = &(pTab->aCol[pTab->nCol-1]);
|
|
if( IN_DECLARE_VTAB ){
|
|
sqlite3ErrorMsg(pParse, "virtual tables cannot use computed columns");
|
|
goto generated_done;
|
|
}
|
|
if( pCol->iDflt>0 ) goto generated_error;
|
|
if( pType ){
|
|
if( pType->n==7 && sqlite3StrNICmp("virtual",pType->z,7)==0 ){
|
|
/* no-op */
|
|
}else if( pType->n==6 && sqlite3StrNICmp("stored",pType->z,6)==0 ){
|
|
eType = COLFLAG_STORED;
|
|
}else{
|
|
goto generated_error;
|
|
}
|
|
}
|
|
if( eType==COLFLAG_VIRTUAL ) pTab->nNVCol--;
|
|
pCol->colFlags |= eType;
|
|
assert( TF_HasVirtual==COLFLAG_VIRTUAL );
|
|
assert( TF_HasStored==COLFLAG_STORED );
|
|
pTab->tabFlags |= eType;
|
|
if( pCol->colFlags & COLFLAG_PRIMKEY ){
|
|
makeColumnPartOfPrimaryKey(pParse, pCol); /* For the error message */
|
|
}
|
|
if( ALWAYS(pExpr) && pExpr->op==TK_ID ){
|
|
/* The value of a generated column needs to be a real expression, not
|
|
** just a reference to another column, in order for covering index
|
|
** optimizations to work correctly. So if the value is not an expression,
|
|
** turn it into one by adding a unary "+" operator. */
|
|
pExpr = sqlite3PExpr(pParse, TK_UPLUS, pExpr, 0);
|
|
}
|
|
if( pExpr && pExpr->op!=TK_RAISE ) pExpr->affExpr = pCol->affinity;
|
|
sqlite3ColumnSetExpr(pParse, pTab, pCol, pExpr);
|
|
pExpr = 0;
|
|
goto generated_done;
|
|
|
|
generated_error:
|
|
sqlite3ErrorMsg(pParse, "error in generated column \"%s\"",
|
|
pCol->zCnName);
|
|
generated_done:
|
|
sqlite3ExprDelete(pParse->db, pExpr);
|
|
#else
|
|
/* Throw and error for the GENERATED ALWAYS AS clause if the
|
|
** SQLITE_OMIT_GENERATED_COLUMNS compile-time option is used. */
|
|
sqlite3ErrorMsg(pParse, "generated columns not supported");
|
|
sqlite3ExprDelete(pParse->db, pExpr);
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
** Generate code that will increment the schema cookie.
|
|
**
|
|
** The schema cookie is used to determine when the schema for the
|
|
** database changes. After each schema change, the cookie value
|
|
** changes. When a process first reads the schema it records the
|
|
** cookie. Thereafter, whenever it goes to access the database,
|
|
** it checks the cookie to make sure the schema has not changed
|
|
** since it was last read.
|
|
**
|
|
** This plan is not completely bullet-proof. It is possible for
|
|
** the schema to change multiple times and for the cookie to be
|
|
** set back to prior value. But schema changes are infrequent
|
|
** and the probability of hitting the same cookie value is only
|
|
** 1 chance in 2^32. So we're safe enough.
|
|
**
|
|
** IMPLEMENTATION-OF: R-34230-56049 SQLite automatically increments
|
|
** the schema-version whenever the schema changes.
|
|
*/
|
|
void sqlite3ChangeCookie(Parse *pParse, int iDb){
|
|
sqlite3 *db = pParse->db;
|
|
Vdbe *v = pParse->pVdbe;
|
|
assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
|
|
sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION,
|
|
(int)(1+(unsigned)db->aDb[iDb].pSchema->schema_cookie));
|
|
}
|
|
|
|
/*
|
|
** Measure the number of characters needed to output the given
|
|
** identifier. The number returned includes any quotes used
|
|
** but does not include the null terminator.
|
|
**
|
|
** The estimate is conservative. It might be larger that what is
|
|
** really needed.
|
|
*/
|
|
static int identLength(const char *z){
|
|
int n;
|
|
for(n=0; *z; n++, z++){
|
|
if( *z=='"' ){ n++; }
|
|
}
|
|
return n + 2;
|
|
}
|
|
|
|
/*
|
|
** The first parameter is a pointer to an output buffer. The second
|
|
** parameter is a pointer to an integer that contains the offset at
|
|
** which to write into the output buffer. This function copies the
|
|
** nul-terminated string pointed to by the third parameter, zSignedIdent,
|
|
** to the specified offset in the buffer and updates *pIdx to refer
|
|
** to the first byte after the last byte written before returning.
|
|
**
|
|
** If the string zSignedIdent consists entirely of alphanumeric
|
|
** characters, does not begin with a digit and is not an SQL keyword,
|
|
** then it is copied to the output buffer exactly as it is. Otherwise,
|
|
** it is quoted using double-quotes.
|
|
*/
|
|
static void identPut(char *z, int *pIdx, char *zSignedIdent){
|
|
unsigned char *zIdent = (unsigned char*)zSignedIdent;
|
|
int i, j, needQuote;
|
|
i = *pIdx;
|
|
|
|
for(j=0; zIdent[j]; j++){
|
|
if( !sqlite3Isalnum(zIdent[j]) && zIdent[j]!='_' ) break;
|
|
}
|
|
needQuote = sqlite3Isdigit(zIdent[0])
|
|
|| sqlite3KeywordCode(zIdent, j)!=TK_ID
|
|
|| zIdent[j]!=0
|
|
|| j==0;
|
|
|
|
if( needQuote ) z[i++] = '"';
|
|
for(j=0; zIdent[j]; j++){
|
|
z[i++] = zIdent[j];
|
|
if( zIdent[j]=='"' ) z[i++] = '"';
|
|
}
|
|
if( needQuote ) z[i++] = '"';
|
|
z[i] = 0;
|
|
*pIdx = i;
|
|
}
|
|
|
|
/*
|
|
** Generate a CREATE TABLE statement appropriate for the given
|
|
** table. Memory to hold the text of the statement is obtained
|
|
** from sqliteMalloc() and must be freed by the calling function.
|
|
*/
|
|
static char *createTableStmt(sqlite3 *db, Table *p){
|
|
int i, k, len;
|
|
i64 n;
|
|
char *zStmt;
|
|
char *zSep, *zSep2, *zEnd;
|
|
Column *pCol;
|
|
n = 0;
|
|
for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
|
|
n += identLength(pCol->zCnName) + 5;
|
|
}
|
|
n += identLength(p->zName);
|
|
if( n<50 ){
|
|
zSep = "";
|
|
zSep2 = ",";
|
|
zEnd = ")";
|
|
}else{
|
|
zSep = "\n ";
|
|
zSep2 = ",\n ";
|
|
zEnd = "\n)";
|
|
}
|
|
n += 35 + 6*p->nCol;
|
|
zStmt = sqlite3DbMallocRaw(0, n);
|
|
if( zStmt==0 ){
|
|
sqlite3OomFault(db);
|
|
return 0;
|
|
}
|
|
assert( n>14 && n<=0x7fffffff );
|
|
memcpy(zStmt, "CREATE TABLE ", 13);
|
|
k = 13;
|
|
identPut(zStmt, &k, p->zName);
|
|
zStmt[k++] = '(';
|
|
for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
|
|
static const char * const azType[] = {
|
|
/* SQLITE_AFF_BLOB */ "",
|
|
/* SQLITE_AFF_TEXT */ " TEXT",
|
|
/* SQLITE_AFF_NUMERIC */ " NUM",
|
|
/* SQLITE_AFF_INTEGER */ " INT",
|
|
/* SQLITE_AFF_REAL */ " REAL",
|
|
/* SQLITE_AFF_FLEXNUM */ " NUM",
|
|
};
|
|
const char *zType;
|
|
|
|
len = sqlite3Strlen30(zSep);
|
|
assert( k+len<n );
|
|
memcpy(&zStmt[k], zSep, len);
|
|
k += len;
|
|
zSep = zSep2;
|
|
identPut(zStmt, &k, pCol->zCnName);
|
|
assert( k<n );
|
|
assert( pCol->affinity-SQLITE_AFF_BLOB >= 0 );
|
|
assert( pCol->affinity-SQLITE_AFF_BLOB < ArraySize(azType) );
|
|
testcase( pCol->affinity==SQLITE_AFF_BLOB );
|
|
testcase( pCol->affinity==SQLITE_AFF_TEXT );
|
|
testcase( pCol->affinity==SQLITE_AFF_NUMERIC );
|
|
testcase( pCol->affinity==SQLITE_AFF_INTEGER );
|
|
testcase( pCol->affinity==SQLITE_AFF_REAL );
|
|
testcase( pCol->affinity==SQLITE_AFF_FLEXNUM );
|
|
|
|
zType = azType[pCol->affinity - SQLITE_AFF_BLOB];
|
|
len = sqlite3Strlen30(zType);
|
|
assert( pCol->affinity==SQLITE_AFF_BLOB
|
|
|| pCol->affinity==SQLITE_AFF_FLEXNUM
|
|
|| pCol->affinity==sqlite3AffinityType(zType, 0) );
|
|
assert( k+len<n );
|
|
memcpy(&zStmt[k], zType, len);
|
|
k += len;
|
|
assert( k<=n );
|
|
}
|
|
len = sqlite3Strlen30(zEnd);
|
|
assert( k+len<n );
|
|
memcpy(&zStmt[k], zEnd, len+1);
|
|
return zStmt;
|
|
}
|
|
|
|
/*
|
|
** Resize an Index object to hold N columns total. Return SQLITE_OK
|
|
** on success and SQLITE_NOMEM on an OOM error.
|
|
*/
|
|
static int resizeIndexObject(Parse *pParse, Index *pIdx, int N){
|
|
char *zExtra;
|
|
u64 nByte;
|
|
sqlite3 *db;
|
|
if( pIdx->nColumn>=N ) return SQLITE_OK;
|
|
db = pParse->db;
|
|
assert( N>0 );
|
|
assert( N <= SQLITE_MAX_COLUMN*2 /* tag-20250221-1 */ );
|
|
testcase( N==2*pParse->db->aLimit[SQLITE_LIMIT_COLUMN] );
|
|
assert( pIdx->isResized==0 );
|
|
nByte = (sizeof(char*) + sizeof(LogEst) + sizeof(i16) + 1)*(u64)N;
|
|
zExtra = sqlite3DbMallocZero(db, nByte);
|
|
if( zExtra==0 ) return SQLITE_NOMEM_BKPT;
|
|
memcpy(zExtra, pIdx->azColl, sizeof(char*)*pIdx->nColumn);
|
|
pIdx->azColl = (const char**)zExtra;
|
|
zExtra += sizeof(char*)*N;
|
|
memcpy(zExtra, pIdx->aiRowLogEst, sizeof(LogEst)*(pIdx->nKeyCol+1));
|
|
pIdx->aiRowLogEst = (LogEst*)zExtra;
|
|
zExtra += sizeof(LogEst)*N;
|
|
memcpy(zExtra, pIdx->aiColumn, sizeof(i16)*pIdx->nColumn);
|
|
pIdx->aiColumn = (i16*)zExtra;
|
|
zExtra += sizeof(i16)*N;
|
|
memcpy(zExtra, pIdx->aSortOrder, pIdx->nColumn);
|
|
pIdx->aSortOrder = (u8*)zExtra;
|
|
pIdx->nColumn = (u16)N; /* See tag-20250221-1 above for proof of safety */
|
|
pIdx->isResized = 1;
|
|
return SQLITE_OK;
|
|
}
|
|
|
|
/*
|
|
** Estimate the total row width for a table.
|
|
*/
|
|
static void estimateTableWidth(Table *pTab){
|
|
unsigned wTable = 0;
|
|
const Column *pTabCol;
|
|
int i;
|
|
for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){
|
|
wTable += pTabCol->szEst;
|
|
}
|
|
if( pTab->iPKey<0 ) wTable++;
|
|
pTab->szTabRow = sqlite3LogEst(wTable*4);
|
|
}
|
|
|
|
/*
|
|
** Estimate the average size of a row for an index.
|
|
*/
|
|
static void estimateIndexWidth(Index *pIdx){
|
|
unsigned wIndex = 0;
|
|
int i;
|
|
const Column *aCol = pIdx->pTable->aCol;
|
|
for(i=0; i<pIdx->nColumn; i++){
|
|
i16 x = pIdx->aiColumn[i];
|
|
assert( x<pIdx->pTable->nCol );
|
|
wIndex += x<0 ? 1 : aCol[x].szEst;
|
|
}
|
|
pIdx->szIdxRow = sqlite3LogEst(wIndex*4);
|
|
}
|
|
|
|
/* Return true if column number x is any of the first nCol entries of aiCol[].
|
|
** This is used to determine if the column number x appears in any of the
|
|
** first nCol entries of an index.
|
|
*/
|
|
static int hasColumn(const i16 *aiCol, int nCol, int x){
|
|
while( nCol-- > 0 ){
|
|
if( x==*(aiCol++) ){
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
** Return true if any of the first nKey entries of index pIdx exactly
|
|
** match the iCol-th entry of pPk. pPk is always a WITHOUT ROWID
|
|
** PRIMARY KEY index. pIdx is an index on the same table. pIdx may
|
|
** or may not be the same index as pPk.
|
|
**
|
|
** The first nKey entries of pIdx are guaranteed to be ordinary columns,
|
|
** not a rowid or expression.
|
|
**
|
|
** This routine differs from hasColumn() in that both the column and the
|
|
** collating sequence must match for this routine, but for hasColumn() only
|
|
** the column name must match.
|
|
*/
|
|
static int isDupColumn(Index *pIdx, int nKey, Index *pPk, int iCol){
|
|
int i, j;
|
|
assert( nKey<=pIdx->nColumn );
|
|
assert( iCol<MAX(pPk->nColumn,pPk->nKeyCol) );
|
|
assert( pPk->idxType==SQLITE_IDXTYPE_PRIMARYKEY );
|
|
assert( pPk->pTable->tabFlags & TF_WithoutRowid );
|
|
assert( pPk->pTable==pIdx->pTable );
|
|
testcase( pPk==pIdx );
|
|
j = pPk->aiColumn[iCol];
|
|
assert( j!=XN_ROWID && j!=XN_EXPR );
|
|
for(i=0; i<nKey; i++){
|
|
assert( pIdx->aiColumn[i]>=0 || j>=0 );
|
|
if( pIdx->aiColumn[i]==j
|
|
&& sqlite3StrICmp(pIdx->azColl[i], pPk->azColl[iCol])==0
|
|
){
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Recompute the colNotIdxed field of the Index.
|
|
**
|
|
** colNotIdxed is a bitmask that has a 0 bit representing each indexed
|
|
** columns that are within the first 63 columns of the table and a 1 for
|
|
** all other bits (all columns that are not in the index). The
|
|
** high-order bit of colNotIdxed is always 1. All unindexed columns
|
|
** of the table have a 1.
|
|
**
|
|
** 2019-10-24: For the purpose of this computation, virtual columns are
|
|
** not considered to be covered by the index, even if they are in the
|
|
** index, because we do not trust the logic in whereIndexExprTrans() to be
|
|
** able to find all instances of a reference to the indexed table column
|
|
** and convert them into references to the index. Hence we always want
|
|
** the actual table at hand in order to recompute the virtual column, if
|
|
** necessary.
|
|
**
|
|
** The colNotIdxed mask is AND-ed with the SrcList.a[].colUsed mask
|
|
** to determine if the index is covering index.
|
|
*/
|
|
static void recomputeColumnsNotIndexed(Index *pIdx){
|
|
Bitmask m = 0;
|
|
int j;
|
|
Table *pTab = pIdx->pTable;
|
|
for(j=pIdx->nColumn-1; j>=0; j--){
|
|
int x = pIdx->aiColumn[j];
|
|
if( x>=0 && (pTab->aCol[x].colFlags & COLFLAG_VIRTUAL)==0 ){
|
|
testcase( x==BMS-1 );
|
|
testcase( x==BMS-2 );
|
|
if( x<BMS-1 ) m |= MASKBIT(x);
|
|
}
|
|
}
|
|
pIdx->colNotIdxed = ~m;
|
|
assert( (pIdx->colNotIdxed>>63)==1 ); /* See note-20221022-a */
|
|
}
|
|
|
|
/*
|
|
** This routine runs at the end of parsing a CREATE TABLE statement that
|
|
** has a WITHOUT ROWID clause. The job of this routine is to convert both
|
|
** internal schema data structures and the generated VDBE code so that they
|
|
** are appropriate for a WITHOUT ROWID table instead of a rowid table.
|
|
** Changes include:
|
|
**
|
|
** (1) Set all columns of the PRIMARY KEY schema object to be NOT NULL.
|
|
** (2) Convert P3 parameter of the OP_CreateBtree from BTREE_INTKEY
|
|
** into BTREE_BLOBKEY.
|
|
** (3) Bypass the creation of the sqlite_schema table entry
|
|
** for the PRIMARY KEY as the primary key index is now
|
|
** identified by the sqlite_schema table entry of the table itself.
|
|
** (4) Set the Index.tnum of the PRIMARY KEY Index object in the
|
|
** schema to the rootpage from the main table.
|
|
** (5) Add all table columns to the PRIMARY KEY Index object
|
|
** so that the PRIMARY KEY is a covering index. The surplus
|
|
** columns are part of KeyInfo.nAllField and are not used for
|
|
** sorting or lookup or uniqueness checks.
|
|
** (6) Replace the rowid tail on all automatically generated UNIQUE
|
|
** indices with the PRIMARY KEY columns.
|
|
**
|
|
** For virtual tables, only (1) is performed.
|
|
*/
|
|
static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
|
|
Index *pIdx;
|
|
Index *pPk;
|
|
int nPk;
|
|
int nExtra;
|
|
int i, j;
|
|
sqlite3 *db = pParse->db;
|
|
Vdbe *v = pParse->pVdbe;
|
|
|
|
/* Mark every PRIMARY KEY column as NOT NULL (except for imposter tables)
|
|
*/
|
|
if( !db->init.imposterTable ){
|
|
for(i=0; i<pTab->nCol; i++){
|
|
if( (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0
|
|
&& (pTab->aCol[i].notNull==OE_None)
|
|
){
|
|
pTab->aCol[i].notNull = OE_Abort;
|
|
}
|
|
}
|
|
pTab->tabFlags |= TF_HasNotNull;
|
|
}
|
|
|
|
/* Convert the P3 operand of the OP_CreateBtree opcode from BTREE_INTKEY
|
|
** into BTREE_BLOBKEY.
|
|
*/
|
|
assert( !pParse->bReturning );
|
|
if( pParse->u1.cr.addrCrTab ){
|
|
assert( v );
|
|
sqlite3VdbeChangeP3(v, pParse->u1.cr.addrCrTab, BTREE_BLOBKEY);
|
|
}
|
|
|
|
/* Locate the PRIMARY KEY index. Or, if this table was originally
|
|
** an INTEGER PRIMARY KEY table, create a new PRIMARY KEY index.
|
|
*/
|
|
if( pTab->iPKey>=0 ){
|
|
ExprList *pList;
|
|
Token ipkToken;
|
|
sqlite3TokenInit(&ipkToken, pTab->aCol[pTab->iPKey].zCnName);
|
|
pList = sqlite3ExprListAppend(pParse, 0,
|
|
sqlite3ExprAlloc(db, TK_ID, &ipkToken, 0));
|
|
if( pList==0 ){
|
|
pTab->tabFlags &= ~TF_WithoutRowid;
|
|
return;
|
|
}
|
|
if( IN_RENAME_OBJECT ){
|
|
sqlite3RenameTokenRemap(pParse, pList->a[0].pExpr, &pTab->iPKey);
|
|
}
|
|
pList->a[0].fg.sortFlags = pParse->iPkSortOrder;
|
|
assert( pParse->pNewTable==pTab );
|
|
pTab->iPKey = -1;
|
|
sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0,
|
|
SQLITE_IDXTYPE_PRIMARYKEY);
|
|
if( pParse->nErr ){
|
|
pTab->tabFlags &= ~TF_WithoutRowid;
|
|
return;
|
|
}
|
|
assert( db->mallocFailed==0 );
|
|
pPk = sqlite3PrimaryKeyIndex(pTab);
|
|
assert( pPk->nKeyCol==1 );
|
|
}else{
|
|
pPk = sqlite3PrimaryKeyIndex(pTab);
|
|
assert( pPk!=0 );
|
|
|
|
/*
|
|
** Remove all redundant columns from the PRIMARY KEY. For example, change
|
|
** "PRIMARY KEY(a,b,a,b,c,b,c,d)" into just "PRIMARY KEY(a,b,c,d)". Later
|
|
** code assumes the PRIMARY KEY contains no repeated columns.
|
|
*/
|
|
for(i=j=1; i<pPk->nKeyCol; i++){
|
|
if( isDupColumn(pPk, j, pPk, i) ){
|
|
pPk->nColumn--;
|
|
}else{
|
|
testcase( hasColumn(pPk->aiColumn, j, pPk->aiColumn[i]) );
|
|
pPk->azColl[j] = pPk->azColl[i];
|
|
pPk->aSortOrder[j] = pPk->aSortOrder[i];
|
|
pPk->aiColumn[j++] = pPk->aiColumn[i];
|
|
}
|
|
}
|
|
pPk->nKeyCol = j;
|
|
}
|
|
assert( pPk!=0 );
|
|
pPk->isCovering = 1;
|
|
if( !db->init.imposterTable ) pPk->uniqNotNull = 1;
|
|
nPk = pPk->nColumn = pPk->nKeyCol;
|
|
|
|
/* Bypass the creation of the PRIMARY KEY btree and the sqlite_schema
|
|
** table entry. This is only required if currently generating VDBE
|
|
** code for a CREATE TABLE (not when parsing one as part of reading
|
|
** a database schema). */
|
|
if( v && pPk->tnum>0 ){
|
|
assert( db->init.busy==0 );
|
|
sqlite3VdbeChangeOpcode(v, (int)pPk->tnum, OP_Goto);
|
|
}
|
|
|
|
/* The root page of the PRIMARY KEY is the table root page */
|
|
pPk->tnum = pTab->tnum;
|
|
|
|
/* Update the in-memory representation of all UNIQUE indices by converting
|
|
** the final rowid column into one or more columns of the PRIMARY KEY.
|
|
*/
|
|
for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
|
|
int n;
|
|
if( IsPrimaryKeyIndex(pIdx) ) continue;
|
|
for(i=n=0; i<nPk; i++){
|
|
if( !isDupColumn(pIdx, pIdx->nKeyCol, pPk, i) ){
|
|
testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) );
|
|
n++;
|
|
}
|
|
}
|
|
if( n==0 ){
|
|
/* This index is a superset of the primary key */
|
|
pIdx->nColumn = pIdx->nKeyCol;
|
|
continue;
|
|
}
|
|
if( resizeIndexObject(pParse, pIdx, pIdx->nKeyCol+n) ) return;
|
|
for(i=0, j=pIdx->nKeyCol; i<nPk; i++){
|
|
if( !isDupColumn(pIdx, pIdx->nKeyCol, pPk, i) ){
|
|
testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) );
|
|
pIdx->aiColumn[j] = pPk->aiColumn[i];
|
|
pIdx->azColl[j] = pPk->azColl[i];
|
|
if( pPk->aSortOrder[i] ){
|
|
/* See ticket https://www.sqlite.org/src/info/bba7b69f9849b5bf */
|
|
pIdx->bAscKeyBug = 1;
|
|
}
|
|
j++;
|
|
}
|
|
}
|
|
assert( pIdx->nColumn>=pIdx->nKeyCol+n );
|
|
assert( pIdx->nColumn>=j );
|
|
}
|
|
|
|
/* Add all table columns to the PRIMARY KEY index
|
|
*/
|
|
nExtra = 0;
|
|
for(i=0; i<pTab->nCol; i++){
|
|
if( !hasColumn(pPk->aiColumn, nPk, i)
|
|
&& (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) nExtra++;
|
|
}
|
|
if( resizeIndexObject(pParse, pPk, nPk+nExtra) ) return;
|
|
for(i=0, j=nPk; i<pTab->nCol; i++){
|
|
if( !hasColumn(pPk->aiColumn, j, i)
|
|
&& (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0
|
|
){
|
|
assert( j<pPk->nColumn );
|
|
pPk->aiColumn[j] = i;
|
|
pPk->azColl[j] = sqlite3StrBINARY;
|
|
j++;
|
|
}
|
|
}
|
|
assert( pPk->nColumn==j );
|
|
assert( pTab->nNVCol<=j );
|
|
recomputeColumnsNotIndexed(pPk);
|
|
}
|
|
|
|
|
|
#ifndef SQLITE_OMIT_VIRTUALTABLE
|
|
/*
|
|
** Return true if pTab is a virtual table and zName is a shadow table name
|
|
** for that virtual table.
|
|
*/
|
|
int sqlite3IsShadowTableOf(sqlite3 *db, Table *pTab, const char *zName){
|
|
int nName; /* Length of zName */
|
|
Module *pMod; /* Module for the virtual table */
|
|
|
|
if( !IsVirtual(pTab) ) return 0;
|
|
nName = sqlite3Strlen30(pTab->zName);
|
|
if( sqlite3_strnicmp(zName, pTab->zName, nName)!=0 ) return 0;
|
|
if( zName[nName]!='_' ) return 0;
|
|
pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->u.vtab.azArg[0]);
|
|
if( pMod==0 ) return 0;
|
|
if( pMod->pModule->iVersion<3 ) return 0;
|
|
if( pMod->pModule->xShadowName==0 ) return 0;
|
|
return pMod->pModule->xShadowName(zName+nName+1);
|
|
}
|
|
#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
|
|
|
|
#ifndef SQLITE_OMIT_VIRTUALTABLE
|
|
/*
|
|
** Table pTab is a virtual table. If it the virtual table implementation
|
|
** exists and has an xShadowName method, then loop over all other ordinary
|
|
** tables within the same schema looking for shadow tables of pTab, and mark
|
|
** any shadow tables seen using the TF_Shadow flag.
|
|
*/
|
|
void sqlite3MarkAllShadowTablesOf(sqlite3 *db, Table *pTab){
|
|
int nName; /* Length of pTab->zName */
|
|
Module *pMod; /* Module for the virtual table */
|
|
HashElem *k; /* For looping through the symbol table */
|
|
|
|
assert( IsVirtual(pTab) );
|
|
pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->u.vtab.azArg[0]);
|
|
if( pMod==0 ) return;
|
|
if( NEVER(pMod->pModule==0) ) return;
|
|
if( pMod->pModule->iVersion<3 ) return;
|
|
if( pMod->pModule->xShadowName==0 ) return;
|
|
assert( pTab->zName!=0 );
|
|
nName = sqlite3Strlen30(pTab->zName);
|
|
for(k=sqliteHashFirst(&pTab->pSchema->tblHash); k; k=sqliteHashNext(k)){
|
|
Table *pOther = sqliteHashData(k);
|
|
assert( pOther->zName!=0 );
|
|
if( !IsOrdinaryTable(pOther) ) continue;
|
|
if( pOther->tabFlags & TF_Shadow ) continue;
|
|
if( sqlite3StrNICmp(pOther->zName, pTab->zName, nName)==0
|
|
&& pOther->zName[nName]=='_'
|
|
&& pMod->pModule->xShadowName(pOther->zName+nName+1)
|
|
){
|
|
pOther->tabFlags |= TF_Shadow;
|
|
}
|
|
}
|
|
}
|
|
#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
|
|
|
|
#ifndef SQLITE_OMIT_VIRTUALTABLE
|
|
/*
|
|
** Return true if zName is a shadow table name in the current database
|
|
** connection.
|
|
**
|
|
** zName is temporarily modified while this routine is running, but is
|
|
** restored to its original value prior to this routine returning.
|
|
*/
|
|
int sqlite3ShadowTableName(sqlite3 *db, const char *zName){
|
|
char *zTail; /* Pointer to the last "_" in zName */
|
|
Table *pTab; /* Table that zName is a shadow of */
|
|
zTail = strrchr(zName, '_');
|
|
if( zTail==0 ) return 0;
|
|
*zTail = 0;
|
|
pTab = sqlite3FindTable(db, zName, 0);
|
|
*zTail = '_';
|
|
if( pTab==0 ) return 0;
|
|
if( !IsVirtual(pTab) ) return 0;
|
|
return sqlite3IsShadowTableOf(db, pTab, zName);
|
|
}
|
|
#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
|
|
|
|
|
|
#ifdef SQLITE_DEBUG
|
|
/*
|
|
** Mark all nodes of an expression as EP_Immutable, indicating that
|
|
** they should not be changed. Expressions attached to a table or
|
|
** index definition are tagged this way to help ensure that we do
|
|
** not pass them into code generator routines by mistake.
|
|
*/
|
|
static int markImmutableExprStep(Walker *pWalker, Expr *pExpr){
|
|
(void)pWalker;
|
|
ExprSetVVAProperty(pExpr, EP_Immutable);
|
|
return WRC_Continue;
|
|
}
|
|
static void markExprListImmutable(ExprList *pList){
|
|
if( pList ){
|
|
Walker w;
|
|
memset(&w, 0, sizeof(w));
|
|
w.xExprCallback = markImmutableExprStep;
|
|
w.xSelectCallback = sqlite3SelectWalkNoop;
|
|
w.xSelectCallback2 = 0;
|
|
sqlite3WalkExprList(&w, pList);
|
|
}
|
|
}
|
|
#else
|
|
#define markExprListImmutable(X) /* no-op */
|
|
#endif /* SQLITE_DEBUG */
|
|
|
|
|
|
/*
|
|
** This routine is called to report the final ")" that terminates
|
|
** a CREATE TABLE statement.
|
|
**
|
|
** The table structure that other action routines have been building
|
|
** is added to the internal hash tables, assuming no errors have
|
|
** occurred.
|
|
**
|
|
** An entry for the table is made in the schema table on disk, unless
|
|
** this is a temporary table or db->init.busy==1. When db->init.busy==1
|
|
** it means we are reading the sqlite_schema table because we just
|
|
** connected to the database or because the sqlite_schema table has
|
|
** recently changed, so the entry for this table already exists in
|
|
** the sqlite_schema table. We do not want to create it again.
|
|
**
|
|
** If the pSelect argument is not NULL, it means that this routine
|
|
** was called to create a table generated from a
|
|
** "CREATE TABLE ... AS SELECT ..." statement. The column names of
|
|
** the new table will match the result set of the SELECT.
|
|
*/
|
|
void sqlite3EndTable(
|
|
Parse *pParse, /* Parse context */
|
|
Token *pCons, /* The ',' token after the last column defn. */
|
|
Token *pEnd, /* The ')' before options in the CREATE TABLE */
|
|
u32 tabOpts, /* Extra table options. Usually 0. */
|
|
Select *pSelect /* Select from a "CREATE ... AS SELECT" */
|
|
){
|
|
Table *p; /* The new table */
|
|
sqlite3 *db = pParse->db; /* The database connection */
|
|
int iDb; /* Database in which the table lives */
|
|
Index *pIdx; /* An implied index of the table */
|
|
|
|
if( pEnd==0 && pSelect==0 ){
|
|
return;
|
|
}
|
|
p = pParse->pNewTable;
|
|
if( p==0 ) return;
|
|
|
|
if( pSelect==0 && sqlite3ShadowTableName(db, p->zName) ){
|
|
p->tabFlags |= TF_Shadow;
|
|
}
|
|
|
|
/* If the db->init.busy is 1 it means we are reading the SQL off the
|
|
** "sqlite_schema" or "sqlite_temp_schema" table on the disk.
|
|
** So do not write to the disk again. Extract the root page number
|
|
** for the table from the db->init.newTnum field. (The page number
|
|
** should have been put there by the sqliteOpenCb routine.)
|
|
**
|
|
** If the root page number is 1, that means this is the sqlite_schema
|
|
** table itself. So mark it read-only.
|
|
*/
|
|
if( db->init.busy ){
|
|
if( pSelect || (!IsOrdinaryTable(p) && db->init.newTnum) ){
|
|
sqlite3ErrorMsg(pParse, "");
|
|
return;
|
|
}
|
|
p->tnum = db->init.newTnum;
|
|
if( p->tnum==1 ) p->tabFlags |= TF_Readonly;
|
|
}
|
|
|
|
/* Special processing for tables that include the STRICT keyword:
|
|
**
|
|
** * Do not allow custom column datatypes. Every column must have
|
|
** a datatype that is one of INT, INTEGER, REAL, TEXT, or BLOB.
|
|
**
|
|
** * If a PRIMARY KEY is defined, other than the INTEGER PRIMARY KEY,
|
|
** then all columns of the PRIMARY KEY must have a NOT NULL
|
|
** constraint.
|
|
*/
|
|
if( tabOpts & TF_Strict ){
|
|
int ii;
|
|
p->tabFlags |= TF_Strict;
|
|
for(ii=0; ii<p->nCol; ii++){
|
|
Column *pCol = &p->aCol[ii];
|
|
if( pCol->eCType==COLTYPE_CUSTOM ){
|
|
if( pCol->colFlags & COLFLAG_HASTYPE ){
|
|
sqlite3ErrorMsg(pParse,
|
|
"unknown datatype for %s.%s: \"%s\"",
|
|
p->zName, pCol->zCnName, sqlite3ColumnType(pCol, "")
|
|
);
|
|
}else{
|
|
sqlite3ErrorMsg(pParse, "missing datatype for %s.%s",
|
|
p->zName, pCol->zCnName);
|
|
}
|
|
return;
|
|
}else if( pCol->eCType==COLTYPE_ANY ){
|
|
pCol->affinity = SQLITE_AFF_BLOB;
|
|
}
|
|
if( (pCol->colFlags & COLFLAG_PRIMKEY)!=0
|
|
&& p->iPKey!=ii
|
|
&& pCol->notNull == OE_None
|
|
){
|
|
pCol->notNull = OE_Abort;
|
|
p->tabFlags |= TF_HasNotNull;
|
|
}
|
|
}
|
|
}
|
|
|
|
assert( (p->tabFlags & TF_HasPrimaryKey)==0
|
|
|| p->iPKey>=0 || sqlite3PrimaryKeyIndex(p)!=0 );
|
|
assert( (p->tabFlags & TF_HasPrimaryKey)!=0
|
|
|| (p->iPKey<0 && sqlite3PrimaryKeyIndex(p)==0) );
|
|
|
|
/* Special processing for WITHOUT ROWID Tables */
|
|
if( tabOpts & TF_WithoutRowid ){
|
|
if( (p->tabFlags & TF_Autoincrement) ){
|
|
sqlite3ErrorMsg(pParse,
|
|
"AUTOINCREMENT not allowed on WITHOUT ROWID tables");
|
|
return;
|
|
}
|
|
if( (p->tabFlags & TF_HasPrimaryKey)==0 ){
|
|
sqlite3ErrorMsg(pParse, "PRIMARY KEY missing on table %s", p->zName);
|
|
return;
|
|
}
|
|
p->tabFlags |= TF_WithoutRowid | TF_NoVisibleRowid;
|
|
convertToWithoutRowidTable(pParse, p);
|
|
}
|
|
iDb = sqlite3SchemaToIndex(db, p->pSchema);
|
|
|
|
#ifndef SQLITE_OMIT_CHECK
|
|
/* Resolve names in all CHECK constraint expressions.
|
|
*/
|
|
if( p->pCheck ){
|
|
sqlite3ResolveSelfReference(pParse, p, NC_IsCheck, 0, p->pCheck);
|
|
if( pParse->nErr ){
|
|
/* If errors are seen, delete the CHECK constraints now, else they might
|
|
** actually be used if PRAGMA writable_schema=ON is set. */
|
|
sqlite3ExprListDelete(db, p->pCheck);
|
|
p->pCheck = 0;
|
|
}else{
|
|
markExprListImmutable(p->pCheck);
|
|
}
|
|
}
|
|
#endif /* !defined(SQLITE_OMIT_CHECK) */
|
|
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
|
|
if( p->tabFlags & TF_HasGenerated ){
|
|
int ii, nNG = 0;
|
|
testcase( p->tabFlags & TF_HasVirtual );
|
|
testcase( p->tabFlags & TF_HasStored );
|
|
for(ii=0; ii<p->nCol; ii++){
|
|
u32 colFlags = p->aCol[ii].colFlags;
|
|
if( (colFlags & COLFLAG_GENERATED)!=0 ){
|
|
Expr *pX = sqlite3ColumnExpr(p, &p->aCol[ii]);
|
|
testcase( colFlags & COLFLAG_VIRTUAL );
|
|
testcase( colFlags & COLFLAG_STORED );
|
|
if( sqlite3ResolveSelfReference(pParse, p, NC_GenCol, pX, 0) ){
|
|
/* If there are errors in resolving the expression, change the
|
|
** expression to a NULL. This prevents code generators that operate
|
|
** on the expression from inserting extra parts into the expression
|
|
** tree that have been allocated from lookaside memory, which is
|
|
** illegal in a schema and will lead to errors or heap corruption
|
|
** when the database connection closes. */
|
|
sqlite3ColumnSetExpr(pParse, p, &p->aCol[ii],
|
|
sqlite3ExprAlloc(db, TK_NULL, 0, 0));
|
|
}
|
|
}else{
|
|
nNG++;
|
|
}
|
|
}
|
|
if( nNG==0 ){
|
|
sqlite3ErrorMsg(pParse, "must have at least one non-generated column");
|
|
return;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* Estimate the average row size for the table and for all implied indices */
|
|
estimateTableWidth(p);
|
|
for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
|
|
estimateIndexWidth(pIdx);
|
|
}
|
|
|
|
/* If not initializing, then create a record for the new table
|
|
** in the schema table of the database.
|
|
**
|
|
** If this is a TEMPORARY table, write the entry into the auxiliary
|
|
** file instead of into the main database file.
|
|
*/
|
|
if( !db->init.busy ){
|
|
int n;
|
|
Vdbe *v;
|
|
char *zType; /* "view" or "table" */
|
|
char *zType2; /* "VIEW" or "TABLE" */
|
|
char *zStmt; /* Text of the CREATE TABLE or CREATE VIEW statement */
|
|
|
|
v = sqlite3GetVdbe(pParse);
|
|
if( NEVER(v==0) ) return;
|
|
|
|
sqlite3VdbeAddOp1(v, OP_Close, 0);
|
|
|
|
/*
|
|
** Initialize zType for the new view or table.
|
|
*/
|
|
if( IsOrdinaryTable(p) ){
|
|
/* A regular table */
|
|
zType = "table";
|
|
zType2 = "TABLE";
|
|
#ifndef SQLITE_OMIT_VIEW
|
|
}else{
|
|
/* A view */
|
|
zType = "view";
|
|
zType2 = "VIEW";
|
|
#endif
|
|
}
|
|
|
|
/* If this is a CREATE TABLE xx AS SELECT ..., execute the SELECT
|
|
** statement to populate the new table. The root-page number for the
|
|
** new table is in register pParse->u1.cr.regRoot.
|
|
**
|
|
** Once the SELECT has been coded by sqlite3Select(), it is in a
|
|
** suitable state to query for the column names and types to be used
|
|
** by the new table.
|
|
**
|
|
** A shared-cache write-lock is not required to write to the new table,
|
|
** as a schema-lock must have already been obtained to create it. Since
|
|
** a schema-lock excludes all other database users, the write-lock would
|
|
** be redundant.
|
|
*/
|
|
if( pSelect ){
|
|
SelectDest dest; /* Where the SELECT should store results */
|
|
int regYield; /* Register holding co-routine entry-point */
|
|
int addrTop; /* Top of the co-routine */
|
|
int regRec; /* A record to be insert into the new table */
|
|
int regRowid; /* Rowid of the next row to insert */
|
|
int addrInsLoop; /* Top of the loop for inserting rows */
|
|
Table *pSelTab; /* A table that describes the SELECT results */
|
|
int iCsr; /* Write cursor on the new table */
|
|
|
|
if( IN_SPECIAL_PARSE ){
|
|
pParse->rc = SQLITE_ERROR;
|
|
pParse->nErr++;
|
|
return;
|
|
}
|
|
iCsr = pParse->nTab++;
|
|
regYield = ++pParse->nMem;
|
|
regRec = ++pParse->nMem;
|
|
regRowid = ++pParse->nMem;
|
|
sqlite3MayAbort(pParse);
|
|
assert( pParse->isCreate );
|
|
sqlite3VdbeAddOp3(v, OP_OpenWrite, iCsr, pParse->u1.cr.regRoot, iDb);
|
|
sqlite3VdbeChangeP5(v, OPFLAG_P2ISREG);
|
|
addrTop = sqlite3VdbeCurrentAddr(v) + 1;
|
|
sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
|
|
if( pParse->nErr ) return;
|
|
pSelTab = sqlite3ResultSetOfSelect(pParse, pSelect, SQLITE_AFF_BLOB);
|
|
if( pSelTab==0 ) return;
|
|
assert( p->aCol==0 );
|
|
p->nCol = p->nNVCol = pSelTab->nCol;
|
|
p->aCol = pSelTab->aCol;
|
|
pSelTab->nCol = 0;
|
|
pSelTab->aCol = 0;
|
|
sqlite3DeleteTable(db, pSelTab);
|
|
sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield);
|
|
sqlite3Select(pParse, pSelect, &dest);
|
|
if( pParse->nErr ) return;
|
|
sqlite3VdbeEndCoroutine(v, regYield);
|
|
sqlite3VdbeJumpHere(v, addrTop - 1);
|
|
addrInsLoop = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm);
|
|
VdbeCoverage(v);
|
|
sqlite3VdbeAddOp3(v, OP_MakeRecord, dest.iSdst, dest.nSdst, regRec);
|
|
sqlite3TableAffinity(v, p, 0);
|
|
sqlite3VdbeAddOp2(v, OP_NewRowid, iCsr, regRowid);
|
|
sqlite3VdbeAddOp3(v, OP_Insert, iCsr, regRec, regRowid);
|
|
sqlite3VdbeGoto(v, addrInsLoop);
|
|
sqlite3VdbeJumpHere(v, addrInsLoop);
|
|
sqlite3VdbeAddOp1(v, OP_Close, iCsr);
|
|
}
|
|
|
|
/* Compute the complete text of the CREATE statement */
|
|
if( pSelect ){
|
|
zStmt = createTableStmt(db, p);
|
|
}else{
|
|
Token *pEnd2 = tabOpts ? &pParse->sLastToken : pEnd;
|
|
n = (int)(pEnd2->z - pParse->sNameToken.z);
|
|
if( pEnd2->z[0]!=';' ) n += pEnd2->n;
|
|
zStmt = sqlite3MPrintf(db,
|
|
"CREATE %s %.*s", zType2, n, pParse->sNameToken.z
|
|
);
|
|
}
|
|
|
|
/* A slot for the record has already been allocated in the
|
|
** schema table. We just need to update that slot with all
|
|
** the information we've collected.
|
|
*/
|
|
assert( pParse->isCreate );
|
|
sqlite3NestedParse(pParse,
|
|
"UPDATE %Q." LEGACY_SCHEMA_TABLE
|
|
" SET type='%s', name=%Q, tbl_name=%Q, rootpage=#%d, sql=%Q"
|
|
" WHERE rowid=#%d",
|
|
db->aDb[iDb].zDbSName,
|
|
zType,
|
|
p->zName,
|
|
p->zName,
|
|
pParse->u1.cr.regRoot,
|
|
zStmt,
|
|
pParse->u1.cr.regRowid
|
|
);
|
|
sqlite3DbFree(db, zStmt);
|
|
sqlite3ChangeCookie(pParse, iDb);
|
|
|
|
#ifndef SQLITE_OMIT_AUTOINCREMENT
|
|
/* Check to see if we need to create an sqlite_sequence table for
|
|
** keeping track of autoincrement keys.
|
|
*/
|
|
if( (p->tabFlags & TF_Autoincrement)!=0 && !IN_SPECIAL_PARSE ){
|
|
Db *pDb = &db->aDb[iDb];
|
|
assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
|
|
if( pDb->pSchema->pSeqTab==0 ){
|
|
sqlite3NestedParse(pParse,
|
|
"CREATE TABLE %Q.sqlite_sequence(name,seq)",
|
|
pDb->zDbSName
|
|
);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* Reparse everything to update our internal data structures */
|
|
sqlite3VdbeAddParseSchemaOp(v, iDb,
|
|
sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName),0);
|
|
|
|
/* Test for cycles in generated columns and illegal expressions
|
|
** in CHECK constraints and in DEFAULT clauses. */
|
|
if( p->tabFlags & TF_HasGenerated ){
|
|
sqlite3VdbeAddOp4(v, OP_SqlExec, 0x0001, 0, 0,
|
|
sqlite3MPrintf(db, "SELECT*FROM\"%w\".\"%w\"",
|
|
db->aDb[iDb].zDbSName, p->zName), P4_DYNAMIC);
|
|
}
|
|
}
|
|
|
|
/* Add the table to the in-memory representation of the database.
|
|
*/
|
|
if( db->init.busy ){
|
|
Table *pOld;
|
|
Schema *pSchema = p->pSchema;
|
|
assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
|
|
assert( HasRowid(p) || p->iPKey<0 );
|
|
pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p);
|
|
if( pOld ){
|
|
assert( p==pOld ); /* Malloc must have failed inside HashInsert() */
|
|
sqlite3OomFault(db);
|
|
return;
|
|
}
|
|
pParse->pNewTable = 0;
|
|
db->mDbFlags |= DBFLAG_SchemaChange;
|
|
|
|
/* If this is the magic sqlite_sequence table used by autoincrement,
|
|
** then record a pointer to this table in the main database structure
|
|
** so that INSERT can find the table easily. */
|
|
assert( !pParse->nested );
|
|
#ifndef SQLITE_OMIT_AUTOINCREMENT
|
|
if( strcmp(p->zName, "sqlite_sequence")==0 ){
|
|
assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
|
|
p->pSchema->pSeqTab = p;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#ifndef SQLITE_OMIT_ALTERTABLE
|
|
if( !pSelect && IsOrdinaryTable(p) ){
|
|
assert( pCons && pEnd );
|
|
if( pCons->z==0 ){
|
|
pCons = pEnd;
|
|
}
|
|
p->u.tab.addColOffset = 13 + (int)(pCons->z - pParse->sNameToken.z);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#ifndef SQLITE_OMIT_VIEW
|
|
/*
|
|
** The parser calls this routine in order to create a new VIEW
|
|
*/
|
|
void sqlite3CreateView(
|
|
Parse *pParse, /* The parsing context */
|
|
Token *pBegin, /* The CREATE token that begins the statement */
|
|
Token *pName1, /* The token that holds the name of the view */
|
|
Token *pName2, /* The token that holds the name of the view */
|
|
ExprList *pCNames, /* Optional list of view column names */
|
|
Select *pSelect, /* A SELECT statement that will become the new view */
|
|
int isTemp, /* TRUE for a TEMPORARY view */
|
|
int noErr /* Suppress error messages if VIEW already exists */
|
|
){
|
|
Table *p;
|
|
int n;
|
|
const char *z;
|
|
Token sEnd;
|
|
DbFixer sFix;
|
|
Token *pName = 0;
|
|
int iDb;
|
|
sqlite3 *db = pParse->db;
|
|
|
|
if( pParse->nVar>0 ){
|
|
sqlite3ErrorMsg(pParse, "parameters are not allowed in views");
|
|
goto create_view_fail;
|
|
}
|
|
sqlite3StartTable(pParse, pName1, pName2, isTemp, 1, 0, noErr);
|
|
p = pParse->pNewTable;
|
|
if( p==0 || pParse->nErr ) goto create_view_fail;
|
|
|
|
/* Legacy versions of SQLite allowed the use of the magic "rowid" column
|
|
** on a view, even though views do not have rowids. The following flag
|
|
** setting fixes this problem. But the fix can be disabled by compiling
|
|
** with -DSQLITE_ALLOW_ROWID_IN_VIEW in case there are legacy apps that
|
|
** depend upon the old buggy behavior. The ability can also be toggled
|
|
** using sqlite3_config(SQLITE_CONFIG_ROWID_IN_VIEW,...) */
|
|
#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
|
|
p->tabFlags |= sqlite3Config.mNoVisibleRowid; /* Optional. Allow by default */
|
|
#else
|
|
p->tabFlags |= TF_NoVisibleRowid; /* Never allow rowid in view */
|
|
#endif
|
|
|
|
sqlite3TwoPartName(pParse, pName1, pName2, &pName);
|
|
iDb = sqlite3SchemaToIndex(db, p->pSchema);
|
|
sqlite3FixInit(&sFix, pParse, iDb, "view", pName);
|
|
if( sqlite3FixSelect(&sFix, pSelect) ) goto create_view_fail;
|
|
|
|
/* Make a copy of the entire SELECT statement that defines the view.
|
|
** This will force all the Expr.token.z values to be dynamically
|
|
** allocated rather than point to the input string - which means that
|
|
** they will persist after the current sqlite3_exec() call returns.
|
|
*/
|
|
pSelect->selFlags |= SF_View;
|
|
if( IN_RENAME_OBJECT ){
|
|
p->u.view.pSelect = pSelect;
|
|
pSelect = 0;
|
|
}else{
|
|
p->u.view.pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
|
|
}
|
|
p->pCheck = sqlite3ExprListDup(db, pCNames, EXPRDUP_REDUCE);
|
|
p->eTabType = TABTYP_VIEW;
|
|
if( db->mallocFailed ) goto create_view_fail;
|
|
|
|
/* Locate the end of the CREATE VIEW statement. Make sEnd point to
|
|
** the end.
|
|
*/
|
|
sEnd = pParse->sLastToken;
|
|
assert( sEnd.z[0]!=0 || sEnd.n==0 );
|
|
if( sEnd.z[0]!=';' ){
|
|
sEnd.z += sEnd.n;
|
|
}
|
|
sEnd.n = 0;
|
|
n = (int)(sEnd.z - pBegin->z);
|
|
assert( n>0 );
|
|
z = pBegin->z;
|
|
while( sqlite3Isspace(z[n-1]) ){ n--; }
|
|
sEnd.z = &z[n-1];
|
|
sEnd.n = 1;
|
|
|
|
/* Use sqlite3EndTable() to add the view to the schema table */
|
|
sqlite3EndTable(pParse, 0, &sEnd, 0, 0);
|
|
|
|
create_view_fail:
|
|
sqlite3SelectDelete(db, pSelect);
|
|
if( IN_RENAME_OBJECT ){
|
|
sqlite3RenameExprlistUnmap(pParse, pCNames);
|
|
}
|
|
sqlite3ExprListDelete(db, pCNames);
|
|
return;
|
|
}
|
|
#endif /* SQLITE_OMIT_VIEW */
|
|
|
|
#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
|
|
/*
|
|
** The Table structure pTable is really a VIEW. Fill in the names of
|
|
** the columns of the view in the pTable structure. Return non-zero if
|
|
** there are errors. If an error is seen an error message is left
|
|
** in pParse->zErrMsg.
|
|
*/
|
|
static SQLITE_NOINLINE int viewGetColumnNames(Parse *pParse, Table *pTable){
|
|
Table *pSelTab; /* A fake table from which we get the result set */
|
|
Select *pSel; /* Copy of the SELECT that implements the view */
|
|
int nErr = 0; /* Number of errors encountered */
|
|
sqlite3 *db = pParse->db; /* Database connection for malloc errors */
|
|
#ifndef SQLITE_OMIT_VIRTUALTABLE
|
|
int rc;
|
|
#endif
|
|
#ifndef SQLITE_OMIT_AUTHORIZATION
|
|
sqlite3_xauth xAuth; /* Saved xAuth pointer */
|
|
#endif
|
|
|
|
assert( pTable );
|
|
|
|
#ifndef SQLITE_OMIT_VIRTUALTABLE
|
|
if( IsVirtual(pTable) ){
|
|
db->nSchemaLock++;
|
|
rc = sqlite3VtabCallConnect(pParse, pTable);
|
|
db->nSchemaLock--;
|
|
return rc;
|
|
}
|
|
#endif
|
|
|
|
#ifndef SQLITE_OMIT_VIEW
|
|
/* A positive nCol means the columns names for this view are
|
|
** already known. This routine is not called unless either the
|
|
** table is virtual or nCol is zero.
|
|
*/
|
|
assert( pTable->nCol<=0 );
|
|
|
|
/* A negative nCol is a special marker meaning that we are currently
|
|
** trying to compute the column names. If we enter this routine with
|
|
** a negative nCol, it means two or more views form a loop, like this:
|
|
**
|
|
** CREATE VIEW one AS SELECT * FROM two;
|
|
** CREATE VIEW two AS SELECT * FROM one;
|
|
**
|
|
** Actually, the error above is now caught prior to reaching this point.
|
|
** But the following test is still important as it does come up
|
|
** in the following:
|
|
**
|
|
** CREATE TABLE main.ex1(a);
|
|
** CREATE TEMP VIEW ex1 AS SELECT a FROM ex1;
|
|
** SELECT * FROM temp.ex1;
|
|
*/
|
|
if( pTable->nCol<0 ){
|
|
sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
|
|
return 1;
|
|
}
|
|
assert( pTable->nCol>=0 );
|
|
|
|
/* If we get this far, it means we need to compute the table names.
|
|
** Note that the call to sqlite3ResultSetOfSelect() will expand any
|
|
** "*" elements in the results set of the view and will assign cursors
|
|
** to the elements of the FROM clause. But we do not want these changes
|
|
** to be permanent. So the computation is done on a copy of the SELECT
|
|
** statement that defines the view.
|
|
*/
|
|
assert( IsView(pTable) );
|
|
pSel = sqlite3SelectDup(db, pTable->u.view.pSelect, 0);
|
|
if( pSel ){
|
|
u8 eParseMode = pParse->eParseMode;
|
|
int nTab = pParse->nTab;
|
|
int nSelect = pParse->nSelect;
|
|
pParse->eParseMode = PARSE_MODE_NORMAL;
|
|
sqlite3SrcListAssignCursors(pParse, pSel->pSrc);
|
|
pTable->nCol = -1;
|
|
DisableLookaside;
|
|
#ifndef SQLITE_OMIT_AUTHORIZATION
|
|
xAuth = db->xAuth;
|
|
db->xAuth = 0;
|
|
pSelTab = sqlite3ResultSetOfSelect(pParse, pSel, SQLITE_AFF_NONE);
|
|
db->xAuth = xAuth;
|
|
#else
|
|
pSelTab = sqlite3ResultSetOfSelect(pParse, pSel, SQLITE_AFF_NONE);
|
|
#endif
|
|
pParse->nTab = nTab;
|
|
pParse->nSelect = nSelect;
|
|
if( pSelTab==0 ){
|
|
pTable->nCol = 0;
|
|
nErr++;
|
|
}else if( pTable->pCheck ){
|
|
/* CREATE VIEW name(arglist) AS ...
|
|
** The names of the columns in the table are taken from
|
|
** arglist which is stored in pTable->pCheck. The pCheck field
|
|
** normally holds CHECK constraints on an ordinary table, but for
|
|
** a VIEW it holds the list of column names.
|
|
*/
|
|
sqlite3ColumnsFromExprList(pParse, pTable->pCheck,
|
|
&pTable->nCol, &pTable->aCol);
|
|
if( pParse->nErr==0
|
|
&& pTable->nCol==pSel->pEList->nExpr
|
|
){
|
|
assert( db->mallocFailed==0 );
|
|
sqlite3SubqueryColumnTypes(pParse, pTable, pSel, SQLITE_AFF_NONE);
|
|
}
|
|
}else{
|
|
/* CREATE VIEW name AS... without an argument list. Construct
|
|
** the column names from the SELECT statement that defines the view.
|
|
*/
|
|
assert( pTable->aCol==0 );
|
|
pTable->nCol = pSelTab->nCol;
|
|
pTable->aCol = pSelTab->aCol;
|
|
pTable->tabFlags |= (pSelTab->tabFlags & COLFLAG_NOINSERT);
|
|
pSelTab->nCol = 0;
|
|
pSelTab->aCol = 0;
|
|
assert( sqlite3SchemaMutexHeld(db, 0, pTable->pSchema) );
|
|
}
|
|
pTable->nNVCol = pTable->nCol;
|
|
sqlite3DeleteTable(db, pSelTab);
|
|
sqlite3SelectDelete(db, pSel);
|
|
EnableLookaside;
|
|
pParse->eParseMode = eParseMode;
|
|
} else {
|
|
nErr++;
|
|
}
|
|
pTable->pSchema->schemaFlags |= DB_UnresetViews;
|
|
if( db->mallocFailed ){
|
|
sqlite3DeleteColumnNames(db, pTable);
|
|
}
|
|
#endif /* SQLITE_OMIT_VIEW */
|
|
return nErr + pParse->nErr;
|
|
}
|
|
int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
|
|
assert( pTable!=0 );
|
|
if( !IsVirtual(pTable) && pTable->nCol>0 ) return 0;
|
|
return viewGetColumnNames(pParse, pTable);
|
|
}
|
|
#endif /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */
|
|
|
|
#ifndef SQLITE_OMIT_VIEW
|
|
/*
|
|
** Clear the column names from every VIEW in database idx.
|
|
*/
|
|
static void sqliteViewResetAll(sqlite3 *db, int idx){
|
|
HashElem *i;
|
|
assert( sqlite3SchemaMutexHeld(db, idx, 0) );
|
|
if( !DbHasProperty(db, idx, DB_UnresetViews) ) return;
|
|
for(i=sqliteHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqliteHashNext(i)){
|
|
Table *pTab = sqliteHashData(i);
|
|
if( IsView(pTab) ){
|
|
sqlite3DeleteColumnNames(db, pTab);
|
|
}
|
|
}
|
|
DbClearProperty(db, idx, DB_UnresetViews);
|
|
}
|
|
#else
|
|
# define sqliteViewResetAll(A,B)
|
|
#endif /* SQLITE_OMIT_VIEW */
|
|
|
|
/*
|
|
** This function is called by the VDBE to adjust the internal schema
|
|
** used by SQLite when the btree layer moves a table root page. The
|
|
** root-page of a table or index in database iDb has changed from iFrom
|
|
** to iTo.
|
|
**
|
|
** Ticket #1728: The symbol table might still contain information
|
|
** on tables and/or indices that are the process of being deleted.
|
|
** If you are unlucky, one of those deleted indices or tables might
|
|
** have the same rootpage number as the real table or index that is
|
|
** being moved. So we cannot stop searching after the first match
|
|
** because the first match might be for one of the deleted indices
|
|
** or tables and not the table/index that is actually being moved.
|
|
** We must continue looping until all tables and indices with
|
|
** rootpage==iFrom have been converted to have a rootpage of iTo
|
|
** in order to be certain that we got the right one.
|
|
*/
|
|
#ifndef SQLITE_OMIT_AUTOVACUUM
|
|
void sqlite3RootPageMoved(sqlite3 *db, int iDb, Pgno iFrom, Pgno iTo){
|
|
HashElem *pElem;
|
|
Hash *pHash;
|
|
Db *pDb;
|
|
|
|
assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
|
|
pDb = &db->aDb[iDb];
|
|
pHash = &pDb->pSchema->tblHash;
|
|
for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
|
|
Table *pTab = sqliteHashData(pElem);
|
|
if( pTab->tnum==iFrom ){
|
|
pTab->tnum = iTo;
|
|
}
|
|
}
|
|
pHash = &pDb->pSchema->idxHash;
|
|
for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
|
|
Index *pIdx = sqliteHashData(pElem);
|
|
if( pIdx->tnum==iFrom ){
|
|
pIdx->tnum = iTo;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
** Write code to erase the table with root-page iTable from database iDb.
|
|
** Also write code to modify the sqlite_schema table and internal schema
|
|
** if a root-page of another table is moved by the btree-layer whilst
|
|
** erasing iTable (this can happen with an auto-vacuum database).
|
|
*/
|
|
static void destroyRootPage(Parse *pParse, int iTable, int iDb){
|
|
Vdbe *v = sqlite3GetVdbe(pParse);
|
|
int r1 = sqlite3GetTempReg(pParse);
|
|
if( iTable<2 ) sqlite3ErrorMsg(pParse, "corrupt schema");
|
|
sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
|
|
sqlite3MayAbort(pParse);
|
|
#ifndef SQLITE_OMIT_AUTOVACUUM
|
|
/* OP_Destroy stores an in integer r1. If this integer
|
|
** is non-zero, then it is the root page number of a table moved to
|
|
** location iTable. The following code modifies the sqlite_schema table to
|
|
** reflect this.
|
|
**
|
|
** The "#NNN" in the SQL is a special constant that means whatever value
|
|
** is in register NNN. See grammar rules associated with the TK_REGISTER
|
|
** token for additional information.
|
|
*/
|
|
sqlite3NestedParse(pParse,
|
|
"UPDATE %Q." LEGACY_SCHEMA_TABLE
|
|
" SET rootpage=%d WHERE #%d AND rootpage=#%d",
|
|
pParse->db->aDb[iDb].zDbSName, iTable, r1, r1);
|
|
#endif
|
|
sqlite3ReleaseTempReg(pParse, r1);
|
|
}
|
|
|
|
/*
|
|
** Write VDBE code to erase table pTab and all associated indices on disk.
|
|
** Code to update the sqlite_schema tables and internal schema definitions
|
|
** in case a root-page belonging to another table is moved by the btree layer
|
|
** is also added (this can happen with an auto-vacuum database).
|
|
*/
|
|
static void destroyTable(Parse *pParse, Table *pTab){
|
|
/* If the database may be auto-vacuum capable (if SQLITE_OMIT_AUTOVACUUM
|
|
** is not defined), then it is important to call OP_Destroy on the
|
|
** table and index root-pages in order, starting with the numerically
|
|
** largest root-page number. This guarantees that none of the root-pages
|
|
** to be destroyed is relocated by an earlier OP_Destroy. i.e. if the
|
|
** following were coded:
|
|
**
|
|
** OP_Destroy 4 0
|
|
** ...
|
|
** OP_Destroy 5 0
|
|
**
|
|
** and root page 5 happened to be the largest root-page number in the
|
|
** database, then root page 5 would be moved to page 4 by the
|
|
** "OP_Destroy 4 0" opcode. The subsequent "OP_Destroy 5 0" would hit
|
|
** a free-list page.
|
|
*/
|
|
Pgno iTab = pTab->tnum;
|
|
Pgno iDestroyed = 0;
|
|
|
|
while( 1 ){
|
|
Index *pIdx;
|
|
Pgno iLargest = 0;
|
|
|
|
if( iDestroyed==0 || iTab<iDestroyed ){
|
|
iLargest = iTab;
|
|
}
|
|
for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
|
|
Pgno iIdx = pIdx->tnum;
|
|
assert( pIdx->pSchema==pTab->pSchema );
|
|
if( (iDestroyed==0 || (iIdx<iDestroyed)) && iIdx>iLargest ){
|
|
iLargest = iIdx;
|
|
}
|
|
}
|
|
if( iLargest==0 ){
|
|
return;
|
|
}else{
|
|
int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
|
|
assert( iDb>=0 && iDb<pParse->db->nDb );
|
|
destroyRootPage(pParse, iLargest, iDb);
|
|
iDestroyed = iLargest;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Remove entries from the sqlite_statN tables (for N in (1,2,3))
|
|
** after a DROP INDEX or DROP TABLE command.
|
|
*/
|
|
static void sqlite3ClearStatTables(
|
|
Parse *pParse, /* The parsing context */
|
|
int iDb, /* The database number */
|
|
const char *zType, /* "idx" or "tbl" */
|
|
const char *zName /* Name of index or table */
|
|
){
|
|
int i;
|
|
const char *zDbName = pParse->db->aDb[iDb].zDbSName;
|
|
for(i=1; i<=4; i++){
|
|
char zTab[24];
|
|
sqlite3_snprintf(sizeof(zTab),zTab,"sqlite_stat%d",i);
|
|
if( sqlite3FindTable(pParse->db, zTab, zDbName) ){
|
|
sqlite3NestedParse(pParse,
|
|
"DELETE FROM %Q.%s WHERE %s=%Q",
|
|
zDbName, zTab, zType, zName
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Generate code to drop a table.
|
|
*/
|
|
void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){
|
|
Vdbe *v;
|
|
sqlite3 *db = pParse->db;
|
|
Trigger *pTrigger;
|
|
Db *pDb = &db->aDb[iDb];
|
|
|
|
v = sqlite3GetVdbe(pParse);
|
|
assert( v!=0 );
|
|
sqlite3BeginWriteOperation(pParse, 1, iDb);
|
|
|
|
#ifndef SQLITE_OMIT_VIRTUALTABLE
|
|
if( IsVirtual(pTab) ){
|
|
sqlite3VdbeAddOp0(v, OP_VBegin);
|
|
}
|
|
#endif
|
|
|
|
/* Drop all triggers associated with the table being dropped. Code
|
|
** is generated to remove entries from sqlite_schema and/or
|
|
** sqlite_temp_schema if required.
|
|
*/
|
|
pTrigger = sqlite3TriggerList(pParse, pTab);
|
|
while( pTrigger ){
|
|
assert( pTrigger->pSchema==pTab->pSchema ||
|
|
pTrigger->pSchema==db->aDb[1].pSchema );
|
|
sqlite3DropTriggerPtr(pParse, pTrigger);
|
|
pTrigger = pTrigger->pNext;
|
|
}
|
|
|
|
#ifndef SQLITE_OMIT_AUTOINCREMENT
|
|
/* Remove any entries of the sqlite_sequence table associated with
|
|
** the table being dropped. This is done before the table is dropped
|
|
** at the btree level, in case the sqlite_sequence table needs to
|
|
** move as a result of the drop (can happen in auto-vacuum mode).
|
|
*/
|
|
if( pTab->tabFlags & TF_Autoincrement ){
|
|
sqlite3NestedParse(pParse,
|
|
"DELETE FROM %Q.sqlite_sequence WHERE name=%Q",
|
|
pDb->zDbSName, pTab->zName
|
|
);
|
|
}
|
|
#endif
|
|
|
|
/* Drop all entries in the schema table that refer to the
|
|
** table. The program name loops through the schema table and deletes
|
|
** every row that refers to a table of the same name as the one being
|
|
** dropped. Triggers are handled separately because a trigger can be
|
|
** created in the temp database that refers to a table in another
|
|
** database.
|
|
*/
|
|
sqlite3NestedParse(pParse,
|
|
"DELETE FROM %Q." LEGACY_SCHEMA_TABLE
|
|
" WHERE tbl_name=%Q and type!='trigger'",
|
|
pDb->zDbSName, pTab->zName);
|
|
if( !isView && !IsVirtual(pTab) ){
|
|
destroyTable(pParse, pTab);
|
|
}
|
|
|
|
/* Remove the table entry from SQLite's internal schema and modify
|
|
** the schema cookie.
|
|
*/
|
|
if( IsVirtual(pTab) ){
|
|
sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
|
|
sqlite3MayAbort(pParse);
|
|
}
|
|
sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
|
|
sqlite3ChangeCookie(pParse, iDb);
|
|
sqliteViewResetAll(db, iDb);
|
|
}
|
|
|
|
/*
|
|
** Return TRUE if shadow tables should be read-only in the current
|
|
** context.
|
|
*/
|
|
int sqlite3ReadOnlyShadowTables(sqlite3 *db){
|
|
#ifndef SQLITE_OMIT_VIRTUALTABLE
|
|
if( (db->flags & SQLITE_Defensive)!=0
|
|
&& db->pVtabCtx==0
|
|
&& db->nVdbeExec==0
|
|
&& !sqlite3VtabInSync(db)
|
|
){
|
|
return 1;
|
|
}
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
** Return true if it is not allowed to drop the given table
|
|
*/
|
|
static int tableMayNotBeDropped(sqlite3 *db, Table *pTab){
|
|
if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
|
|
if( sqlite3StrNICmp(pTab->zName+7, "stat", 4)==0 ) return 0;
|
|
if( sqlite3StrNICmp(pTab->zName+7, "parameters", 10)==0 ) return 0;
|
|
return 1;
|
|
}
|
|
if( (pTab->tabFlags & TF_Shadow)!=0 && sqlite3ReadOnlyShadowTables(db) ){
|
|
return 1;
|
|
}
|
|
if( pTab->tabFlags & TF_Eponymous ){
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
** This routine is called to do the work of a DROP TABLE statement.
|
|
** pName is the name of the table to be dropped.
|
|
*/
|
|
void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){
|
|
Table *pTab;
|
|
Vdbe *v;
|
|
sqlite3 *db = pParse->db;
|
|
int iDb;
|
|
|
|
if( db->mallocFailed ){
|
|
goto exit_drop_table;
|
|
}
|
|
assert( pParse->nErr==0 );
|
|
assert( pName->nSrc==1 );
|
|
assert( pName->a[0].fg.fixedSchema==0 );
|
|
assert( pName->a[0].fg.isSubquery==0 );
|
|
if( sqlite3ReadSchema(pParse) ) goto exit_drop_table;
|
|
if( noErr ) db->suppressErr++;
|
|
assert( isView==0 || isView==LOCATE_VIEW );
|
|
pTab = sqlite3LocateTableItem(pParse, isView, &pName->a[0]);
|
|
if( noErr ) db->suppressErr--;
|
|
|
|
if( pTab==0 ){
|
|
if( noErr ){
|
|
sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].u4.zDatabase);
|
|
sqlite3ForceNotReadOnly(pParse);
|
|
}
|
|
goto exit_drop_table;
|
|
}
|
|
iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
|
|
assert( iDb>=0 && iDb<db->nDb );
|
|
|
|
/* If pTab is a virtual table, call ViewGetColumnNames() to ensure
|
|
** it is initialized.
|
|
*/
|
|
if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){
|
|
goto exit_drop_table;
|
|
}
|
|
#ifndef SQLITE_OMIT_AUTHORIZATION
|
|
{
|
|
int code;
|
|
const char *zTab = SCHEMA_TABLE(iDb);
|
|
const char *zDb = db->aDb[iDb].zDbSName;
|
|
const char *zArg2 = 0;
|
|
if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){
|
|
goto exit_drop_table;
|
|
}
|
|
if( isView ){
|
|
if( !OMIT_TEMPDB && iDb==1 ){
|
|
code = SQLITE_DROP_TEMP_VIEW;
|
|
}else{
|
|
code = SQLITE_DROP_VIEW;
|
|
}
|
|
#ifndef SQLITE_OMIT_VIRTUALTABLE
|
|
}else if( IsVirtual(pTab) ){
|
|
code = SQLITE_DROP_VTABLE;
|
|
zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
|
|
#endif
|
|
}else{
|
|
if( !OMIT_TEMPDB && iDb==1 ){
|
|
code = SQLITE_DROP_TEMP_TABLE;
|
|
}else{
|
|
code = SQLITE_DROP_TABLE;
|
|
}
|
|
}
|
|
if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
|
|
goto exit_drop_table;
|
|
}
|
|
if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
|
|
goto exit_drop_table;
|
|
}
|
|
}
|
|
#endif
|
|
if( tableMayNotBeDropped(db, pTab) ){
|
|
sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
|
|
goto exit_drop_table;
|
|
}
|
|
|
|
#ifndef SQLITE_OMIT_VIEW
|
|
/* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
|
|
** on a table.
|
|
*/
|
|
if( isView && !IsView(pTab) ){
|
|
sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
|
|
goto exit_drop_table;
|
|
}
|
|
if( !isView && IsView(pTab) ){
|
|
sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
|
|
goto exit_drop_table;
|
|
}
|
|
#endif
|
|
|
|
/* Generate code to remove the table from the schema table
|
|
** on disk.
|
|
*/
|
|
v = sqlite3GetVdbe(pParse);
|
|
if( v ){
|
|
sqlite3BeginWriteOperation(pParse, 1, iDb);
|
|
if( !isView ){
|
|
sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
|
|
sqlite3FkDropTable(pParse, pName, pTab);
|
|
}
|
|
sqlite3CodeDropTable(pParse, pTab, iDb, isView);
|
|
}
|
|
|
|
exit_drop_table:
|
|
sqlite3SrcListDelete(db, pName);
|
|
}
|
|
|
|
/*
|
|
** This routine is called to create a new foreign key on the table
|
|
** currently under construction. pFromCol determines which columns
|
|
** in the current table point to the foreign key. If pFromCol==0 then
|
|
** connect the key to the last column inserted. pTo is the name of
|
|
** the table referred to (a.k.a the "parent" table). pToCol is a list
|
|
** of tables in the parent pTo table. flags contains all
|
|
** information about the conflict resolution algorithms specified
|
|
** in the ON DELETE, ON UPDATE and ON INSERT clauses.
|
|
**
|
|
** An FKey structure is created and added to the table currently
|
|
** under construction in the pParse->pNewTable field.
|
|
**
|
|
** The foreign key is set for IMMEDIATE processing. A subsequent call
|
|
** to sqlite3DeferForeignKey() might change this to DEFERRED.
|
|
*/
|
|
void sqlite3CreateForeignKey(
|
|
Parse *pParse, /* Parsing context */
|
|
ExprList *pFromCol, /* Columns in this table that point to other table */
|
|
Token *pTo, /* Name of the other table */
|
|
ExprList *pToCol, /* Columns in the other table */
|
|
int flags /* Conflict resolution algorithms. */
|
|
){
|
|
sqlite3 *db = pParse->db;
|
|
#ifndef SQLITE_OMIT_FOREIGN_KEY
|
|
FKey *pFKey = 0;
|
|
FKey *pNextTo;
|
|
Table *p = pParse->pNewTable;
|
|
i64 nByte;
|
|
int i;
|
|
int nCol;
|
|
char *z;
|
|
|
|
assert( pTo!=0 );
|
|
if( p==0 || IN_DECLARE_VTAB ) goto fk_end;
|
|
if( pFromCol==0 ){
|
|
int iCol = p->nCol-1;
|
|
if( NEVER(iCol<0) ) goto fk_end;
|
|
if( pToCol && pToCol->nExpr!=1 ){
|
|
sqlite3ErrorMsg(pParse, "foreign key on %s"
|
|
" should reference only one column of table %T",
|
|
p->aCol[iCol].zCnName, pTo);
|
|
goto fk_end;
|
|
}
|
|
nCol = 1;
|
|
}else if( pToCol && pToCol->nExpr!=pFromCol->nExpr ){
|
|
sqlite3ErrorMsg(pParse,
|
|
"number of columns in foreign key does not match the number of "
|
|
"columns in the referenced table");
|
|
goto fk_end;
|
|
}else{
|
|
nCol = pFromCol->nExpr;
|
|
}
|
|
nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
|
|
if( pToCol ){
|
|
for(i=0; i<pToCol->nExpr; i++){
|
|
nByte += sqlite3Strlen30(pToCol->a[i].zEName) + 1;
|
|
}
|
|
}
|
|
pFKey = sqlite3DbMallocZero(db, nByte );
|
|
if( pFKey==0 ){
|
|
goto fk_end;
|
|
}
|
|
pFKey->pFrom = p;
|
|
assert( IsOrdinaryTable(p) );
|
|
pFKey->pNextFrom = p->u.tab.pFKey;
|
|
z = (char*)&pFKey->aCol[nCol];
|
|
pFKey->zTo = z;
|
|
if( IN_RENAME_OBJECT ){
|
|
sqlite3RenameTokenMap(pParse, (void*)z, pTo);
|
|
}
|
|
memcpy(z, pTo->z, pTo->n);
|
|
z[pTo->n] = 0;
|
|
sqlite3Dequote(z);
|
|
z += pTo->n+1;
|
|
pFKey->nCol = nCol;
|
|
if( pFromCol==0 ){
|
|
pFKey->aCol[0].iFrom = p->nCol-1;
|
|
}else{
|
|
for(i=0; i<nCol; i++){
|
|
int j;
|
|
for(j=0; j<p->nCol; j++){
|
|
if( sqlite3StrICmp(p->aCol[j].zCnName, pFromCol->a[i].zEName)==0 ){
|
|
pFKey->aCol[i].iFrom = j;
|
|
break;
|
|
}
|
|
}
|
|
if( j>=p->nCol ){
|
|
sqlite3ErrorMsg(pParse,
|
|
"unknown column \"%s\" in foreign key definition",
|
|
pFromCol->a[i].zEName);
|
|
goto fk_end;
|
|
}
|
|
if( IN_RENAME_OBJECT ){
|
|
sqlite3RenameTokenRemap(pParse, &pFKey->aCol[i], pFromCol->a[i].zEName);
|
|
}
|
|
}
|
|
}
|
|
if( pToCol ){
|
|
for(i=0; i<nCol; i++){
|
|
int n = sqlite3Strlen30(pToCol->a[i].zEName);
|
|
pFKey->aCol[i].zCol = z;
|
|
if( IN_RENAME_OBJECT ){
|
|
sqlite3RenameTokenRemap(pParse, z, pToCol->a[i].zEName);
|
|
}
|
|
memcpy(z, pToCol->a[i].zEName, n);
|
|
z[n] = 0;
|
|
z += n+1;
|
|
}
|
|
}
|
|
pFKey->isDeferred = 0;
|
|
pFKey->aAction[0] = (u8)(flags & 0xff); /* ON DELETE action */
|
|
pFKey->aAction[1] = (u8)((flags >> 8 ) & 0xff); /* ON UPDATE action */
|
|
|
|
assert( sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
|
|
pNextTo = (FKey *)sqlite3HashInsert(&p->pSchema->fkeyHash,
|
|
pFKey->zTo, (void *)pFKey
|
|
);
|
|
if( pNextTo==pFKey ){
|
|
sqlite3OomFault(db);
|
|
goto fk_end;
|
|
}
|
|
if( pNextTo ){
|
|
assert( pNextTo->pPrevTo==0 );
|
|
pFKey->pNextTo = pNextTo;
|
|
pNextTo->pPrevTo = pFKey;
|
|
}
|
|
|
|
/* Link the foreign key to the table as the last step.
|
|
*/
|
|
assert( IsOrdinaryTable(p) );
|
|
p->u.tab.pFKey = pFKey;
|
|
pFKey = 0;
|
|
|
|
fk_end:
|
|
sqlite3DbFree(db, pFKey);
|
|
#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
|
|
sqlite3ExprListDelete(db, pFromCol);
|
|
sqlite3ExprListDelete(db, pToCol);
|
|
}
|
|
|
|
/*
|
|
** This routine is called when an INITIALLY IMMEDIATE or INITIALLY DEFERRED
|
|
** clause is seen as part of a foreign key definition. The isDeferred
|
|
** parameter is 1 for INITIALLY DEFERRED and 0 for INITIALLY IMMEDIATE.
|
|
** The behavior of the most recently created foreign key is adjusted
|
|
** accordingly.
|
|
*/
|
|
void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){
|
|
#ifndef SQLITE_OMIT_FOREIGN_KEY
|
|
Table *pTab;
|
|
FKey *pFKey;
|
|
if( (pTab = pParse->pNewTable)==0 ) return;
|
|
if( NEVER(!IsOrdinaryTable(pTab)) ) return;
|
|
if( (pFKey = pTab->u.tab.pFKey)==0 ) return;
|
|
assert( isDeferred==0 || isDeferred==1 ); /* EV: R-30323-21917 */
|
|
pFKey->isDeferred = (u8)isDeferred;
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
** Generate code that will erase and refill index *pIdx. This is
|
|
** used to initialize a newly created index or to recompute the
|
|
** content of an index in response to a REINDEX command.
|
|
**
|
|
** if memRootPage is not negative, it means that the index is newly
|
|
** created. The register specified by memRootPage contains the
|
|
** root page number of the index. If memRootPage is negative, then
|
|
** the index already exists and must be cleared before being refilled and
|
|
** the root page number of the index is taken from pIndex->tnum.
|
|
*/
|
|
static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){
|
|
Table *pTab = pIndex->pTable; /* The table that is indexed */
|
|
int iTab = pParse->nTab++; /* Btree cursor used for pTab */
|
|
int iIdx = pParse->nTab++; /* Btree cursor used for pIndex */
|
|
int iSorter; /* Cursor opened by OpenSorter (if in use) */
|
|
int addr1; /* Address of top of loop */
|
|
int addr2; /* Address to jump to for next iteration */
|
|
Pgno tnum; /* Root page of index */
|
|
int iPartIdxLabel; /* Jump to this label to skip a row */
|
|
Vdbe *v; /* Generate code into this virtual machine */
|
|
KeyInfo *pKey; /* KeyInfo for index */
|
|
int regRecord; /* Register holding assembled index record */
|
|
sqlite3 *db = pParse->db; /* The database connection */
|
|
int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
|
|
|
|
#ifndef SQLITE_OMIT_AUTHORIZATION
|
|
if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
|
|
db->aDb[iDb].zDbSName ) ){
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
/* Require a write-lock on the table to perform this operation */
|
|
sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
|
|
|
|
v = sqlite3GetVdbe(pParse);
|
|
if( v==0 ) return;
|
|
if( memRootPage>=0 ){
|
|
tnum = (Pgno)memRootPage;
|
|
}else{
|
|
tnum = pIndex->tnum;
|
|
}
|
|
pKey = sqlite3KeyInfoOfIndex(pParse, pIndex);
|
|
assert( pKey!=0 || pParse->nErr );
|
|
|
|
/* Open the sorter cursor if we are to use one. */
|
|
iSorter = pParse->nTab++;
|
|
sqlite3VdbeAddOp4(v, OP_SorterOpen, iSorter, 0, pIndex->nKeyCol, (char*)
|
|
sqlite3KeyInfoRef(pKey), P4_KEYINFO);
|
|
|
|
/* Open the table. Loop through all rows of the table, inserting index
|
|
** records into the sorter. */
|
|
sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
|
|
addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0); VdbeCoverage(v);
|
|
regRecord = sqlite3GetTempReg(pParse);
|
|
sqlite3MultiWrite(pParse);
|
|
|
|
sqlite3GenerateIndexKey(pParse,pIndex,iTab,regRecord,0,&iPartIdxLabel,0,0);
|
|
sqlite3VdbeAddOp2(v, OP_SorterInsert, iSorter, regRecord);
|
|
sqlite3ResolvePartIdxLabel(pParse, iPartIdxLabel);
|
|
sqlite3VdbeAddOp2(v, OP_Next, iTab, addr1+1); VdbeCoverage(v);
|
|
sqlite3VdbeJumpHere(v, addr1);
|
|
if( memRootPage<0 ) sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb);
|
|
sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, (int)tnum, iDb,
|
|
(char *)pKey, P4_KEYINFO);
|
|
sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR|((memRootPage>=0)?OPFLAG_P2ISREG:0));
|
|
|
|
addr1 = sqlite3VdbeAddOp2(v, OP_SorterSort, iSorter, 0); VdbeCoverage(v);
|
|
if( IsUniqueIndex(pIndex) ){
|
|
int j2 = sqlite3VdbeGoto(v, 1);
|
|
addr2 = sqlite3VdbeCurrentAddr(v);
|
|
sqlite3VdbeVerifyAbortable(v, OE_Abort);
|
|
sqlite3VdbeAddOp4Int(v, OP_SorterCompare, iSorter, j2, regRecord,
|
|
pIndex->nKeyCol); VdbeCoverage(v);
|
|
sqlite3UniqueConstraint(pParse, OE_Abort, pIndex);
|
|
sqlite3VdbeJumpHere(v, j2);
|
|
}else{
|
|
/* Most CREATE INDEX and REINDEX statements that are not UNIQUE can not
|
|
** abort. The exception is if one of the indexed expressions contains a
|
|
** user function that throws an exception when it is evaluated. But the
|
|
** overhead of adding a statement journal to a CREATE INDEX statement is
|
|
** very small (since most of the pages written do not contain content that
|
|
** needs to be restored if the statement aborts), so we call
|
|
** sqlite3MayAbort() for all CREATE INDEX statements. */
|
|
sqlite3MayAbort(pParse);
|
|
addr2 = sqlite3VdbeCurrentAddr(v);
|
|
}
|
|
sqlite3VdbeAddOp3(v, OP_SorterData, iSorter, regRecord, iIdx);
|
|
if( !pIndex->bAscKeyBug ){
|
|
/* This OP_SeekEnd opcode makes index insert for a REINDEX go much
|
|
** faster by avoiding unnecessary seeks. But the optimization does
|
|
** not work for UNIQUE constraint indexes on WITHOUT ROWID tables
|
|
** with DESC primary keys, since those indexes have there keys in
|
|
** a different order from the main table.
|
|
** See ticket: https://www.sqlite.org/src/info/bba7b69f9849b5bf
|
|
*/
|
|
sqlite3VdbeAddOp1(v, OP_SeekEnd, iIdx);
|
|
}
|
|
sqlite3VdbeAddOp2(v, OP_IdxInsert, iIdx, regRecord);
|
|
sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
|
|
sqlite3ReleaseTempReg(pParse, regRecord);
|
|
sqlite3VdbeAddOp2(v, OP_SorterNext, iSorter, addr2); VdbeCoverage(v);
|
|
sqlite3VdbeJumpHere(v, addr1);
|
|
|
|
sqlite3VdbeAddOp1(v, OP_Close, iTab);
|
|
sqlite3VdbeAddOp1(v, OP_Close, iIdx);
|
|
sqlite3VdbeAddOp1(v, OP_Close, iSorter);
|
|
}
|
|
|
|
/*
|
|
** Allocate heap space to hold an Index object with nCol columns.
|
|
**
|
|
** Increase the allocation size to provide an extra nExtra bytes
|
|
** of 8-byte aligned space after the Index object and return a
|
|
** pointer to this extra space in *ppExtra.
|
|
*/
|
|
Index *sqlite3AllocateIndexObject(
|
|
sqlite3 *db, /* Database connection */
|
|
int nCol, /* Total number of columns in the index */
|
|
int nExtra, /* Number of bytes of extra space to alloc */
|
|
char **ppExtra /* Pointer to the "extra" space */
|
|
){
|
|
Index *p; /* Allocated index object */
|
|
i64 nByte; /* Bytes of space for Index object + arrays */
|
|
|
|
assert( nCol <= 2*db->aLimit[SQLITE_LIMIT_COLUMN] );
|
|
nByte = ROUND8(sizeof(Index)) + /* Index structure */
|
|
ROUND8(sizeof(char*)*nCol) + /* Index.azColl */
|
|
ROUND8(sizeof(LogEst)*(nCol+1) + /* Index.aiRowLogEst */
|
|
sizeof(i16)*nCol + /* Index.aiColumn */
|
|
sizeof(u8)*nCol); /* Index.aSortOrder */
|
|
p = sqlite3DbMallocZero(db, nByte + nExtra);
|
|
if( p ){
|
|
char *pExtra = ((char*)p)+ROUND8(sizeof(Index));
|
|
p->azColl = (const char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol);
|
|
p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
|
|
p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol;
|
|
p->aSortOrder = (u8*)pExtra;
|
|
assert( nCol>0 );
|
|
p->nColumn = (u16)nCol;
|
|
p->nKeyCol = (u16)(nCol - 1);
|
|
*ppExtra = ((char*)p) + nByte;
|
|
}
|
|
return p;
|
|
}
|
|
|
|
/*
|
|
** If expression list pList contains an expression that was parsed with
|
|
** an explicit "NULLS FIRST" or "NULLS LAST" clause, leave an error in
|
|
** pParse and return non-zero. Otherwise, return zero.
|
|
*/
|
|
int sqlite3HasExplicitNulls(Parse *pParse, ExprList *pList){
|
|
if( pList ){
|
|
int i;
|
|
for(i=0; i<pList->nExpr; i++){
|
|
if( pList->a[i].fg.bNulls ){
|
|
u8 sf = pList->a[i].fg.sortFlags;
|
|
sqlite3ErrorMsg(pParse, "unsupported use of NULLS %s",
|
|
(sf==0 || sf==3) ? "FIRST" : "LAST"
|
|
);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
** Create a new index for an SQL table. pName1.pName2 is the name of the index
|
|
** and pTblList is the name of the table that is to be indexed. Both will
|
|
** be NULL for a primary key or an index that is created to satisfy a
|
|
** UNIQUE constraint. If pTable and pIndex are NULL, use pParse->pNewTable
|
|
** as the table to be indexed. pParse->pNewTable is a table that is
|
|
** currently being constructed by a CREATE TABLE statement.
|
|
**
|
|
** pList is a list of columns to be indexed. pList will be NULL if this
|
|
** is a primary key or unique-constraint on the most recent column added
|
|
** to the table currently under construction.
|
|
*/
|
|
void sqlite3CreateIndex(
|
|
Parse *pParse, /* All information about this parse */
|
|
Token *pName1, /* First part of index name. May be NULL */
|
|
Token *pName2, /* Second part of index name. May be NULL */
|
|
SrcList *pTblName, /* Table to index. Use pParse->pNewTable if 0 */
|
|
ExprList *pList, /* A list of columns to be indexed */
|
|
int onError, /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
|
|
Token *pStart, /* The CREATE token that begins this statement */
|
|
Expr *pPIWhere, /* WHERE clause for partial indices */
|
|
int sortOrder, /* Sort order of primary key when pList==NULL */
|
|
int ifNotExist, /* Omit error if index already exists */
|
|
u8 idxType /* The index type */
|
|
){
|
|
Table *pTab = 0; /* Table to be indexed */
|
|
Index *pIndex = 0; /* The index to be created */
|
|
char *zName = 0; /* Name of the index */
|
|
int nName; /* Number of characters in zName */
|
|
int i, j;
|
|
DbFixer sFix; /* For assigning database names to pTable */
|
|
int sortOrderMask; /* 1 to honor DESC in index. 0 to ignore. */
|
|
sqlite3 *db = pParse->db;
|
|
Db *pDb; /* The specific table containing the indexed database */
|
|
int iDb; /* Index of the database that is being written */
|
|
Token *pName = 0; /* Unqualified name of the index to create */
|
|
struct ExprList_item *pListItem; /* For looping over pList */
|
|
int nExtra = 0; /* Space allocated for zExtra[] */
|
|
int nExtraCol; /* Number of extra columns needed */
|
|
char *zExtra = 0; /* Extra space after the Index object */
|
|
Index *pPk = 0; /* PRIMARY KEY index for WITHOUT ROWID tables */
|
|
|
|
assert( db->pParse==pParse );
|
|
if( pParse->nErr ){
|
|
goto exit_create_index;
|
|
}
|
|
assert( db->mallocFailed==0 );
|
|
if( IN_DECLARE_VTAB && idxType!=SQLITE_IDXTYPE_PRIMARYKEY ){
|
|
goto exit_create_index;
|
|
}
|
|
if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
|
|
goto exit_create_index;
|
|
}
|
|
if( sqlite3HasExplicitNulls(pParse, pList) ){
|
|
goto exit_create_index;
|
|
}
|
|
|
|
/*
|
|
** Find the table that is to be indexed. Return early if not found.
|
|
*/
|
|
if( pTblName!=0 ){
|
|
|
|
/* Use the two-part index name to determine the database
|
|
** to search for the table. 'Fix' the table name to this db
|
|
** before looking up the table.
|
|
*/
|
|
assert( pName1 && pName2 );
|
|
iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
|
|
if( iDb<0 ) goto exit_create_index;
|
|
assert( pName && pName->z );
|
|
|
|
#ifndef SQLITE_OMIT_TEMPDB
|
|
/* If the index name was unqualified, check if the table
|
|
** is a temp table. If so, set the database to 1. Do not do this
|
|
** if initializing a database schema.
|
|
*/
|
|
if( !db->init.busy ){
|
|
pTab = sqlite3SrcListLookup(pParse, pTblName);
|
|
if( pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){
|
|
iDb = 1;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
sqlite3FixInit(&sFix, pParse, iDb, "index", pName);
|
|
if( sqlite3FixSrcList(&sFix, pTblName) ){
|
|
/* Because the parser constructs pTblName from a single identifier,
|
|
** sqlite3FixSrcList can never fail. */
|
|
assert(0);
|
|
}
|
|
pTab = sqlite3LocateTableItem(pParse, 0, &pTblName->a[0]);
|
|
assert( db->mallocFailed==0 || pTab==0 );
|
|
if( pTab==0 ) goto exit_create_index;
|
|
if( iDb==1 && db->aDb[iDb].pSchema!=pTab->pSchema ){
|
|
sqlite3ErrorMsg(pParse,
|
|
"cannot create a TEMP index on non-TEMP table \"%s\"",
|
|
pTab->zName);
|
|
goto exit_create_index;
|
|
}
|
|
if( !HasRowid(pTab) ) pPk = sqlite3PrimaryKeyIndex(pTab);
|
|
}else{
|
|
assert( pName==0 );
|
|
assert( pStart==0 );
|
|
pTab = pParse->pNewTable;
|
|
if( !pTab ) goto exit_create_index;
|
|
iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
|
|
}
|
|
pDb = &db->aDb[iDb];
|
|
|
|
assert( pTab!=0 );
|
|
if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
|
|
&& db->init.busy==0
|
|
&& pTblName!=0
|
|
){
|
|
sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
|
|
goto exit_create_index;
|
|
}
|
|
#ifndef SQLITE_OMIT_VIEW
|
|
if( IsView(pTab) ){
|
|
sqlite3ErrorMsg(pParse, "views may not be indexed");
|
|
goto exit_create_index;
|
|
}
|
|
#endif
|
|
#ifndef SQLITE_OMIT_VIRTUALTABLE
|
|
if( IsVirtual(pTab) ){
|
|
sqlite3ErrorMsg(pParse, "virtual tables may not be indexed");
|
|
goto exit_create_index;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
** Find the name of the index. Make sure there is not already another
|
|
** index or table with the same name.
|
|
**
|
|
** Exception: If we are reading the names of permanent indices from the
|
|
** sqlite_schema table (because some other process changed the schema) and
|
|
** one of the index names collides with the name of a temporary table or
|
|
** index, then we will continue to process this index.
|
|
**
|
|
** If pName==0 it means that we are
|
|
** dealing with a primary key or UNIQUE constraint. We have to invent our
|
|
** own name.
|
|
*/
|
|
if( pName ){
|
|
zName = sqlite3NameFromToken(db, pName);
|
|
if( zName==0 ) goto exit_create_index;
|
|
assert( pName->z!=0 );
|
|
if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName,"index",pTab->zName) ){
|
|
goto exit_create_index;
|
|
}
|
|
if( !IN_RENAME_OBJECT ){
|
|
if( !db->init.busy ){
|
|
if( sqlite3FindTable(db, zName, pDb->zDbSName)!=0 ){
|
|
sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
|
|
goto exit_create_index;
|
|
}
|
|
}
|
|
if( sqlite3FindIndex(db, zName, pDb->zDbSName)!=0 ){
|
|
if( !ifNotExist ){
|
|
sqlite3ErrorMsg(pParse, "index %s already exists", zName);
|
|
}else{
|
|
assert( !db->init.busy );
|
|
sqlite3CodeVerifySchema(pParse, iDb);
|
|
sqlite3ForceNotReadOnly(pParse);
|
|
}
|
|
goto exit_create_index;
|
|
}
|
|
}
|
|
}else{
|
|
int n;
|
|
Index *pLoop;
|
|
for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
|
|
zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
|
|
if( zName==0 ){
|
|
goto exit_create_index;
|
|
}
|
|
|
|
/* Automatic index names generated from within sqlite3_declare_vtab()
|
|
** must have names that are distinct from normal automatic index names.
|
|
** The following statement converts "sqlite3_autoindex..." into
|
|
** "sqlite3_butoindex..." in order to make the names distinct.
|
|
** The "vtab_err.test" test demonstrates the need of this statement. */
|
|
if( IN_SPECIAL_PARSE ) zName[7]++;
|
|
}
|
|
|
|
/* Check for authorization to create an index.
|
|
*/
|
|
#ifndef SQLITE_OMIT_AUTHORIZATION
|
|
if( !IN_RENAME_OBJECT ){
|
|
const char *zDb = pDb->zDbSName;
|
|
if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
|
|
goto exit_create_index;
|
|
}
|
|
i = SQLITE_CREATE_INDEX;
|
|
if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX;
|
|
if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
|
|
goto exit_create_index;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* If pList==0, it means this routine was called to make a primary
|
|
** key out of the last column added to the table under construction.
|
|
** So create a fake list to simulate this.
|
|
*/
|
|
if( pList==0 ){
|
|
Token prevCol;
|
|
Column *pCol = &pTab->aCol[pTab->nCol-1];
|
|
pCol->colFlags |= COLFLAG_UNIQUE;
|
|
sqlite3TokenInit(&prevCol, pCol->zCnName);
|
|
pList = sqlite3ExprListAppend(pParse, 0,
|
|
sqlite3ExprAlloc(db, TK_ID, &prevCol, 0));
|
|
if( pList==0 ) goto exit_create_index;
|
|
assert( pList->nExpr==1 );
|
|
sqlite3ExprListSetSortOrder(pList, sortOrder, SQLITE_SO_UNDEFINED);
|
|
}else{
|
|
sqlite3ExprListCheckLength(pParse, pList, "index");
|
|
if( pParse->nErr ) goto exit_create_index;
|
|
}
|
|
|
|
/* Figure out how many bytes of space are required to store explicitly
|
|
** specified collation sequence names.
|
|
*/
|
|
for(i=0; i<pList->nExpr; i++){
|
|
Expr *pExpr = pList->a[i].pExpr;
|
|
assert( pExpr!=0 );
|
|
if( pExpr->op==TK_COLLATE ){
|
|
assert( !ExprHasProperty(pExpr, EP_IntValue) );
|
|
nExtra += (1 + sqlite3Strlen30(pExpr->u.zToken));
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Allocate the index structure.
|
|
*/
|
|
nName = sqlite3Strlen30(zName);
|
|
nExtraCol = pPk ? pPk->nKeyCol : 1;
|
|
assert( pList->nExpr + nExtraCol <= 32767 /* Fits in i16 */ );
|
|
pIndex = sqlite3AllocateIndexObject(db, pList->nExpr + nExtraCol,
|
|
nName + nExtra + 1, &zExtra);
|
|
if( db->mallocFailed ){
|
|
goto exit_create_index;
|
|
}
|
|
assert( EIGHT_BYTE_ALIGNMENT(pIndex->aiRowLogEst) );
|
|
assert( EIGHT_BYTE_ALIGNMENT(pIndex->azColl) );
|
|
pIndex->zName = zExtra;
|
|
zExtra += nName + 1;
|
|
memcpy(pIndex->zName, zName, nName+1);
|
|
pIndex->pTable = pTab;
|
|
pIndex->onError = (u8)onError;
|
|
pIndex->uniqNotNull = onError!=OE_None;
|
|
pIndex->idxType = idxType;
|
|
pIndex->pSchema = db->aDb[iDb].pSchema;
|
|
pIndex->nKeyCol = pList->nExpr;
|
|
if( pPIWhere ){
|
|
sqlite3ResolveSelfReference(pParse, pTab, NC_PartIdx, pPIWhere, 0);
|
|
pIndex->pPartIdxWhere = pPIWhere;
|
|
pPIWhere = 0;
|
|
}
|
|
assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
|
|
|
|
/* Check to see if we should honor DESC requests on index columns
|
|
*/
|
|
if( pDb->pSchema->file_format>=4 ){
|
|
sortOrderMask = -1; /* Honor DESC */
|
|
}else{
|
|
sortOrderMask = 0; /* Ignore DESC */
|
|
}
|
|
|
|
/* Analyze the list of expressions that form the terms of the index and
|
|
** report any errors. In the common case where the expression is exactly
|
|
** a table column, store that column in aiColumn[]. For general expressions,
|
|
** populate pIndex->aColExpr and store XN_EXPR (-2) in aiColumn[].
|
|
**
|
|
** TODO: Issue a warning if two or more columns of the index are identical.
|
|
** TODO: Issue a warning if the table primary key is used as part of the
|
|
** index key.
|
|
*/
|
|
pListItem = pList->a;
|
|
if( IN_RENAME_OBJECT ){
|
|
pIndex->aColExpr = pList;
|
|
pList = 0;
|
|
}
|
|
for(i=0; i<pIndex->nKeyCol; i++, pListItem++){
|
|
Expr *pCExpr; /* The i-th index expression */
|
|
int requestedSortOrder; /* ASC or DESC on the i-th expression */
|
|
const char *zColl; /* Collation sequence name */
|
|
|
|
sqlite3StringToId(pListItem->pExpr);
|
|
sqlite3ResolveSelfReference(pParse, pTab, NC_IdxExpr, pListItem->pExpr, 0);
|
|
if( pParse->nErr ) goto exit_create_index;
|
|
pCExpr = sqlite3ExprSkipCollate(pListItem->pExpr);
|
|
if( pCExpr->op!=TK_COLUMN ){
|
|
if( pTab==pParse->pNewTable ){
|
|
sqlite3ErrorMsg(pParse, "expressions prohibited in PRIMARY KEY and "
|
|
"UNIQUE constraints");
|
|
goto exit_create_index;
|
|
}
|
|
if( pIndex->aColExpr==0 ){
|
|
pIndex->aColExpr = pList;
|
|
pList = 0;
|
|
}
|
|
j = XN_EXPR;
|
|
pIndex->aiColumn[i] = XN_EXPR;
|
|
pIndex->uniqNotNull = 0;
|
|
pIndex->bHasExpr = 1;
|
|
}else{
|
|
j = pCExpr->iColumn;
|
|
assert( j<=0x7fff );
|
|
if( j<0 ){
|
|
j = pTab->iPKey;
|
|
}else{
|
|
if( pTab->aCol[j].notNull==0 ){
|
|
pIndex->uniqNotNull = 0;
|
|
}
|
|
if( pTab->aCol[j].colFlags & COLFLAG_VIRTUAL ){
|
|
pIndex->bHasVCol = 1;
|
|
pIndex->bHasExpr = 1;
|
|
}
|
|
}
|
|
pIndex->aiColumn[i] = (i16)j;
|
|
}
|
|
zColl = 0;
|
|
if( pListItem->pExpr->op==TK_COLLATE ){
|
|
int nColl;
|
|
assert( !ExprHasProperty(pListItem->pExpr, EP_IntValue) );
|
|
zColl = pListItem->pExpr->u.zToken;
|
|
nColl = sqlite3Strlen30(zColl) + 1;
|
|
assert( nExtra>=nColl );
|
|
memcpy(zExtra, zColl, nColl);
|
|
zColl = zExtra;
|
|
zExtra += nColl;
|
|
nExtra -= nColl;
|
|
}else if( j>=0 ){
|
|
zColl = sqlite3ColumnColl(&pTab->aCol[j]);
|
|
}
|
|
if( !zColl ) zColl = sqlite3StrBINARY;
|
|
if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl) ){
|
|
goto exit_create_index;
|
|
}
|
|
pIndex->azColl[i] = zColl;
|
|
requestedSortOrder = pListItem->fg.sortFlags & sortOrderMask;
|
|
pIndex->aSortOrder[i] = (u8)requestedSortOrder;
|
|
}
|
|
|
|
/* Append the table key to the end of the index. For WITHOUT ROWID
|
|
** tables (when pPk!=0) this will be the declared PRIMARY KEY. For
|
|
** normal tables (when pPk==0) this will be the rowid.
|
|
*/
|
|
if( pPk ){
|
|
for(j=0; j<pPk->nKeyCol; j++){
|
|
int x = pPk->aiColumn[j];
|
|
assert( x>=0 );
|
|
if( isDupColumn(pIndex, pIndex->nKeyCol, pPk, j) ){
|
|
pIndex->nColumn--;
|
|
}else{
|
|
testcase( hasColumn(pIndex->aiColumn,pIndex->nKeyCol,x) );
|
|
pIndex->aiColumn[i] = x;
|
|
pIndex->azColl[i] = pPk->azColl[j];
|
|
pIndex->aSortOrder[i] = pPk->aSortOrder[j];
|
|
i++;
|
|
}
|
|
}
|
|
assert( i==pIndex->nColumn );
|
|
}else{
|
|
pIndex->aiColumn[i] = XN_ROWID;
|
|
pIndex->azColl[i] = sqlite3StrBINARY;
|
|
}
|
|
sqlite3DefaultRowEst(pIndex);
|
|
if( pParse->pNewTable==0 ) estimateIndexWidth(pIndex);
|
|
|
|
/* If this index contains every column of its table, then mark
|
|
** it as a covering index */
|
|
assert( HasRowid(pTab)
|
|
|| pTab->iPKey<0 || sqlite3TableColumnToIndex(pIndex, pTab->iPKey)>=0 );
|
|
recomputeColumnsNotIndexed(pIndex);
|
|
if( pTblName!=0 && pIndex->nColumn>=pTab->nCol ){
|
|
pIndex->isCovering = 1;
|
|
for(j=0; j<pTab->nCol; j++){
|
|
if( j==pTab->iPKey ) continue;
|
|
if( sqlite3TableColumnToIndex(pIndex,j)>=0 ) continue;
|
|
pIndex->isCovering = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( pTab==pParse->pNewTable ){
|
|
/* This routine has been called to create an automatic index as a
|
|
** result of a PRIMARY KEY or UNIQUE clause on a column definition, or
|
|
** a PRIMARY KEY or UNIQUE clause following the column definitions.
|
|
** i.e. one of:
|
|
**
|
|
** CREATE TABLE t(x PRIMARY KEY, y);
|
|
** CREATE TABLE t(x, y, UNIQUE(x, y));
|
|
**
|
|
** Either way, check to see if the table already has such an index. If
|
|
** so, don't bother creating this one. This only applies to
|
|
** automatically created indices. Users can do as they wish with
|
|
** explicit indices.
|
|
**
|
|
** Two UNIQUE or PRIMARY KEY constraints are considered equivalent
|
|
** (and thus suppressing the second one) even if they have different
|
|
** sort orders.
|
|
**
|
|
** If there are different collating sequences or if the columns of
|
|
** the constraint occur in different orders, then the constraints are
|
|
** considered distinct and both result in separate indices.
|
|
*/
|
|
Index *pIdx;
|
|
for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
|
|
int k;
|
|
assert( IsUniqueIndex(pIdx) );
|
|
assert( pIdx->idxType!=SQLITE_IDXTYPE_APPDEF );
|
|
assert( IsUniqueIndex(pIndex) );
|
|
|
|
if( pIdx->nKeyCol!=pIndex->nKeyCol ) continue;
|
|
for(k=0; k<pIdx->nKeyCol; k++){
|
|
const char *z1;
|
|
const char *z2;
|
|
assert( pIdx->aiColumn[k]>=0 );
|
|
if( pIdx->aiColumn[k]!=pIndex->aiColumn[k] ) break;
|
|
z1 = pIdx->azColl[k];
|
|
z2 = pIndex->azColl[k];
|
|
if( sqlite3StrICmp(z1, z2) ) break;
|
|
}
|
|
if( k==pIdx->nKeyCol ){
|
|
if( pIdx->onError!=pIndex->onError ){
|
|
/* This constraint creates the same index as a previous
|
|
** constraint specified somewhere in the CREATE TABLE statement.
|
|
** However the ON CONFLICT clauses are different. If both this
|
|
** constraint and the previous equivalent constraint have explicit
|
|
** ON CONFLICT clauses this is an error. Otherwise, use the
|
|
** explicitly specified behavior for the index.
|
|
*/
|
|
if( !(pIdx->onError==OE_Default || pIndex->onError==OE_Default) ){
|
|
sqlite3ErrorMsg(pParse,
|
|
"conflicting ON CONFLICT clauses specified", 0);
|
|
}
|
|
if( pIdx->onError==OE_Default ){
|
|
pIdx->onError = pIndex->onError;
|
|
}
|
|
}
|
|
if( idxType==SQLITE_IDXTYPE_PRIMARYKEY ) pIdx->idxType = idxType;
|
|
if( IN_RENAME_OBJECT ){
|
|
pIndex->pNext = pParse->pNewIndex;
|
|
pParse->pNewIndex = pIndex;
|
|
pIndex = 0;
|
|
}
|
|
goto exit_create_index;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( !IN_RENAME_OBJECT ){
|
|
|
|
/* Link the new Index structure to its table and to the other
|
|
** in-memory database structures.
|
|
*/
|
|
assert( pParse->nErr==0 );
|
|
if( db->init.busy ){
|
|
Index *p;
|
|
assert( !IN_SPECIAL_PARSE );
|
|
assert( sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
|
|
if( pTblName!=0 ){
|
|
pIndex->tnum = db->init.newTnum;
|
|
if( sqlite3IndexHasDuplicateRootPage(pIndex) ){
|
|
sqlite3ErrorMsg(pParse, "invalid rootpage");
|
|
pParse->rc = SQLITE_CORRUPT_BKPT;
|
|
goto exit_create_index;
|
|
}
|
|
}
|
|
p = sqlite3HashInsert(&pIndex->pSchema->idxHash,
|
|
pIndex->zName, pIndex);
|
|
if( p ){
|
|
assert( p==pIndex ); /* Malloc must have failed */
|
|
sqlite3OomFault(db);
|
|
goto exit_create_index;
|
|
}
|
|
db->mDbFlags |= DBFLAG_SchemaChange;
|
|
}
|
|
|
|
/* If this is the initial CREATE INDEX statement (or CREATE TABLE if the
|
|
** index is an implied index for a UNIQUE or PRIMARY KEY constraint) then
|
|
** emit code to allocate the index rootpage on disk and make an entry for
|
|
** the index in the sqlite_schema table and populate the index with
|
|
** content. But, do not do this if we are simply reading the sqlite_schema
|
|
** table to parse the schema, or if this index is the PRIMARY KEY index
|
|
** of a WITHOUT ROWID table.
|
|
**
|
|
** If pTblName==0 it means this index is generated as an implied PRIMARY KEY
|
|
** or UNIQUE index in a CREATE TABLE statement. Since the table
|
|
** has just been created, it contains no data and the index initialization
|
|
** step can be skipped.
|
|
*/
|
|
else if( HasRowid(pTab) || pTblName!=0 ){
|
|
Vdbe *v;
|
|
char *zStmt;
|
|
int iMem = ++pParse->nMem;
|
|
|
|
v = sqlite3GetVdbe(pParse);
|
|
if( v==0 ) goto exit_create_index;
|
|
|
|
sqlite3BeginWriteOperation(pParse, 1, iDb);
|
|
|
|
/* Create the rootpage for the index using CreateIndex. But before
|
|
** doing so, code a Noop instruction and store its address in
|
|
** Index.tnum. This is required in case this index is actually a
|
|
** PRIMARY KEY and the table is actually a WITHOUT ROWID table. In
|
|
** that case the convertToWithoutRowidTable() routine will replace
|
|
** the Noop with a Goto to jump over the VDBE code generated below. */
|
|
pIndex->tnum = (Pgno)sqlite3VdbeAddOp0(v, OP_Noop);
|
|
sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, iMem, BTREE_BLOBKEY);
|
|
|
|
/* Gather the complete text of the CREATE INDEX statement into
|
|
** the zStmt variable
|
|
*/
|
|
assert( pName!=0 || pStart==0 );
|
|
if( pStart ){
|
|
int n = (int)(pParse->sLastToken.z - pName->z) + pParse->sLastToken.n;
|
|
if( pName->z[n-1]==';' ) n--;
|
|
/* A named index with an explicit CREATE INDEX statement */
|
|
zStmt = sqlite3MPrintf(db, "CREATE%s INDEX %.*s",
|
|
onError==OE_None ? "" : " UNIQUE", n, pName->z);
|
|
}else{
|
|
/* An automatic index created by a PRIMARY KEY or UNIQUE constraint */
|
|
/* zStmt = sqlite3MPrintf(""); */
|
|
zStmt = 0;
|
|
}
|
|
|
|
/* Add an entry in sqlite_schema for this index
|
|
*/
|
|
sqlite3NestedParse(pParse,
|
|
"INSERT INTO %Q." LEGACY_SCHEMA_TABLE " VALUES('index',%Q,%Q,#%d,%Q);",
|
|
db->aDb[iDb].zDbSName,
|
|
pIndex->zName,
|
|
pTab->zName,
|
|
iMem,
|
|
zStmt
|
|
);
|
|
sqlite3DbFree(db, zStmt);
|
|
|
|
/* Fill the index with data and reparse the schema. Code an OP_Expire
|
|
** to invalidate all pre-compiled statements.
|
|
*/
|
|
if( pTblName ){
|
|
sqlite3RefillIndex(pParse, pIndex, iMem);
|
|
sqlite3ChangeCookie(pParse, iDb);
|
|
sqlite3VdbeAddParseSchemaOp(v, iDb,
|
|
sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName), 0);
|
|
sqlite3VdbeAddOp2(v, OP_Expire, 0, 1);
|
|
}
|
|
|
|
sqlite3VdbeJumpHere(v, (int)pIndex->tnum);
|
|
}
|
|
}
|
|
if( db->init.busy || pTblName==0 ){
|
|
pIndex->pNext = pTab->pIndex;
|
|
pTab->pIndex = pIndex;
|
|
pIndex = 0;
|
|
}
|
|
else if( IN_RENAME_OBJECT ){
|
|
assert( pParse->pNewIndex==0 );
|
|
pParse->pNewIndex = pIndex;
|
|
pIndex = 0;
|
|
}
|
|
|
|
/* Clean up before exiting */
|
|
exit_create_index:
|
|
if( pIndex ) sqlite3FreeIndex(db, pIndex);
|
|
if( pTab ){
|
|
/* Ensure all REPLACE indexes on pTab are at the end of the pIndex list.
|
|
** The list was already ordered when this routine was entered, so at this
|
|
** point at most a single index (the newly added index) will be out of
|
|
** order. So we have to reorder at most one index. */
|
|
Index **ppFrom;
|
|
Index *pThis;
|
|
for(ppFrom=&pTab->pIndex; (pThis = *ppFrom)!=0; ppFrom=&pThis->pNext){
|
|
Index *pNext;
|
|
if( pThis->onError!=OE_Replace ) continue;
|
|
while( (pNext = pThis->pNext)!=0 && pNext->onError!=OE_Replace ){
|
|
*ppFrom = pNext;
|
|
pThis->pNext = pNext->pNext;
|
|
pNext->pNext = pThis;
|
|
ppFrom = &pNext->pNext;
|
|
}
|
|
break;
|
|
}
|
|
#ifdef SQLITE_DEBUG
|
|
/* Verify that all REPLACE indexes really are now at the end
|
|
** of the index list. In other words, no other index type ever
|
|
** comes after a REPLACE index on the list. */
|
|
for(pThis = pTab->pIndex; pThis; pThis=pThis->pNext){
|
|
assert( pThis->onError!=OE_Replace
|
|
|| pThis->pNext==0
|
|
|| pThis->pNext->onError==OE_Replace );
|
|
}
|
|
#endif
|
|
}
|
|
sqlite3ExprDelete(db, pPIWhere);
|
|
sqlite3ExprListDelete(db, pList);
|
|
sqlite3SrcListDelete(db, pTblName);
|
|
sqlite3DbFree(db, zName);
|
|
}
|
|
|
|
/*
|
|
** Fill the Index.aiRowEst[] array with default information - information
|
|
** to be used when we have not run the ANALYZE command.
|
|
**
|
|
** aiRowEst[0] is supposed to contain the number of elements in the index.
|
|
** Since we do not know, guess 1 million. aiRowEst[1] is an estimate of the
|
|
** number of rows in the table that match any particular value of the
|
|
** first column of the index. aiRowEst[2] is an estimate of the number
|
|
** of rows that match any particular combination of the first 2 columns
|
|
** of the index. And so forth. It must always be the case that
|
|
*
|
|
** aiRowEst[N]<=aiRowEst[N-1]
|
|
** aiRowEst[N]>=1
|
|
**
|
|
** Apart from that, we have little to go on besides intuition as to
|
|
** how aiRowEst[] should be initialized. The numbers generated here
|
|
** are based on typical values found in actual indices.
|
|
*/
|
|
void sqlite3DefaultRowEst(Index *pIdx){
|
|
/* 10, 9, 8, 7, 6 */
|
|
static const LogEst aVal[] = { 33, 32, 30, 28, 26 };
|
|
LogEst *a = pIdx->aiRowLogEst;
|
|
LogEst x;
|
|
int nCopy = MIN(ArraySize(aVal), pIdx->nKeyCol);
|
|
int i;
|
|
|
|
/* Indexes with default row estimates should not have stat1 data */
|
|
assert( !pIdx->hasStat1 );
|
|
|
|
/* Set the first entry (number of rows in the index) to the estimated
|
|
** number of rows in the table, or half the number of rows in the table
|
|
** for a partial index.
|
|
**
|
|
** 2020-05-27: If some of the stat data is coming from the sqlite_stat1
|
|
** table but other parts we are having to guess at, then do not let the
|
|
** estimated number of rows in the table be less than 1000 (LogEst 99).
|
|
** Failure to do this can cause the indexes for which we do not have
|
|
** stat1 data to be ignored by the query planner.
|
|
*/
|
|
x = pIdx->pTable->nRowLogEst;
|
|
assert( 99==sqlite3LogEst(1000) );
|
|
if( x<99 ){
|
|
pIdx->pTable->nRowLogEst = x = 99;
|
|
}
|
|
if( pIdx->pPartIdxWhere!=0 ){ x -= 10; assert( 10==sqlite3LogEst(2) ); }
|
|
a[0] = x;
|
|
|
|
/* Estimate that a[1] is 10, a[2] is 9, a[3] is 8, a[4] is 7, a[5] is
|
|
** 6 and each subsequent value (if any) is 5. */
|
|
memcpy(&a[1], aVal, nCopy*sizeof(LogEst));
|
|
for(i=nCopy+1; i<=pIdx->nKeyCol; i++){
|
|
a[i] = 23; assert( 23==sqlite3LogEst(5) );
|
|
}
|
|
|
|
assert( 0==sqlite3LogEst(1) );
|
|
if( IsUniqueIndex(pIdx) ) a[pIdx->nKeyCol] = 0;
|
|
}
|
|
|
|
/*
|
|
** This routine will drop an existing named index. This routine
|
|
** implements the DROP INDEX statement.
|
|
*/
|
|
void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){
|
|
Index *pIndex;
|
|
Vdbe *v;
|
|
sqlite3 *db = pParse->db;
|
|
int iDb;
|
|
|
|
if( db->mallocFailed ){
|
|
goto exit_drop_index;
|
|
}
|
|
assert( pParse->nErr==0 ); /* Never called with prior non-OOM errors */
|
|
assert( pName->nSrc==1 );
|
|
assert( pName->a[0].fg.fixedSchema==0 );
|
|
assert( pName->a[0].fg.isSubquery==0 );
|
|
if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
|
|
goto exit_drop_index;
|
|
}
|
|
pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].u4.zDatabase);
|
|
if( pIndex==0 ){
|
|
if( !ifExists ){
|
|
sqlite3ErrorMsg(pParse, "no such index: %S", pName->a);
|
|
}else{
|
|
sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].u4.zDatabase);
|
|
sqlite3ForceNotReadOnly(pParse);
|
|
}
|
|
pParse->checkSchema = 1;
|
|
goto exit_drop_index;
|
|
}
|
|
if( pIndex->idxType!=SQLITE_IDXTYPE_APPDEF ){
|
|
sqlite3ErrorMsg(pParse, "index associated with UNIQUE "
|
|
"or PRIMARY KEY constraint cannot be dropped", 0);
|
|
goto exit_drop_index;
|
|
}
|
|
iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
|
|
#ifndef SQLITE_OMIT_AUTHORIZATION
|
|
{
|
|
int code = SQLITE_DROP_INDEX;
|
|
Table *pTab = pIndex->pTable;
|
|
const char *zDb = db->aDb[iDb].zDbSName;
|
|
const char *zTab = SCHEMA_TABLE(iDb);
|
|
if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
|
|
goto exit_drop_index;
|
|
}
|
|
if( !OMIT_TEMPDB && iDb==1 ) code = SQLITE_DROP_TEMP_INDEX;
|
|
if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
|
|
goto exit_drop_index;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* Generate code to remove the index and from the schema table */
|
|
v = sqlite3GetVdbe(pParse);
|
|
if( v ){
|
|
sqlite3BeginWriteOperation(pParse, 1, iDb);
|
|
sqlite3NestedParse(pParse,
|
|
"DELETE FROM %Q." LEGACY_SCHEMA_TABLE " WHERE name=%Q AND type='index'",
|
|
db->aDb[iDb].zDbSName, pIndex->zName
|
|
);
|
|
sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
|
|
sqlite3ChangeCookie(pParse, iDb);
|
|
destroyRootPage(pParse, pIndex->tnum, iDb);
|
|
sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
|
|
}
|
|
|
|
exit_drop_index:
|
|
sqlite3SrcListDelete(db, pName);
|
|
}
|
|
|
|
/*
|
|
** pArray is a pointer to an array of objects. Each object in the
|
|
** array is szEntry bytes in size. This routine uses sqlite3DbRealloc()
|
|
** to extend the array so that there is space for a new object at the end.
|
|
**
|
|
** When this function is called, *pnEntry contains the current size of
|
|
** the array (in entries - so the allocation is ((*pnEntry) * szEntry) bytes
|
|
** in total).
|
|
**
|
|
** If the realloc() is successful (i.e. if no OOM condition occurs), the
|
|
** space allocated for the new object is zeroed, *pnEntry updated to
|
|
** reflect the new size of the array and a pointer to the new allocation
|
|
** returned. *pIdx is set to the index of the new array entry in this case.
|
|
**
|
|
** Otherwise, if the realloc() fails, *pIdx is set to -1, *pnEntry remains
|
|
** unchanged and a copy of pArray returned.
|
|
*/
|
|
void *sqlite3ArrayAllocate(
|
|
sqlite3 *db, /* Connection to notify of malloc failures */
|
|
void *pArray, /* Array of objects. Might be reallocated */
|
|
int szEntry, /* Size of each object in the array */
|
|
int *pnEntry, /* Number of objects currently in use */
|
|
int *pIdx /* Write the index of a new slot here */
|
|
){
|
|
char *z;
|
|
sqlite3_int64 n = *pIdx = *pnEntry;
|
|
if( (n & (n-1))==0 ){
|
|
sqlite3_int64 sz = (n==0) ? 1 : 2*n;
|
|
void *pNew = sqlite3DbRealloc(db, pArray, sz*szEntry);
|
|
if( pNew==0 ){
|
|
*pIdx = -1;
|
|
return pArray;
|
|
}
|
|
pArray = pNew;
|
|
}
|
|
z = (char*)pArray;
|
|
memset(&z[n * szEntry], 0, szEntry);
|
|
++*pnEntry;
|
|
return pArray;
|
|
}
|
|
|
|
/*
|
|
** Append a new element to the given IdList. Create a new IdList if
|
|
** need be.
|
|
**
|
|
** A new IdList is returned, or NULL if malloc() fails.
|
|
*/
|
|
IdList *sqlite3IdListAppend(Parse *pParse, IdList *pList, Token *pToken){
|
|
sqlite3 *db = pParse->db;
|
|
int i;
|
|
if( pList==0 ){
|
|
pList = sqlite3DbMallocZero(db, sizeof(IdList) );
|
|
if( pList==0 ) return 0;
|
|
}else{
|
|
IdList *pNew;
|
|
pNew = sqlite3DbRealloc(db, pList,
|
|
sizeof(IdList) + pList->nId*sizeof(pList->a));
|
|
if( pNew==0 ){
|
|
sqlite3IdListDelete(db, pList);
|
|
return 0;
|
|
}
|
|
pList = pNew;
|
|
}
|
|
i = pList->nId++;
|
|
pList->a[i].zName = sqlite3NameFromToken(db, pToken);
|
|
if( IN_RENAME_OBJECT && pList->a[i].zName ){
|
|
sqlite3RenameTokenMap(pParse, (void*)pList->a[i].zName, pToken);
|
|
}
|
|
return pList;
|
|
}
|
|
|
|
/*
|
|
** Delete an IdList.
|
|
*/
|
|
void sqlite3IdListDelete(sqlite3 *db, IdList *pList){
|
|
int i;
|
|
assert( db!=0 );
|
|
if( pList==0 ) return;
|
|
for(i=0; i<pList->nId; i++){
|
|
sqlite3DbFree(db, pList->a[i].zName);
|
|
}
|
|
sqlite3DbNNFreeNN(db, pList);
|
|
}
|
|
|
|
/*
|
|
** Return the index in pList of the identifier named zId. Return -1
|
|
** if not found.
|
|
*/
|
|
int sqlite3IdListIndex(IdList *pList, const char *zName){
|
|
int i;
|
|
assert( pList!=0 );
|
|
for(i=0; i<pList->nId; i++){
|
|
if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
** Maximum size of a SrcList object.
|
|
** The SrcList object is used to represent the FROM clause of a
|
|
** SELECT statement, and the query planner cannot deal with more
|
|
** than 64 tables in a join. So any value larger than 64 here
|
|
** is sufficient for most uses. Smaller values, like say 10, are
|
|
** appropriate for small and memory-limited applications.
|
|
*/
|
|
#ifndef SQLITE_MAX_SRCLIST
|
|
# define SQLITE_MAX_SRCLIST 200
|
|
#endif
|
|
|
|
/*
|
|
** Expand the space allocated for the given SrcList object by
|
|
** creating nExtra new slots beginning at iStart. iStart is zero based.
|
|
** New slots are zeroed.
|
|
**
|
|
** For example, suppose a SrcList initially contains two entries: A,B.
|
|
** To append 3 new entries onto the end, do this:
|
|
**
|
|
** sqlite3SrcListEnlarge(db, pSrclist, 3, 2);
|
|
**
|
|
** After the call above it would contain: A, B, nil, nil, nil.
|
|
** If the iStart argument had been 1 instead of 2, then the result
|
|
** would have been: A, nil, nil, nil, B. To prepend the new slots,
|
|
** the iStart value would be 0. The result then would
|
|
** be: nil, nil, nil, A, B.
|
|
**
|
|
** If a memory allocation fails or the SrcList becomes too large, leave
|
|
** the original SrcList unchanged, return NULL, and leave an error message
|
|
** in pParse.
|
|
*/
|
|
SrcList *sqlite3SrcListEnlarge(
|
|
Parse *pParse, /* Parsing context into which errors are reported */
|
|
SrcList *pSrc, /* The SrcList to be enlarged */
|
|
int nExtra, /* Number of new slots to add to pSrc->a[] */
|
|
int iStart /* Index in pSrc->a[] of first new slot */
|
|
){
|
|
int i;
|
|
|
|
/* Sanity checking on calling parameters */
|
|
assert( iStart>=0 );
|
|
assert( nExtra>=1 );
|
|
assert( pSrc!=0 );
|
|
assert( iStart<=pSrc->nSrc );
|
|
|
|
/* Allocate additional space if needed */
|
|
if( (u32)pSrc->nSrc+nExtra>pSrc->nAlloc ){
|
|
SrcList *pNew;
|
|
sqlite3_int64 nAlloc = 2*(sqlite3_int64)pSrc->nSrc+nExtra;
|
|
sqlite3 *db = pParse->db;
|
|
|
|
if( pSrc->nSrc+nExtra>=SQLITE_MAX_SRCLIST ){
|
|
sqlite3ErrorMsg(pParse, "too many FROM clause terms, max: %d",
|
|
SQLITE_MAX_SRCLIST);
|
|
return 0;
|
|
}
|
|
if( nAlloc>SQLITE_MAX_SRCLIST ) nAlloc = SQLITE_MAX_SRCLIST;
|
|
pNew = sqlite3DbRealloc(db, pSrc,
|
|
sizeof(*pSrc) + (nAlloc-1)*sizeof(pSrc->a[0]) );
|
|
if( pNew==0 ){
|
|
assert( db->mallocFailed );
|
|
return 0;
|
|
}
|
|
pSrc = pNew;
|
|
pSrc->nAlloc = nAlloc;
|
|
}
|
|
|
|
/* Move existing slots that come after the newly inserted slots
|
|
** out of the way */
|
|
for(i=pSrc->nSrc-1; i>=iStart; i--){
|
|
pSrc->a[i+nExtra] = pSrc->a[i];
|
|
}
|
|
pSrc->nSrc += nExtra;
|
|
|
|
/* Zero the newly allocated slots */
|
|
memset(&pSrc->a[iStart], 0, sizeof(pSrc->a[0])*nExtra);
|
|
for(i=iStart; i<iStart+nExtra; i++){
|
|
pSrc->a[i].iCursor = -1;
|
|
}
|
|
|
|
/* Return a pointer to the enlarged SrcList */
|
|
return pSrc;
|
|
}
|
|
|
|
|
|
/*
|
|
** Append a new table name to the given SrcList. Create a new SrcList if
|
|
** need be. A new entry is created in the SrcList even if pTable is NULL.
|
|
**
|
|
** A SrcList is returned, or NULL if there is an OOM error or if the
|
|
** SrcList grows to large. The returned
|
|
** SrcList might be the same as the SrcList that was input or it might be
|
|
** a new one. If an OOM error does occurs, then the prior value of pList
|
|
** that is input to this routine is automatically freed.
|
|
**
|
|
** If pDatabase is not null, it means that the table has an optional
|
|
** database name prefix. Like this: "database.table". The pDatabase
|
|
** points to the table name and the pTable points to the database name.
|
|
** The SrcList.a[].zName field is filled with the table name which might
|
|
** come from pTable (if pDatabase is NULL) or from pDatabase.
|
|
** SrcList.a[].zDatabase is filled with the database name from pTable,
|
|
** or with NULL if no database is specified.
|
|
**
|
|
** In other words, if call like this:
|
|
**
|
|
** sqlite3SrcListAppend(D,A,B,0);
|
|
**
|
|
** Then B is a table name and the database name is unspecified. If called
|
|
** like this:
|
|
**
|
|
** sqlite3SrcListAppend(D,A,B,C);
|
|
**
|
|
** Then C is the table name and B is the database name. If C is defined
|
|
** then so is B. In other words, we never have a case where:
|
|
**
|
|
** sqlite3SrcListAppend(D,A,0,C);
|
|
**
|
|
** Both pTable and pDatabase are assumed to be quoted. They are dequoted
|
|
** before being added to the SrcList.
|
|
*/
|
|
SrcList *sqlite3SrcListAppend(
|
|
Parse *pParse, /* Parsing context, in which errors are reported */
|
|
SrcList *pList, /* Append to this SrcList. NULL creates a new SrcList */
|
|
Token *pTable, /* Table to append */
|
|
Token *pDatabase /* Database of the table */
|
|
){
|
|
SrcItem *pItem;
|
|
sqlite3 *db;
|
|
assert( pDatabase==0 || pTable!=0 ); /* Cannot have C without B */
|
|
assert( pParse!=0 );
|
|
assert( pParse->db!=0 );
|
|
db = pParse->db;
|
|
if( pList==0 ){
|
|
pList = sqlite3DbMallocRawNN(pParse->db, sizeof(SrcList) );
|
|
if( pList==0 ) return 0;
|
|
pList->nAlloc = 1;
|
|
pList->nSrc = 1;
|
|
memset(&pList->a[0], 0, sizeof(pList->a[0]));
|
|
pList->a[0].iCursor = -1;
|
|
}else{
|
|
SrcList *pNew = sqlite3SrcListEnlarge(pParse, pList, 1, pList->nSrc);
|
|
if( pNew==0 ){
|
|
sqlite3SrcListDelete(db, pList);
|
|
return 0;
|
|
}else{
|
|
pList = pNew;
|
|
}
|
|
}
|
|
pItem = &pList->a[pList->nSrc-1];
|
|
if( pDatabase && pDatabase->z==0 ){
|
|
pDatabase = 0;
|
|
}
|
|
assert( pItem->fg.fixedSchema==0 );
|
|
assert( pItem->fg.isSubquery==0 );
|
|
if( pDatabase ){
|
|
pItem->zName = sqlite3NameFromToken(db, pDatabase);
|
|
pItem->u4.zDatabase = sqlite3NameFromToken(db, pTable);
|
|
}else{
|
|
pItem->zName = sqlite3NameFromToken(db, pTable);
|
|
pItem->u4.zDatabase = 0;
|
|
}
|
|
return pList;
|
|
}
|
|
|
|
/*
|
|
** Assign VdbeCursor index numbers to all tables in a SrcList
|
|
*/
|
|
void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){
|
|
int i;
|
|
SrcItem *pItem;
|
|
assert( pList || pParse->db->mallocFailed );
|
|
if( ALWAYS(pList) ){
|
|
for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
|
|
if( pItem->iCursor>=0 ) continue;
|
|
pItem->iCursor = pParse->nTab++;
|
|
if( pItem->fg.isSubquery ){
|
|
assert( pItem->u4.pSubq!=0 );
|
|
assert( pItem->u4.pSubq->pSelect!=0 );
|
|
assert( pItem->u4.pSubq->pSelect->pSrc!=0 );
|
|
sqlite3SrcListAssignCursors(pParse, pItem->u4.pSubq->pSelect->pSrc);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Delete a Subquery object and its substructure.
|
|
*/
|
|
void sqlite3SubqueryDelete(sqlite3 *db, Subquery *pSubq){
|
|
assert( pSubq!=0 && pSubq->pSelect!=0 );
|
|
sqlite3SelectDelete(db, pSubq->pSelect);
|
|
sqlite3DbFree(db, pSubq);
|
|
}
|
|
|
|
/*
|
|
** Remove a Subquery from a SrcItem. Return the associated Select object.
|
|
** The returned Select becomes the responsibility of the caller.
|
|
*/
|
|
Select *sqlite3SubqueryDetach(sqlite3 *db, SrcItem *pItem){
|
|
Select *pSel;
|
|
assert( pItem!=0 );
|
|
assert( pItem->fg.isSubquery );
|
|
pSel = pItem->u4.pSubq->pSelect;
|
|
sqlite3DbFree(db, pItem->u4.pSubq);
|
|
pItem->u4.pSubq = 0;
|
|
pItem->fg.isSubquery = 0;
|
|
return pSel;
|
|
}
|
|
|
|
/*
|
|
** Delete an entire SrcList including all its substructure.
|
|
*/
|
|
void sqlite3SrcListDelete(sqlite3 *db, SrcList *pList){
|
|
int i;
|
|
SrcItem *pItem;
|
|
assert( db!=0 );
|
|
if( pList==0 ) return;
|
|
for(pItem=pList->a, i=0; i<pList->nSrc; i++, pItem++){
|
|
|
|
/* Check invariants on SrcItem */
|
|
assert( !pItem->fg.isIndexedBy || !pItem->fg.isTabFunc );
|
|
assert( !pItem->fg.isCte || !pItem->fg.isIndexedBy );
|
|
assert( !pItem->fg.fixedSchema || !pItem->fg.isSubquery );
|
|
assert( !pItem->fg.isSubquery || (pItem->u4.pSubq!=0 &&
|
|
pItem->u4.pSubq->pSelect!=0) );
|
|
|
|
if( pItem->zName ) sqlite3DbNNFreeNN(db, pItem->zName);
|
|
if( pItem->zAlias ) sqlite3DbNNFreeNN(db, pItem->zAlias);
|
|
if( pItem->fg.isSubquery ){
|
|
sqlite3SubqueryDelete(db, pItem->u4.pSubq);
|
|
}else if( pItem->fg.fixedSchema==0 && pItem->u4.zDatabase!=0 ){
|
|
sqlite3DbNNFreeNN(db, pItem->u4.zDatabase);
|
|
}
|
|
if( pItem->fg.isIndexedBy ) sqlite3DbFree(db, pItem->u1.zIndexedBy);
|
|
if( pItem->fg.isTabFunc ) sqlite3ExprListDelete(db, pItem->u1.pFuncArg);
|
|
sqlite3DeleteTable(db, pItem->pSTab);
|
|
if( pItem->fg.isUsing ){
|
|
sqlite3IdListDelete(db, pItem->u3.pUsing);
|
|
}else if( pItem->u3.pOn ){
|
|
sqlite3ExprDelete(db, pItem->u3.pOn);
|
|
}
|
|
}
|
|
sqlite3DbNNFreeNN(db, pList);
|
|
}
|
|
|
|
/*
|
|
** Attach a Subquery object to pItem->uv.pSubq. Set the
|
|
** pSelect value but leave all the other values initialized
|
|
** to zero.
|
|
**
|
|
** A copy of the Select object is made if dupSelect is true, and the
|
|
** SrcItem takes responsibility for deleting the copy. If dupSelect is
|
|
** false, ownership of the Select passes to the SrcItem. Either way,
|
|
** the SrcItem will take responsibility for deleting the Select.
|
|
**
|
|
** When dupSelect is zero, that means the Select might get deleted right
|
|
** away if there is an OOM error. Beware.
|
|
**
|
|
** Return non-zero on success. Return zero on an OOM error.
|
|
*/
|
|
int sqlite3SrcItemAttachSubquery(
|
|
Parse *pParse, /* Parsing context */
|
|
SrcItem *pItem, /* Item to which the subquery is to be attached */
|
|
Select *pSelect, /* The subquery SELECT. Must be non-NULL */
|
|
int dupSelect /* If true, attach a copy of pSelect, not pSelect itself.*/
|
|
){
|
|
Subquery *p;
|
|
assert( pSelect!=0 );
|
|
assert( pItem->fg.isSubquery==0 );
|
|
if( pItem->fg.fixedSchema ){
|
|
pItem->u4.pSchema = 0;
|
|
pItem->fg.fixedSchema = 0;
|
|
}else if( pItem->u4.zDatabase!=0 ){
|
|
sqlite3DbFree(pParse->db, pItem->u4.zDatabase);
|
|
pItem->u4.zDatabase = 0;
|
|
}
|
|
if( dupSelect ){
|
|
pSelect = sqlite3SelectDup(pParse->db, pSelect, 0);
|
|
if( pSelect==0 ) return 0;
|
|
}
|
|
p = pItem->u4.pSubq = sqlite3DbMallocRawNN(pParse->db, sizeof(Subquery));
|
|
if( p==0 ){
|
|
sqlite3SelectDelete(pParse->db, pSelect);
|
|
return 0;
|
|
}
|
|
pItem->fg.isSubquery = 1;
|
|
p->pSelect = pSelect;
|
|
assert( offsetof(Subquery, pSelect)==0 );
|
|
memset(((char*)p)+sizeof(p->pSelect), 0, sizeof(*p)-sizeof(p->pSelect));
|
|
return 1;
|
|
}
|
|
|
|
|
|
/*
|
|
** This routine is called by the parser to add a new term to the
|
|
** end of a growing FROM clause. The "p" parameter is the part of
|
|
** the FROM clause that has already been constructed. "p" is NULL
|
|
** if this is the first term of the FROM clause. pTable and pDatabase
|
|
** are the name of the table and database named in the FROM clause term.
|
|
** pDatabase is NULL if the database name qualifier is missing - the
|
|
** usual case. If the term has an alias, then pAlias points to the
|
|
** alias token. If the term is a subquery, then pSubquery is the
|
|
** SELECT statement that the subquery encodes. The pTable and
|
|
** pDatabase parameters are NULL for subqueries. The pOn and pUsing
|
|
** parameters are the content of the ON and USING clauses.
|
|
**
|
|
** Return a new SrcList which encodes is the FROM with the new
|
|
** term added.
|
|
*/
|
|
SrcList *sqlite3SrcListAppendFromTerm(
|
|
Parse *pParse, /* Parsing context */
|
|
SrcList *p, /* The left part of the FROM clause already seen */
|
|
Token *pTable, /* Name of the table to add to the FROM clause */
|
|
Token *pDatabase, /* Name of the database containing pTable */
|
|
Token *pAlias, /* The right-hand side of the AS subexpression */
|
|
Select *pSubquery, /* A subquery used in place of a table name */
|
|
OnOrUsing *pOnUsing /* Either the ON clause or the USING clause */
|
|
){
|
|
SrcItem *pItem;
|
|
sqlite3 *db = pParse->db;
|
|
if( !p && pOnUsing!=0 && (pOnUsing->pOn || pOnUsing->pUsing) ){
|
|
sqlite3ErrorMsg(pParse, "a JOIN clause is required before %s",
|
|
(pOnUsing->pOn ? "ON" : "USING")
|
|
);
|
|
goto append_from_error;
|
|
}
|
|
p = sqlite3SrcListAppend(pParse, p, pTable, pDatabase);
|
|
if( p==0 ){
|
|
goto append_from_error;
|
|
}
|
|
assert( p->nSrc>0 );
|
|
pItem = &p->a[p->nSrc-1];
|
|
assert( (pTable==0)==(pDatabase==0) );
|
|
assert( pItem->zName==0 || pDatabase!=0 );
|
|
if( IN_RENAME_OBJECT && pItem->zName ){
|
|
Token *pToken = (ALWAYS(pDatabase) && pDatabase->z) ? pDatabase : pTable;
|
|
sqlite3RenameTokenMap(pParse, pItem->zName, pToken);
|
|
}
|
|
assert( pAlias!=0 );
|
|
if( pAlias->n ){
|
|
pItem->zAlias = sqlite3NameFromToken(db, pAlias);
|
|
}
|
|
assert( pSubquery==0 || pDatabase==0 );
|
|
if( pSubquery ){
|
|
if( sqlite3SrcItemAttachSubquery(pParse, pItem, pSubquery, 0) ){
|
|
if( pSubquery->selFlags & SF_NestedFrom ){
|
|
pItem->fg.isNestedFrom = 1;
|
|
}
|
|
}
|
|
}
|
|
assert( pOnUsing==0 || pOnUsing->pOn==0 || pOnUsing->pUsing==0 );
|
|
assert( pItem->fg.isUsing==0 );
|
|
if( pOnUsing==0 ){
|
|
pItem->u3.pOn = 0;
|
|
}else if( pOnUsing->pUsing ){
|
|
pItem->fg.isUsing = 1;
|
|
pItem->u3.pUsing = pOnUsing->pUsing;
|
|
}else{
|
|
pItem->u3.pOn = pOnUsing->pOn;
|
|
}
|
|
return p;
|
|
|
|
append_from_error:
|
|
assert( p==0 );
|
|
sqlite3ClearOnOrUsing(db, pOnUsing);
|
|
sqlite3SelectDelete(db, pSubquery);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
** Add an INDEXED BY or NOT INDEXED clause to the most recently added
|
|
** element of the source-list passed as the second argument.
|
|
*/
|
|
void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){
|
|
assert( pIndexedBy!=0 );
|
|
if( p && pIndexedBy->n>0 ){
|
|
SrcItem *pItem;
|
|
assert( p->nSrc>0 );
|
|
pItem = &p->a[p->nSrc-1];
|
|
assert( pItem->fg.notIndexed==0 );
|
|
assert( pItem->fg.isIndexedBy==0 );
|
|
assert( pItem->fg.isTabFunc==0 );
|
|
if( pIndexedBy->n==1 && !pIndexedBy->z ){
|
|
/* A "NOT INDEXED" clause was supplied. See parse.y
|
|
** construct "indexed_opt" for details. */
|
|
pItem->fg.notIndexed = 1;
|
|
}else{
|
|
pItem->u1.zIndexedBy = sqlite3NameFromToken(pParse->db, pIndexedBy);
|
|
pItem->fg.isIndexedBy = 1;
|
|
assert( pItem->fg.isCte==0 ); /* No collision on union u2 */
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Append the contents of SrcList p2 to SrcList p1 and return the resulting
|
|
** SrcList. Or, if an error occurs, return NULL. In all cases, p1 and p2
|
|
** are deleted by this function.
|
|
*/
|
|
SrcList *sqlite3SrcListAppendList(Parse *pParse, SrcList *p1, SrcList *p2){
|
|
assert( p1 && p1->nSrc==1 );
|
|
if( p2 ){
|
|
SrcList *pNew = sqlite3SrcListEnlarge(pParse, p1, p2->nSrc, 1);
|
|
if( pNew==0 ){
|
|
sqlite3SrcListDelete(pParse->db, p2);
|
|
}else{
|
|
p1 = pNew;
|
|
memcpy(&p1->a[1], p2->a, p2->nSrc*sizeof(SrcItem));
|
|
sqlite3DbFree(pParse->db, p2);
|
|
p1->a[0].fg.jointype |= (JT_LTORJ & p1->a[1].fg.jointype);
|
|
}
|
|
}
|
|
return p1;
|
|
}
|
|
|
|
/*
|
|
** Add the list of function arguments to the SrcList entry for a
|
|
** table-valued-function.
|
|
*/
|
|
void sqlite3SrcListFuncArgs(Parse *pParse, SrcList *p, ExprList *pList){
|
|
if( p ){
|
|
SrcItem *pItem = &p->a[p->nSrc-1];
|
|
assert( pItem->fg.notIndexed==0 );
|
|
assert( pItem->fg.isIndexedBy==0 );
|
|
assert( pItem->fg.isTabFunc==0 );
|
|
pItem->u1.pFuncArg = pList;
|
|
pItem->fg.isTabFunc = 1;
|
|
}else{
|
|
sqlite3ExprListDelete(pParse->db, pList);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** When building up a FROM clause in the parser, the join operator
|
|
** is initially attached to the left operand. But the code generator
|
|
** expects the join operator to be on the right operand. This routine
|
|
** Shifts all join operators from left to right for an entire FROM
|
|
** clause.
|
|
**
|
|
** Example: Suppose the join is like this:
|
|
**
|
|
** A natural cross join B
|
|
**
|
|
** The operator is "natural cross join". The A and B operands are stored
|
|
** in p->a[0] and p->a[1], respectively. The parser initially stores the
|
|
** operator with A. This routine shifts that operator over to B.
|
|
**
|
|
** Additional changes:
|
|
**
|
|
** * All tables to the left of the right-most RIGHT JOIN are tagged with
|
|
** JT_LTORJ (mnemonic: Left Table Of Right Join) so that the
|
|
** code generator can easily tell that the table is part of
|
|
** the left operand of at least one RIGHT JOIN.
|
|
*/
|
|
void sqlite3SrcListShiftJoinType(Parse *pParse, SrcList *p){
|
|
(void)pParse;
|
|
if( p && p->nSrc>1 ){
|
|
int i = p->nSrc-1;
|
|
u8 allFlags = 0;
|
|
do{
|
|
allFlags |= p->a[i].fg.jointype = p->a[i-1].fg.jointype;
|
|
}while( (--i)>0 );
|
|
p->a[0].fg.jointype = 0;
|
|
|
|
/* All terms to the left of a RIGHT JOIN should be tagged with the
|
|
** JT_LTORJ flags */
|
|
if( allFlags & JT_RIGHT ){
|
|
for(i=p->nSrc-1; ALWAYS(i>0) && (p->a[i].fg.jointype&JT_RIGHT)==0; i--){}
|
|
i--;
|
|
assert( i>=0 );
|
|
do{
|
|
p->a[i].fg.jointype |= JT_LTORJ;
|
|
}while( (--i)>=0 );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Generate VDBE code for a BEGIN statement.
|
|
*/
|
|
void sqlite3BeginTransaction(Parse *pParse, int type){
|
|
sqlite3 *db;
|
|
Vdbe *v;
|
|
int i;
|
|
|
|
assert( pParse!=0 );
|
|
db = pParse->db;
|
|
assert( db!=0 );
|
|
if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ){
|
|
return;
|
|
}
|
|
v = sqlite3GetVdbe(pParse);
|
|
if( !v ) return;
|
|
if( type!=TK_DEFERRED ){
|
|
for(i=0; i<db->nDb; i++){
|
|
int eTxnType;
|
|
Btree *pBt = db->aDb[i].pBt;
|
|
if( pBt && sqlite3BtreeIsReadonly(pBt) ){
|
|
eTxnType = 0; /* Read txn */
|
|
}else if( type==TK_EXCLUSIVE ){
|
|
eTxnType = 2; /* Exclusive txn */
|
|
}else{
|
|
eTxnType = 1; /* Write txn */
|
|
}
|
|
sqlite3VdbeAddOp2(v, OP_Transaction, i, eTxnType);
|
|
sqlite3VdbeUsesBtree(v, i);
|
|
}
|
|
}
|
|
sqlite3VdbeAddOp0(v, OP_AutoCommit);
|
|
}
|
|
|
|
/*
|
|
** Generate VDBE code for a COMMIT or ROLLBACK statement.
|
|
** Code for ROLLBACK is generated if eType==TK_ROLLBACK. Otherwise
|
|
** code is generated for a COMMIT.
|
|
*/
|
|
void sqlite3EndTransaction(Parse *pParse, int eType){
|
|
Vdbe *v;
|
|
int isRollback;
|
|
|
|
assert( pParse!=0 );
|
|
assert( pParse->db!=0 );
|
|
assert( eType==TK_COMMIT || eType==TK_END || eType==TK_ROLLBACK );
|
|
isRollback = eType==TK_ROLLBACK;
|
|
if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION,
|
|
isRollback ? "ROLLBACK" : "COMMIT", 0, 0) ){
|
|
return;
|
|
}
|
|
v = sqlite3GetVdbe(pParse);
|
|
if( v ){
|
|
sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, isRollback);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** This function is called by the parser when it parses a command to create,
|
|
** release or rollback an SQL savepoint.
|
|
*/
|
|
void sqlite3Savepoint(Parse *pParse, int op, Token *pName){
|
|
char *zName = sqlite3NameFromToken(pParse->db, pName);
|
|
if( zName ){
|
|
Vdbe *v = sqlite3GetVdbe(pParse);
|
|
#ifndef SQLITE_OMIT_AUTHORIZATION
|
|
static const char * const az[] = { "BEGIN", "RELEASE", "ROLLBACK" };
|
|
assert( !SAVEPOINT_BEGIN && SAVEPOINT_RELEASE==1 && SAVEPOINT_ROLLBACK==2 );
|
|
#endif
|
|
if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
|
|
sqlite3DbFree(pParse->db, zName);
|
|
return;
|
|
}
|
|
sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Make sure the TEMP database is open and available for use. Return
|
|
** the number of errors. Leave any error messages in the pParse structure.
|
|
*/
|
|
int sqlite3OpenTempDatabase(Parse *pParse){
|
|
sqlite3 *db = pParse->db;
|
|
if( db->aDb[1].pBt==0 && !pParse->explain ){
|
|
int rc;
|
|
Btree *pBt;
|
|
static const int flags =
|
|
SQLITE_OPEN_READWRITE |
|
|
SQLITE_OPEN_CREATE |
|
|
SQLITE_OPEN_EXCLUSIVE |
|
|
SQLITE_OPEN_DELETEONCLOSE |
|
|
SQLITE_OPEN_TEMP_DB;
|
|
|
|
rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pBt, 0, flags);
|
|
if( rc!=SQLITE_OK ){
|
|
sqlite3ErrorMsg(pParse, "unable to open a temporary database "
|
|
"file for storing temporary tables");
|
|
pParse->rc = rc;
|
|
return 1;
|
|
}
|
|
db->aDb[1].pBt = pBt;
|
|
assert( db->aDb[1].pSchema );
|
|
if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, 0, 0) ){
|
|
sqlite3OomFault(db);
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
** Record the fact that the schema cookie will need to be verified
|
|
** for database iDb. The code to actually verify the schema cookie
|
|
** will occur at the end of the top-level VDBE and will be generated
|
|
** later, by sqlite3FinishCoding().
|
|
*/
|
|
static void sqlite3CodeVerifySchemaAtToplevel(Parse *pToplevel, int iDb){
|
|
assert( iDb>=0 && iDb<pToplevel->db->nDb );
|
|
assert( pToplevel->db->aDb[iDb].pBt!=0 || iDb==1 );
|
|
assert( iDb<SQLITE_MAX_DB );
|
|
assert( sqlite3SchemaMutexHeld(pToplevel->db, iDb, 0) );
|
|
if( DbMaskTest(pToplevel->cookieMask, iDb)==0 ){
|
|
DbMaskSet(pToplevel->cookieMask, iDb);
|
|
if( !OMIT_TEMPDB && iDb==1 ){
|
|
sqlite3OpenTempDatabase(pToplevel);
|
|
}
|
|
}
|
|
}
|
|
void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
|
|
sqlite3CodeVerifySchemaAtToplevel(sqlite3ParseToplevel(pParse), iDb);
|
|
}
|
|
|
|
|
|
/*
|
|
** If argument zDb is NULL, then call sqlite3CodeVerifySchema() for each
|
|
** attached database. Otherwise, invoke it for the database named zDb only.
|
|
*/
|
|
void sqlite3CodeVerifyNamedSchema(Parse *pParse, const char *zDb){
|
|
sqlite3 *db = pParse->db;
|
|
int i;
|
|
for(i=0; i<db->nDb; i++){
|
|
Db *pDb = &db->aDb[i];
|
|
if( pDb->pBt && (!zDb || 0==sqlite3StrICmp(zDb, pDb->zDbSName)) ){
|
|
sqlite3CodeVerifySchema(pParse, i);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Generate VDBE code that prepares for doing an operation that
|
|
** might change the database.
|
|
**
|
|
** This routine starts a new transaction if we are not already within
|
|
** a transaction. If we are already within a transaction, then a checkpoint
|
|
** is set if the setStatement parameter is true. A checkpoint should
|
|
** be set for operations that might fail (due to a constraint) part of
|
|
** the way through and which will need to undo some writes without having to
|
|
** rollback the whole transaction. For operations where all constraints
|
|
** can be checked before any changes are made to the database, it is never
|
|
** necessary to undo a write and the checkpoint should not be set.
|
|
*/
|
|
void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
|
|
Parse *pToplevel = sqlite3ParseToplevel(pParse);
|
|
sqlite3CodeVerifySchemaAtToplevel(pToplevel, iDb);
|
|
DbMaskSet(pToplevel->writeMask, iDb);
|
|
pToplevel->isMultiWrite |= setStatement;
|
|
}
|
|
|
|
/*
|
|
** Indicate that the statement currently under construction might write
|
|
** more than one entry (example: deleting one row then inserting another,
|
|
** inserting multiple rows in a table, or inserting a row and index entries.)
|
|
** If an abort occurs after some of these writes have completed, then it will
|
|
** be necessary to undo the completed writes.
|
|
*/
|
|
void sqlite3MultiWrite(Parse *pParse){
|
|
Parse *pToplevel = sqlite3ParseToplevel(pParse);
|
|
pToplevel->isMultiWrite = 1;
|
|
}
|
|
|
|
/*
|
|
** The code generator calls this routine if is discovers that it is
|
|
** possible to abort a statement prior to completion. In order to
|
|
** perform this abort without corrupting the database, we need to make
|
|
** sure that the statement is protected by a statement transaction.
|
|
**
|
|
** Technically, we only need to set the mayAbort flag if the
|
|
** isMultiWrite flag was previously set. There is a time dependency
|
|
** such that the abort must occur after the multiwrite. This makes
|
|
** some statements involving the REPLACE conflict resolution algorithm
|
|
** go a little faster. But taking advantage of this time dependency
|
|
** makes it more difficult to prove that the code is correct (in
|
|
** particular, it prevents us from writing an effective
|
|
** implementation of sqlite3AssertMayAbort()) and so we have chosen
|
|
** to take the safe route and skip the optimization.
|
|
*/
|
|
void sqlite3MayAbort(Parse *pParse){
|
|
Parse *pToplevel = sqlite3ParseToplevel(pParse);
|
|
pToplevel->mayAbort = 1;
|
|
}
|
|
|
|
/*
|
|
** Code an OP_Halt that causes the vdbe to return an SQLITE_CONSTRAINT
|
|
** error. The onError parameter determines which (if any) of the statement
|
|
** and/or current transaction is rolled back.
|
|
*/
|
|
void sqlite3HaltConstraint(
|
|
Parse *pParse, /* Parsing context */
|
|
int errCode, /* extended error code */
|
|
int onError, /* Constraint type */
|
|
char *p4, /* Error message */
|
|
i8 p4type, /* P4_STATIC or P4_TRANSIENT */
|
|
u8 p5Errmsg /* P5_ErrMsg type */
|
|
){
|
|
Vdbe *v;
|
|
assert( pParse->pVdbe!=0 );
|
|
v = sqlite3GetVdbe(pParse);
|
|
assert( (errCode&0xff)==SQLITE_CONSTRAINT || pParse->nested );
|
|
if( onError==OE_Abort ){
|
|
sqlite3MayAbort(pParse);
|
|
}
|
|
sqlite3VdbeAddOp4(v, OP_Halt, errCode, onError, 0, p4, p4type);
|
|
sqlite3VdbeChangeP5(v, p5Errmsg);
|
|
}
|
|
|
|
/*
|
|
** Code an OP_Halt due to UNIQUE or PRIMARY KEY constraint violation.
|
|
*/
|
|
void sqlite3UniqueConstraint(
|
|
Parse *pParse, /* Parsing context */
|
|
int onError, /* Constraint type */
|
|
Index *pIdx /* The index that triggers the constraint */
|
|
){
|
|
char *zErr;
|
|
int j;
|
|
StrAccum errMsg;
|
|
Table *pTab = pIdx->pTable;
|
|
|
|
sqlite3StrAccumInit(&errMsg, pParse->db, 0, 0,
|
|
pParse->db->aLimit[SQLITE_LIMIT_LENGTH]);
|
|
if( pIdx->aColExpr ){
|
|
sqlite3_str_appendf(&errMsg, "index '%q'", pIdx->zName);
|
|
}else{
|
|
for(j=0; j<pIdx->nKeyCol; j++){
|
|
char *zCol;
|
|
assert( pIdx->aiColumn[j]>=0 );
|
|
zCol = pTab->aCol[pIdx->aiColumn[j]].zCnName;
|
|
if( j ) sqlite3_str_append(&errMsg, ", ", 2);
|
|
sqlite3_str_appendall(&errMsg, pTab->zName);
|
|
sqlite3_str_append(&errMsg, ".", 1);
|
|
sqlite3_str_appendall(&errMsg, zCol);
|
|
}
|
|
}
|
|
zErr = sqlite3StrAccumFinish(&errMsg);
|
|
sqlite3HaltConstraint(pParse,
|
|
IsPrimaryKeyIndex(pIdx) ? SQLITE_CONSTRAINT_PRIMARYKEY
|
|
: SQLITE_CONSTRAINT_UNIQUE,
|
|
onError, zErr, P4_DYNAMIC, P5_ConstraintUnique);
|
|
}
|
|
|
|
|
|
/*
|
|
** Code an OP_Halt due to non-unique rowid.
|
|
*/
|
|
void sqlite3RowidConstraint(
|
|
Parse *pParse, /* Parsing context */
|
|
int onError, /* Conflict resolution algorithm */
|
|
Table *pTab /* The table with the non-unique rowid */
|
|
){
|
|
char *zMsg;
|
|
int rc;
|
|
if( pTab->iPKey>=0 ){
|
|
zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
|
|
pTab->aCol[pTab->iPKey].zCnName);
|
|
rc = SQLITE_CONSTRAINT_PRIMARYKEY;
|
|
}else{
|
|
zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
|
|
rc = SQLITE_CONSTRAINT_ROWID;
|
|
}
|
|
sqlite3HaltConstraint(pParse, rc, onError, zMsg, P4_DYNAMIC,
|
|
P5_ConstraintUnique);
|
|
}
|
|
|
|
/*
|
|
** Check to see if pIndex uses the collating sequence pColl. Return
|
|
** true if it does and false if it does not.
|
|
*/
|
|
#ifndef SQLITE_OMIT_REINDEX
|
|
static int collationMatch(const char *zColl, Index *pIndex){
|
|
int i;
|
|
assert( zColl!=0 );
|
|
for(i=0; i<pIndex->nColumn; i++){
|
|
const char *z = pIndex->azColl[i];
|
|
assert( z!=0 || pIndex->aiColumn[i]<0 );
|
|
if( pIndex->aiColumn[i]>=0 && 0==sqlite3StrICmp(z, zColl) ){
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
** Recompute all indices of pTab that use the collating sequence pColl.
|
|
** If pColl==0 then recompute all indices of pTab.
|
|
*/
|
|
#ifndef SQLITE_OMIT_REINDEX
|
|
static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){
|
|
if( !IsVirtual(pTab) ){
|
|
Index *pIndex; /* An index associated with pTab */
|
|
|
|
for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
|
|
if( zColl==0 || collationMatch(zColl, pIndex) ){
|
|
int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
|
|
sqlite3BeginWriteOperation(pParse, 0, iDb);
|
|
sqlite3RefillIndex(pParse, pIndex, -1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
** Recompute all indices of all tables in all databases where the
|
|
** indices use the collating sequence pColl. If pColl==0 then recompute
|
|
** all indices everywhere.
|
|
*/
|
|
#ifndef SQLITE_OMIT_REINDEX
|
|
static void reindexDatabases(Parse *pParse, char const *zColl){
|
|
Db *pDb; /* A single database */
|
|
int iDb; /* The database index number */
|
|
sqlite3 *db = pParse->db; /* The database connection */
|
|
HashElem *k; /* For looping over tables in pDb */
|
|
Table *pTab; /* A table in the database */
|
|
|
|
assert( sqlite3BtreeHoldsAllMutexes(db) ); /* Needed for schema access */
|
|
for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
|
|
assert( pDb!=0 );
|
|
for(k=sqliteHashFirst(&pDb->pSchema->tblHash); k; k=sqliteHashNext(k)){
|
|
pTab = (Table*)sqliteHashData(k);
|
|
reindexTable(pParse, pTab, zColl);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
** Generate code for the REINDEX command.
|
|
**
|
|
** REINDEX -- 1
|
|
** REINDEX <collation> -- 2
|
|
** REINDEX ?<database>.?<tablename> -- 3
|
|
** REINDEX ?<database>.?<indexname> -- 4
|
|
**
|
|
** Form 1 causes all indices in all attached databases to be rebuilt.
|
|
** Form 2 rebuilds all indices in all databases that use the named
|
|
** collating function. Forms 3 and 4 rebuild the named index or all
|
|
** indices associated with the named table.
|
|
*/
|
|
#ifndef SQLITE_OMIT_REINDEX
|
|
void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){
|
|
CollSeq *pColl; /* Collating sequence to be reindexed, or NULL */
|
|
char *z; /* Name of a table or index */
|
|
const char *zDb; /* Name of the database */
|
|
Table *pTab; /* A table in the database */
|
|
Index *pIndex; /* An index associated with pTab */
|
|
int iDb; /* The database index number */
|
|
sqlite3 *db = pParse->db; /* The database connection */
|
|
Token *pObjName; /* Name of the table or index to be reindexed */
|
|
|
|
/* Read the database schema. If an error occurs, leave an error message
|
|
** and code in pParse and return NULL. */
|
|
if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
|
|
return;
|
|
}
|
|
|
|
if( pName1==0 ){
|
|
reindexDatabases(pParse, 0);
|
|
return;
|
|
}else if( NEVER(pName2==0) || pName2->z==0 ){
|
|
char *zColl;
|
|
assert( pName1->z );
|
|
zColl = sqlite3NameFromToken(pParse->db, pName1);
|
|
if( !zColl ) return;
|
|
pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
|
|
if( pColl ){
|
|
reindexDatabases(pParse, zColl);
|
|
sqlite3DbFree(db, zColl);
|
|
return;
|
|
}
|
|
sqlite3DbFree(db, zColl);
|
|
}
|
|
iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName);
|
|
if( iDb<0 ) return;
|
|
z = sqlite3NameFromToken(db, pObjName);
|
|
if( z==0 ) return;
|
|
zDb = pName2->n ? db->aDb[iDb].zDbSName : 0;
|
|
pTab = sqlite3FindTable(db, z, zDb);
|
|
if( pTab ){
|
|
reindexTable(pParse, pTab, 0);
|
|
sqlite3DbFree(db, z);
|
|
return;
|
|
}
|
|
pIndex = sqlite3FindIndex(db, z, zDb);
|
|
sqlite3DbFree(db, z);
|
|
if( pIndex ){
|
|
iDb = sqlite3SchemaToIndex(db, pIndex->pTable->pSchema);
|
|
sqlite3BeginWriteOperation(pParse, 0, iDb);
|
|
sqlite3RefillIndex(pParse, pIndex, -1);
|
|
return;
|
|
}
|
|
sqlite3ErrorMsg(pParse, "unable to identify the object to be reindexed");
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
** Return a KeyInfo structure that is appropriate for the given Index.
|
|
**
|
|
** The caller should invoke sqlite3KeyInfoUnref() on the returned object
|
|
** when it has finished using it.
|
|
*/
|
|
KeyInfo *sqlite3KeyInfoOfIndex(Parse *pParse, Index *pIdx){
|
|
int i;
|
|
int nCol = pIdx->nColumn;
|
|
int nKey = pIdx->nKeyCol;
|
|
KeyInfo *pKey;
|
|
if( pParse->nErr ) return 0;
|
|
if( pIdx->uniqNotNull ){
|
|
pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
|
|
}else{
|
|
pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
|
|
}
|
|
if( pKey ){
|
|
assert( sqlite3KeyInfoIsWriteable(pKey) );
|
|
for(i=0; i<nCol; i++){
|
|
const char *zColl = pIdx->azColl[i];
|
|
pKey->aColl[i] = zColl==sqlite3StrBINARY ? 0 :
|
|
sqlite3LocateCollSeq(pParse, zColl);
|
|
pKey->aSortFlags[i] = pIdx->aSortOrder[i];
|
|
assert( 0==(pKey->aSortFlags[i] & KEYINFO_ORDER_BIGNULL) );
|
|
}
|
|
if( pParse->nErr ){
|
|
assert( pParse->rc==SQLITE_ERROR_MISSING_COLLSEQ );
|
|
if( pIdx->bNoQuery==0 ){
|
|
/* Deactivate the index because it contains an unknown collating
|
|
** sequence. The only way to reactive the index is to reload the
|
|
** schema. Adding the missing collating sequence later does not
|
|
** reactive the index. The application had the chance to register
|
|
** the missing index using the collation-needed callback. For
|
|
** simplicity, SQLite will not give the application a second chance.
|
|
*/
|
|
pIdx->bNoQuery = 1;
|
|
pParse->rc = SQLITE_ERROR_RETRY;
|
|
}
|
|
sqlite3KeyInfoUnref(pKey);
|
|
pKey = 0;
|
|
}
|
|
}
|
|
return pKey;
|
|
}
|
|
|
|
#ifndef SQLITE_OMIT_CTE
|
|
/*
|
|
** Create a new CTE object
|
|
*/
|
|
Cte *sqlite3CteNew(
|
|
Parse *pParse, /* Parsing context */
|
|
Token *pName, /* Name of the common-table */
|
|
ExprList *pArglist, /* Optional column name list for the table */
|
|
Select *pQuery, /* Query used to initialize the table */
|
|
u8 eM10d /* The MATERIALIZED flag */
|
|
){
|
|
Cte *pNew;
|
|
sqlite3 *db = pParse->db;
|
|
|
|
pNew = sqlite3DbMallocZero(db, sizeof(*pNew));
|
|
assert( pNew!=0 || db->mallocFailed );
|
|
|
|
if( db->mallocFailed ){
|
|
sqlite3ExprListDelete(db, pArglist);
|
|
sqlite3SelectDelete(db, pQuery);
|
|
}else{
|
|
pNew->pSelect = pQuery;
|
|
pNew->pCols = pArglist;
|
|
pNew->zName = sqlite3NameFromToken(pParse->db, pName);
|
|
pNew->eM10d = eM10d;
|
|
}
|
|
return pNew;
|
|
}
|
|
|
|
/*
|
|
** Clear information from a Cte object, but do not deallocate storage
|
|
** for the object itself.
|
|
*/
|
|
static void cteClear(sqlite3 *db, Cte *pCte){
|
|
assert( pCte!=0 );
|
|
sqlite3ExprListDelete(db, pCte->pCols);
|
|
sqlite3SelectDelete(db, pCte->pSelect);
|
|
sqlite3DbFree(db, pCte->zName);
|
|
}
|
|
|
|
/*
|
|
** Free the contents of the CTE object passed as the second argument.
|
|
*/
|
|
void sqlite3CteDelete(sqlite3 *db, Cte *pCte){
|
|
assert( pCte!=0 );
|
|
cteClear(db, pCte);
|
|
sqlite3DbFree(db, pCte);
|
|
}
|
|
|
|
/*
|
|
** This routine is invoked once per CTE by the parser while parsing a
|
|
** WITH clause. The CTE described by the third argument is added to
|
|
** the WITH clause of the second argument. If the second argument is
|
|
** NULL, then a new WITH argument is created.
|
|
*/
|
|
With *sqlite3WithAdd(
|
|
Parse *pParse, /* Parsing context */
|
|
With *pWith, /* Existing WITH clause, or NULL */
|
|
Cte *pCte /* CTE to add to the WITH clause */
|
|
){
|
|
sqlite3 *db = pParse->db;
|
|
With *pNew;
|
|
char *zName;
|
|
|
|
if( pCte==0 ){
|
|
return pWith;
|
|
}
|
|
|
|
/* Check that the CTE name is unique within this WITH clause. If
|
|
** not, store an error in the Parse structure. */
|
|
zName = pCte->zName;
|
|
if( zName && pWith ){
|
|
int i;
|
|
for(i=0; i<pWith->nCte; i++){
|
|
if( sqlite3StrICmp(zName, pWith->a[i].zName)==0 ){
|
|
sqlite3ErrorMsg(pParse, "duplicate WITH table name: %s", zName);
|
|
}
|
|
}
|
|
}
|
|
|
|
if( pWith ){
|
|
sqlite3_int64 nByte = sizeof(*pWith) + (sizeof(pWith->a[1]) * pWith->nCte);
|
|
pNew = sqlite3DbRealloc(db, pWith, nByte);
|
|
}else{
|
|
pNew = sqlite3DbMallocZero(db, sizeof(*pWith));
|
|
}
|
|
assert( (pNew!=0 && zName!=0) || db->mallocFailed );
|
|
|
|
if( db->mallocFailed ){
|
|
sqlite3CteDelete(db, pCte);
|
|
pNew = pWith;
|
|
}else{
|
|
pNew->a[pNew->nCte++] = *pCte;
|
|
sqlite3DbFree(db, pCte);
|
|
}
|
|
|
|
return pNew;
|
|
}
|
|
|
|
/*
|
|
** Free the contents of the With object passed as the second argument.
|
|
*/
|
|
void sqlite3WithDelete(sqlite3 *db, With *pWith){
|
|
if( pWith ){
|
|
int i;
|
|
for(i=0; i<pWith->nCte; i++){
|
|
cteClear(db, &pWith->a[i]);
|
|
}
|
|
sqlite3DbFree(db, pWith);
|
|
}
|
|
}
|
|
void sqlite3WithDeleteGeneric(sqlite3 *db, void *pWith){
|
|
sqlite3WithDelete(db, (With*)pWith);
|
|
}
|
|
#endif /* !defined(SQLITE_OMIT_CTE) */
|