Lines Matching refs:pTab
11250 Table *pTab; /* Source table */
11331 ** is a disk table or the "old.*" pseudo-table, then pTab points to the
11390 Table *pTab; /* Table for TK_COLUMN expressions. */
11568 Table *pTab; /* An SQL table corresponding to zName */
11584 Bitmask colUsed; /* Bit N (1<<N) set if column N of pTab is used */
11834 Table *pTab; /* Table this info block refers to */
11835 int iDb; /* Index in sqlite3.aDb[] of database holding pTab */
74684 Table *pTab;
74705 pTab = sqlite3LocateTable(pParse, 0, zTable, zDb);
74706 if( pTab && IsVirtual(pTab) ){
74707 pTab = 0;
74710 if( pTab && !HasRowid(pTab) ){
74711 pTab = 0;
74715 if( pTab && pTab->pSelect ){
74716 pTab = 0;
74720 if( !pTab ){
74731 /* Now search pTab for the exact column. */
74732 for(iCol=0; iCol<pTab->nCol; iCol++) {
74733 if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
74737 if( iCol==pTab->nCol ){
74759 for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){
74769 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
74790 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
74794 pTab->pSchema->schema_cookie,
74795 pTab->pSchema->iGeneration);
74807 sqlite3VdbeChangeP2(v, 1, pTab->tnum);
74809 sqlite3VdbeChangeP4(v, 1, pTab->zName, P4_TRANSIENT);
74813 ** parameter of the other to pTab->tnum. */
74815 sqlite3VdbeChangeP2(v, 2 + flags, pTab->tnum);
74825 sqlite3VdbeChangeP4(v, 2+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32);
74826 sqlite3VdbeChangeP2(v, 6, pTab->nCol);
76962 ** pExpr->pTab Points to the Table structure of X.Y (even if
76997 Table *pTab = 0; /* Table hold the row */
76998 Column *pCol; /* A column of pTab */
77006 pExpr->pTab = 0;
77039 pTab = pItem->pTab;
77040 assert( pTab!=0 && pTab->zName!=0 );
77041 assert( pTab->nCol>0 );
77056 if( zDb && pTab->pSchema!=pSchema ){
77060 const char *zTabName = pItem->zAlias ? pItem->zAlias : pTab->zName;
77069 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
77082 pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j;
77089 pExpr->pTab = pMatch->pTab;
77090 pSchema = pExpr->pTab->pSchema;
77103 pTab = pParse->pTriggerTab;
77106 pTab = pParse->pTriggerTab;
77108 pTab = 0;
77111 if( pTab ){
77113 pSchema = pTab->pSchema;
77115 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
77117 if( iCol==pTab->iPKey ){
77123 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && HasRowid(pTab) ){
77128 if( iCol<pTab->nCol ){
77142 pExpr->pTab = pTab;
77153 && HasRowid(pMatch->pTab) ){
77223 pExpr->pTab = 0;
77296 p->pTab = pItem->pTab;
77298 if( p->pTab->iPKey==iCol ){
77401 pExpr->pTab = pItem->pTab;
78088 ** Expr.pTab Points to the Table object for X.Y
78197 Table *pTab, /* The table being referenced */
78210 sSrc.a[0].zName = pTab->zName;
78211 sSrc.a[0].pTab = pTab;
78275 && pExpr->pTab!=0
78277 /* op==TK_REGISTER && pExpr->pTab!=0 happens when pExpr was originally
78281 assert( pExpr->pTab && j<pExpr->pTab->nCol );
78282 return pExpr->pTab->aCol[j].affinity;
78361 if( p->pTab!=0
78365 /* op==TK_REGISTER && p->pTab!=0 happens when pExpr was originally
78369 const char *zColl = p->pTab->aCol[j].zColl;
79225 Table *pTab;
79240 pTab = pNewItem->pTab = pOldItem->pTab;
79241 if( pTab ){
79242 pTab->nRef++;
79598 assert( p->pTab!=0 );
79599 return p->iColumn>=0 && p->pTab->aCol[p->iColumn].notNull==0;
79671 Table *pTab;
79687 pTab = pSrc->a[0].pTab;
79688 if( NEVER(pTab==0) ) return 0;
79689 assert( pTab->pSelect==0 ); /* FROM clause is not a view */
79690 if( IsVirtual(pTab) ) return 0; /* FROM clause not a virtual table */
79829 Table *pTab; /* Table <table>. */
79832 i16 iDb; /* Database idx for pTab */
79838 pTab = p->pSrc->a[0].pTab;
79843 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
79845 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
79856 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
79872 int affinity_ok = sqlite3IndexAffinityOk(pX, pTab->aCol[iCol].affinity);
79874 for(pIdx=pTab->pIndex; pIdx && eType==0 && affinity_ok; pIdx=pIdx->pNext){
79886 if( prRhsHasNull && !pTab->aCol[iCol].notNull ){
80569 Table *pTab, /* The table containing the value */
80574 if( iCol<0 || iCol==pTab->iPKey ){
80577 int op = IsVirtual(pTab) ? OP_VColumn : OP_Column;
80579 if( !HasRowid(pTab) ){
80580 x = sqlite3ColumnOfIndex(sqlite3PrimaryKeyIndex(pTab), iCol);
80585 sqlite3ColumnDefault(v, pTab, iCol, regOut);
80591 ** table pTab and store the column value in a register. An effort
80595 ** There must be an open cursor to pTab in iTable when this routine
80600 Table *pTab, /* Description of the table we are reading from */
80618 sqlite3ExprCodeGetColumnOfTable(v, pTab, iTable, iColumn, iReg);
80760 inReg = sqlite3ExprCodeGetColumn(pParse, pExpr->pTab,
81191 Table *pTab = pExpr->pTab;
81192 int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn;
81195 assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
81196 assert( pTab->iPKey<0 || pExpr->iColumn!=pTab->iPKey );
81197 assert( p1>=0 && p1<(pTab->nCol*2+2) );
81202 (pExpr->iColumn<0 ? "rowid" : pExpr->pTab->aCol[pExpr->iColumn].zName),
81210 && pTab->aCol[pExpr->iColumn].affinity==SQLITE_AFF_REAL
82387 pCol->pTab = pExpr->pTab;
82859 ** tables that have foreign key constraints that refer to table pTab (i.e.
82860 ** constraints for which pTab is the parent table) from the sqlite_master
82863 static char *whereForeignKeys(Parse *pParse, Table *pTab){
82866 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
82875 ** temporary triggers on table pTab from the sqlite_temp_master table. If
82876 ** table pTab has no temporary triggers, or is itself stored in the
82879 static char *whereTempTriggers(Parse *pParse, Table *pTab){
82889 if( pTab->pSchema!=pTempSchema ){
82891 for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
82907 ** pTab from the database, including triggers and temporary triggers.
82910 ** pTab->zName if this function is being called to code part of an
82913 static void reloadTableSchema(Parse *pParse, Table *pTab, const char *zName){
82916 int iDb; /* Index of database containing pTab */
82924 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
82929 for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
82937 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
82948 if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){
82981 Table *pTab; /* Table being renamed */
82998 pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
82999 if( !pTab ) goto exit_rename_table;
83000 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
83020 if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
83028 if( pTab->pSelect ){
83029 sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
83036 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
83042 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
83045 if( IsVirtual(pTab) ){
83046 pVTab = sqlite3GetVTable(db, pTab);
83080 zTabName = pTab->zName;
83088 if( (zWhere=whereForeignKeys(pParse, pTab))!=0 ){
83130 zDb, zName, pTab->zName);
83139 if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){
83152 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
83154 if( pFrom!=pTab ){
83162 reloadTableSchema(pParse, pTab, zName);
83207 Table *pTab; /* Table being altered */
83227 pTab = sqlite3FindTable(db, zTab, zDb);
83228 assert( pTab );
83232 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
83311 reloadTableSchema(pParse, pTab, pTab->zName);
83331 Table *pTab;
83342 pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
83343 if( !pTab ) goto exit_begin_add_column;
83346 if( IsVirtual(pTab) ){
83353 if( pTab->pSelect ){
83357 if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
83361 assert( pTab->addColOffset>0 );
83362 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
83375 pNew->nCol = pTab->nCol;
83380 pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
83385 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
83395 pNew->addColOffset = pTab->addColOffset;
84363 Table *pTab, /* Table whose indices are to be analyzed */
84376 int iDb; /* Index of database containing pTab */
84392 if( v==0 || NEVER(pTab==0) ){
84395 if( pTab->tnum==0 ){
84399 if( sqlite3_strnicmp(pTab->zName, "sqlite_", 7)==0 ){
84404 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
84408 if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,
84418 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
84422 sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
84423 sqlite3VdbeAddOp4(v, OP_String8, 0, regTabname, 0, pTab->zName, 0);
84425 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
84434 if( !HasRowid(pTab) && IsPrimaryKeyIndex(pIdx) ){
84436 zIdxName = pTab->zName;
84446 VdbeComment((v, "Analysis for %s.%s", pTab->zName, zIdxName));
84587 if( HasRowid(pTab) ){
84596 VdbeComment((v, "%s", pTab->aCol[pPk->aiColumn[j]].zName));
84626 u8 seekOp = HasRowid(pTab) ? OP_NotExists : OP_NotFound;
84643 sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur,
84648 sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur, iCol, regCol+i);
84669 VdbeComment((v, "%s", pTab->zName));
84712 Table *pTab = (Table*)sqliteHashData(k);
84713 analyzeOneTable(pParse, pTab, 0, iStatCur, iMem, iTab);
84721 ** in pTab that should be analyzed.
84723 static void analyzeTable(Parse *pParse, Table *pTab, Index *pOnlyIdx){
84727 assert( pTab!=0 );
84729 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
84736 openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
84738 analyzeOneTable(pParse, pTab, pOnlyIdx, iStatCur,pParse->nMem+1,pParse->nTab);
84759 Table *pTab;
84788 }else if( (pTab = sqlite3LocateTable(pParse, 0, z, 0))!=0 ){
84789 analyzeTable(pParse, pTab, 0);
84803 }else if( (pTab = sqlite3LocateTable(pParse, 0, z, zDb))!=0 ){
84804 analyzeTable(pParse, pTab, 0);
85020 Table *pTab = sqlite3FindTable(db, zName, zDb);
85021 if( pTab && !HasRowid(pTab) ) pIdx = sqlite3PrimaryKeyIndex(pTab);
85981 Table *pTab = 0; /* The table being read */
85997 pTab = pParse->pTriggerTab;
86002 pTab = pTabList->a[iSrc].pTab;
86008 if( NEVER(pTab==0) ) return;
86011 assert( iCol<pTab->nCol );
86012 zCol = pTab->aCol[iCol].zName;
86013 }else if( pTab->iPKey>=0 ){
86014 assert( pTab->iPKey<pTab->nCol );
86015 zCol = pTab->aCol[pTab->iPKey].zName;
86020 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
86863 SQLITE_PRIVATE Index *sqlite3PrimaryKeyIndex(Table *pTab){
86865 for(p=pTab->pIndex; p && !IsPrimaryKeyIndex(p); p=p->pNext){}
87345 Table *pTab = pParse->pNewTable;
87349 if( pTab==0 || IN_DECLARE_VTAB ) goto primary_key_exit;
87350 if( pTab->tabFlags & TF_HasPrimaryKey ){
87352 "table \"%s\" has more than one primary key", pTab->zName);
87355 pTab->tabFlags |= TF_HasPrimaryKey;
87357 iCol = pTab->nCol - 1;
87358 pTab->aCol[iCol].colFlags |= COLFLAG_PRIMKEY;
87359 zType = pTab->aCol[iCol].zType;
87364 for(iCol=0; iCol<pTab->nCol; iCol++){
87365 if( sqlite3StrICmp(pList->a[i].zName, pTab->aCol[iCol].zName)==0 ){
87366 pTab->aCol[iCol].colFlags |= COLFLAG_PRIMKEY;
87367 zType = pTab->aCol[iCol].zType;
87377 pTab->iPKey = iCol;
87378 pTab->keyConf = (u8)onError;
87380 pTab->tabFlags |= autoInc*TF_Autoincrement;
87413 Table *pTab = pParse->pNewTable;
87415 if( pTab && !IN_DECLARE_VTAB
87418 pTab->pCheck = sqlite3ExprListAppend(pParse, pTab->pCheck, pCheckExpr);
87420 sqlite3ExprListSetName(pParse, pTab->pCheck, &pParse->constraintName, 1);
87675 static void estimateTableWidth(Table *pTab){
87679 for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){
87682 if( pTab->iPKey<0 ) wTable++;
87683 pTab->szTabRow = sqlite3LogEst(wTable*4);
87731 static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
87759 if( pTab->iPKey>=0 ){
87764 pTab->aCol[pTab->iPKey].zName);
87766 assert( pParse->pNewTable==pTab );
87767 pPk = sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0);
87770 pTab->iPKey = -1;
87772 pPk = sqlite3PrimaryKeyIndex(pTab);
87780 pTab->aCol[pPk->aiColumn[i]].notNull = 1;
87785 pPk->tnum = pTab->tnum;
87790 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
87815 if( nPk<pTab->nCol ){
87816 if( resizeIndexObject(db, pPk, pTab->nCol) ) return;
87817 for(i=0, j=nPk; i<pTab->nCol; i++){
87826 assert( pTab->nCol==j );
87828 pPk->nColumn = pTab->nCol;
88247 Table *pTab = sqliteHashData(i);
88248 if( pTab->pSelect ){
88249 sqliteDeleteColumnNames(db, pTab);
88250 pTab->aCol = 0;
88251 pTab->nCol = 0;
88287 Table *pTab = sqliteHashData(pElem);
88288 if( pTab->tnum==iFrom ){
88289 pTab->tnum = iTo;
88331 ** Write VDBE code to erase table pTab and all associated indices on disk.
88336 static void destroyTable(Parse *pParse, Table *pTab){
88339 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
88340 destroyRootPage(pParse, pTab->tnum, iDb);
88341 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
88361 int iTab = pTab->tnum;
88371 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
88373 assert( pIdx->pSchema==pTab->pSchema );
88381 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
88417 SQLITE_PRIVATE void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){
88428 if( IsVirtual(pTab) ){
88437 pTrigger = sqlite3TriggerList(pParse, pTab);
88439 assert( pTrigger->pSchema==pTab->pSchema ||
88451 if( pTab->tabFlags & TF_Autoincrement ){
88454 pDb->zName, pTab->zName
88468 pDb->zName, SCHEMA_TABLE(iDb), pTab->zName);
88469 if( !isView && !IsVirtual(pTab) ){
88470 destroyTable(pParse, pTab);
88476 if( IsVirtual(pTab) ){
88477 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
88479 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
88489 Table *pTab;
88500 pTab = sqlite3LocateTableItem(pParse, isView, &pName->a[0]);
88503 if( pTab==0 ){
88507 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
88510 /* If pTab is a virtual table, call ViewGetColumnNames() to ensure
88513 if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){
88532 }else if( IsVirtual(pTab) ){
88534 zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
88543 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
88546 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
88551 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
88552 && sqlite3StrNICmp(pTab->zName, "sqlite_stat", 11)!=0 ){
88553 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
88561 if( isView && pTab->pSelect==0 ){
88562 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
88565 if( !isView && pTab->pSelect ){
88566 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
88577 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
88578 sqlite3FkDropTable(pParse, pName, pTab);
88579 sqlite3CodeDropTable(pParse, pTab, iDb, isView);
88725 Table *pTab;
88727 if( (pTab = pParse->pNewTable)==0 || (pFKey = pTab->pFKey)==0 ) return;
88745 Table *pTab = pIndex->pTable; /* The table that is indexed */
88746 int iTab = pParse->nTab++; /* Btree cursor used for pTab */
88767 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
88785 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
88887 Table *pTab = 0; /* Table to be indexed */
88933 pTab = sqlite3SrcListLookup(pParse, pTblName);
88934 if( pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){
88946 pTab = sqlite3LocateTableItem(pParse, 0, &pTblName->a[0]);
88947 assert( db->mallocFailed==0 || pTab==0 );
88948 if( pTab==0 ) goto exit_create_index;
88949 if( iDb==1 && db->aDb[iDb].pSchema!=pTab->pSchema ){
88952 pTab->zName);
88955 if( !HasRowid(pTab) ) pPk = sqlite3PrimaryKeyIndex(pTab);
88959 pTab = pParse->pNewTable;
88960 if( !pTab ) goto exit_create_index;
88961 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
88965 assert( pTab!=0 );
88967 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
88968 && sqlite3StrNICmp(&pTab->zName[7],"altertab_",9)!=0 ){
88969 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
88973 if( pTab->pSelect ){
88979 if( IsVirtual(pTab) ){
89023 for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
89024 zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
89040 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
89054 pTab->aCol[pTab->nCol-1].zName);
89084 pIndex->pTable = pTab;
89091 sqlite3ResolveSelfReference(pParse, pTab, NC_PartIdx, pPIWhere, 0);
89120 for(j=0, pTabCol=pTab->aCol; j<pTab->nCol; j++, pTabCol++){
89123 if( j>=pTab->nCol ){
89125 pTab->zName, zColName);
89129 assert( pTab->nCol<=0x7fff && j<=0x7fff );
89142 zColl = pTab->aCol[j].zColl;
89151 if( pTab->aCol[j].notNull==0 ) pIndex->uniqNotNull = 0;
89173 if( pTab==pParse->pNewTable ){
89196 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
89266 else if( pParse->nErr==0 && (HasRowid(pTab) || pTblName!=0) ){
89301 pTab->zName,
89326 if( onError!=OE_Replace || pTab->pIndex==0
89327 || pTab->pIndex->onError==OE_Replace){
89328 pIndex->pNext = pTab->pIndex;
89329 pTab->pIndex = pIndex;
89331 Index *pOther = pTab->pIndex;
89431 Table *pTab = pIndex->pTable;
89438 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
89720 sqlite3DeleteTable(db, pItem->pTab);
90066 Table *pTab = pIdx->pTable;
90071 char *zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
90073 sqlite3StrAccumAppendAll(&errMsg, pTab->zName);
90091 Table *pTab /* The table with the non-unique rowid */
90095 if( pTab->iPKey>=0 ){
90096 zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
90097 pTab->aCol[pTab->iPKey].zName);
90100 zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
90127 ** Recompute all indices of pTab that use the collating sequence pColl.
90128 ** If pColl==0 then recompute all indices of pTab.
90131 static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){
90132 Index *pIndex; /* An index associated with pTab */
90134 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
90136 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
90155 Table *pTab; /* A table in the database */
90161 pTab = (Table*)sqliteHashData(k);
90162 reindexTable(pParse, pTab, zColl);
90186 Table *pTab; /* A table in the database */
90187 Index *pIndex; /* An index associated with pTab */
90219 pTab = sqlite3FindTable(db, z, zDb);
90220 if( pTab ){
90221 reindexTable(pParse, pTab, 0);
90797 Table *pTab = sqliteHashData(pElem);
90798 sqlite3DeleteTable(0, pTab);
90859 ** pSrc->a[0].pTab Pointer to the Table object
90865 Table *pTab;
90867 pTab = sqlite3LocateTableItem(pParse, 0, pItem);
90868 sqlite3DeleteTable(pParse->db, pItem->pTab);
90869 pItem->pTab = pTab;
90870 if( pTab ){
90871 pTab->nRef++;
90874 pTab = 0;
90876 return pTab;
90884 SQLITE_PRIVATE int sqlite3IsReadOnly(Parse *pParse, Table *pTab, int viewOk){
90895 if( ( IsVirtual(pTab)
90896 && sqlite3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0 )
90897 || ( (pTab->tabFlags & TF_Readonly)!=0
90901 sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
90906 if( !viewOk && pTab->pSelect ){
90907 sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
91055 Table *pTab; /* The table from which records will be deleted */
91056 const char *zDb; /* Name of database holding pTab */
91102 pTab = sqlite3SrcListLookup(pParse, pTabList);
91103 if( pTab==0 ) goto delete_from_cleanup;
91109 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
91110 isView = pTab->pSelect!=0;
91120 /* If pTab is really a view, make sure it has been initialized.
91122 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
91126 if( sqlite3IsReadOnly(pParse, pTab, (pTrigger?1:0)) ){
91129 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
91132 rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb);
91143 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
91150 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
91167 sqlite3MaterializeView(pParse, pTab, pWhere, iTabCur);
91194 if( rcauth==SQLITE_OK && pWhere==0 && !pTrigger && !IsVirtual(pTab)
91195 && 0==sqlite3FkRequired(pParse, pTab, 0, 0)
91198 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
91199 if( HasRowid(pTab) ){
91200 sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt,
91201 pTab->zName, P4_STATIC);
91203 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
91204 assert( pIdx->pSchema==pTab->pSchema );
91210 if( HasRowid(pTab) ){
91219 pPk = sqlite3PrimaryKeyIndex(pTab);
91246 sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur,
91252 iKey = sqlite3ExprCodeGetColumn(pParse, pTab, -1, iTabCur, iKey, 0);
91301 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, iTabCur, aToOpen,
91330 if( IsVirtual(pTab) ){
91331 const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
91332 sqlite3VtabMakeWritable(pParse, pTab);
91340 sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
91356 if( !isView && !IsVirtual(pTab) ){
91358 for(i=0, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
91411 ** 2. Read/write cursors for all indices of pTab must be open as
91421 Table *pTab, /* Table containing the row to be deleted */
91445 opSeek = HasRowid(pTab) ? OP_NotExists : OP_NotFound;
91454 if( sqlite3FkRequired(pParse, pTab, 0, 0) || pTrigger ){
91462 pParse, pTrigger, 0, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onconf
91464 mask |= sqlite3FkOldmask(pParse, pTab);
91466 pParse->nMem += (1 + pTab->nCol);
91471 for(iCol=0; iCol<pTab->nCol; iCol++){
91475 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, iCol, iOld+iCol+1);
91482 TK_DELETE, 0, TRIGGER_BEFORE, pTab, iOld, onconf, iLabel
91499 sqlite3FkCheck(pParse, pTab, iOld, 0, 0, 0);
91502 /* Delete the index and table entries. Skip this step if pTab is really
91505 if( pTab->pSelect==0 ){
91506 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, 0);
91509 sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_TRANSIENT);
91516 sqlite3FkActions(pParse, pTab, 0, iOld, 0, 0);
91520 TK_DELETE, 0, TRIGGER_AFTER, pTab, iOld, onconf, iLabel
91532 ** index entries associated with a single row of a single table, pTab
91537 ** btree for the table pTab. (This will be either the table itself
91541 ** 2. Read/write cursors for all indices of pTab must be open as
91542 ** cursor number iIdxCur+i for the i-th index. (The pTab->pIndex
91550 Table *pTab, /* Table containing the row to be deleted */
91564 pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
91565 for(i=0, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
91581 ** regOut. The key with be for index pIdx which is an index on pTab.
91582 ** iCur is the index of a cursor open on the pTab table and pointing to
91583 ** the entry that needs indexing. If pTab is a WITHOUT ROWID table, then
91622 Table *pTab = pIdx->pTable;
91642 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, pIdx->aiColumn[j],
93740 int iDb, /* Index of database housing pTab */
93741 Table *pTab, /* Parent table of FK pFKey */
93742 Index *pIdx, /* Unique index on parent key columns in pTab */
93747 int isIgnore /* If true, pretend pTab contains all NULL values */
93773 ** column of the parent table (table pTab). */
93790 if( pTab==pFKey->pFrom && nIncr==1 ){
93795 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);
93822 if( pTab==pFKey->pFrom && nIncr==1 ){
93827 assert( aiCol[i]!=pTab->iPKey );
93828 if( pIdx->aiColumn[i]==pTab->iPKey ){
93872 ** to column iCol of table pTab.
93875 ** for pTab. regBase itself holds the rowid. regBase+1 holds the first
93880 Table *pTab, /* The table whose content is at r[regBase]... */
93881 int regBase, /* Contents of table pTab */
93882 i16 iCol /* Which column of pTab is desired */
93891 if( iCol>=0 && iCol!=pTab->iPKey ){
93892 pCol = &pTab->aCol[iCol];
93907 ** Return an Expr object that refers to column iCol of table pTab which
93912 Table *pTab, /* The table whose column is desired */
93918 pExpr->pTab = pTab;
93956 Table *pTab, /* The parent table */
93958 FKey *pFKey, /* The foreign key linking pSrc to pTab */
93971 assert( pIdx==0 || pIdx->pTable==pTab );
93974 assert( pIdx!=0 || HasRowid(pTab) );
93997 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
94017 if( pTab==pFKey->pFrom && nIncr>0 ){
94021 if( HasRowid(pTab) ){
94022 pLeft = exprTableRegister(pParse, pTab, regData, -1);
94023 pRight = exprTableColumn(db, pTab, pSrc->a[0].iCursor, -1);
94027 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
94031 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
94032 pRight = exprTableColumn(db, pTab, pSrc->a[0].iCursor, iCol);
94069 ** FKey.pNextTo) holding all children of table pTab. For example,
94081 SQLITE_PRIVATE FKey *sqlite3FkReferences(Table *pTab){
94082 int nName = sqlite3Strlen30(pTab->zName);
94083 return (FKey *)sqlite3HashFind(&pTab->pSchema->fkeyHash, pTab->zName, nName);
94106 ** This function is called to generate code that runs when table pTab is
94109 ** table pTab.
94122 SQLITE_PRIVATE void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTab){
94124 if( (db->flags&SQLITE_ForeignKeys) && !IsVirtual(pTab) && !pTab->pSelect ){
94129 if( sqlite3FkReferences(pTab)==0 ){
94136 for(p=pTab->pFKey; p; p=p->pNextFrom){
94173 ** for which pTab is the child table. An UPDATE statement against pTab
94184 Table *pTab, /* Table being updated */
94185 FKey *p, /* Foreign key for which pTab is the child */
94193 if( iChildKey==pTab->iPKey && bChngRowid ) return 1;
94200 ** for which pTab is the parent table. An UPDATE statement against pTab
94211 Table *pTab,
94220 for(iKey=0; iKey<pTab->nCol; iKey++){
94221 if( aChange[iKey]>=0 || (iKey==pTab->iPKey && bChngRowid) ){
94222 Column *pCol = &pTab->aCol[iKey];
94236 ** table pTab to generate VDBE code to perform foreign key constraint
94240 ** first register in an array of (pTab->nCol+1) registers containing the
94246 ** first register of an array of (pTab->nCol+1) registers containing the new
94256 Table *pTab, /* Row is being deleted from this table */
94264 int iDb; /* Index of database containing pTab */
94265 const char *zDb; /* Name of database containing pTab */
94274 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
94277 /* Loop through all the foreign key constraints for which pTab is the
94279 for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){
94289 && sqlite3_stricmp(pTab->zName, pFKey->zTo)!=0
94290 && fkChildIsModified(pTab, pFKey, aChange, bChngRowid)==0
94334 if( aiCol[i]==pTab->iPKey ){
94373 for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){
94378 if( aChange && fkParentIsModified(pTab, pFKey, aChange, bChngRowid)==0 ){
94391 if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ){
94402 pItem->pTab = pFKey->pFrom;
94404 pItem->pTab->nRef++;
94408 fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regNew, -1);
94417 fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regOld, 1);
94430 ** row contained in table pTab.
94434 Table *pTab /* Table being modified */
94440 for(p=pTab->pFKey; p; p=p->pNextFrom){
94443 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
94445 sqlite3FkLocateIndex(pParse, pTab, p, &pIdx, 0);
94457 ** row contained in table pTab. If the operation is a DELETE, then
94459 ** to an array of size N, where N is the number of columns in table pTab.
94471 Table *pTab, /* Table being modified */
94480 return (sqlite3FkReferences(pTab) || pTab->pFKey);
94487 for(p=pTab->pFKey; p; p=p->pNextFrom){
94488 if( fkChildIsModified(pTab, p, aChange, chngRowid) ) return 1;
94492 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
94493 if( fkParentIsModified(pTab, p, aChange, chngRowid) ) return 1;
94502 ** compiled on table pTab, which is the parent table of foreign-key pFKey.
94513 ** For example, if pFKey is the foreign key and pTab is table "p" in
94531 Table *pTab, /* Table being updated or deleted from */
94556 if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ) return 0;
94569 tToCol.z = pIdx ? pTab->aCol[pIdx->aiColumn[i]].zName : "oid";
94702 pTrigger->pSchema = pTab->pSchema;
94703 pTrigger->pTabSchema = pTab->pSchema;
94717 Table *pTab, /* Table being updated or deleted from */
94724 ** refer to table pTab. If there is an action associated with the FK
94729 for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){
94730 if( aChange==0 || fkParentIsModified(pTab, pFKey, aChange, bChngRowid) ){
94731 Trigger *pAct = fkActionTrigger(pParse, pTab, pFKey, pChanges);
94733 sqlite3CodeRowTriggerDirect(pParse, pAct, pTab, regOld, OE_Abort, 0);
94744 ** table pTab. Remove the deleted foreign keys from the Schema.fkeyHash
94747 SQLITE_PRIVATE void sqlite3FkDelete(sqlite3 *db, Table *pTab){
94751 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pTab->pSchema) );
94752 for(pFKey=pTab->pFKey; pFKey; pFKey=pNext){
94761 sqlite3HashInsert(&pTab->pSchema->fkeyHash, z, sqlite3Strlen30(z), p);
94805 ** (1) acquire a lock for table pTab then
94806 ** (2) open pTab as cursor iCur.
94808 ** If pTab is a WITHOUT ROWID table, then it is the PRIMARY KEY index
94815 Table *pTab, /* The table to be opened */
94819 assert( !IsVirtual(pTab) );
94822 sqlite3TableLock(pParse, iDb, pTab->tnum,
94823 (opcode==OP_OpenWrite)?1:0, pTab->zName);
94824 if( HasRowid(pTab) ){
94825 sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nCol);
94826 VdbeComment((v, "%s", pTab->zName));
94828 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
94830 assert( pPk->tnum=pTab->tnum );
94833 VdbeComment((v, "%s", pTab->zName));
94868 Table *pTab = pIdx->pTable;
94877 pIdx->zColAff[n] = x<0 ? SQLITE_AFF_INTEGER : pTab->aCol[x].affinity;
94886 ** Compute the affinity string for table pTab, if it has not already been
94905 SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){
94907 char *zColAff = pTab->zColAff;
94910 zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
94916 for(i=0; i<pTab->nCol; i++){
94917 zColAff[i] = pTab->aCol[i].affinity;
94922 pTab->zColAff = zColAff;
94935 ** Return non-zero if the table pTab in database iDb or any of its indices
94937 ** a statement of the form "INSERT INTO <iDb, pTab> SELECT ..." can
94940 static int readsTable(Parse *p, int iDb, Table *pTab){
94945 VTable *pVTab = IsVirtual(pTab) ? sqlite3GetVTable(p->db, pTab) : 0;
94954 if( tnum==pTab->tnum ){
94957 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
94976 ** Locate or create an AutoincInfo structure associated with table pTab
94983 ** first use of table pTab. On 2nd and subsequent uses, the original
94988 ** (1) Register to hold the name of the pTab table.
94989 ** (2) Register to hold the maximum ROWID of pTab.
94990 ** (3) Register to hold the rowid in sqlite_sequence of pTab
94997 int iDb, /* Index of the database holding pTab */
94998 Table *pTab /* The table we are writing to */
95001 if( pTab->tabFlags & TF_Autoincrement ){
95006 while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; }
95012 pInfo->pTab = pTab;
95048 sqlite3VdbeAddOp4(v, OP_String8, 0, memId-1, 0, p->pTab->zName, 0);
95229 Table *pTab; /* The table to insert into. aka TABLE */
95264 Trigger *pTrigger; /* List of triggers on pTab, if required */
95290 pTab = sqlite3SrcListLookup(pParse, pTabList);
95291 if( pTab==0 ){
95294 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
95298 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb) ){
95301 withoutRowid = !HasRowid(pTab);
95307 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0, &tmask);
95308 isView = pTab->pSelect!=0;
95320 /* If pTab is really a view, make sure it has been initialized.
95321 ** ViewGetColumnNames() is a no-op if pTab is not a view.
95323 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
95329 if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
95350 if( pColumn==0 && xferOptimization(pParse, pTab, pSelect, onError, iDb) ){
95360 regAutoinc = autoIncBegin(pParse, iDb, pTab);
95366 pParse->nMem += pTab->nCol + 1;
95367 if( IsVirtual(pTab) ){
95382 ** PRIMARY KEY in the original table is pTab->iPKey.)
95389 for(j=0; j<pTab->nCol; j++){
95390 if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){
95393 if( j==pTab->iPKey ){
95399 if( j>=pTab->nCol ){
95429 dest.nSdst = pTab->nCol;
95448 if( pTrigger || readsTable(pParse, iDb, pTab) ){
95502 ipkColumn = pTab->iPKey;
95508 if( IsVirtual(pTab) ){
95509 for(i=0; i<pTab->nCol; i++){
95510 nHidden += (IsHiddenColumn(&pTab->aCol[i]) ? 1 : 0);
95513 if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){
95516 pTabList, 0, pTab->nCol-nHidden, nColumn);
95534 nIdx = sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, -1, 0,
95575 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
95603 assert( !IsVirtual(pTab) );
95607 for(i=0; i<pTab->nCol; i++){
95616 sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, regCols+i+1);
95631 sqlite3TableAffinity(v, pTab, regCols+1);
95636 pTab, regCols-pTab->nCol-1, onError, endOfLoop);
95638 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
95645 if( IsVirtual(pTab) ){
95658 if( ALWAYS(pOp) && pOp->opcode==OP_Null && !IsVirtual(pTab) ){
95671 if( !IsVirtual(pTab) ){
95681 }else if( IsVirtual(pTab) || withoutRowid ){
95693 for(i=0; i<pTab->nCol; i++){
95695 if( i==pTab->iPKey ){
95705 if( IsHiddenColumn(&pTab->aCol[i]) ){
95706 assert( IsVirtual(pTab) );
95718 sqlite3ExprCodeFactorable(pParse, pTab->aCol[i].pDflt, iRegStore);
95734 if( IsVirtual(pTab) ){
95735 const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
95736 sqlite3VtabMakeWritable(pParse, pTab);
95737 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
95744 sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
95747 sqlite3FkCheck(pParse, pTab, 0, regIns, 0, 0);
95748 sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur,
95762 pTab, regData-2-pTab->nCol, onError, endOfLoop);
95778 if( !IsVirtual(pTab) && !isView ){
95781 for(idx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
95829 ** on table pTab.
95833 ** pTab->nCol+1 registers in this range. The first register (the one
95860 ** at pTab->pIndex.
95867 ** for the first index in the pTab->pIndex list. Cursors for other indices
95868 ** are at iIdxCur+N for the N-th element of the pTab->pIndex list.
95912 Table *pTab, /* The table being inserted or updated */
95944 assert( pTab->pSelect==0 ); /* This table is not a VIEW */
95945 nCol = pTab->nCol;
95951 if( HasRowid(pTab) ){
95955 pPk = sqlite3PrimaryKeyIndex(pTab);
95966 if( i==pTab->iPKey ){
95969 onError = pTab->aCol[i].notNull;
95976 if( onError==OE_Replace && pTab->aCol[i].pDflt==0 ){
95987 char *zMsg = sqlite3MPrintf(db, "%s.%s", pTab->zName,
95988 pTab->aCol[i].zName);
96003 sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, regNewData+1+i);
96013 if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){
96014 ExprList *pCheck = pTab->pCheck;
96024 if( zName==0 ) zName = pTab->zName;
96042 onError = pTab->keyConf;
96064 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
96086 sqlite3RowidConstraint(pParse, onError, pTab);
96114 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
96116 if( pTrigger || sqlite3FkRequired(pParse, pTab, 0, 0) ){
96118 sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
96120 }else if( pTab->pIndex ){
96122 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, 0);
96147 for(ix=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, ix++){
96155 sqlite3TableAffinity(v, pTab, regNewData+1);
96177 if( iField<0 || iField==pTab->iPKey ){
96185 VdbeComment((v, "%s", iField<0 ? "rowid" : pTab->aCol[iField].zName));
96220 if( HasRowid(pTab) ){
96237 VdbeComment((v, "%s.%s", pTab->zName,
96238 pTab->aCol[pPk->aiColumn[i]].zName));
96290 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
96292 sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
96322 Table *pTab, /* the table into which we are inserting */
96341 assert( pTab->pSelect==0 ); /* This table is not a VIEW */
96342 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
96352 if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
96358 if( !HasRowid(pTab) ) return;
96361 sqlite3VdbeAddOp3(v, OP_MakeRecord, regData, pTab->nCol, regRec);
96362 if( !bAffinityDone ) sqlite3TableAffinity(v, pTab, 0);
96363 sqlite3ExprCacheAffinityChange(pParse, regData, pTab->nCol);
96378 sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_TRANSIENT);
96384 ** Allocate cursors for the pTab table and all its indices and generate
96399 ** pTab->pIndex list.
96403 Table *pTab, /* Table to be opened */
96417 if( IsVirtual(pTab) ){
96423 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
96429 if( HasRowid(pTab) && (aToOpen==0 || aToOpen[0]) ){
96430 sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op);
96432 sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
96435 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
96437 assert( pIdx->pSchema==pTab->pSchema );
96438 if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) && piDataCur ){
99629 Table *pTab;
99630 pTab = sqlite3FindTable(db, zRight, zDb);
99631 if( pTab ){
99635 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
99645 sqlite3ViewGetColumnNames(pParse, pTab);
99646 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
99666 for(k=1; ALWAYS(k<=pTab->nCol) && pPk->aiColumn[k-1]!=i; k++){}
99687 Table *pTab = sqliteHashData(i);
99688 sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, pTab->zName, 0);
99691 (int)sqlite3LogEstToInt(pTab->szTabRow), 3);
99693 (int)sqlite3LogEstToInt(pTab->nRowLogEst), 4);
99695 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
99709 Table *pTab;
99713 pTab = pIdx->pTable;
99724 assert( pTab->nCol>cnum );
99725 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pTab->aCol[cnum].zName, 0);
99734 Table *pTab;
99736 pTab = sqlite3FindTable(db, zRight, zDb);
99737 if( pTab ){
99745 for(pIdx=pTab->pIndex, i=0; pIdx; pIdx=pIdx->pNext, i++){
99794 Table *pTab;
99795 pTab = sqlite3FindTable(db, zRight, zDb);
99796 if( pTab ){
99798 pFK = pTab->pFKey;
99822 pTab->aCol[pFK->aCol[j].iFrom].zName, 0);
99842 Table *pTab; /* Child table contain "REFERENCES" keyword */
99845 int i; /* Loop counter: Foreign key number for pTab */
99851 int regRow; /* Registers to hold a row from pTab */
99870 pTab = sqlite3LocateTable(pParse, 0, zRight, zDb);
99873 pTab = (Table*)sqliteHashData(k);
99876 if( pTab==0 || pTab->pFKey==0 ) continue;
99877 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
99878 if( pTab->nCol+regRow>pParse->nMem ) pParse->nMem = pTab->nCol + regRow;
99879 sqlite3OpenTable(pParse, 0, iDb, pTab, OP_OpenRead);
99880 sqlite3VdbeAddOp4(v, OP_String8, 0, regResult, 0, pTab->zName,
99882 for(i=1, pFK=pTab->pFKey; pFK; i++, pFK=pFK->pNextFrom){
99904 for(i=1, pFK=pTab->pFKey; pFK; i++, pFK=pFK->pNextFrom){
99915 assert( iKey>=0 && iKey<pTab->nCol );
99916 if( iKey!=pTab->iPKey ){
99918 sqlite3ColumnDefault(v, pTab, iKey, regRow);
99930 sqlite3ExprCodeGetColumnOfTable(v, pTab, 0,
100056 Table *pTab = sqliteHashData(x);
100058 if( HasRowid(pTab) ){
100059 sqlite3VdbeAddOp2(v, OP_Integer, pTab->tnum, 2+cnt);
100060 VdbeComment((v, "%s", pTab->zName));
100063 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
100088 Table *pTab = sqliteHashData(x);
100095 if( pTab->pIndex==0 ) continue;
100096 pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
100102 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenRead,
100105 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
100112 for(j=0; j<pTab->nCol; j++){
100115 if( j==pTab->iPKey ) continue;
100116 if( pTab->aCol[j].notNull==0 ) continue;
100117 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, j, 3);
100121 zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName,
100122 pTab->aCol[j].zName);
100131 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
100164 assert( iCol>=0 && iCol<pTab->nCol );
100165 if( pTab->aCol[iCol].notNull ) continue;
100188 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
100702 Table *pTab;
100767 pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName);
100768 if( ALWAYS(pTab) ){
100769 pTab->tabFlags |= TF_Readonly;
101674 static int columnIndex(Table *pTab, const char *zCol){
101676 for(i=0; i<pTab->nCol; i++){
101677 if( sqlite3StrICmp(pTab->aCol[i].zName, zCol)==0 ) return i;
101696 int *piCol /* Write index of pSrc->a[*piTab].pTab->aCol[] here */
101703 iCol = columnIndex(pSrc->a[i].pTab, zCol);
101743 assert( pSrc->a[iLeft].pTab );
101744 assert( pSrc->a[iRight].pTab );
101820 Table *pLeftTab = pLeft->pTab;
101821 Table *pRightTab = pRight->pTab;
102736 Table *pTab = 0; /* Table structure column is extracted from */
102738 int iCol = pExpr->iColumn; /* Index of column in pTab */
102741 while( pNC && !pTab ){
102745 pTab = pTabList->a[j].pTab;
102752 if( pTab==0 ){
102773 assert( pTab && pExpr->pTab==pTab );
102791 }else if( pTab->pSchema ){
102794 if( iCol<0 ) iCol = pTab->iPKey;
102795 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
102801 zType = pTab->aCol[iCol].zType;
102802 zOrigCol = pTab->aCol[iCol].zName;
102803 estWidth = pTab->aCol[iCol].szEst;
102805 zOrigTab = pTab->zName;
102807 int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
102814 zType = pTab->aCol[iCol].zType;
102815 estWidth = pTab->aCol[iCol].szEst;
102926 Table *pTab;
102933 pTab = pTabList->a[j].pTab;
102934 if( iCol<0 ) iCol = pTab->iPKey;
102935 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
102939 zCol = pTab->aCol[iCol].zName;
102946 zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol);
103008 Table *pTab; /* Table associated with this expression */
103013 if( pColExpr->op==TK_COLUMN && ALWAYS(pColExpr->pTab!=0) ){
103016 pTab = pColExpr->pTab;
103017 if( iCol<0 ) iCol = pTab->iPKey;
103019 iCol>=0 ? pTab->aCol[iCol].zName : "rowid");
103078 Table *pTab, /* Add column type information to this table */
103092 assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed );
103097 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
103108 pTab->szTabRow = sqlite3LogEst(szAll*4);
103116 Table *pTab;
103127 pTab = sqlite3DbMallocZero(db, sizeof(Table) );
103128 if( pTab==0 ){
103134 pTab->nRef = 1;
103135 pTab->zName = 0;
103136 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
103137 selectColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
103138 selectAddColumnTypeAndCollation(pParse, pTab, pSelect);
103139 pTab->iPKey = -1;
103141 sqlite3DeleteTable(db, pTab);
103144 return pTab;
104848 ** complete, since there may still exist Expr.pTab entries that
104851 ** pSubitem->pTab is always non-NULL by test restrictions and tests above.
104853 if( ALWAYS(pSubitem->pTab!=0) ){
104854 Table *pTabToDel = pSubitem->pTab;
104862 pSubitem->pTab = 0;
105058 Table *pTab;
105068 pTab = p->pSrc->a[0].pTab;
105070 assert( pTab && !pTab->pSelect && pExpr );
105072 if( IsVirtual(pTab) ) return 0;
105078 return pTab;
105089 if( pFrom->pTab && pFrom->zIndex ){
105090 Table *pTab = pFrom->pTab;
105093 for(pIdx=pTab->pIndex;
105231 ** If pFrom falls into either of the two categories above, pFrom->pTab
105233 ** (pFrom->pTab!=0) to determine whether or not a successful match
105249 assert( pFrom->pTab==0 );
105253 Table *pTab;
105269 assert( pFrom->pTab==0 );
105270 pFrom->pTab = pTab = sqlite3DbMallocZero(db, sizeof(Table));
105271 if( pTab==0 ) return WRC_Abort;
105272 pTab->nRef = 1;
105273 pTab->zName = sqlite3DbStrDup(db, pCte->zName);
105274 pTab->iPKey = -1;
105275 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
105276 pTab->tabFlags |= TF_Ephemeral;
105293 pItem->pTab = pTab;
105295 pTab->nRef++;
105302 if( pTab->nRef>2 ){
105308 assert( pTab->nRef==1 || ((pSel->selFlags&SF_Recursive) && pTab->nRef==2 ));
105328 selectColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
105373 ** (2) Fill in the pTabList->a[].pTab fields in the SrcList that
105421 Table *pTab;
105422 assert( pFrom->isRecursive==0 || pFrom->pTab );
105424 if( pFrom->pTab!=0 ){
105435 if( pFrom->pTab ) {} else
105442 assert( pFrom->pTab==0 );
105444 pFrom->pTab = pTab = sqlite3DbMallocZero(db, sizeof(Table));
105445 if( pTab==0 ) return WRC_Abort;
105446 pTab->nRef = 1;
105447 pTab->zName = sqlite3MPrintf(db, "sqlite_sq_%p", (void*)pTab);
105449 selectColumnsFromExprList(pParse, pSel->pEList, &pTab->nCol, &pTab->aCol);
105450 pTab->iPKey = -1;
105451 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
105452 pTab->tabFlags |= TF_Ephemeral;
105456 assert( pFrom->pTab==0 );
105457 pFrom->pTab = pTab = sqlite3LocateTableItem(pParse, 0, pFrom);
105458 if( pTab==0 ) return WRC_Abort;
105459 if( pTab->nRef==0xffff ){
105461 pTab->zName);
105462 pFrom->pTab = 0;
105465 pTab->nRef++;
105467 if( pTab->pSelect || IsVirtual(pTab) ){
105469 if( sqlite3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort;
105471 pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect, 0);
105551 Table *pTab = pFrom->pTab;
105557 zTabName = pTab->zName;
105565 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
105568 for(j=0; j<pTab->nCol; j++){
105569 char *zName = pTab->aCol[j].zName;
105585 if( IsHiddenColumn(&pTab->aCol[j]) ){
105586 assert(IsVirtual(pTab));
105730 Table *pTab = pFrom->pTab;
105731 if( ALWAYS(pTab!=0) && (pTab->tabFlags & TF_Ephemeral)!=0 ){
105736 selectAddColumnTypeAndCollation(pParse, pTab, pSel);
105937 ** count(*) query ("SELECT count(*) FROM pTab").
105942 Table *pTab, /* Table being queried */
105946 int bCover = (pIdx!=0 && (HasRowid(pTab) || !IsPrimaryKeyIndex(pIdx)));
105948 pTab->zName,
106097 VdbeComment((v, "%s", pItem->pTab->zName));
106102 pItem->pTab->nRowLogEst = sqlite3LogEst(pSub->nSelectRow);
106126 VdbeComment((v, "materialize \"%s\"", pItem->pTab->zName));
106128 VdbeNoopComment((v, "materialize \"%s\"", pItem->pTab->zName));
106133 pItem->pTab->nRowLogEst = sqlite3LogEst(pSub->nSelectRow);
106136 VdbeComment((v, "end %s", pItem->pTab->zName));
106452 pCol->pTab, pCol->iColumn, pCol->iTable, r1, 0);
106591 Table *pTab;
106592 if( (pTab = isSimpleCount(p, &sAggInfo))!=0 ){
106606 const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
106611 int iRoot = pTab->tnum; /* Root page of scanned b-tree */
106614 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
106625 if( !HasRowid(pTab) ) pBest = sqlite3PrimaryKeyIndex(pTab);
106626 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
106628 && pIdx->szIdxRow<pTab->szTabRow
106647 explainSimpleCount(pParse, pTab, pBest);
106791 if( pItem->pTab ){
106792 sqlite3ExplainPrintf(pVdbe, " (tabname=%s)", pItem->pTab->zName);
107092 ** Given table pTab, return a list of all the triggers attached to
107095 ** All of the triggers on pTab that are in the same database as pTab
107096 ** are already attached to pTab->pTrigger. But there might be additional
107097 ** triggers on pTab in the TEMP schema. This routine prepends all
107098 ** TEMP triggers on pTab to the beginning of the pTab->pTrigger list
107102 ** that fire off of pTab. The list will include any TEMP triggers on
107103 ** pTab as well as the triggers lised in pTab->pTrigger.
107105 SQLITE_PRIVATE Trigger *sqlite3TriggerList(Parse *pParse, Table *pTab){
107113 if( pTmpSchema!=pTab->pSchema ){
107118 if( pTrig->pTabSchema==pTab->pSchema
107119 && 0==sqlite3StrICmp(pTrig->table, pTab->zName)
107121 pTrig->pNext = (pList ? pList : pTab->pTrigger);
107127 return (pList ? pList : pTab->pTrigger);
107151 Table *pTab; /* Table that the trigger fires off of */
107157 int iTabDb; /* Index of the database holding pTab */
107200 pTab = sqlite3SrcListLookup(pParse, pTableName);
107201 if( db->init.busy==0 && pName2->n==0 && pTab
107202 && pTab->pSchema==db->aDb[1].pSchema ){
107213 pTab = sqlite3SrcListLookup(pParse, pTableName);
107214 if( !pTab ){
107229 if( IsVirtual(pTab) ){
107253 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
107262 if( pTab->pSelect && tr_tm!=TK_INSTEAD ){
107267 if( !pTab->pSelect && tr_tm==TK_INSTEAD ){
107272 iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
107280 if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
107305 pTrigger->pTabSchema = pTab->pSchema;
107389 Table *pTab;
107391 pTab = sqlite3HashFind(&pLink->pTabSchema->tblHash, pLink->table, n);
107392 assert( pTab!=0 );
107393 pLink->pNext = pTab->pTrigger;
107394 pTab->pTrigger = pLink;
107666 Table *pTab = tableOfTrigger(pTrigger);
107668 for(pp=&pTab->pTrigger; *pp!=pTrigger; pp=&((*pp)->pNext));
107695 ** Return a list of all triggers on table pTab if there exists at least
107702 Table *pTab, /* The table the contains the triggers */
107712 pList = sqlite3TriggerList(pParse, pTab);
107714 assert( pList==0 || IsVirtual(pTab)==0 );
107874 Table *pTab, /* The table pTrigger is attached to */
107887 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
107912 pSubParse->pTriggerTab = pTab;
107926 pTab->zName
107988 Table *pTab, /* The table trigger pTrigger is attached to */
107994 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
108007 pPrg = codeRowTrigger(pParse, pTrigger, pTab, orconf);
108015 ** table pTab. The reg, orconf and ignoreJump parameters passed to this
108022 Table *pTab, /* The table to code triggers from */
108029 pPrg = getRowTrigger(pParse, p, pTab, orconf);
108053 ** on table pTab. The operation to code triggers for (INSERT, UPDATE or DELETE)
108059 ** operation on pTab, this function is a no-op.
108063 ** in the trigger program. If N is the number of columns in table pTab
108064 ** (a copy of pTab->nCol), then registers are populated as follows:
108069 ** reg+1 OLD.* value of left-most column of pTab
108071 ** reg+N OLD.* value of right-most column of pTab
108073 ** reg+N+2 OLD.* value of left-most column of pTab
108075 ** reg+N+N+1 NEW.* value of right-most column of pTab
108093 Trigger *pTrigger, /* List of triggers on table pTab */
108097 Table *pTab, /* The table to code triggers from */
108123 sqlite3CodeRowTriggerDirect(pParse, p, pTab, reg, orconf, ignoreJump);
108155 Trigger *pTrigger, /* List of triggers on table pTab */
108159 Table *pTab, /* The table to code triggers from */
108172 pPrg = getRowTrigger(pParse, p, pTab, orconf);
108206 Table *pTab, /* The virtual table */
108209 int *aXRef, /* Mapping from columns of pTab to entries in pChanges */
108217 ** i-th column of table pTab. This routine sets the P4 parameter of the
108245 SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){
108246 assert( pTab!=0 );
108247 if( !pTab->pSelect ){
108250 Column *pCol = &pTab->aCol[i];
108251 VdbeComment((v, "%s.%s", pTab->zName, pCol->zName));
108252 assert( i<pTab->nCol );
108259 if( pTab->aCol[i].affinity==SQLITE_AFF_REAL ){
108281 Table *pTab; /* The table to be updated */
108311 Trigger *pTrigger; /* List of triggers on pTab, if required */
108337 pTab = sqlite3SrcListLookup(pParse, pTabList);
108338 if( pTab==0 ) goto update_cleanup;
108339 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
108345 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask);
108346 isView = pTab->pSelect!=0;
108358 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
108361 if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
108372 pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
108373 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
108384 aXRef = sqlite3DbMallocRaw(db, sizeof(int) * (pTab->nCol+nIdx) + nIdx+2 );
108386 aRegIdx = aXRef+pTab->nCol;
108390 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
108408 for(j=0; j<pTab->nCol; j++){
108409 if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zName)==0 ){
108410 if( j==pTab->iPKey ){
108413 }else if( pPk && (pTab->aCol[j].colFlags & COLFLAG_PRIMKEY)!=0 ){
108420 if( j>=pTab->nCol ){
108434 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
108435 j<0 ? "ROWID" : pTab->aCol[j].zName,
108455 hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngKey);
108461 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
108486 if( IsVirtual(pTab) ){
108487 updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef,
108500 pParse->nMem += pTab->nCol;
108506 pParse->nMem += pTab->nCol;
108510 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
108518 sqlite3MaterializeView(pParse, pTab, pWhere, iDataCur);
108531 if( HasRowid(pTab) ){
108568 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, pPk->aiColumn[i],
108601 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
108612 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, iBaseCur, aToOpen,
108654 u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0);
108656 pTrigger, pChanges, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onError
108658 for(i=0; i<pTab->nCol; i++){
108661 || (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0
108664 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regOld+i);
108688 pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError
108690 /*sqlite3VdbeAddOp3(v, OP_Null, 0, regNew, regNew+pTab->nCol-1);*/
108691 for(i=0; i<pTab->nCol; i++){
108692 if( i==pTab->iPKey ){
108706 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regNew+i);
108717 sqlite3TableAffinity(v, pTab, regNew);
108719 TRIGGER_BEFORE, pTab, regOldRowid, onError, labelContinue);
108740 for(i=0; i<pTab->nCol; i++){
108741 if( aXRef[i]<0 && i!=pTab->iPKey ){
108742 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regNew+i);
108753 sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
108758 sqlite3FkCheck(pParse, pTab, regOldRowid, 0, aXRef, chngKey);
108770 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, aRegIdx);
108781 sqlite3FkCheck(pParse, pTab, 0, regNewRowid, aXRef, chngKey);
108785 sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur,
108792 sqlite3FkActions(pParse, pTab, pChanges, regOldRowid, aXRef, chngKey);
108803 TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue);
108819 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
108887 Table *pTab, /* The virtual table */
108890 int *aXRef, /* Mapping from columns of pTab to entries in pChanges */
108903 const char *pVTab = (const char*)sqlite3GetVTable(db, pTab);
108914 assert( pTab->iPKey<0 );
108915 for(i=0; i<pTab->nCol; i++){
108919 pExpr = sqlite3Expr(db, TK_ID, pTab->aCol[i].zName);
108930 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, pTab->nCol+1+(pRowid!=0));
108940 pParse->nMem += pTab->nCol+1;
108944 for(i=0; i<pTab->nCol; i++){
108947 sqlite3VtabMakeWritable(pParse, pTab);
108948 sqlite3VdbeAddOp4(v, OP_VUpdate, 0, pTab->nCol+2, iReg, pVTab, P4_VTAB);
109356 Table *pTab; /* The Table object to which the virtual table belongs */
109444 ** pTab is a pointer to a Table structure representing a virtual-table.
109448 SQLITE_PRIVATE VTable *sqlite3GetVTable(sqlite3 *db, Table *pTab){
109450 assert( IsVirtual(pTab) );
109451 for(pVtab=pTab->pVTable; pVtab && pVtab->db!=db; pVtab=pVtab->pNext);
109693 Table *pTab = pParse->pNewTable; /* The table being constructed */
109696 if( pTab==0 ) return;
109699 if( pTab->nModuleArg<1 ) return;
109727 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
109733 pTab->zName,
109734 pTab->zName,
109743 zWhere = sqlite3MPrintf(db, "name='%q' AND type='table'", pTab->zName);
109746 pTab->zName, sqlite3Strlen30(pTab->zName) + 1);
109756 Schema *pSchema = pTab->pSchema;
109757 const char *zName = pTab->zName;
109760 pOld = sqlite3HashInsert(&pSchema->tblHash, zName, nName, pTab);
109763 assert( pTab==pOld ); /* Malloc must have failed inside HashInsert() */
109802 Table *pTab,
109810 const char *const*azArg = (const char *const*)pTab->azModuleArg;
109811 int nArg = pTab->nModuleArg;
109813 char *zModuleName = sqlite3MPrintf(db, "%s", pTab->zName);
109828 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
109829 pTab->azModuleArg[1] = db->aDb[iDb].zName;
109834 sCtx.pTab = pTab;
109855 if( sCtx.pTab ){
109857 *pzErr = sqlite3MPrintf(db, zFormat, pTab->zName);
109863 ** into the linked list headed by pTab->pVTable. Then loop through the
109867 pVTable->pNext = pTab->pVTable;
109868 pTab->pVTable = pVTable;
109870 for(iCol=0; iCol<pTab->nCol; iCol++){
109871 char *zType = pTab->aCol[iCol].zType;
109896 pTab->aCol[iCol].colFlags |= COLFLAG_HIDDEN;
109908 ** of the virtual table pTab. If an error occurs, an error code is returned
109911 ** This call is a no-op if table pTab is not a virtual table.
109913 SQLITE_PRIVATE int sqlite3VtabCallConnect(Parse *pParse, Table *pTab){
109919 assert( pTab );
109920 if( (pTab->tabFlags & TF_Virtual)==0 || sqlite3GetVTable(db, pTab) ){
109925 zMod = pTab->azModuleArg[0];
109929 const char *zModule = pTab->azModuleArg[0];
109934 rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xConnect, &zErr);
109985 Table *pTab;
109989 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
109990 assert( pTab && (pTab->tabFlags & TF_Virtual)!=0 && !pTab->pVTable );
109993 zMod = pTab->azModuleArg[0];
110004 rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr);
110009 if( rc==SQLITE_OK && ALWAYS(sqlite3GetVTable(db, pTab)) ){
110012 addToVTrans(db, sqlite3GetVTable(db, pTab));
110028 Table *pTab;
110032 if( !db->pVtabCtx || !(pTab = db->pVtabCtx->pTab) ){
110037 assert( (pTab->tabFlags & TF_Virtual)!=0 );
110053 if( !pTab->aCol ){
110054 pTab->aCol = pParse->pNewTable->aCol;
110055 pTab->nCol = pParse->pNewTable->nCol;
110059 db->pVtabCtx->pTab = 0;
110090 Table *pTab;
110092 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
110093 if( ALWAYS(pTab!=0 && pTab->pVTable!=0) ){
110094 VTable *p = vtabDisconnectAll(db, pTab);
110101 assert( pTab->pVTable==p && p->pNext==0 );
110103 pTab->pVTable = 0;
110297 Table *pTab;
110311 pTab = pExpr->pTab;
110312 if( NEVER(pTab==0) ) return pDef;
110313 if( (pTab->tabFlags & TF_Virtual)==0 ) return pDef;
110314 pVtab = sqlite3GetVTable(db, pTab)->pVtab;
110352 ** Make sure virtual table pTab is contained in the pParse->apVirtualLock[]
110353 ** array so that an OP_VBegin will get generated for it. Add pTab to the
110354 ** array if it is missing. If pTab is already in the array, this routine
110357 SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){
110362 assert( IsVirtual(pTab) );
110364 if( pTab==pToplevel->apVtabLock[i] ) return;
110370 pToplevel->apVtabLock[pToplevel->nVtabLock++] = pTab;
110411 assert( p->pTab==0 || (p->pTab->tabFlags & TF_Virtual)!=0 );
111557 || IsVirtual(pLeft->pTab)
112332 Table *pTab;
112342 pTab = pTabList->a[0].pTab;
112366 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
112372 if( iIdxCol<0 || pTab->aCol[iCol].notNull==0 ){
112455 aff = pSrc->pTab->aCol[pTerm->u.leftColumn].affinity;
112503 pTable = pSrc->pTab;
112744 static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){
112745 sqlite3_vtab *pVtab = sqlite3GetVTable(pParse->db, pTab)->pVtab;
112768 "table %s: xBestIndex returned an invalid plan", pTab->zName);
113622 ** Argument pLevel describes a strategy for scanning table pTab. This
113640 static char *explainIndexRange(sqlite3 *db, WhereLoop *pLoop, Table *pTab){
113645 Column *aCol = pTab->aCol;
113730 char *zWhere = explainIndexRange(db, pLoop, pItem->pTab);
113732 if( !HasRowid(pItem->pTab) && IsPrimaryKeyIndex(pIdx) ){
113810 VdbeModuleComment((v, "Begin WHERE-loop%d: %s",iLevel,pTabItem->pTab->zName));
113841 VdbeComment((v, "next row of \"%s\"", pTabItem->pTab->zName));
114322 Table *pTab = pTabItem->pTab;
114367 if( HasRowid(pTab) ){
114371 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
114445 if( HasRowid(pTab) ){
114446 r = sqlite3ExprCodeGetColumn(pParse, pTab, -1, iCur, regRowid, 0);
114450 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
114458 sqlite3ExprCodeGetColumn(pParse, pTab, iCol, iCur, r+iPk, 0);
114517 && (HasRowid(pTab) || !IsPrimaryKeyIndex(pSubLoop->u.btree.pIndex))
114672 Table *pTab = pItem->pTab;
114676 pItem->zAlias ? pItem->zAlias : pTab->zName);
115238 && (iCol<0 || pSrc->pTab->aCol[iCol].notNull)
115360 rCostIdx = pNew->nOut + 1 + (15*pProbe->szIdxRow)/pSrc->pTab->szTabRow;
115512 Table *pTab; /* Table being queried */
115518 pTab = pSrc->pTab;
115520 assert( !IsVirtual(pSrc->pTab) );
115525 }else if( !HasRowid(pTab) ){
115526 pProbe = pTab->pIndex;
115539 sPk.pTable = pTab;
115540 sPk.szIdxRow = pTab->szTabRow;
115541 aiRowEstPk[0] = pTab->nRowLogEst;
115543 pFirst = pSrc->pTab->pIndex;
115551 rSize = pTab->nRowLogEst;
115561 && HasRowid(pTab)
115580 ApplyCostMultiplier(pNew->rSetup, pTab->costMult);
115622 ApplyCostMultiplier(pNew->rRun, pTab->costMult);
115639 || !HasRowid(pTab)
115642 && (pProbe->szIdxRow<pTab->szTabRow)
115654 pNew->rRun = rSize + 1 + (15*pProbe->szIdxRow)/pTab->szTabRow;
115658 ApplyCostMultiplier(pNew->rRun, pTab->costMult);
115693 Table *pTab;
115714 pTab = pSrc->pTab;
115715 assert( IsVirtual(pTab) );
115774 rc = vtabBestIndex(pParse, pTab, pIdxInfo);
115791 sqlite3ErrorMsg(pParse, "%s.xBestIndex() malfunction", pTab->zName);
115902 if( IsVirtual(pItem->pTab) ){
115984 if( IsVirtual(pItem->pTab) ){
116697 Table *pTab;
116704 pTab = pItem->pTab;
116705 if( IsVirtual(pTab) ) return 0;
116721 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
117137 if( HasRowid(pTabList->a[0].pTab) ){
117147 Table *pTab; /* Table to open */
117152 pTab = pTabItem->pTab;
117153 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
117155 if( (pTab->tabFlags & TF_Ephemeral)!=0 || pTab->pSelect ){
117160 const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
117163 }else if( IsVirtual(pTab) ){
117174 sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op);
117176 testcase( !pWInfo->okOnePass && pTab->nCol==BMS-1 );
117177 testcase( !pWInfo->okOnePass && pTab->nCol==BMS );
117178 if( !pWInfo->okOnePass && pTab->nCol<BMS && HasRowid(pTab) ){
117184 assert( n<=pTab->nCol );
117187 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
117195 if( !HasRowid(pTab) && IsPrimaryKeyIndex(pIx)
117203 Index *pJ = pTabItem->pTab->pIndex;
117219 assert( pIx->pSchema==pTab->pSchema );
117335 pWInfo->pTabList->a[pLevel->iFrom].pTab->zName));
117349 Table *pTab = pTabItem->pTab;
117350 assert( pTab!=0 );
117382 if( (pTab->tabFlags & TF_Ephemeral)==0
117383 && pTab->pSelect==0
117422 assert( pIdx->pTable==pTab );
117423 if( !HasRowid(pTab) ){
117424 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
122960 Table *pTab = (Table *)sqliteHashData(p);
122961 if( IsVirtual(pTab) ) sqlite3VtabDisconnect(db, pTab);
124130 Table *pTab; /* A table in the database */
124137 pTab = (Table*)sqliteHashData(k);
124138 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
125075 Table *pTab = 0;
125094 pTab = sqlite3FindTable(db, zTableName, zDbName);
125095 if( !pTab || pTab->pSelect ){
125096 pTab = 0;
125102 iCol = pTab->iPKey;
125104 pCol = &pTab->aCol[iCol];
125107 for(iCol=0; iCol<pTab->nCol; iCol++){
125108 pCol = &pTab->aCol[iCol];
125113 if( iCol==pTab->nCol ){
125114 pTab = 0;
125134 autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
125156 if( SQLITE_OK==rc && !pTab ){
130750 Fts3Table *pTab, /* FTS Table pointer */
130794 fts3DoclistPhraseMerge(pTab->bDescIdx, nDiff, pLeft, nLeft, pRight,&nRight);
130813 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
130824 rc = fts3TermSelect(pTab, pToken, p->iColumn, &nThis, &pThis);
130826 fts3EvalPhraseMergeToken(pTab, p, iToken, pThis, nThis);
130958 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
130969 && pCsr->bDesc==pTab->bDescIdx
130973 && pTab->bNoIncrDoclist==0
130986 int iCol = (p->iColumn >= pTab->nColumn ? -1 : p->iColumn);
130991 rc = sqlite3Fts3MsrIncrStart(pTab, pSegcsr, iCol, pToken->z, pToken->n);
131108 Fts3Table *pTab,
131127 if( pTab->bDescIdx==0 || pDL->pNextDocid==0 ){
131171 Fts3Table *pTab, /* Virtual table handle */
131182 fts3EvalDlPhraseNext(pTab, &pPhrase->doclist, pbEof);
131193 pTab, pToken->pSegcsr, &p->iDocid, &p->pList, &p->nList
131229 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
131237 rc = sqlite3Fts3MsrIncrNext(pTab, p->aToken[0].pSegcsr,
131256 rc = incrPhraseTokenNext(pTab, p, i, &a[i], &bEof);
131270 rc = incrPhraseTokenNext(pTab, p, i, &a[i], &bEof);
131329 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
131333 }else if( pCsr->bDesc!=pTab->bDescIdx && pDL->nAll ){
131334 sqlite3Fts3DoclistPrev(pTab->bDescIdx, pDL->aAll, pDL->nAll,
131339 fts3EvalDlPhraseNext(pTab, pDL, pbEof);
131533 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
131548 if( pTab->zContentTbl ){
131626 rc = fts3TermSelect(pTab, pToken, pTC->iCol, &nList, &pList);
131630 fts3EvalPhraseMergeToken(pTab, pTC->pPhrase, pTC->iToken,pList,nList);
131657 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
131667 if( rc==SQLITE_OK && nToken>1 && pTab->bFts4 ){
132297 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
132318 pE->aMI = (u32 *)sqlite3_malloc(pTab->nColumn * 3 * sizeof(u32));
132320 memset(pE->aMI, 0, pTab->nColumn * 3 * sizeof(u32));
132406 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
132412 for(iCol=0; iCol<pTab->nColumn; iCol++){
132420 for(iCol=0; iCol<pTab->nColumn; iCol++){
132456 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
132464 assert( iCol>=0 && iCol<pTab->nColumn );
132465 if( (pPhrase->iColumn<pTab->nColumn && pPhrase->iColumn!=iCol) ){
132472 int bDescDoclist = pTab->bDescIdx; /* For DOCID_CMP macro */
136409 Fts3tokTable *pTab;
136439 pTab = (Fts3tokTable *)sqlite3_malloc(sizeof(Fts3tokTable));
136440 if( pTab==0 ){
136446 memset(pTab, 0, sizeof(Fts3tokTable));
136447 pTab->pMod = pMod;
136448 pTab->pTok = pTok;
136449 *ppVtab = &pTab->base;
136466 Fts3tokTable *pTab = (Fts3tokTable *)pVtab;
136468 pTab->pMod->xDestroy(pTab->pTok);
136469 sqlite3_free(pTab);
136525 Fts3tokTable *pTab = (Fts3tokTable *)(pCsr->base.pVtab);
136526 pTab->pMod->xClose(pCsr->pCsr);
136555 Fts3tokTable *pTab = (Fts3tokTable *)(pCursor->pVtab);
136559 rc = pTab->pMod->xNext(pCsr->pCsr,
136584 Fts3tokTable *pTab = (Fts3tokTable *)(pCursor->pVtab);
136598 rc = pTab->pMod->xOpen(pTab->pTok, pCsr->zInput, nByte, &pCsr->pCsr);
136600 pCsr->pCsr->pTokenizer = pTab->pTok;
137127 Fts3Table *pTab, /* FTS3 table handle */
137134 rc = fts3SqlStmt(pTab, SQL_SELECT_DOCSIZE, &pStmt, 0);
137152 Fts3Table *pTab, /* Fts3 table handle */
137157 rc = fts3SqlStmt(pTab, SQL_SELECT_STAT, &pStmt, 0);
137173 Fts3Table *pTab, /* Fts3 table handle */
137177 return fts3SelectDocsize(pTab, iDocid, ppStmt);
138106 static int fts3SegReaderFirstDocid(Fts3Table *pTab, Fts3SegReader *pReader){
138110 if( pTab->bDescIdx && fts3SegReaderIsPending(pReader) ){
138139 Fts3Table *pTab,
138150 if( pTab->bDescIdx && fts3SegReaderIsPending(pReader) ){
138214 if( pTab->bDescIdx ){
142899 Fts3Table *pTab, /* FTS3 table snippet comes from */
142931 pMod = (sqlite3_tokenizer_module *)pTab->pTokenizer->pModule;
142936 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, iLangid, zDoc, nDoc, &pC);
142973 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
142996 pMod = (sqlite3_tokenizer_module *)pTab->pTokenizer->pModule;
142997 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid, zDoc,nDoc,&pC);
143036 pTab, pCsr->iLangid, nSnippet, &zDoc[iBegin], n, &iPos, &hlmask
143168 Fts3Table *pTab,
143174 || (cArg==FTS3_MATCHINFO_NDOC && pTab->bFts4)
143175 || (cArg==FTS3_MATCHINFO_AVGLENGTH && pTab->bFts4)
143176 || (cArg==FTS3_MATCHINFO_LENGTH && pTab->bHasDocsize)
143212 Fts3Table *pTab,
143222 int rc = sqlite3Fts3SelectDoctotal(pTab, ppStmt);
143392 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
143409 rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &nDoc, 0);
143419 rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &nDoc, &a);
143435 rc = sqlite3Fts3SelectDocsize(pTab, pCsr->iPrevId, &pSelectDocsize);
143464 rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &pInfo->nDoc, 0);
143492 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
143498 sInfo.nCol = pTab->nColumn;
143564 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
143609 for(iRead=0; iRead<pTab->nColumn; iRead++){
143644 sqlite3Fts3SegmentsClose(pTab);
143707 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
143708 sqlite3_tokenizer_module const *pMod = pTab->pTokenizer->pModule;
143739 for(iCol=0; iCol<pTab->nColumn; iCol++){
143774 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid,
143812 }else if( rc==SQLITE_DONE && pTab->zContentTbl==0 ){
143828 sqlite3Fts3SegmentsClose(pTab);
143846 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
143854 if( fts3MatchinfoCheck(pTab, zArg[i], &zErr) ){
143872 sqlite3Fts3SegmentsClose(pTab);