Lines Matching refs:pTab
16507 Table *pTab; /* Used when p4type is P4_TABLE */ member
18483 ((X)->op==TK_COLUMN && (X)->y.pTab->eTabType==TABTYP_VTAB)
18853 Table *pTab; /* Source table */ member
19023 Table *pTab; /* TK_COLUMN: Table containing column. Can be NULL member
19267 Table *pTab; /* An SQL table corresponding to zName */ member
19686 Table *pTab; /* Table this info block refers to */ member
20300 struct Table *pTab; /* Table of generated column */ member
21067 SQLITE_PRIVATE const char *sqlite3RowidAlias(Table *pTab);
21157 SQLITE_PRIVATE int sqlite3ColumnIndex(Table *pTab, const char *zCol);
23645 Table *pTab; /* Schema object being updated */ member
32780 if( pItem->pTab ){ in sqlite3TreeViewSrcList()
32782 pItem->pTab->zName, pItem->pTab->nCol, pItem->pTab, in sqlite3TreeViewSrcList()
32825 if( pItem->pTab ){ in sqlite3TreeViewSrcList()
32826 Table *pTab = pItem->pTab; in sqlite3TreeViewSrcList() local
32827 sqlite3TreeViewColumnList(pView, pTab->aCol, pTab->nCol, 1); in sqlite3TreeViewSrcList()
33131 pExpr->y.pTab, zFlgs); in sqlite3TreeViewExpr()
86829 zP4 = pOp->p4.pTab->zName;
90306 Table *pTab, /* Modified table */
90314 const char *zTbl = pTab->zName;
90318 if( pTab->tabFlags & TF_WithoutRowid ){
90319 nRealCol = sqlite3PrimaryKeyIndex(pTab)->nColumn;
90320 }else if( pTab->tabFlags & TF_HasVirtual ){
90321 nRealCol = pTab->nNVCol;
90323 nRealCol = pTab->nCol;
90329 if( HasRowid(pTab)==0 ){
90331 preupdate.pPk = sqlite3PrimaryKeyIndex(pTab);
90352 preupdate.keyinfo.nKeyField = pTab->nCol;
90356 preupdate.pTab = pTab;
92581 if( iIdx==p->pTab->iPKey ){
92585 }else if( p->pTab->aCol[iIdx].affinity==SQLITE_AFF_REAL ){
92698 if( iIdx==p->pTab->iPKey ){
92720 if( iIdx==p->pTab->iPKey ){
96344 Table *pTab;
96349 pTab = pOp->p4.pTab;
96350 assert( pTab->tabFlags & TF_Strict );
96351 assert( pTab->nNVCol==pOp->p2 );
96352 aCol = pTab->aCol;
96354 for(i=0; i<pTab->nCol; i++){
96416 pTab->zName, aCol[i].zCnName);
98773 Table *pTab; /* Table structure - used by update and pre-update hooks */
98798 pTab = pOp->p4.pTab;
98799 assert( (pOp->p5 & OPFLAG_ISNOOP) || HasRowid(pTab) );
98801 pTab = 0;
98807 if( pTab ){
98809 sqlite3VdbePreUpdateHook(p,pC,SQLITE_INSERT,zDb,pTab,x.nKey,pOp->p2,-1);
98811 if( db->xUpdateCallback==0 || pTab->aCol==0 ){
98813 pTab = 0;
98845 if( pTab ){
98847 assert( pTab->aCol!=0 );
98850 zDb, pTab->zName, x.nKey);
98925 Table *pTab;
98939 && HasRowid(pOp->p4.pTab)
98958 assert( pOp->p4.pTab!=0 );
98960 pTab = pOp->p4.pTab;
98966 pTab = 0;
98971 assert( db->xPreUpdateCallback==0 || pTab==pOp->p4.pTab );
98972 if( db->xPreUpdateCallback && pTab ){
98974 || HasRowid(pTab)==0
98979 zDb, pTab, pC->movetoTarget,
99014 if( db->xUpdateCallback && ALWAYS(pTab!=0) && HasRowid(pTab) ){
99015 db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, pTab->zName,
101324 Table *pTab;
101332 pTab = pOp->p4.pTab;
101333 assert( pTab!=0 );
101334 assert( pTab->nTabRef>0 );
101335 assert( IsVirtual(pTab) );
101336 if( pTab->u.vtab.p==0 ) break;
101337 pVtab = pTab->u.vtab.p->pVtab;
101343 sqlite3VtabLock(pTab->u.vtab.p);
101345 rc = pModule->xIntegrity(pVtab, db->aDb[pOp->p1].zDbSName, pTab->zName,
101347 sqlite3VtabUnlock(pTab->u.vtab.p);
102316 Table *pTab; /* Table object */
102417 Table *pTab;
102444 pTab = sqlite3LocateTable(&sParse, 0, zTable, zDb);
102445 if( pTab && IsVirtual(pTab) ){
102446 pTab = 0;
102449 if( pTab && !HasRowid(pTab) ){
102450 pTab = 0;
102454 if( pTab && IsView(pTab) ){
102455 pTab = 0;
102459 if( !pTab ){
102469 pBlob->pTab = pTab;
102470 pBlob->zDb = db->aDb[sqlite3SchemaToIndex(db, pTab->pSchema)].zDbSName;
102473 for(iCol=0; iCol<pTab->nCol; iCol++) {
102474 if( sqlite3StrICmp(pTab->aCol[iCol].zCnName, zColumn)==0 ){
102478 if( iCol==pTab->nCol ){
102499 assert( IsOrdinaryTable(pTab) );
102500 for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){
102510 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
102558 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
102562 pTab->pSchema->schema_cookie,
102563 pTab->pSchema->iGeneration);
102578 aOp[0].p2 = pTab->tnum;
102580 sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT);
102588 aOp[1].p2 = pTab->tnum;
102599 aOp[1].p4.i = pTab->nCol+1;
102600 aOp[3].p2 = pTab->nCol;
102712 v, v->apCsr[0], SQLITE_DELETE, p->zDb, p->pTab, iKey, -1, p->iCol
105730 bytecodevtab *pTab = (bytecodevtab*)cur->pVtab;
105744 pTab->bTablesUsed,
105789 Table *pTab = (Table*)sqliteHashData(k);
105790 if( !IsVirtual(pTab) && pTab->tnum==iRoot ){
105791 pCur->zName = pTab->zName;
106909 pExTab = pExpr->y.pTab;
106942 pNew->y.pTab = pMatch->pTab;
106954 Table *pTab, /* The schema table we are trying to match */
106958 assert( pTab!=0 );
106959 assert( pTab->tnum==1 );
106961 zLegacy = pTab->zName;
107020 Table *pTab = 0; /* Table holding the row */
107073 pTab = pItem->pTab;
107074 assert( pTab!=0 && pTab->zName!=0 );
107075 assert( pTab->nCol>0 || pParse->nErr );
107088 assert( pEList->nExpr==pTab->nCol );
107140 if( pTab->pSchema!=pSchema ) continue;
107147 }else if( sqlite3StrICmp(zTab, pTab->zName)!=0 ){
107148 if( pTab->tnum!=1 ) continue;
107149 if( !isValidSchemaTableName(zTab, pTab, zDb) ) continue;
107153 sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab);
107157 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
107188 pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j;
107195 if( 0==cnt && VisibleRowid(pTab) ){
107210 && ALWAYS(pMatch->pTab!=0)
107211 && (pMatch->pTab->tabFlags & TF_Ephemeral)!=0
107212 && (pTab->tabFlags & TF_Ephemeral)==0)
107232 pExpr->y.pTab = pMatch->pTab;
107236 pSchema = pExpr->y.pTab->pSchema;
107247 pTab = 0;
107259 pTab = pParse->pTriggerTab;
107263 pTab = pParse->pTriggerTab;
107266 pTab = pParse->pTriggerTab;
107274 pTab = pUpsert->pUpsertSrc->a[0].pTab;
107280 if( pTab ){
107283 pSchema = pTab->pSchema;
107285 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
107289 if( iCol==pTab->iPKey ){
107295 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
107299 if( iCol<pTab->nCol ){
107308 pExpr->y.pTab = pTab;
107312 sqlite3TableColumnToStorage(pTab, iCol);
107319 pExpr->y.pTab = pTab;
107324 pExpr->iTable = pNC->uNC.iBaseReg + (pTab->nCol+1)*pExpr->iTable +
107325 sqlite3TableColumnToStorage(pTab, iCol) + 1;
107357 && ALWAYS(VisibleRowid(pMatch->pTab) || pMatch->fg.isNestedFrom)
107361 if( pMatch->pTab!=0 && IsView(pMatch->pTab) ){
107596 Table *pTab;
107598 pTab = p->y.pTab = pItem->pTab;
107600 if( p->y.pTab->iPKey==iCol ){
107604 if( (pTab->tabFlags & TF_HasGenerated)!=0
107605 && (pTab->aCol[iCol].colFlags & COLFLAG_GENERATED)!=0
107607 testcase( pTab->nCol==63 );
107608 testcase( pTab->nCol==64 );
107609 pItem->colUsed = pTab->nCol>=64 ? ALLBITS : MASKBIT(pTab->nCol)-1;
107717 pExpr->y.pTab = pItem->pTab;
107833 sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft);
108977 Table *pTab, /* The table being referenced, or NULL */
108986 assert( type==0 || pTab!=0 );
108988 || type==NC_GenCol || pTab==0 );
108991 if( pTab ){
108993 sSrc.a[0].zName = pTab->zName;
108994 sSrc.a[0].pTab = pTab;
108996 if( pTab->pSchema!=pParse->db->aDb[1].pSchema ){
109035 SQLITE_PRIVATE char sqlite3TableColumnAffinity(const Table *pTab, int iCol){
109036 if( iCol<0 || NEVER(iCol>=pTab->nCol) ) return SQLITE_AFF_INTEGER;
109037 return pTab->aCol[iCol].affinity;
109060 if( op==TK_COLUMN || (op==TK_AGG_COLUMN && pExpr->y.pTab!=0) ){
109062 assert( pExpr->y.pTab!=0 );
109063 return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
109262 if( (op==TK_AGG_COLUMN && p->y.pTab!=0)
109267 assert( p->y.pTab!=0 );
109269 const char *zColl = sqlite3ColumnColl(&p->y.pTab->aCol[j]);
110888 Table *pTab;
110910 pTab = pNewItem->pTab = pOldItem->pTab;
110911 if( pTab ){
110912 pTab->nTabRef++;
111868 || NEVER(p->y.pTab==0) /* Reference to column of index on expr */
111870 || (p->iColumn==XN_ROWID && IsView(p->y.pTab))
111873 && p->y.pTab->aCol!=0 /* Possible due to prior error */
111874 && ALWAYS(p->iColumn<p->y.pTab->nCol)
111875 && p->y.pTab->aCol[p->iColumn].notNull==0);
111939 SQLITE_PRIVATE const char *sqlite3RowidAlias(Table *pTab){
111942 assert( VisibleRowid(pTab) );
111945 for(iCol=0; iCol<pTab->nCol; iCol++){
111946 if( sqlite3_stricmp(azOpt[ii], pTab->aCol[iCol].zCnName)==0 ) break;
111948 if( iCol==pTab->nCol ){
111967 Table *pTab;
111985 pTab = pSrc->a[0].pTab;
111986 assert( pTab!=0 );
111987 assert( !IsView(pTab) ); /* FROM clause is not a view */
111988 if( IsVirtual(pTab) ) return 0; /* FROM clause not a virtual table */
112160 Table *pTab; /* Table <table>. */
112168 pTab = p->pSrc->a[0].pTab;
112171 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
112174 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
112182 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
112185 "USING ROWID SEARCH ON TABLE %s FOR IN-OPERATOR",pTab->zName));
112199 char idxaff = sqlite3TableColumnAffinity(pTab,iCol); /* RHS table */
112220 for(pIdx=pTab->pIndex; pIdx && eType==0; pIdx=pIdx->pNext){
113141 Table *pTab, /* Table containing the generated column */
113155 sqlite3ExprCodeCopy(pParse, sqlite3ColumnExpr(pTab,pCol), regOut);
113169 Table *pTab, /* The table containing the value */
113176 assert( pTab!=0 );
113178 if( iCol<0 || iCol==pTab->iPKey ){
113180 VdbeComment((v, "%s.rowid", pTab->zName));
113184 if( IsVirtual(pTab) ){
113188 }else if( (pCol = &pTab->aCol[iCol])->colFlags & COLFLAG_VIRTUAL ){
113197 sqlite3ExprCodeGeneratedColumn(pParse, pTab, pCol, regOut);
113203 }else if( !HasRowid(pTab) ){
113204 testcase( iCol!=sqlite3TableColumnToStorage(pTab, iCol) );
113205 x = sqlite3TableColumnToIndex(sqlite3PrimaryKeyIndex(pTab), iCol);
113208 x = sqlite3TableColumnToStorage(pTab,iCol);
113213 sqlite3ColumnDefault(v, pTab, iCol, regOut);
113226 Table *pTab, /* Description of the table we are reading from */
113234 assert( IsVirtual(pTab) || (p5 & OPFLAG_NOCHNG)==0 );
113235 sqlite3ExprCodeGetColumnOfTable(pParse->pVdbe, pTab, iTable, iColumn, iReg);
113586 Table *pTab = pCol->pTab;
113589 if( pTab==0 ){
113592 VdbeComment((v,"%s.rowid",pTab->zName));
113595 pTab->zName, pTab->aCol[pCol->iColumn].zCnName));
113596 if( pTab->aCol[pCol->iColumn].affinity==SQLITE_AFF_REAL ){
113601 }else if( pExpr->y.pTab==0 ){
113623 assert( pExpr->y.pTab!=0 );
113624 aff = sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
113643 Table *pTab;
113647 pTab = pExpr->y.pTab;
113648 assert( pTab!=0 );
113650 assert( iCol<pTab->nCol );
113654 pCol = pTab->aCol + iCol;
113655 testcase( iCol!=sqlite3TableColumnToStorage(pTab,iCol) );
113656 iSrc = sqlite3TableColumnToStorage(pTab, iCol) - pParse->iSelfTab;
113666 sqlite3ExprCodeGeneratedColumn(pParse, pTab, pCol, iSrc);
113691 assert( pExpr->y.pTab!=0 );
113692 iReg = sqlite3ExprCodeGetColumn(pParse, pExpr->y.pTab,
114140 Table *pTab;
114145 pTab = pExpr->y.pTab;
114147 p1 = pExpr->iTable * (pTab->nCol+1) + 1
114148 + sqlite3TableColumnToStorage(pTab, iCol);
114151 assert( iCol>=-1 && iCol<pTab->nCol );
114152 assert( pTab->iPKey<0 || iCol!=pTab->iPKey );
114153 assert( p1>=0 && p1<(pTab->nCol*2+2) );
114158 (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zCnName)
114167 if( iCol>=0 && pTab->aCol[iCol].affinity==SQLITE_AFF_REAL ){
115428 && ALWAYS(pLeft->y.pTab!=0)
115429 && IsVirtual(pLeft->y.pTab))
115431 && ALWAYS(pRight->y.pTab!=0)
115432 && IsVirtual(pRight->y.pTab))
115791 pCol->pTab = pExpr->y.pTab;
116173 static int isAlterableTable(Parse *pParse, Table *pTab){
116174 if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7)
116176 || (pTab->tabFlags & TF_Eponymous)!=0
116177 || ( (pTab->tabFlags & TF_Shadow)!=0
116182 sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName);
116273 Table *pTab; /* Table being renamed */
116285 pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
116286 if( !pTab ) goto exit_rename_table;
116287 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
116299 || sqlite3IsShadowTableOf(db, pTab, zName)
116309 if( SQLITE_OK!=isAlterableTable(pParse, pTab) ){
116317 if( IsView(pTab) ){
116318 sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
116325 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
116331 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
116334 if( IsVirtual(pTab) ){
116335 pVTab = sqlite3GetVTable(db, pTab);
116353 zTabName = pTab->zName;
116391 zDb, zName, pTab->zName);
116457 Table *pTab; /* Table being altered */
116481 pTab = sqlite3FindTable(db, zTab, zDb);
116482 assert( pTab );
116486 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
116557 assert( IsOrdinaryTable(pTab) );
116591 || (pTab->tabFlags & TF_Strict)!=0
116627 Table *pTab;
116637 pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
116638 if( !pTab ) goto exit_begin_add_column;
116641 if( IsVirtual(pTab) ){
116648 if( IsView(pTab) ){
116652 if( SQLITE_OK!=isAlterableTable(pParse, pTab) ){
116657 assert( IsOrdinaryTable(pTab) );
116658 assert( pTab->u.tab.addColOffset>0 );
116659 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
116672 pNew->nCol = pTab->nCol;
116677 pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
116682 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
116689 pNew->u.tab.pDfltList = sqlite3ExprListDup(db, pTab->u.tab.pDfltList, 0);
116691 pNew->u.tab.addColOffset = pTab->u.tab.addColOffset;
116708 static int isRealTable(Parse *pParse, Table *pTab, int bDrop){
116711 if( IsView(pTab) ){
116716 if( IsVirtual(pTab) ){
116723 zType, pTab->zName
116745 Table *pTab; /* Table being updated */
116754 pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
116755 if( !pTab ) goto exit_rename_column;
116758 if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_rename_column;
116759 if( SQLITE_OK!=isRealTable(pParse, pTab, 0) ) goto exit_rename_column;
116762 iSchema = sqlite3SchemaToIndex(db, pTab->pSchema);
116768 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
116777 for(iCol=0; iCol<pTab->nCol; iCol++){
116778 if( 0==sqlite3StrICmp(pTab->aCol[iCol].zCnName, zOld) ) break;
116780 if( iCol==pTab->nCol ){
116804 zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1,
116805 pTab->zName
116812 zDb, pTab->zName, iCol, zNew, bQuote
116858 Table *pTab; /* Table being ALTERed */
116961 sqlite3RenameTokenRemap(pParse, 0, (const void*)&pExpr->y.pTab);
117160 && pWalker->pParse->pTriggerTab==p->pTab
117166 && p->pTab==pExpr->y.pTab
117652 Table *pTab;
117663 pTab = sqlite3FindTable(db, zTable, zDb);
117664 if( pTab==0 || iCol>=pTab->nCol ){
117668 zOld = pTab->aCol[iCol].zCnName;
117670 sCtx.iCol = ((iCol==pTab->iPKey) ? -1 : iCol);
117684 sCtx.pTab = pTab;
117701 sCtx.pTab = sParse.pNewTable;
117753 if( pTarget==pTab ){
117766 if( sParse.pTriggerTab==pTab ){
117803 && p->pTab==pExpr->y.pTab
117805 renameTokenFind(pWalker->pParse, p, (void*)&pExpr->y.pTab);
117828 if( pItem->pTab==p->pTab ){
117885 sCtx.pTab = sqlite3FindTable(db, zOld, zDb);
117897 Table *pTab = sParse.pNewTable;
117899 if( IsView(pTab) ){
117901 Select *pSelect = pTab->u.view.pSelect;
117908 sqlite3SelectPrep(&sParse, pTab->u.view.pSelect, &sNC);
117912 sqlite3WalkSelect(&sWalker, pTab->u.view.pSelect);
117919 && !IsVirtual(pTab)
117922 assert( IsOrdinaryTable(pTab) );
117923 for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){
117934 if( sqlite3_stricmp(zOld, pTab->zName)==0 ){
117935 sCtx.pTab = pTab;
117937 sqlite3WalkExprList(&sWalker, pTab->pCheck);
117939 renameTokenFind(&sParse, &sCtx, pTab->zName);
117956 && sCtx.pTab->pSchema==pTrigger->pTabSchema
118244 Table *pTab;
118256 pTab = sParse.pNewTable;
118257 if( pTab==0 || pTab->nCol==1 || iCol>=pTab->nCol ){
118263 pCol = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol].zCnName);
118264 if( iCol<pTab->nCol-1 ){
118266 pEnd = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol+1].zCnName);
118269 assert( IsOrdinaryTable(pTab) );
118270 zEnd = (const char*)&zSql[pTab->u.tab.addColOffset];
118298 Table *pTab; /* Table to modify */
118308 pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
118309 if( !pTab ) goto exit_drop_column;
118313 if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_drop_column;
118314 if( SQLITE_OK!=isRealTable(pParse, pTab, 1) ) goto exit_drop_column;
118322 iCol = sqlite3ColumnIndex(pTab, zCol);
118330 if( pTab->aCol[iCol].colFlags & (COLFLAG_PRIMKEY|COLFLAG_UNIQUE) ){
118332 (pTab->aCol[iCol].colFlags&COLFLAG_PRIMKEY) ? "PRIMARY KEY" : "UNIQUE",
118339 if( pTab->nCol<=1 ){
118345 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
118350 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, zCol) ){
118360 , zDb, iDb, iCol, pTab->zName
118368 if( pParse->nErr==0 && (pTab->aCol[iCol].colFlags & COLFLAG_VIRTUAL)==0 ){
118378 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite);
118381 if( HasRowid(pTab) ){
118383 pParse->nMem += pTab->nCol;
118385 pPk = sqlite3PrimaryKeyIndex(pTab);
118393 for(i=0; i<pTab->nCol; i++){
118394 if( i!=iCol && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ){
118404 if( i==pTab->iPKey ){
118407 char aff = pTab->aCol[i].affinity;
118409 pTab->aCol[i].affinity = SQLITE_AFF_NUMERIC;
118411 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, i, regOut);
118412 pTab->aCol[i].affinity = aff;
119434 Table *pTab, /* Table whose indices are to be analyzed */
119469 if( v==0 || NEVER(pTab==0) ){
119472 if( !IsOrdinaryTable(pTab) ){
119476 if( sqlite3_strlike("sqlite\\_%", pTab->zName, '\\')==0 ){
119481 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
119485 if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,
119507 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
119511 sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
119512 sqlite3VdbeLoadString(v, regTabname, pTab->zName);
119514 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
119523 if( !HasRowid(pTab) && IsPrimaryKeyIndex(pIdx) ){
119525 zIdxName = pTab->zName;
119535 VdbeComment((v, "Analysis for %s.%s", pTab->zName, zIdxName));
119685 if( HasRowid(pTab) ){
119749 u8 seekOp = HasRowid(pTab) ? OP_NotExists : OP_NotFound;
119763 for(pX=pTab->pIndex; pX; pX=pX->pNext){
119765 if( !HasRowid(pTab) && IsPrimaryKeyIndex(pX) ){
119818 VdbeComment((v, "%s", pTab->zName));
119865 Table *pTab = (Table*)sqliteHashData(k);
119866 analyzeOneTable(pParse, pTab, 0, iStatCur, iMem, iTab);
119881 static void analyzeTable(Parse *pParse, Table *pTab, Index *pOnlyIdx){
119885 assert( pTab!=0 );
119887 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
119894 openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
119896 analyzeOneTable(pParse, pTab, pOnlyIdx, iStatCur,pParse->nMem+1,pParse->nTab);
119917 Table *pTab;
119948 }else if( (pTab = sqlite3LocateTable(pParse, 0, z, zDb))!=0 ){
119949 analyzeTable(pParse, pTab, 0);
120214 Table *pTab = sqlite3FindTable(db, zName, zDb);
120215 if( pTab && !HasRowid(pTab) ) pIdx = sqlite3PrimaryKeyIndex(pTab);
120417 Table *pTab = sqliteHashData(i);
120418 pTab->tabFlags &= ~TF_HasStat1;
121242 Table *pTab = 0; /* The table being read */
121259 pTab = pParse->pTriggerTab;
121264 pTab = pTabList->a[iSrc].pTab;
121270 if( pTab==0 ) return;
121273 assert( iCol<pTab->nCol );
121274 zCol = pTab->aCol[iCol].zCnName;
121275 }else if( pTab->iPKey>=0 ){
121276 assert( pTab->iPKey<pTab->nCol );
121277 zCol = pTab->aCol[pTab->iPKey].zCnName;
121282 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
122064 Table *pTab, /* The table containing the column */
122069 assert( IsOrdinaryTable(pTab) );
122070 pList = pTab->u.tab.pDfltList;
122076 pTab->u.tab.pDfltList = sqlite3ExprListAppend(pParse, pList, pExpr);
122088 SQLITE_PRIVATE Expr *sqlite3ColumnExpr(Table *pTab, Column *pCol){
122090 if( !IsOrdinaryTable(pTab) ) return 0;
122091 if( NEVER(pTab->u.tab.pDfltList==0) ) return 0;
122092 if( NEVER(pTab->u.tab.pDfltList->nExpr<pCol->iDflt) ) return 0;
122093 return pTab->u.tab.pDfltList->a[pCol->iDflt-1].pExpr;
122448 SQLITE_PRIVATE Index *sqlite3PrimaryKeyIndex(Table *pTab){
122450 for(p=pTab->pIndex; p && !IsPrimaryKeyIndex(p); p=p->pNext){}
122480 SQLITE_PRIVATE i16 sqlite3StorageColumnToTable(Table *pTab, i16 iCol){
122481 if( pTab->tabFlags & TF_HasVirtual ){
122484 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) iCol++;
122528 SQLITE_PRIVATE i16 sqlite3TableColumnToStorage(Table *pTab, i16 iCol){
122531 assert( iCol<pTab->nCol );
122532 if( (pTab->tabFlags & TF_HasVirtual)==0 || iCol<0 ) return iCol;
122534 if( (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) n++;
122536 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ){
122538 return pTab->nNVCol + i - n;
122770 SQLITE_PRIVATE void sqlite3ColumnPropertiesFromName(Table *pTab, Column *pCol){
122773 if( pTab ) pTab->tabFlags |= TF_HasHidden;
122774 }else if( pTab && pCol!=pTab->aCol && (pCol[-1].colFlags & COLFLAG_HIDDEN) ){
122775 pTab->tabFlags |= TF_OOOHidden;
123203 Table *pTab = pParse->pNewTable;
123207 if( pTab==0 ) goto primary_key_exit;
123208 if( pTab->tabFlags & TF_HasPrimaryKey ){
123210 "table \"%s\" has more than one primary key", pTab->zName);
123213 pTab->tabFlags |= TF_HasPrimaryKey;
123215 iCol = pTab->nCol - 1;
123216 pCol = &pTab->aCol[iCol];
123229 for(iCol=0; iCol<pTab->nCol; iCol++){
123230 if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zCnName)==0 ){
123231 pCol = &pTab->aCol[iCol];
123246 sqlite3RenameTokenRemap(pParse, &pTab->iPKey, pCExpr);
123248 pTab->iPKey = iCol;
123249 pTab->keyConf = (u8)onError;
123251 pTab->tabFlags |= autoInc*TF_Autoincrement;
123280 Table *pTab = pParse->pNewTable;
123282 if( pTab && !IN_DECLARE_VTAB
123285 pTab->pCheck = sqlite3ExprListAppend(pParse, pTab->pCheck, pCheckExpr);
123287 sqlite3ExprListSetName(pParse, pTab->pCheck, &pParse->constraintName, 1);
123294 sqlite3ExprListSetName(pParse, pTab->pCheck, &t, 1);
123343 Table *pTab = pParse->pNewTable;
123345 if( pTab==0 ){
123349 pCol = &(pTab->aCol[pTab->nCol-1]);
123364 if( eType==COLFLAG_VIRTUAL ) pTab->nNVCol--;
123368 pTab->tabFlags |= eType;
123380 sqlite3ColumnSetExpr(pParse, pTab, pCol, pExpr);
123579 static void estimateTableWidth(Table *pTab){
123583 for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){
123586 if( pTab->iPKey<0 ) wTable++;
123587 pTab->szTabRow = sqlite3LogEst(wTable*4);
123674 Table *pTab = pIdx->pTable;
123677 if( x>=0 && (pTab->aCol[x].colFlags & COLFLAG_VIRTUAL)==0 ){
123711 static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
123723 for(i=0; i<pTab->nCol; i++){
123724 if( (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0
123725 && (pTab->aCol[i].notNull==OE_None)
123727 pTab->aCol[i].notNull = OE_Abort;
123730 pTab->tabFlags |= TF_HasNotNull;
123745 if( pTab->iPKey>=0 ){
123748 sqlite3TokenInit(&ipkToken, pTab->aCol[pTab->iPKey].zCnName);
123752 pTab->tabFlags &= ~TF_WithoutRowid;
123756 sqlite3RenameTokenRemap(pParse, pList->a[0].pExpr, &pTab->iPKey);
123759 assert( pParse->pNewTable==pTab );
123760 pTab->iPKey = -1;
123761 sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0,
123764 pTab->tabFlags &= ~TF_WithoutRowid;
123768 pPk = sqlite3PrimaryKeyIndex(pTab);
123771 pPk = sqlite3PrimaryKeyIndex(pTab);
123806 pPk->tnum = pTab->tnum;
123811 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
123845 for(i=0; i<pTab->nCol; i++){
123847 && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) nExtra++;
123850 for(i=0, j=nPk; i<pTab->nCol; i++){
123852 && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0
123861 assert( pTab->nNVCol<=j );
123871 SQLITE_PRIVATE int sqlite3IsShadowTableOf(sqlite3 *db, Table *pTab, const char *zName){
123875 if( !IsVirtual(pTab) ) return 0;
123876 nName = sqlite3Strlen30(pTab->zName);
123877 if( sqlite3_strnicmp(zName, pTab->zName, nName)!=0 ) return 0;
123879 pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->u.vtab.azArg[0]);
123894 SQLITE_PRIVATE void sqlite3MarkAllShadowTablesOf(sqlite3 *db, Table *pTab){
123899 assert( IsVirtual(pTab) );
123900 pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->u.vtab.azArg[0]);
123905 assert( pTab->zName!=0 );
123906 nName = sqlite3Strlen30(pTab->zName);
123907 for(k=sqliteHashFirst(&pTab->pSchema->tblHash); k; k=sqliteHashNext(k)){
123912 if( sqlite3StrNICmp(pOther->zName, pTab->zName, nName)==0
123932 Table *pTab; /* Table that zName is a shadow of */
123936 pTab = sqlite3FindTable(db, zName, 0);
123938 if( pTab==0 ) return 0;
123939 if( !IsVirtual(pTab) ) return 0;
123940 return sqlite3IsShadowTableOf(db, pTab, zName);
124577 Table *pTab = sqliteHashData(i);
124578 if( IsView(pTab) ){
124579 sqlite3DeleteColumnNames(db, pTab);
124615 Table *pTab = sqliteHashData(pElem);
124616 if( pTab->tnum==iFrom ){
124617 pTab->tnum = iTo;
124666 static void destroyTable(Parse *pParse, Table *pTab){
124683 Pgno iTab = pTab->tnum;
124693 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
124695 assert( pIdx->pSchema==pTab->pSchema );
124703 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
124738 SQLITE_PRIVATE void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){
124749 if( IsVirtual(pTab) ){
124758 pTrigger = sqlite3TriggerList(pParse, pTab);
124760 assert( pTrigger->pSchema==pTab->pSchema ||
124772 if( pTab->tabFlags & TF_Autoincrement ){
124775 pDb->zDbSName, pTab->zName
124790 pDb->zDbSName, pTab->zName);
124791 if( !isView && !IsVirtual(pTab) ){
124792 destroyTable(pParse, pTab);
124798 if( IsVirtual(pTab) ){
124799 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
124802 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
124827 static int tableMayNotBeDropped(sqlite3 *db, Table *pTab){
124828 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
124829 if( sqlite3StrNICmp(pTab->zName+7, "stat", 4)==0 ) return 0;
124830 if( sqlite3StrNICmp(pTab->zName+7, "parameters", 10)==0 ) return 0;
124833 if( (pTab->tabFlags & TF_Shadow)!=0 && sqlite3ReadOnlyShadowTables(db) ){
124836 if( pTab->tabFlags & TF_Eponymous ){
124847 Table *pTab;
124860 pTab = sqlite3LocateTableItem(pParse, isView, &pName->a[0]);
124863 if( pTab==0 ){
124870 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
124876 if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){
124895 }else if( IsVirtual(pTab) ){
124897 zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
124906 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
124909 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
124914 if( tableMayNotBeDropped(db, pTab) ){
124915 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
124923 if( isView && !IsView(pTab) ){
124924 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
124927 if( !isView && IsView(pTab) ){
124928 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
124940 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
124941 sqlite3FkDropTable(pParse, pName, pTab);
124943 sqlite3CodeDropTable(pParse, pTab, iDb, isView);
125100 Table *pTab;
125102 if( (pTab = pParse->pNewTable)==0 ) return;
125103 if( NEVER(!IsOrdinaryTable(pTab)) ) return;
125104 if( (pFKey = pTab->u.tab.pFKey)==0 ) return;
125122 Table *pTab = pIndex->pTable; /* The table that is indexed */
125144 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
125163 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
125301 Table *pTab = 0; /* Table to be indexed */
125353 pTab = sqlite3SrcListLookup(pParse, pTblName);
125354 if( pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){
125366 pTab = sqlite3LocateTableItem(pParse, 0, &pTblName->a[0]);
125367 assert( db->mallocFailed==0 || pTab==0 );
125368 if( pTab==0 ) goto exit_create_index;
125369 if( iDb==1 && db->aDb[iDb].pSchema!=pTab->pSchema ){
125372 pTab->zName);
125375 if( !HasRowid(pTab) ) pPk = sqlite3PrimaryKeyIndex(pTab);
125379 pTab = pParse->pNewTable;
125380 if( !pTab ) goto exit_create_index;
125381 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
125385 assert( pTab!=0 );
125386 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
125390 && sqlite3UserAuthTable(pTab->zName)==0
125393 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
125397 if( IsView(pTab) ){
125403 if( IsVirtual(pTab) ){
125426 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName,"index",pTab->zName) ){
125450 for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
125451 zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
125474 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
125486 Column *pCol = &pTab->aCol[pTab->nCol-1];
125527 pIndex->pTable = pTab;
125534 sqlite3ResolveSelfReference(pParse, pTab, NC_PartIdx, pPIWhere, 0);
125568 sqlite3ResolveSelfReference(pParse, pTab, NC_IdxExpr, pListItem->pExpr, 0);
125572 if( pTab==pParse->pNewTable ){
125589 j = pTab->iPKey;
125591 if( pTab->aCol[j].notNull==0 ){
125594 if( pTab->aCol[j].colFlags & COLFLAG_VIRTUAL ){
125613 zColl = sqlite3ColumnColl(&pTab->aCol[j]);
125652 assert( HasRowid(pTab)
125653 || pTab->iPKey<0 || sqlite3TableColumnToIndex(pIndex, pTab->iPKey)>=0 );
125655 if( pTblName!=0 && pIndex->nColumn>=pTab->nCol ){
125657 for(j=0; j<pTab->nCol; j++){
125658 if( j==pTab->iPKey ) continue;
125665 if( pTab==pParse->pNewTable ){
125688 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
125773 else if( HasRowid(pTab) || pTblName!=0 ){
125814 pTab->zName,
125835 pIndex->pNext = pTab->pIndex;
125836 pTab->pIndex = pIndex;
125848 if( pTab ){
125855 for(ppFrom=&pTab->pIndex; (pThis = *ppFrom)!=0; ppFrom=&pThis->pNext){
125870 for(pThis = pTab->pIndex; pThis; pThis=pThis->pNext){
125979 Table *pTab = pIndex->pTable;
125986 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
126303 sqlite3DeleteTable(db, pItem->pTab);
126732 Table *pTab = pIdx->pTable;
126742 zCol = pTab->aCol[pIdx->aiColumn[j]].zCnName;
126744 sqlite3_str_appendall(&errMsg, pTab->zName);
126763 Table *pTab /* The table with the non-unique rowid */
126767 if( pTab->iPKey>=0 ){
126768 zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
126769 pTab->aCol[pTab->iPKey].zCnName);
126772 zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
126803 static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){
126804 if( !IsVirtual(pTab) ){
126807 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
126809 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
126829 Table *pTab; /* A table in the database */
126835 pTab = (Table*)sqliteHashData(k);
126836 reindexTable(pParse, pTab, zColl);
126860 Table *pTab; /* A table in the database */
126893 pTab = sqlite3FindTable(db, z, zDb);
126894 if( pTab ){
126895 reindexTable(pParse, pTab, 0);
127581 Table *pTab = sqliteHashData(pElem);
127582 sqlite3DeleteTable(&xdb, pTab);
127650 Table *pTab;
127652 pTab = sqlite3LocateTableItem(pParse, 0, pItem);
127653 if( pItem->pTab ) sqlite3DeleteTable(pParse->db, pItem->pTab);
127654 pItem->pTab = pTab;
127656 if( pTab ){
127657 pTab->nTabRef++;
127659 pTab = 0;
127662 return pTab;
127694 static int vtabIsReadOnly(Parse *pParse, Table *pTab){
127695 if( sqlite3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0 ){
127706 && pTab->u.vtab.p->eVtabRisk >
127710 pTab->zName);
127714 static int tabIsReadOnly(Parse *pParse, Table *pTab){
127716 if( IsVirtual(pTab) ){
127717 return vtabIsReadOnly(pParse, pTab);
127719 if( (pTab->tabFlags & (TF_Readonly|TF_Shadow))==0 ) return 0;
127721 if( (pTab->tabFlags & TF_Readonly)!=0 ){
127724 assert( pTab->tabFlags & TF_Shadow );
127735 SQLITE_PRIVATE int sqlite3IsReadOnly(Parse *pParse, Table *pTab, Trigger *pTrigger){
127736 if( tabIsReadOnly(pParse, pTab) ){
127737 sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
127741 if( IsView(pTab)
127744 sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
127811 Table *pTab;
127838 pTab = pSrc->a[0].pTab;
127839 if( HasRowid(pTab) ){
127845 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
127850 assert( pPk->aiColumn[0]>=0 && pPk->aiColumn[0]<pTab->nCol );
127851 zName = pTab->aCol[pPk->aiColumn[0]].zCnName;
127858 assert( pPk->aiColumn[i]>=0 && pPk->aiColumn[i]<pTab->nCol );
127859 p = sqlite3Expr(db, TK_ID, pTab->aCol[pPk->aiColumn[i]].zCnName);
127871 pSrc->a[0].pTab = 0;
127873 pSrc->a[0].pTab = pTab;
127911 Table *pTab; /* The table from which records will be deleted */
127960 pTab = sqlite3SrcListLookup(pParse, pTabList);
127961 if( pTab==0 ) goto delete_from_cleanup;
127967 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
127968 isView = IsView(pTab);
127973 bComplex = pTrigger || sqlite3FkRequired(pParse, pTab, 0, 0);
127999 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
128003 if( sqlite3IsReadOnly(pParse, pTab, pTrigger) ){
128006 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
128008 rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0,
128020 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
128027 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
128044 sqlite3MaterializeView(pParse, pTab,
128089 && !IsVirtual(pTab)
128095 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
128096 if( HasRowid(pTab) ){
128097 sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt ? memCnt : -1,
128098 pTab->zName, P4_STATIC);
128100 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
128101 assert( pIdx->pSchema==pTab->pSchema );
128102 if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
128114 if( HasRowid(pTab) ){
128123 pPk = sqlite3PrimaryKeyIndex(pTab);
128144 assert( IsVirtual(pTab)==0 || eOnePass!=ONEPASS_MULTI );
128145 assert( IsVirtual(pTab) || bComplex || eOnePass!=ONEPASS_OFF
128161 sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur,
128167 sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur, -1, iKey);
128212 testcase( IsVirtual(pTab) );
128213 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, OPFLAG_FORDELETE,
128215 assert( pPk || IsVirtual(pTab) || iDataCur==iTabCur );
128216 assert( pPk || IsVirtual(pTab) || iIdxCur==iDataCur+1 );
128227 if( !IsVirtual(pTab) && aToOpen[iDataCur-iTabCur] ){
128228 assert( pPk!=0 || IsView(pTab) );
128234 if( IsVirtual(pTab) ){
128248 if( IsVirtual(pTab) ){
128249 const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
128250 sqlite3VtabMakeWritable(pParse, pTab);
128265 sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
128362 Table *pTab, /* Table containing the row to be deleted */
128387 opSeek = HasRowid(pTab) ? OP_NotExists : OP_NotFound;
128396 if( sqlite3FkRequired(pParse, pTab, 0, 0) || pTrigger ){
128404 pParse, pTrigger, 0, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onconf
128406 mask |= sqlite3FkOldmask(pParse, pTab);
128408 pParse->nMem += (1 + pTab->nCol);
128413 for(iCol=0; iCol<pTab->nCol; iCol++){
128417 int kk = sqlite3TableColumnToStorage(pTab, iCol);
128418 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, iCol, iOld+kk+1);
128425 TK_DELETE, 0, TRIGGER_BEFORE, pTab, iOld, onconf, iLabel
128447 sqlite3FkCheck(pParse, pTab, iOld, 0, 0, 0);
128460 if( !IsView(pTab) ){
128462 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,iIdxNoSeek);
128464 if( pParse->nested==0 || 0==sqlite3_stricmp(pTab->zName, "sqlite_stat1") ){
128465 sqlite3VdbeAppendP4(v, (char*)pTab, P4_TABLE);
128480 sqlite3FkActions(pParse, pTab, 0, iOld, 0, 0);
128485 TK_DELETE, 0, TRIGGER_AFTER, pTab, iOld, onconf, iLabel
128516 Table *pTab, /* Table containing the row to be deleted */
128531 pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
128532 for(i=0, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
131731 Table *pTab, /* Parent table of FK pFKey */
131787 if( pTab==pFKey->pFrom && nIncr==1 ){
131792 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);
131820 if( pTab==pFKey->pFrom && nIncr==1 ){
131829 assert( aiCol[i]!=pTab->iPKey );
131830 if( pIdx->aiColumn[i]==pTab->iPKey ){
131881 Table *pTab, /* The table whose content is at r[regBase]... */
131892 if( iCol>=0 && iCol!=pTab->iPKey ){
131893 pCol = &pTab->aCol[iCol];
131894 pExpr->iTable = regBase + sqlite3TableColumnToStorage(pTab,iCol) + 1;
131913 Table *pTab, /* The table whose column is desired */
131920 pExpr->y.pTab = pTab;
131958 Table *pTab, /* The parent table */
131973 assert( pIdx==0 || pIdx->pTable==pTab );
131976 assert( pIdx!=0 || HasRowid(pTab) );
131999 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
132022 if( pTab==pFKey->pFrom && nIncr>0 ){
132026 if( HasRowid(pTab) ){
132027 pLeft = exprTableRegister(pParse, pTab, regData, -1);
132028 pRight = exprTableColumn(db, pTab, pSrc->a[0].iCursor, -1);
132036 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
132037 pRight = sqlite3Expr(db, TK_ID, pTab->aCol[iCol].zCnName);
132084 SQLITE_PRIVATE FKey *sqlite3FkReferences(Table *pTab){
132085 return (FKey *)sqlite3HashFind(&pTab->pSchema->fkeyHash, pTab->zName);
132116 Table *pTab = sqliteHashData(k);
132118 if( !IsOrdinaryTable(pTab) ) continue;
132119 for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){
132143 SQLITE_PRIVATE void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTab){
132145 if( (db->flags&SQLITE_ForeignKeys) && IsOrdinaryTable(pTab) ){
132150 assert( IsOrdinaryTable(pTab) );
132151 if( sqlite3FkReferences(pTab)==0 ){
132158 for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){
132207 Table *pTab, /* Table being updated */
132216 if( iChildKey==pTab->iPKey && bChngRowid ) return 1;
132234 Table *pTab,
132243 for(iKey=0; iKey<pTab->nCol; iKey++){
132244 if( aChange[iKey]>=0 || (iKey==pTab->iPKey && bChngRowid) ){
132245 Column *pCol = &pTab->aCol[iKey];
132298 Table *pTab, /* Row is being deleted from this table */
132315 if( !IsOrdinaryTable(pTab) ) return;
132317 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
132322 for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){
132332 && sqlite3_stricmp(pTab->zName, pFKey->zTo)!=0
132333 && fkChildIsModified(pTab, pFKey, aChange, bChngRowid)==0
132379 if( aiCol[i]==pTab->iPKey ){
132425 for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){
132430 if( aChange && fkParentIsModified(pTab, pFKey, aChange, bChngRowid)==0 ){
132443 if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ){
132454 pItem->pTab = pFKey->pFrom;
132456 pItem->pTab->nTabRef++;
132460 fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regNew, -1);
132466 fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regOld, 1);
132503 Table *pTab /* Table being modified */
132506 if( pParse->db->flags&SQLITE_ForeignKeys && IsOrdinaryTable(pTab) ){
132509 for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){
132512 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
132514 sqlite3FkLocateIndex(pParse, pTab, p, &pIdx, 0);
132553 Table *pTab, /* Table being modified */
132559 if( pParse->db->flags&SQLITE_ForeignKeys && IsOrdinaryTable(pTab) ){
132564 bHaveFK = (sqlite3FkReferences(pTab) || pTab->u.tab.pFKey);
132571 for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){
132572 if( fkChildIsModified(pTab, p, aChange, chngRowid) ){
132573 if( 0==sqlite3_stricmp(pTab->zName, p->zTo) ) eRet = 2;
132579 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
132580 if( fkParentIsModified(pTab, p, aChange, chngRowid) ){
132625 Table *pTab, /* Table being updated or deleted from */
132653 if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ) return 0;
132666 assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKey<pTab->nCol) );
132669 pTab->aCol[pIdx ? pIdx->aiColumn[i] : pTab->iPKey].zCnName);
132735 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
132808 pTrigger->pSchema = pTab->pSchema;
132809 pTrigger->pTabSchema = pTab->pSchema;
132823 Table *pTab, /* Table being updated or deleted from */
132835 for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){
132836 if( aChange==0 || fkParentIsModified(pTab, pFKey, aChange, bChngRowid) ){
132837 Trigger *pAct = fkActionTrigger(pParse, pTab, pFKey, pChanges);
132839 sqlite3CodeRowTriggerDirect(pParse, pAct, pTab, regOld, OE_Abort, 0);
132853 SQLITE_PRIVATE void sqlite3FkDelete(sqlite3 *db, Table *pTab){
132857 assert( IsOrdinaryTable(pTab) );
132859 for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pNext){
132860 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pTab->pSchema) );
132868 sqlite3HashInsert(&pTab->pSchema->fkeyHash, z, pFKey->pNextTo);
132923 Table *pTab, /* The table to be opened */
132927 assert( !IsVirtual(pTab) );
132932 sqlite3TableLock(pParse, iDb, pTab->tnum,
132933 (opcode==OP_OpenWrite)?1:0, pTab->zName);
132935 if( HasRowid(pTab) ){
132936 sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nNVCol);
132937 VdbeComment((v, "%s", pTab->zName));
132939 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
132941 assert( pPk->tnum==pTab->tnum || CORRUPT_DB );
132944 VdbeComment((v, "%s", pTab->zName));
132978 Table *pTab = pIdx->pTable;
132988 aff = pTab->aCol[x].affinity;
133015 SQLITE_PRIVATE char *sqlite3TableAffinityStr(sqlite3 *db, const Table *pTab){
133017 zColAff = (char *)sqlite3DbMallocRaw(db, pTab->nCol+1);
133020 for(i=j=0; i<pTab->nCol; i++){
133021 if( (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ){
133022 zColAff[j++] = pTab->aCol[i].affinity;
133072 SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){
133075 if( pTab->tabFlags & TF_Strict ){
133081 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
133089 sqlite3VdbeAddOp2(v, OP_TypeCheck, iReg, pTab->nNVCol);
133090 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
133094 zColAff = pTab->zColAff;
133096 zColAff = sqlite3TableAffinityStr(0, pTab);
133101 pTab->zColAff = zColAff;
133122 static int readsTable(Parse *p, int iDb, Table *pTab){
133127 VTable *pVTab = IsVirtual(pTab) ? sqlite3GetVTable(p->db, pTab) : 0;
133136 if( tnum==pTab->tnum ){
133139 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
133161 assert( pExpr->iColumn < pWalker->u.pTab->nCol );
133162 pWalker->eCode |= pWalker->u.pTab->aCol[pExpr->iColumn].colFlags;
133178 Table *pTab /* The table */
133186 assert( pTab->tabFlags & TF_HasGenerated );
133187 testcase( pTab->tabFlags & TF_HasVirtual );
133188 testcase( pTab->tabFlags & TF_HasStored );
133193 sqlite3TableAffinity(pParse->pVdbe, pTab, iRegStore);
133194 if( (pTab->tabFlags & TF_HasStored)!=0 ){
133205 if( pTab->aCol[ii].colFlags & COLFLAG_VIRTUAL ){
133208 if( pTab->aCol[ii].colFlags & COLFLAG_STORED ){
133225 for(i=0; i<pTab->nCol; i++){
133226 if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){
133227 testcase( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL );
133228 testcase( pTab->aCol[i].colFlags & COLFLAG_STORED );
133229 pTab->aCol[i].colFlags |= COLFLAG_NOTAVAIL;
133233 w.u.pTab = pTab;
133247 for(i=0; i<pTab->nCol; i++){
133248 Column *pCol = pTab->aCol + i;
133253 sqlite3WalkExpr(&w, sqlite3ColumnExpr(pTab, pCol));
133261 x = sqlite3TableColumnToStorage(pTab, i) + iRegStore;
133262 sqlite3ExprCodeGeneratedColumn(pParse, pTab, pCol, x);
133302 Table *pTab /* The table we are writing to */
133306 if( (pTab->tabFlags & TF_Autoincrement)!=0
133327 while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; }
133335 pInfo->pTab = pTab;
133384 sqlite3VdbeLoadString(v, memId-1, p->pTab->zName);
133779 Table *pTab; /* The table to insert into. aka TABLE */
133838 pTab = sqlite3SrcListLookup(pParse, pTabList);
133839 if( pTab==0 ){
133842 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
133844 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0,
133848 withoutRowid = !HasRowid(pTab);
133854 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0, &tmask);
133855 isView = IsView(pTab);
133878 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
133884 if( sqlite3IsReadOnly(pParse, pTab, pTrigger) ){
133908 && xferOptimization(pParse, pTab, pSelect, onError, iDb)
133919 regAutoinc = autoIncBegin(pParse, iDb, pTab);
133925 pParse->nMem += pTab->nCol + 1;
133926 if( IsVirtual(pTab) ){
133951 bIdListInOrder = (pTab->tabFlags & (TF_OOOHidden|TF_HasStored))==0;
133959 for(j=0; j<pTab->nCol; j++){
133960 if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zCnName)==0 ){
133963 if( j==pTab->iPKey ){
133967 if( pTab->aCol[j].colFlags & (COLFLAG_STORED|COLFLAG_VIRTUAL) ){
133970 pTab->aCol[j].zCnName);
133977 if( j>=pTab->nCol ){
134010 if( bIdListInOrder && nColumn==pTab->nCol ){
134013 regIns = regRowid - (IsVirtual(pTab) ? 1 : 0);
134022 dest.nSdst = pTab->nCol;
134043 if( pTrigger || readsTable(pParse, iDb, pTab) ){
134099 ipkColumn = pTab->iPKey;
134101 if( ipkColumn>=0 && (pTab->tabFlags & TF_HasGenerated)!=0 ){
134102 testcase( pTab->tabFlags & TF_HasVirtual );
134103 testcase( pTab->tabFlags & TF_HasStored );
134105 if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){
134106 testcase( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL );
134107 testcase( pTab->aCol[i].colFlags & COLFLAG_STORED );
134120 if( (pTab->tabFlags & (TF_HasGenerated|TF_HasHidden))!=0 ){
134121 for(i=0; i<pTab->nCol; i++){
134122 if( pTab->aCol[i].colFlags & COLFLAG_NOINSERT ) nHidden++;
134125 if( nColumn!=(pTab->nCol-nHidden) ){
134128 pTabList->a, pTab->nCol-nHidden, nColumn);
134151 nIdx = sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, -1, 0,
134157 for(i=0, pIdx=pTab->pIndex; i<nIdx; pIdx=pIdx->pNext, i++){
134167 if( IsVirtual(pTab) ){
134169 pTab->zName);
134172 if( IsView(pTab) ){
134219 sqlite3VdbeReleaseRegisters(pParse, regData, pTab->nCol, 0, 0);
134239 for(i=0; i<pTab->nCol; i++, iRegStore++){
134243 if( i==pTab->iPKey ){
134251 if( ((colFlags = pTab->aCol[i].colFlags) & COLFLAG_NOINSERT)!=0 ){
134272 sqlite3ColumnExpr(pTab, &pTab->aCol[i]),
134284 sqlite3ColumnExpr(pTab, &pTab->aCol[i]),
134292 sqlite3ColumnExpr(pTab, &pTab->aCol[i]),
134320 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
134346 assert( pTab->nNVCol>0 || pParse->nErr>0 );
134347 sqlite3VdbeAddOp3(v, OP_Copy, regRowid+1, regCols+1, pTab->nNVCol-1);
134354 if( pTab->tabFlags & TF_HasGenerated ){
134355 testcase( pTab->tabFlags & TF_HasVirtual );
134356 testcase( pTab->tabFlags & TF_HasStored );
134357 sqlite3ComputeGeneratedColumns(pParse, regCols+1, pTab);
134367 sqlite3TableAffinity(v, pTab, regCols+1);
134372 pTab, regCols-pTab->nCol-1, onError, endOfLoop);
134374 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
134378 if( IsVirtual(pTab) ){
134390 if( pIpk->op==TK_NULL && !IsVirtual(pTab) ){
134402 if( !IsVirtual(pTab) ){
134412 }else if( IsVirtual(pTab) || withoutRowid ){
134425 if( pTab->tabFlags & TF_HasGenerated ){
134426 sqlite3ComputeGeneratedColumns(pParse, regRowid+1, pTab);
134434 if( IsVirtual(pTab) ){
134435 const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
134436 sqlite3VtabMakeWritable(pParse, pTab);
134437 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
134445 sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
134449 sqlite3FkCheck(pParse, pTab, 0, regIns, 0, 0);
134461 sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur,
134483 pTab, regData-2-pTab->nCol, onError, endOfLoop);
134770 Table *pTab, /* The table being inserted or updated */
134813 assert( !IsView(pTab) ); /* This table is not a VIEW */
134814 nCol = pTab->nCol;
134820 if( HasRowid(pTab) ){
134824 pPk = sqlite3PrimaryKeyIndex(pTab);
134834 if( pTab->tabFlags & TF_HasNotNull ){
134841 Column *pCol = &pTab->aCol[i]; /* The column to check for NOT NULL */
134845 if( i==pTab->iPKey ){
134878 testcase( i!=sqlite3TableColumnToStorage(pTab, i) );
134879 iReg = sqlite3TableColumnToStorage(pTab, i) + regNewData + 1;
134887 sqlite3ColumnExpr(pTab, pCol), iReg);
134896 char *zMsg = sqlite3MPrintf(db, "%s.%s", pTab->zName,
134923 if( nSeenReplace>0 && (pTab->tabFlags & TF_HasGenerated)!=0 ){
134928 sqlite3ComputeGeneratedColumns(pParse, regNewData+1, pTab);
134937 if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){
134938 ExprList *pCheck = pTab->pCheck;
134953 sqlite3TableAffinity(v, pTab, regNewData+1);
135010 sIdxIter.u.lx.pIdx = pTab->pIndex;
135024 }else if( pTab->pIndex!=0 ){
135032 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
135046 pIdx = pTab->pIndex;
135057 for(jj=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, jj++){
135094 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
135095 regTrigCnt = pTrigger!=0 || sqlite3FkRequired(pParse, pTab, 0, 0);
135098 regTrigCnt = sqlite3FkRequired(pParse, pTab, 0, 0);
135118 onError = pTab->keyConf;
135150 && pTab->pIndex /* There exist other constraints */
135184 sqlite3RowidConstraint(pParse, onError, pTab);
135212 sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
135218 assert( HasRowid(pTab) );
135224 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
135226 if( pTab->pIndex ){
135228 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,-1);
135236 sqlite3UpsertDoUpdate(pParse, pUpsert, pTab, 0, iDataCur);
135281 sqlite3TableAffinity(v, pTab, regNewData+1);
135309 }else if( iField==XN_ROWID || iField==pTab->iPKey ){
135314 testcase( sqlite3TableColumnToStorage(pTab, iField)!=iField );
135315 x = sqlite3TableColumnToStorage(pTab, iField) + regNewData + 1;
135317 VdbeComment((v, "%s", pTab->aCol[iField].zCnName));
135369 assert( IsOrdinaryTable(pTab) );
135375 0==sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0))
135377 (0==pTab->u.tab.pFKey && 0==sqlite3FkReferences(pTab)))
135393 if( HasRowid(pTab) ){
135411 VdbeComment((v, "%s.%s", pTab->zName,
135412 pTab->aCol[pPk->aiColumn[i]].zCnName));
135435 x = sqlite3TableColumnToStorage(pTab, x);
135462 sqlite3UpsertDoUpdate(pParse, pUpsert, pTab, pIdx, iIdxCur+ix);
135486 sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
135577 sqlite3RowidConstraint(pParse, OE_Abort, pTab);
135585 if( HasRowid(pTab) ){
135587 sqlite3VdbeAddOp3(v, OP_MakeRecord, regNewData+1, pTab->nNVCol, regRec);
135588 sqlite3SetMakeRecordP5(v, pTab);
135590 sqlite3TableAffinity(v, pTab, 0);
135605 SQLITE_PRIVATE void sqlite3SetMakeRecordP5(Vdbe *v, Table *pTab){
135610 if( pTab->pSchema->file_format<2 ) return;
135612 for(i=pTab->nCol-1; i>0; i--){
135613 if( pTab->aCol[i].iDflt!=0 ) break;
135614 if( pTab->aCol[i].colFlags & COLFLAG_PRIMKEY ) break;
135629 Table *pTab, /* Table being updated */
135635 assert( !HasRowid(pTab) );
135638 sqlite3VdbeAddOp4(v, OP_Insert, iCur, regData, r, (char*)pTab, P4_TABLE);
135657 Table *pTab, /* the table into which we are inserting */
135678 assert( !IsView(pTab) ); /* This table is not a VIEW */
135679 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
135690 if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
135694 codeWithoutRowidPreupdate(pParse, pTab, iIdxCur+i, aRegIdx[i]);
135702 if( !HasRowid(pTab) ) return;
135717 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
135745 Table *pTab, /* Table to be opened */
135763 if( IsVirtual(pTab) ){
135770 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
135776 if( HasRowid(pTab) && (aToOpen==0 || aToOpen[0]) ){
135777 sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op);
135779 sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
135782 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
135784 assert( pIdx->pSchema==pTab->pSchema );
135785 if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
139923 Table *pTab;
139925 pTab = sqlite3LocateTable(pParse, LOCATE_NOERR, zRight, zDb);
139926 if( pTab ){
139930 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
139932 sqlite3ViewGetColumnNames(pParse, pTab);
139933 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
139954 for(k=1; k<=pTab->nCol && pPk->aiColumn[k-1]!=i; k++){}
139956 pColExpr = sqlite3ColumnExpr(pTab,pCol);
140005 Table *pTab;
140007 pTab = sqliteHashData(k);
140008 if( pTab->nCol==0 ){
140009 char *zSql = sqlite3MPrintf(db, "SELECT*FROM\"%w\"", pTab->zName);
140027 Table *pTab = sqliteHashData(k);
140029 if( zRight && sqlite3_stricmp(zRight, pTab->zName)!=0 ) continue;
140030 if( IsView(pTab) ){
140032 }else if( IsVirtual(pTab) ){
140034 }else if( pTab->tabFlags & TF_Shadow ){
140041 sqlite3PreferredTableName(pTab->zName),
140043 pTab->nCol,
140044 (pTab->tabFlags & TF_WithoutRowid)!=0,
140045 (pTab->tabFlags & TF_Strict)!=0
140059 Table *pTab = sqliteHashData(i);
140061 sqlite3PreferredTableName(pTab->zName),
140063 pTab->szTabRow,
140064 pTab->nRowLogEst,
140065 pTab->tabFlags);
140066 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
140081 Table *pTab;
140087 pTab = sqlite3LocateTable(pParse, LOCATE_NOERR, zRight, zDb);
140088 if( pTab && !HasRowid(pTab) ){
140089 pIdx = sqlite3PrimaryKeyIndex(pTab);
140105 pTab = pIdx->pTable;
140111 cnum<0 ? 0 : pTab->aCol[cnum].zCnName);
140126 Table *pTab;
140128 pTab = sqlite3FindTable(db, zRight, zDb);
140129 if( pTab ){
140130 int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
140133 for(pIdx=pTab->pIndex, i=0; pIdx; pIdx=pIdx->pNext, i++){
140218 Table *pTab;
140219 pTab = sqlite3FindTable(db, zRight, zDb);
140220 if( pTab && IsOrdinaryTable(pTab) ){
140221 pFK = pTab->u.tab.pFKey;
140223 int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
140234 pTab->aCol[pFK->aCol[j].iFrom].zCnName,
140253 Table *pTab; /* Child table contain "REFERENCES" keyword */
140272 pTab = sqlite3LocateTable(pParse, 0, zRight, zDb);
140275 pTab = (Table*)sqliteHashData(k);
140278 if( pTab==0 || !IsOrdinaryTable(pTab) || pTab->u.tab.pFKey==0 ) continue;
140279 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
140282 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
140283 sqlite3TouchRegister(pParse, pTab->nCol+regRow);
140284 sqlite3OpenTable(pParse, 0, iDb, pTab, OP_OpenRead);
140285 sqlite3VdbeLoadString(v, regResult, pTab->zName);
140286 assert( IsOrdinaryTable(pTab) );
140287 for(i=1, pFK=pTab->u.tab.pFKey; pFK; i++, pFK=pFK->pNextFrom){
140309 assert( IsOrdinaryTable(pTab) );
140310 for(i=1, pFK=pTab->u.tab.pFKey; pFK; i++, pFK=pFK->pNextFrom){
140327 sqlite3ExprCodeGetColumnOfTable(v, pTab, 0, iCol, regRow+j);
140346 if( HasRowid(pTab) ){
140462 Table *pTab = sqliteHashData(x); /* Current table */
140465 if( pObjTab && pObjTab!=pTab ) continue;
140466 if( HasRowid(pTab) ) cnt++;
140467 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){ cnt++; }
140476 Table *pTab = sqliteHashData(x);
140478 if( pObjTab && pObjTab!=pTab ) continue;
140479 if( HasRowid(pTab) ) aRoot[++cnt] = pTab->tnum;
140480 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
140506 Table *pTab = sqliteHashData(x);
140508 if( pObjTab && pObjTab!=pTab ) continue;
140509 if( HasRowid(pTab) ){
140513 for(pIdx=pTab->pIndex; ALWAYS(pIdx); pIdx=pIdx->pNext){
140518 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
140534 Table *pTab = sqliteHashData(x);
140544 if( pObjTab && pObjTab!=pTab ) continue;
140545 if( !IsOrdinaryTable(pTab) ) continue;
140546 if( isQuick || HasRowid(pTab) ){
140550 pPk = sqlite3PrimaryKeyIndex(pTab);
140554 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenRead, 0,
140560 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
140573 assert( !IsVirtual(pTab) );
140574 if( HasRowid(pTab) ){
140576 for(j=0; j<pTab->nCol; j++){
140577 if( (pTab->aCol[j].colFlags & COLFLAG_VIRTUAL)==0 ) mxCol++;
140579 if( mxCol==pTab->iPKey ) mxCol--;
140584 mxCol = sqlite3PrimaryKeyIndex(pTab)->nColumn-1;
140601 pTab->zName);
140620 bStrict = (pTab->tabFlags & TF_Strict)!=0;
140621 for(j=0; j<pTab->nCol; j++){
140623 Column *pCol = pTab->aCol + j; /* The column to be checked */
140629 if( j==pTab->iPKey ) continue;
140640 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, j, 3);
140646 sqlite3ValueFromExpr(db, sqlite3ColumnExpr(pTab,pCol), ENC(db),
140654 if( !HasRowid(pTab) ){
140655 testcase( j!=sqlite3TableColumnToStorage(pTab, j) );
140656 p3 = sqlite3TableColumnToIndex(sqlite3PrimaryKeyIndex(pTab), j);
140658 p3 = sqlite3TableColumnToStorage(pTab,j);
140680 sqlite3ColumnDefault(v, pTab, j, 3);
140684 zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName,
140711 pTab->zName, pTab->aCol[j].zCnName);
140720 pTab->zName, pTab->aCol[j].zCnName);
140729 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, j, 3);
140736 pTab->zName, pTab->aCol[j].zCnName);
140744 if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){
140745 ExprList *pCheck = sqlite3ExprListDup(db, pTab->pCheck, 0);
140760 pTab->zName);
140769 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
140794 if( HasRowid(pTab) ){
140834 assert( iCol!=XN_ROWID && iCol<pTab->nCol );
140835 if( iCol>=0 && pTab->aCol[iCol].notNull ) continue;
140865 Table *pTab = sqliteHashData(x);
140868 if( pObjTab && pObjTab!=pTab ) continue;
140869 if( IsOrdinaryTable(pTab) ) continue;
140870 if( !IsVirtual(pTab) ) continue;
140871 if( pTab->nCol<=0 ){
140872 const char *zMod = pTab->u.vtab.azArg[0];
140875 sqlite3ViewGetColumnNames(pParse, pTab);
140876 if( pTab->u.vtab.p==0 ) continue;
140877 pVTab = pTab->u.vtab.p->pVtab;
140883 pTab->nTabRef++;
140884 sqlite3VdbeAppendP4(v, pTab, P4_TABLEREF);
141217 Table *pTab; /* A table in the schema */
141247 pTab = (Table*)sqliteHashData(k);
141250 if( !IsOrdinaryTable(pTab) ) continue;
141253 if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7) ) continue;
141259 szThreshold = pTab->nRowLogEst;
141261 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
141271 if( (pTab->tabFlags & TF_MaybeReanalyze)!=0 ){
141275 }else if( pTab->pIndex!=0 && szThreshold<0 ){
141293 sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
141307 db->aDb[iDb].zDbSName, pTab->zName);
141518 PragmaVtab *pTab = 0;
141551 pTab = (PragmaVtab*)sqlite3_malloc(sizeof(PragmaVtab));
141552 if( pTab==0 ){
141555 memset(pTab, 0, sizeof(PragmaVtab));
141556 pTab->pName = pPragma;
141557 pTab->db = db;
141558 pTab->iHidden = i;
141559 pTab->nHidden = j;
141565 *ppVtab = (sqlite3_vtab*)pTab;
141573 PragmaVtab *pTab = (PragmaVtab*)pVtab;
141574 sqlite3_free(pTab);
141586 PragmaVtab *pTab = (PragmaVtab*)tab;
141592 if( pTab->nHidden==0 ){ return SQLITE_OK; }
141597 if( pConstraint->iColumn < pTab->iHidden ) continue;
141600 j = pConstraint->iColumn - pTab->iHidden;
141678 PragmaVtab *pTab = (PragmaVtab*)(pVtabCursor->pVtab);
141687 j = (pTab->pName->mPragFlg & PragFlg_Result1)!=0 ? 0 : 1;
141699 sqlite3StrAccumInit(&acc, 0, 0, 0, pTab->db->aLimit[SQLITE_LIMIT_SQL_LENGTH]);
141704 sqlite3_str_appendall(&acc, pTab->pName->zName);
141710 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pPragma, 0);
141713 pTab->base.zErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(pTab->db));
141736 PragmaVtab *pTab = (PragmaVtab*)(pVtabCursor->pVtab);
141737 if( i<pTab->iHidden ){
141740 sqlite3_result_text(ctx, pCsr->azArg[i-pTab->iHidden],-1,SQLITE_TRANSIENT);
142953 Table *pTab; /* Table definition */
143211 SQLITE_PRIVATE int sqlite3ColumnIndex(Table *pTab, const char *zCol){
143215 for(pCol=pTab->aCol, i=0; i<pTab->nCol; pCol++, i++){
143264 iCol = sqlite3ColumnIndex(pSrc->a[i].pTab, zCol);
143266 && (bIgnoreHidden==0 || IsHiddenColumn(&pSrc->a[i].pTab->aCol[iCol])==0)
143395 Table *pRightTab = pRight->pTab;
143398 if( NEVER(pLeft->pTab==0 || pRightTab==0) ) continue;
143938 Table *pTab;
143942 && (pTab = pExpr->y.pTab)!=0
143943 && IsOrdinaryTable(pTab)
143944 && (pTab->aCol[pExpr->iColumn].colFlags & COLFLAG_SORTERREF)!=0
143957 if( !HasRowid(pTab) ){
143958 pPk = sqlite3PrimaryKeyIndex(pTab);
143966 pNew->y.pTab = pExpr->y.pTab;
143971 pSort->aDefer[nDefer].pTab = pExpr->y.pTab;
144591 Table *pTab = pSort->aDefer[i].pTab;
144592 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
144593 sqlite3OpenTable(pParse, pSort->aDefer[i].iCsr, iDb, pTab, OP_OpenRead);
144650 Table *pTab = pSort->aDefer[i].pTab;
144654 if( HasRowid(pTab) ){
144661 assert( sqlite3PrimaryKeyIndex(pTab)->nKeyCol==nKey );
144811 Table *pTab = 0; /* Table structure column is extracted from */
144814 while( pNC && !pTab ){
144818 pTab = pTabList->a[j].pTab;
144825 if( pTab==0 ){
144846 assert( pTab && ExprUseYTab(pExpr) && pExpr->y.pTab==pTab );
144870 if( iCol<0 ) iCol = pTab->iPKey;
144871 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
144876 zOrigCol = pTab->aCol[iCol].zCnName;
144877 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
144879 zOrigTab = pTab->zName;
144880 if( pNC->pParse && pTab->pSchema ){
144881 int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
144885 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
144889 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
145004 Table *pTab;
145029 || (ExprUseYTab(p) && p->y.pTab!=0) ); /* Covering idx not yet coded */
145037 pTab = p->y.pTab;
145038 assert( pTab!=0 );
145039 if( iCol<0 ) iCol = pTab->iPKey;
145040 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
145044 zCol = pTab->aCol[iCol].zCnName;
145048 zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol);
145098 Table *pTab;
145129 && ALWAYS( pColExpr->y.pTab!=0 )
145133 pTab = pColExpr->y.pTab;
145134 if( iCol<0 ) iCol = pTab->iPKey;
145135 zName = iCol>=0 ? pTab->aCol[iCol].zCnName : "rowid";
145205 Table *pTab, /* Add column type information to this table */
145219 assert( pTab->nCol==pSelect->pEList->nExpr || pParse->nErr>0 );
145226 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
145231 pTab->tabFlags |= (pCol->colFlags & COLFLAG_NOINSERT);
145285 assert( pTab->pIndex==0 );
145289 pTab->szTabRow = 1; /* Any non-zero value works */
145297 Table *pTab;
145308 pTab = sqlite3DbMallocZero(db, sizeof(Table) );
145309 if( pTab==0 ){
145312 pTab->nTabRef = 1;
145313 pTab->zName = 0;
145314 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
145315 sqlite3ColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
145316 sqlite3SubqueryColumnTypes(pParse, pTab, pSelect, aff);
145317 pTab->iPKey = -1;
145319 sqlite3DeleteTable(db, pTab);
145322 return pTab;
146897 if( NEVER(pSrcItem->pTab==0) ) return;
147302 || IsVirtual(pSubSrc->a[0].pTab) /* (3b) */
147436 Table *pItemTab = pSubitem->pTab;
147437 pSubitem->pTab = 0;
147445 pSubitem->pTab = pItemTab;
147475 if( ALWAYS(pSubitem->pTab!=0) ){
147476 Table *pTabToDel = pSubitem->pTab;
147484 pSubitem->pTab = 0;
148215 Table *pTab; /* The table that describes the subquery */
148224 assert( pItem->pTab!=0 );
148225 pTab = pItem->pTab;
148228 assert( pSub->pEList->nExpr==pTab->nCol );
148259 nCol = pTab->nCol;
148348 Table *pTab;
148362 pTab = p->pSrc->a[0].pTab;
148363 assert( pTab!=0 );
148364 assert( !IsView(pTab) );
148365 if( !IsOrdinaryTable(pTab) ) return 0;
148376 return pTab;
148387 Table *pTab = pFrom->pTab;
148390 assert( pTab!=0 );
148393 for(pIdx=pTab->pIndex;
148589 assert( pFrom->pTab==0 );
148615 Table *pTab;
148635 assert( pFrom->pTab==0 );
148636 pTab = sqlite3DbMallocZero(db, sizeof(Table));
148637 if( pTab==0 ) return 2;
148644 sqlite3DbFree(db, pTab);
148649 pFrom->pTab = pTab;
148650 pTab->nTabRef = 1;
148651 pTab->zName = sqlite3DbStrDup(db, pCte->zName);
148652 pTab->iPKey = -1;
148653 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
148654 pTab->tabFlags |= TF_Ephemeral | TF_NoVisibleRowid;
148680 pItem->pTab = pTab;
148681 pTab->nTabRef++;
148736 sqlite3ColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
148783 Table *pTab;
148786 pFrom->pTab = pTab = sqlite3DbMallocZero(pParse->db, sizeof(Table));
148787 if( pTab==0 ) return SQLITE_NOMEM;
148788 pTab->nTabRef = 1;
148790 pTab->zName = sqlite3DbStrDup(pParse->db, pFrom->zAlias);
148792 pTab->zName = sqlite3MPrintf(pParse->db, "%!S", pFrom);
148795 sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol);
148796 pTab->iPKey = -1;
148797 pTab->eTabType = TABTYP_VIEW;
148798 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
148801 pTab->tabFlags |= TF_Ephemeral | TF_NoVisibleRowid;
148804 pTab->tabFlags |= TF_Ephemeral | sqlite3Config.mNoVisibleRowid;
148905 Table *pTab;
148906 assert( pFrom->fg.isRecursive==0 || pFrom->pTab!=0 );
148907 if( pFrom->pTab ) continue;
148914 assert( pFrom->pTab==0 );
148921 pTab = pFrom->pTab;
148922 assert( pTab!=0 );
148926 assert( pFrom->pTab==0 );
148927 pFrom->pTab = pTab = sqlite3LocateTableItem(pParse, 0, pFrom);
148928 if( pTab==0 ) return WRC_Abort;
148929 if( pTab->nTabRef>=0xffff ){
148931 pTab->zName);
148932 pFrom->pTab = 0;
148935 pTab->nTabRef++;
148936 if( !IsVirtual(pTab) && cannotBeFunction(pParse, pFrom) ){
148940 if( !IsOrdinaryTable(pTab) ){
148943 if( sqlite3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort;
148945 if( IsView(pTab) ){
148947 && pTab->pSchema!=db->aDb[1].pSchema
148950 pTab->zName);
148952 pFrom->pSelect = sqlite3SelectDup(db, pTab->u.view.pSelect, 0);
148955 else if( ALWAYS(IsVirtual(pTab))
148957 && ALWAYS(pTab->u.vtab.p!=0)
148958 && pTab->u.vtab.p->eVtabRisk > ((db->flags & SQLITE_TrustedSchema)!=0)
148961 pTab->zName);
148965 nCol = pTab->nCol;
148966 pTab->nCol = -1;
148970 pTab->nCol = nCol;
149055 Table *pTab = pFrom->pTab; /* Table for this data source */
149063 zTabName = pTab->zName;
149071 assert( pNestedFrom->nExpr==pTab->nCol );
149072 assert( VisibleRowid(pTab)==0 || ViewCanHaveRowid );
149078 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
149104 nAdd = pTab->nCol;
149105 if( VisibleRowid(pTab) && (selFlags & SF_NestedFrom)!=0 ) nAdd++;
149110 if( j==pTab->nCol ){
149111 zName = sqlite3RowidAlias(pTab);
149114 zName = pTab->aCol[j].zCnName;
149134 && IsHiddenColumn(&pTab->aCol[j])
149138 if( (pTab->aCol[j].colFlags & COLFLAG_NOEXPAND)!=0
149196 pX->fg.eEName = (j==pTab->nCol ? ENAME_ROWID : ENAME_TAB);
149200 || (j<pTab->nCol && (pTab->aCol[j].colFlags & COLFLAG_NOEXPAND))
149308 Table *pTab = pFrom->pTab;
149309 assert( pTab!=0 );
149310 if( (pTab->tabFlags & TF_Ephemeral)!=0 ){
149314 sqlite3SubqueryColumnTypes(pParse, pTab, pSel, SQLITE_AFF_NONE);
149382 ii, pCol->pTab ? pCol->pTab->zName : "NULL",
149862 Table *pTab, /* Table being queried */
149866 int bCover = (pIdx!=0 && (HasRowid(pTab) || !IsPrimaryKeyIndex(pIdx)));
149868 pTab->zName,
149970 assert( pItem->pTab!=0 );
149971 assert( pThis->pTab!=0 );
149972 if( pItem->pTab->pSchema!=pThis->pTab->pSchema ) continue;
149975 if( pItem->pTab->pSchema==0 && pThis->pSelect->selId!=pS1->selId ){
150102 if( p0->pTab==p1->pTab && 0==sqlite3_stricmp(p0->zAlias, p1->zAlias) ){
150283 p0->zAlias ? p0->zAlias : p0->pTab->zName
150323 Table *pTab = pItem->pTab;
150328 assert( pTab!=0 );
150386 if( pTab->nCol!=pSub->pEList->nExpr ){
150388 pTab->nCol, pTab->zName, pSub->pEList->nExpr);
150635 pItem->pTab->nRowLogEst = pSub->nSelectRow;
150688 pItem->pTab->nRowLogEst = pSub->nSelectRow;
151306 Table *pTab;
151307 if( (pTab = isSimpleCount(p, pAggInfo))!=0 ){
151321 const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
151326 Pgno iRoot = pTab->tnum; /* Root page of scanned b-tree */
151329 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
151340 if( !HasRowid(pTab) ) pBest = sqlite3PrimaryKeyIndex(pTab);
151342 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
151344 && pIdx->szIdxRow<pTab->szTabRow
151365 explainSimpleCount(pParse, pTab, pBest);
151762 SQLITE_PRIVATE Trigger *sqlite3TriggerList(Parse *pParse, Table *pTab){
151770 pList = pTab->pTrigger;
151773 if( pTrig->pTabSchema==pTab->pSchema
151775 && 0==sqlite3StrICmp(pTrig->table, pTab->zName)
151786 pTrig->table = pTab->zName;
151787 pTrig->pTabSchema = pTab->pSchema;
151796 printf("Triggers for %s:", pTab->zName);
151828 Table *pTab; /* Table that the trigger fires off of */
151876 pTab = sqlite3SrcListLookup(pParse, pTableName);
151877 if( db->init.busy==0 && pName2->n==0 && pTab
151878 && pTab->pSchema==db->aDb[1].pSchema ){
151889 pTab = sqlite3SrcListLookup(pParse, pTableName);
151890 if( !pTab ){
151894 if( IsVirtual(pTab) ){
151898 if( (pTab->tabFlags & TF_Shadow)!=0 && sqlite3ReadOnlyShadowTables(db) ){
151910 if( sqlite3CheckObjectName(pParse, zName, "trigger", pTab->zName) ){
151928 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
151936 if( IsView(pTab) && tr_tm!=TK_INSTEAD ){
151941 if( !IsView(pTab) && tr_tm==TK_INSTEAD ){
151949 int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
151954 if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
151979 pTrigger->pTabSchema = pTab->pSchema;
152114 Table *pTab;
152115 pTab = sqlite3HashFind(&pLink->pTabSchema->tblHash, pLink->table);
152116 assert( pTab!=0 );
152117 pLink->pNext = pTab->pTrigger;
152118 pTab->pTrigger = pLink;
152430 Table *pTab = tableOfTrigger(pTrigger);
152431 if( pTab ){
152433 for(pp=&pTab->pTrigger; *pp; pp=&((*pp)->pNext)){
152481 Table *pTab, /* The table the contains the triggers */
152490 pList = sqlite3TriggerList(pParse, pTab);
152491 assert( pList==0 || IsVirtual(pTab)==0
152496 && pTab->pTrigger!=0
152501 if( pList==pTab->pTrigger ){
152505 while( ALWAYS(p->pNext) && p->pNext!=pTab->pTrigger ) p = p->pNext;
152517 if( IsVirtual(pTab) ){
152544 Table *pTab, /* The table the contains the triggers */
152549 assert( pTab!=0 );
152550 if( (pTab->pTrigger==0 && !tempTriggersExist(pParse->db))
152556 return triggersReallyExist(pParse,pTab,op,pChanges,pMask);
152631 Table *pTab /* The table being updated */
152642 for(jj=0; jj<pTab->nCol; jj++){
152644 if( IsHiddenColumn(pTab->aCol+jj) ) continue;
152645 pNewExpr = sqlite3Expr(db, TK_ID, pTab->aCol[jj].zCnName);
152649 pItem->zEName = sqlite3DbStrDup(db, pTab->aCol[jj].zCnName);
152696 if( pSrc->a[i].pTab==pWalker->u.pTab ){
152717 Table *pTab
152723 w.u.pTab = pTab;
152740 Table *pTab, /* The table to code triggers from */
152767 sFrom.a[0].pTab = pTab;
152768 sFrom.a[0].zName = pTab->zName; /* tag-20240424-1 */
152776 pNew = sqlite3ExpandReturning(pParse, pReturning->pReturnEL, pTab);
152788 pParse->pTriggerTab = pTab;
152795 sqlite3ProcessReturningSubqueries(pNew, pTab);
152945 Table *pTab, /* The table pTrigger is attached to */
152958 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
152981 sSubParse.pTriggerTab = pTab;
152996 pTab->zName
153059 Table *pTab, /* The table trigger pTrigger is attached to */
153065 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
153078 pPrg = codeRowTrigger(pParse, pTrigger, pTab, orconf);
153094 Table *pTab, /* The table to code triggers from */
153101 pPrg = getRowTrigger(pParse, p, pTab, orconf);
153169 Table *pTab, /* The table to code triggers from */
153200 sqlite3CodeRowTriggerDirect(pParse, p, pTab, reg, orconf, ignoreJump);
153202 codeReturningTrigger(pParse, p, pTab, reg);
153239 Table *pTab, /* The table to code triggers from */
153247 if( IsView(pTab) ){
153259 pPrg = getRowTrigger(pParse, p, pTab, orconf);
153295 Table *pTab, /* The virtual table */
153334 SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){
153336 assert( pTab!=0 );
153337 assert( pTab->nCol>i );
153338 pCol = &pTab->aCol[i];
153342 assert( !IsView(pTab) );
153343 VdbeComment((v, "%s.%s", pTab->zName, pCol->zCnName));
153344 assert( i<pTab->nCol );
153346 sqlite3ColumnExpr(pTab,pCol), enc,
153353 if( pCol->affinity==SQLITE_AFF_REAL && !IsVirtual(pTab) ){
153478 Table *pTab = pTabList->a[0].pTab;
153502 pSrc->a[0].pTab->nTabRef--;
153503 pSrc->a[0].pTab = 0;
153515 eDest = IsVirtual(pTab) ? SRT_Table : SRT_Upfrom;
153516 }else if( IsView(pTab) ){
153517 for(i=0; i<pTab->nCol; i++){
153522 eDest = IsVirtual(pTab) ? SRT_Table : SRT_Upfrom;
153569 Table *pTab; /* The table to be updated */
153635 pTab = sqlite3SrcListLookup(pParse, pTabList);
153636 if( pTab==0 ) goto update_cleanup;
153637 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
153643 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask);
153644 isView = IsView(pTab);
153681 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
153684 if( sqlite3IsReadOnly(pParse, pTab, pTrigger) ){
153695 pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
153696 testcase( pPk!=0 && pPk!=pTab->pIndex );
153697 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
153714 aXRef = sqlite3DbMallocRawNN(db, sizeof(int) * (pTab->nCol+nIdx+1) + nIdx+2 );
153716 aRegIdx = aXRef+pTab->nCol;
153720 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
153747 for(j=0; j<pTab->nCol; j++){
153748 if( pTab->aCol[j].hName==hCol
153749 && sqlite3StrICmp(pTab->aCol[j].zCnName, pChanges->a[i].zEName)==0
153751 if( j==pTab->iPKey ){
153755 }else if( pPk && (pTab->aCol[j].colFlags & COLFLAG_PRIMKEY)!=0 ){
153759 else if( pTab->aCol[j].colFlags & COLFLAG_GENERATED ){
153760 testcase( pTab->aCol[j].colFlags & COLFLAG_VIRTUAL );
153761 testcase( pTab->aCol[j].colFlags & COLFLAG_STORED );
153764 pTab->aCol[j].zCnName);
153772 if( j>=pTab->nCol ){
153787 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
153788 j<0 ? "ROWID" : pTab->aCol[j].zCnName,
153811 if( pTab->tabFlags & TF_HasGenerated ){
153813 testcase( pTab->tabFlags & TF_HasVirtual );
153814 testcase( pTab->tabFlags & TF_HasStored );
153817 for(i=0; i<pTab->nCol; i++){
153819 if( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)==0 ) continue;
153821 sqlite3ColumnExpr(pTab, &pTab->aCol[i]),
153837 pTabList->a[0].colUsed = IsVirtual(pTab) ? ALLBITS : 0;
153839 hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngKey);
153846 for(nAllIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nAllIdx++){
153880 if( !IsVirtual(pTab) ){
153891 pParse->nMem += pTab->nCol;
153897 pParse->nMem += pTab->nCol;
153902 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
153910 sqlite3MaterializeView(pParse, pTab,
153927 if( IsVirtual(pTab) ){
153928 updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef,
153949 if( nChangeFrom==0 && HasRowid(pTab) ){
153954 assert( pPk!=0 || HasRowid(pTab) );
153961 int nEphCol = nPk + nChangeFrom + (isView ? pTab->nCol : 0);
154043 assert( iCur!=iDataCur || !HasRowid(pTab) );
154048 if( HasRowid(pTab) ){
154067 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur,
154101 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, iBaseCur,
154179 u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0);
154181 pTrigger, pChanges, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onError
154183 for(i=0; i<pTab->nCol; i++){
154184 u32 colFlags = pTab->aCol[i].colFlags;
154185 k = sqlite3TableColumnToStorage(pTab, i) + regOld;
154191 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k);
154218 pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError
154220 for(i=0, k=regNew; i<pTab->nCol; i++, k++){
154221 if( i==pTab->iPKey ){
154223 }else if( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)!=0 ){
154224 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) k--;
154229 int nOff = (isView ? pTab->nCol : nPk);
154243 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k);
154251 if( pTab->tabFlags & TF_HasGenerated ){
154252 testcase( pTab->tabFlags & TF_HasVirtual );
154253 testcase( pTab->tabFlags & TF_HasStored );
154254 sqlite3ComputeGeneratedColumns(pParse, regNew, pTab);
154262 sqlite3TableAffinity(v, pTab, regNew);
154264 TRIGGER_BEFORE, pTab, regOldRowid, onError, labelContinue);
154290 for(i=0, k=regNew; i<pTab->nCol; i++, k++){
154291 if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){
154292 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) k--;
154293 }else if( aXRef[i]<0 && i!=pTab->iPKey ){
154294 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k);
154298 if( pTab->tabFlags & TF_HasGenerated ){
154299 testcase( pTab->tabFlags & TF_HasVirtual );
154300 testcase( pTab->tabFlags & TF_HasStored );
154301 sqlite3ComputeGeneratedColumns(pParse, regNew, pTab);
154310 sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
154328 sqlite3FkCheck(pParse, pTab, regOldRowid, 0, aXRef, chngKey);
154332 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, aRegIdx, -1);
154363 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
154372 sqlite3FkCheck(pParse, pTab, 0, regNewRowid, aXRef, chngKey);
154377 pParse, pTab, iDataCur, iIdxCur, regNewRowid, aRegIdx,
154386 sqlite3FkActions(pParse, pTab, pChanges, regOldRowid, aXRef, chngKey);
154398 TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue);
154478 Table *pTab, /* The virtual table */
154489 const char *pVTab = (const char*)sqlite3GetVTable(db, pTab);
154491 int nArg = 2 + pTab->nCol; /* Number of arguments to VUpdate */
154512 if( HasRowid(pTab) ){
154520 pPk = sqlite3PrimaryKeyIndex(pTab);
154532 for(i=0; i<pTab->nCol; i++){
154558 for(i=0; i<pTab->nCol; i++){
154559 assert( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)==0 );
154567 if( HasRowid(pTab) ){
154577 pPk = sqlite3PrimaryKeyIndex(pTab);
154626 sqlite3VtabMakeWritable(pParse, pTab);
154740 Table *pTab; /* That table into which we are inserting */
154751 assert( pTabList->a[0].pTab!=0 );
154770 pTab = pTabList->a[0].pTab;
154773 if( HasRowid(pTab)
154796 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
154914 Table *pTab, /* The table being updated */
154931 if( HasRowid(pTab) ){
154938 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
154948 pTab->aCol[pPk->aiColumn[i]].zCnName));
154963 for(i=0; i<pTab->nCol; i++){
154964 if( pTab->aCol[i].affinity==SQLITE_AFF_REAL ){
155418 Table *pTab; /* The Table object to which the virtual table belongs */
155584 SQLITE_PRIVATE VTable *sqlite3GetVTable(sqlite3 *db, Table *pTab){
155586 assert( IsVirtual(pTab) );
155587 for(pVtab=pTab->u.vtab.p; pVtab && pVtab->db!=db; pVtab=pVtab->pNext);
155840 Table *pTab = pParse->pNewTable; /* The table being constructed */
155843 if( pTab==0 ) return;
155844 assert( IsVirtual(pTab) );
155847 if( pTab->u.vtab.nArg<1 ) return;
155878 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
155884 pTab->zName,
155885 pTab->zName,
155893 zWhere = sqlite3MPrintf(db, "name=%Q AND sql=%Q", pTab->zName, zStmt);
155898 sqlite3VdbeLoadString(v, iReg, pTab->zName);
155904 Schema *pSchema = pTab->pSchema;
155905 const char *zName = pTab->zName;
155907 sqlite3MarkAllShadowTablesOf(db, pTab);
155908 pOld = sqlite3HashInsert(&pSchema->tblHash, zName, pTab);
155911 assert( pTab==pOld ); /* Malloc must have failed inside HashInsert() */
155950 Table *pTab,
155959 int nArg = pTab->u.vtab.nArg;
155965 assert( IsVirtual(pTab) );
155966 azArg = (const char *const*)pTab->u.vtab.azArg;
155970 if( pCtx->pTab==pTab ){
155972 "vtable constructor called recursively: %s", pTab->zName
155978 zModuleName = sqlite3DbStrDup(db, pTab->zName);
155993 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
155994 pTab->u.vtab.azArg[1] = db->aDb[iDb].zDbSName;
155999 sCtx.pTab = pTab;
156004 pTab->nTabRef++;
156006 assert( pTab!=0 );
156007 assert( pTab->nTabRef>1 || rc!=SQLITE_OK );
156008 sqlite3DeleteTable(db, pTab);
156011 assert( sCtx.pTab==pTab );
156041 pVTable->pNext = pTab->u.vtab.p;
156042 pTab->u.vtab.p = pVTable;
156044 for(iCol=0; iCol<pTab->nCol; iCol++){
156045 char *zType = sqlite3ColumnType(&pTab->aCol[iCol], "");
156067 pTab->aCol[iCol].colFlags |= COLFLAG_HIDDEN;
156068 pTab->tabFlags |= TF_HasHidden;
156071 pTab->tabFlags |= oooHidden;
156088 SQLITE_PRIVATE int sqlite3VtabCallConnect(Parse *pParse, Table *pTab){
156094 assert( pTab );
156095 assert( IsVirtual(pTab) );
156096 if( sqlite3GetVTable(db, pTab) ){
156101 zMod = pTab->u.vtab.azArg[0];
156105 const char *zModule = pTab->u.vtab.azArg[0];
156110 rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xConnect, &zErr);
156163 Table *pTab;
156167 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
156168 assert( pTab && IsVirtual(pTab) && !pTab->u.vtab.p );
156171 zMod = pTab->u.vtab.azArg[0];
156182 rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr);
156187 if( rc==SQLITE_OK && ALWAYS(sqlite3GetVTable(db, pTab)) ){
156190 addToVTrans(db, sqlite3GetVTable(db, pTab));
156205 Table *pTab;
156240 pTab = pCtx->pTab;
156241 assert( IsVirtual(pTab) );
156258 if( !pTab->aCol ){
156261 pTab->aCol = pNew->aCol;
156263 pTab->nNVCol = pTab->nCol = pNew->nCol;
156264 pTab->tabFlags |= pNew->tabFlags & (TF_WithoutRowid|TF_NoVisibleRowid);
156267 assert( pTab->pIndex==0 );
156280 pTab->pIndex = pIdx;
156282 pIdx->pTable = pTab;
156316 Table *pTab;
156318 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
156319 if( ALWAYS(pTab!=0)
156320 && ALWAYS(IsVirtual(pTab))
156321 && ALWAYS(pTab->u.vtab.p!=0)
156325 for(p=pTab->u.vtab.p; p; p=p->pNext){
156331 p = vtabDisconnectAll(db, pTab);
156335 pTab->nTabRef++;
156339 assert( pTab->u.vtab.p==p && p->pNext==0 );
156341 pTab->u.vtab.p = 0;
156344 sqlite3DeleteTable(db, pTab);
156547 Table *pTab;
156559 pTab = pExpr->y.pTab;
156560 if( NEVER(pTab==0) ) return pDef;
156561 if( !IsVirtual(pTab) ) return pDef;
156562 pVtab = sqlite3GetVTable(db, pTab)->pVtab;
156611 SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){
156616 assert( IsVirtual(pTab) );
156618 if( pTab==pToplevel->apVtabLock[i] ) return;
156624 pToplevel->apVtabLock[pToplevel->nVtabLock++] = pTab;
156647 Table *pTab;
156653 pTab = sqlite3DbMallocZero(db, sizeof(Table));
156654 if( pTab==0 ) return 0;
156655 pTab->zName = sqlite3DbStrDup(db, pMod->zName);
156656 if( pTab->zName==0 ){
156657 sqlite3DbFree(db, pTab);
156660 pMod->pEpoTab = pTab;
156661 pTab->nTabRef = 1;
156662 pTab->eTabType = TABTYP_VTAB;
156663 pTab->pSchema = db->aDb[0].pSchema;
156664 assert( pTab->u.vtab.nArg==0 );
156665 pTab->iPKey = -1;
156666 pTab->tabFlags |= TF_Eponymous;
156667 addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
156668 addModuleArgument(pParse, pTab, 0);
156669 addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
156670 rc = vtabCallConstructor(db, pTab, pMod, pModule->xConnect, &zErr);
156684 Table *pTab = pMod->pEpoTab;
156685 if( pTab!=0 ){
156689 pTab->tabFlags |= TF_Ephemeral;
156690 sqlite3DeleteTable(db, pTab);
156733 assert( p->pTab==0 || IsVirtual(p->pTab) );
157571 if( !HasRowid(pItem->pTab) && IsPrimaryKeyIndex(pIdx) ){
157592 const Table *pTab = pItem->pTab;
157593 const char *zRowid = pTab->iPKey>=0 ? pTab->aCol[pTab->iPKey].zCnName:
157667 const Table *pTab = pItem->pTab;
157668 if( pTab->iPKey>=0 ){
157669 sqlite3_str_appendf(&str, "%s=?", pTab->aCol[pTab->iPKey].zCnName);
158605 Table *pTab = pIdx->pTable;
158606 u32 *ai = (u32*)sqlite3DbMallocZero(pParse->db, sizeof(u32)*(pTab->nCol+1));
158608 ai[0] = pTab->nCol;
158611 assert( pIdx->aiColumn[i]<pTab->nCol );
158613 x2 = sqlite3TableColumnToStorage(pTab, x1);
158808 VdbeModuleComment((v, "Begin WHERE-loop%d: %s",iLevel,pTabItem->pTab->zName));
158867 VdbeComment((v, "next row of %s", pTabItem->pTab->zName));
159596 Table *pTab = pTabItem->pTab;
159641 if( HasRowid(pTab) ){
159645 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
159752 if( HasRowid(pTab) ){
159753 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, -1, regRowid);
159758 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
159767 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk);
159827 && (HasRowid(pTab) || !IsPrimaryKeyIndex(pSubLoop->u.btree.pIndex))
160044 Table *pTab;
160055 pTab = pWInfo->pTabList->a[pLevel->iFrom].pTab;
160056 if( HasRowid(pTab) ){
160058 sqlite3ExprCodeGetColumnOfTable(v, pTab, pLevel->iTabCur, -1, r+1);
160062 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
160067 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+1+iPk);
160072 VdbeComment((v, "match against %s", pTab->zName));
160162 ExplainQueryPlan((pParse, 1, "RIGHT-JOIN %s", pTabItem->pTab->zName));
160212 Table *pTab = pTabItem->pTab;
160213 if( HasRowid(pTab) ){
160214 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, -1, r);
160218 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
160223 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk);
160510 && ALWAYS(pLeft->y.pTab)
160511 && IsVirtual(pLeft->y.pTab)) /* Might be numeric */
160627 assert( pCol->op!=TK_COLUMN || (ExprUseYTab(pCol) && pCol->y.pTab!=0) );
160652 assert( pCol->op!=TK_COLUMN || (ExprUseYTab(pCol) && pCol->y.pTab!=0) );
160658 pVtab = sqlite3GetVTable(db, pCol->y.pTab)->pVtab;
160677 assert( pLeft->op!=TK_COLUMN || (ExprUseYTab(pLeft) && pLeft->y.pTab!=0) );
160682 || (ExprUseYTab(pRight) && pRight->y.pTab!=0) );
161227 for(pIdx=pFrom->a[j].pTab->pIndex; pIdx; pIdx=pIdx->pNext){
161271 for(pIdx=pFrom->a[i].pTab->pIndex; pIdx; pIdx=pIdx->pNext){
161859 && (p->pSrc->nSrc==1 && IsVirtual(p->pSrc->a[0].pTab)) /* 3 */
162074 Table *pTab;
162080 pTab = pItem->pTab;
162081 assert( pTab!=0 );
162087 while( k<pTab->nCol && (pTab->aCol[k].colFlags & COLFLAG_HIDDEN)==0 ){k++;}
162088 if( k>=pTab->nCol ){
162090 pTab->zName, j);
162098 pColRef->y.pTab = pTab;
162754 Table *pTab;
162764 pTab = pTabList->a[0].pTab;
162790 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
162879 Table *pTab /* The TABLE that is the virtual table */
162883 sqlite3DebugPrintf("sqlite3_index_info inputs for %s:\n", pTab->zName);
162903 Table *pTab /* The TABLE that is the virtual table */
162907 sqlite3DebugPrintf("sqlite3_index_info outputs for %s:\n", pTab->zName);
162985 aff = pSrc->pTab->aCol[pTerm->u.x.leftColumn].affinity;
163014 Table *pTab = pIdx->pTable;
163019 sqlite3_str_appendf(pStr,"CREATE AUTOMATIC INDEX ON %s(", pTab->zName);
163026 zName = pTab->aCol[iCol].zCnName;
163096 pTable = pSrc->pTab;
163243 VdbeComment((v, "next row of %s", pSrc->pTab->zName));
163340 const Table *pTab;
163360 pTab = pItem->pTab;
163361 assert( pTab!=0 );
163362 sz = sqlite3LogEstToInt(pTab->nRowLogEst);
163391 assert( pIdx->pTable==pItem->pTab );
163452 const Table *pTab;
163457 pTab = pSrc->pTab;
163458 assert( pTab!=0 );
163459 assert( IsVirtual(pTab) );
163479 assert( pTerm->u.x.leftColumn<pTab->nCol );
163510 assert( pExpr->iColumn>=XN_ROWID && pExpr->iColumn<pTab->nCol );
163523 assert( pE2->iColumn>=XN_ROWID && pE2->iColumn<pTab->nCol );
163526 zColl = sqlite3ColumnColl(&pTab->aCol[pE2->iColumn]);
163661 static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){
163662 sqlite3_vtab *pVtab = sqlite3GetVTable(pParse->db, pTab)->pVtab;
163665 whereTraceIndexInfoInputs(p, pTab);
163669 whereTraceIndexInfoOutputs(p, pTab);
163680 if( pTab->u.vtab.p->bAllSchemas ){
164435 Table *pTab = pItem->pTab;
164440 pItem->zAlias ? pItem->zAlias : pTab->zName);
165423 assert( pSrc->pTab->szTabRow>0 );
165431 rCostIdx = pNew->nOut + 1 + (15*pProbe->szIdxRow)/pSrc->pTab->szTabRow;
165890 Table *pTab; /* Table being queried */
165896 pTab = pSrc->pTab;
165898 assert( !IsVirtual(pSrc->pTab) );
165904 }else if( !HasRowid(pTab) ){
165905 pProbe = pTab->pIndex;
165918 sPk.pTable = pTab;
165921 aiRowEstPk[0] = pTab->nRowLogEst;
165923 pFirst = pSrc->pTab->pIndex;
165931 rSize = pTab->nRowLogEst;
165940 && HasRowid(pTab) /* Not WITHOUT ROWID table. (FIXME: Why not?) */
165967 if( !IsView(pTab) && (pTab->tabFlags & TF_Ephemeral)==0 ){
165973 ApplyCostMultiplier(pNew->rSetup, pTab->costMult);
166036 pNew->rRun = rSize + 16 - 2*((pTab->tabFlags & TF_HasStat4)!=0);
166040 ApplyCostMultiplier(pNew->rRun, pTab->costMult);
166080 && (HasRowid(pTab) || pWInfo->pSelect!=0 || sqlite3FaultSim(700))
166091 || !HasRowid(pTab)
166096 && (pProbe->szIdxRow<pTab->szTabRow)
166107 pNew->rRun = rSize + 1 + (15*pProbe->szIdxRow)/pTab->szTabRow;
166135 ApplyCostMultiplier(pNew->rRun, pTab->costMult);
166157 pTab->tabFlags |= TF_MaybeReanalyze;
166267 rc = vtabBestIndex(pParse, pSrc->pTab, pIdxInfo);
166296 sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
166364 sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
166564 assert( IsVirtual(pSrc->pTab) );
166578 WHERETRACE(0x800, ("BEGIN %s.addVirtual()\n", pSrc->pTab->zName));
166662 WHERETRACE(0x800, ("END %s.addVirtual(), rc=%d\n", pSrc->pTab->zName, rc));
166734 if( IsVirtual(pItem->pTab) ){
166848 if( IsVirtual(pItem->pTab) ){
167821 Table *pTab;
167829 pTab = pItem->pTab;
167830 if( IsVirtual(pTab) ) return 0;
167852 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
168092 Table *pTab = pItem->pTab;
168093 if( (pTab->tabFlags & TF_HasStat1)==0 ) break;
168094 pTab->tabFlags |= TF_MaybeReanalyze;
168100 if( nSearch > pTab->nRowLogEst ){
168107 pLoop->cId, (double)sqlite3LogEstToInt(nSearch), pTab->zName,
168108 (double)sqlite3LogEstToInt(pTab->nRowLogEst)));
168186 Table *pTab;
168188 pTab = pIdx->pTable;
168194 }else if( j>=0 && (pTab->aCol[j].colFlags & COLFLAG_VIRTUAL)!=0 ){
168195 pExpr = sqlite3ColumnExpr(pTab, &pTab->aCol[j]);
168739 assert( !(wsFlags & WHERE_VIRTUALTABLE) || IsVirtual(pTabList->a[0].pTab) );
168742 && !IsVirtual(pTabList->a[0].pTab)
168747 if( HasRowid(pTabList->a[0].pTab) && (wsFlags & WHERE_IDX_ONLY) ){
168760 Table *pTab; /* Table to open */
168765 pTab = pTabItem->pTab;
168766 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
168768 if( (pTab->tabFlags & TF_Ephemeral)!=0 || IsView(pTab) ){
168773 const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
168776 }else if( IsVirtual(pTab) ){
168789 sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op);
168791 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS-1 );
168792 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS );
168794 && pTab->nCol<BMS
168795 && (pTab->tabFlags & (TF_HasGenerated|TF_WithoutRowid))==0
168805 assert( n<=pTab->nCol );
168808 if( pLoop->u.btree.pIndex!=0 && (pTab->tabFlags & TF_WithoutRowid)==0 ){
168820 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
168828 if( !HasRowid(pTab) && IsPrimaryKeyIndex(pIx)
168836 Index *pJ = pTabItem->pTab->pIndex;
168861 assert( pIx->pSchema==pTab->pSchema );
168903 assert( pTab==pTabItem->pTab );
168904 if( HasRowid(pTab) ){
168914 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
169162 assert( pSrc->pTab!=0 );
169163 m = pSrc->pTab->nCol;
169187 pWInfo->pTabList->a[pLevel->iFrom].pTab->zName));
169196 Table *pTab = pTabItem->pTab;
169197 assert( pTab!=0 );
169286 assert( pIdx->pTable==pTab );
169292 if( !HasRowid(pTab) ){
169293 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
169297 testcase( x!=sqlite3StorageColumnToTable(pTab,x) );
169298 x = sqlite3StorageColumnToTable(pTab,x);
170086 Table *pTab;
170165 pExpr->y.pTab = p->pTab;
170210 Table *pTab,
170223 sRewrite.pTab = pTab;
170324 Table *pTab;
170329 pTab = sqlite3DbMallocZero(db, sizeof(Table));
170330 if( pTab==0 ){
170369 selectWindowRewriteEList(pParse, pMWin, pSrc, p->pEList, pTab, &pSublist);
170370 selectWindowRewriteEList(pParse, pMWin, pSrc, p->pOrderBy, pTab, &pSublist);
170389 selectWindowRewriteEList(pParse, pMWin, pSrc, pArgs, pTab, &pSublist);
170441 memcpy(pTab, pTab2, sizeof(Table));
170442 pTab->tabFlags |= TF_Ephemeral;
170443 p->pSrc->a[0].pTab = pTab;
170444 pTab = pTab2;
170459 sqlite3ParserAddCleanup(pParse, sqlite3DbFree, pTab);
172139 int nInput = p->pSrc->a[0].pTab->nCol; /* Number of cols returned by sub */
180980 Table *pTab = (Table *)sqliteHashData(p);
180981 if( IsVirtual(pTab) ) sqlite3VtabDisconnect(db, pTab);
183695 Table *pTab = 0;
183720 pTab = sqlite3FindTable(db, zTableName, zDbName);
183721 if( !pTab || IsView(pTab) ){
183722 pTab = 0;
183730 for(iCol=0; iCol<pTab->nCol; iCol++){
183731 pCol = &pTab->aCol[iCol];
183736 if( iCol==pTab->nCol ){
183737 if( HasRowid(pTab) && sqlite3IsRowid(zColumnName) ){
183738 iCol = pTab->iPKey;
183739 pCol = iCol>=0 ? &pTab->aCol[iCol] : 0;
183741 pTab = 0;
183762 autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
183784 if( SQLITE_OK==rc && !pTab ){
187996 Fts3Table *pTab = (Fts3Table*)pCsr->base.pVtab;
187997 pTab->bLock++;
188001 pTab->bLock--;
188004 pTab->bLock--;
189401 Fts3Table *pTab = (Fts3Table*)pCursor->pVtab;
189402 pTab->bLock++;
189410 pTab->bLock--;
190084 Fts3Table *pTab = (Fts3Table*)pVtab;
190085 assert( pTab->inTransaction );
190086 assert( pTab->mxSavepoint<=iSavepoint );
190087 TESTONLY( pTab->mxSavepoint = iSavepoint );
190089 if( pTab->bIgnoreSavepoint==0 ){
190090 if( fts3HashCount(&pTab->aIndex[0].hPending)>0 ){
190092 pTab->zDb, pTab->zName, pTab->zName
190095 pTab->bIgnoreSavepoint = 1;
190096 rc = sqlite3_exec(pTab->db, zSql, 0, 0, 0);
190097 pTab->bIgnoreSavepoint = 0;
190104 pTab->iSavepoint = iSavepoint+1;
190116 Fts3Table *pTab = (Fts3Table*)pVtab;
190117 assert( pTab->inTransaction );
190118 assert( pTab->mxSavepoint >= iSavepoint );
190119 TESTONLY( pTab->mxSavepoint = iSavepoint-1 );
190120 pTab->iSavepoint = iSavepoint;
190130 Fts3Table *pTab = (Fts3Table*)pVtab;
190132 assert( pTab->inTransaction );
190133 TESTONLY( pTab->mxSavepoint = iSavepoint );
190134 if( (iSavepoint+1)<=pTab->iSavepoint ){
190135 sqlite3Fts3PendingTermsClear(pTab);
190413 Fts3Table *pTab, /* FTS Table pointer */
190459 pTab->bDescIdx, nDiff, pLeft, nLeft, &pRight, &nRight
190480 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
190491 rc = fts3TermSelect(pTab, pToken, p->iColumn, &nThis, &pThis);
190493 rc = fts3EvalPhraseMergeToken(pTab, p, iToken, pThis, nThis);
190630 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
190641 && pCsr->bDesc==pTab->bDescIdx
190644 && pTab->bNoIncrDoclist==0
190657 int iCol = (p->iColumn >= pTab->nColumn ? -1 : p->iColumn);
190662 rc = sqlite3Fts3MsrIncrStart(pTab, pSegcsr, iCol, pToken->z, pToken->n);
190780 Fts3Table *pTab,
190800 if( pTab->bDescIdx==0 || pDL->pNextDocid==0 ){
190844 Fts3Table *pTab, /* Virtual table handle */
190855 fts3EvalDlPhraseNext(pTab, &pPhrase->doclist, pbEof);
190866 pTab, pToken->pSegcsr, &p->iDocid, &p->pList, &p->nList
190902 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
190910 rc = sqlite3Fts3MsrIncrNext(pTab, p->aToken[0].pSegcsr,
190929 rc = incrPhraseTokenNext(pTab, p, i, &a[i], &bEof);
190943 rc = incrPhraseTokenNext(pTab, p, i, &a[i], &bEof);
191003 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
191007 }else if( pCsr->bDesc!=pTab->bDescIdx && pDL->nAll ){
191008 sqlite3Fts3DoclistPrev(pTab->bDescIdx, pDL->aAll, pDL->nAll,
191013 fts3EvalDlPhraseNext(pTab, pDL, pbEof);
191209 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
191224 if( pTab->zContentTbl ){
191302 rc = fts3TermSelect(pTab, pToken, pTC->iCol, &nList, &pList);
191306 pTab, pTC->pPhrase, pTC->iToken,pList,nList
191337 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
191347 if( rc==SQLITE_OK && nToken>1 && pTab->bFts4 ){
191980 Fts3Table *pTab = (Fts3Table*)pCtx;
191983 pExpr->aMI = (u32 *)sqlite3_malloc64(pTab->nColumn * 3 * sizeof(u32));
191986 memset(pExpr->aMI, 0, pTab->nColumn * 3 * sizeof(u32));
192009 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
192028 rc = sqlite3Fts3ExprIterate(pRoot, fts3AllocateMSI, (void*)pTab);
192051 fts3EvalUpdateCounts(pRoot, pTab->nColumn);
192113 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
192119 for(iCol=0; iCol<pTab->nColumn; iCol++){
192127 for(iCol=0; iCol<pTab->nColumn; iCol++){
192163 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
192171 assert( iCol>=0 && iCol<pTab->nColumn );
192172 if( (pPhrase->iColumn<pTab->nColumn && pPhrase->iColumn!=iCol) ){
192180 int bDescDoclist = pTab->bDescIdx; /* For DOCID_CMP macro */
196175 Fts3tokTable *pTab = 0;
196206 pTab = (Fts3tokTable *)sqlite3_malloc(sizeof(Fts3tokTable));
196207 if( pTab==0 ){
196213 memset(pTab, 0, sizeof(Fts3tokTable));
196214 pTab->pMod = pMod;
196215 pTab->pTok = pTok;
196216 *ppVtab = &pTab->base;
196233 Fts3tokTable *pTab = (Fts3tokTable *)pVtab;
196235 pTab->pMod->xDestroy(pTab->pTok);
196236 sqlite3_free(pTab);
196292 Fts3tokTable *pTab = (Fts3tokTable *)(pCsr->base.pVtab);
196293 pTab->pMod->xClose(pCsr->pCsr);
196322 Fts3tokTable *pTab = (Fts3tokTable *)(pCursor->pVtab);
196326 rc = pTab->pMod->xNext(pCsr->pCsr,
196351 Fts3tokTable *pTab = (Fts3tokTable *)(pCursor->pVtab);
196365 rc = pTab->pMod->xOpen(pTab->pTok, pCsr->zInput, nByte, &pCsr->pCsr);
196367 pCsr->pCsr->pTokenizer = pTab->pTok;
196904 Fts3Table *pTab, /* FTS3 table handle */
196911 rc = fts3SqlStmt(pTab, SQL_SELECT_DOCSIZE, &pStmt, 0);
196929 Fts3Table *pTab, /* Fts3 table handle */
196934 rc = fts3SqlStmt(pTab, SQL_SELECT_STAT, &pStmt, 0);
196950 Fts3Table *pTab, /* Fts3 table handle */
196954 return fts3SelectDocsize(pTab, iDocid, ppStmt);
197912 static int fts3SegReaderFirstDocid(Fts3Table *pTab, Fts3SegReader *pReader){
197916 if( pTab->bDescIdx && fts3SegReaderIsPending(pReader) ){
197945 Fts3Table *pTab,
197956 if( pTab->bDescIdx && fts3SegReaderIsPending(pReader) ){
198020 if( pTab->bDescIdx ){
202964 Fts3Table *pTab, /* FTS3 table snippet comes from */
202997 pMod = (sqlite3_tokenizer_module *)pTab->pTokenizer->pModule;
203002 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, iLangid, zDoc, nDoc, &pC);
203039 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
203062 pMod = (sqlite3_tokenizer_module *)pTab->pTokenizer->pModule;
203063 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid, zDoc,nDoc,&pC);
203102 pTab, pCsr->iLangid, nSnippet, &zDoc[iBegin], n, &iPos, &hlmask
203178 Fts3Table *pTab = (Fts3Table *)p->pCursor->base.pVtab;
203193 if( (pPhrase->iColumn>=pTab->nColumn || pPhrase->iColumn==iCol) ){
203296 Fts3Table *pTab,
203302 || (cArg==FTS3_MATCHINFO_NDOC && pTab->bFts4)
203303 || (cArg==FTS3_MATCHINFO_AVGLENGTH && pTab->bFts4)
203304 || (cArg==FTS3_MATCHINFO_LENGTH && pTab->bHasDocsize)
203350 Fts3Table *pTab,
203364 int rc = sqlite3Fts3SelectDoctotal(pTab, ppStmt);
203548 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
203565 rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &nDoc, 0, 0);
203576 rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &nDoc, &a, &pEnd);
203596 rc = sqlite3Fts3SelectDocsize(pTab, pCsr->iPrevId, &pSelectDocsize);
203638 rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &pInfo->nDoc,0,0);
203668 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
203677 sInfo.nCol = pTab->nColumn;
203703 if( fts3MatchinfoCheck(pTab, zArg[i], &zErr) ){
203756 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
203805 for(iRead=0; iRead<pTab->nColumn; iRead++){
203840 sqlite3Fts3SegmentsClose(pTab);
203903 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
203904 sqlite3_tokenizer_module const *pMod = pTab->pTokenizer->pModule;
203935 for(iCol=0; iCol<pTab->nColumn; iCol++){
203972 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid,
204010 }else if( rc==SQLITE_DONE && pTab->zContentTbl==0 ){
204026 sqlite3Fts3SegmentsClose(pTab);
204044 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
204059 sqlite3Fts3SegmentsClose(pTab);
223702 StatTable *pTab = 0;
223721 pTab = (StatTable *)sqlite3_malloc64(sizeof(StatTable));
223722 if( pTab==0 ) rc = SQLITE_NOMEM_BKPT;
223725 assert( rc==SQLITE_OK || pTab==0 );
223727 memset(pTab, 0, sizeof(StatTable));
223728 pTab->db = db;
223729 pTab->iDb = iDb;
223732 *ppVtab = (sqlite3_vtab*)pTab;
223829 StatTable *pTab = (StatTable *)pVTab;
223838 pCsr->iDb = pTab->iDb;
224050 StatTable *pTab = (StatTable *)((sqlite3_vtab_cursor *)pCsr)->pVtab;
224051 Btree *pBt = pTab->db->aDb[pTab->iDb].pBt;
224113 StatTable *pTab = (StatTable *)pCursor->pVtab;
224114 Btree *pBt = pTab->db->aDb[pCsr->iDb].pBt;
224279 StatTable *pTab = (StatTable*)(pCursor->pVtab);
224294 pCsr->iDb = sqlite3FindDbName(pTab->db, zDbase);
224301 pCsr->iDb = pTab->iDb;
224313 pSql = sqlite3_str_new(pTab->db);
224320 pTab->db->aDb[pCsr->iDb].zDbSName);
224331 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pStmt, 0);
224520 DbpageTable *pTab = 0;
224532 pTab = (DbpageTable *)sqlite3_malloc64(sizeof(DbpageTable));
224533 if( pTab==0 ) rc = SQLITE_NOMEM_BKPT;
224536 assert( rc==SQLITE_OK || pTab==0 );
224538 memset(pTab, 0, sizeof(DbpageTable));
224539 pTab->db = db;
224542 *ppVtab = (sqlite3_vtab*)pTab;
224675 DbpageTable *pTab = (DbpageTable *)pCursor->pVtab;
224677 sqlite3 *db = pTab->db;
224766 DbpageTable *pTab = (DbpageTable *)pVtab;
224778 if( pTab->db->flags & SQLITE_Defensive ){
224794 iDb = ALWAYS(zSchema) ? sqlite3FindDbName(pTab->db, zSchema) : -1;
224799 pBt = pTab->db->aDb[iDb].pBt;
224815 assert( pData!=0 || pTab->db->mallocFailed );
224836 DbpageTable *pTab = (DbpageTable *)pVtab;
224837 sqlite3 *db = pTab->db;
225422 SessionTable *pTab, /* Session table handle */
225430 if( pTab->bRowid ){
225431 assert( pTab->nCol-1==pSession->hook.xCount(pSession->hook.pCtx) );
225435 assert( pTab->nCol==pSession->hook.xCount(pSession->hook.pCtx) );
225436 for(i=0; i<pTab->nCol; i++){
225437 if( pTab->abPK[i] ){
225474 assert( pTab->bStat1==0 || i!=1 );
225481 *piHash = (h % pTab->nChange);
225511 SessionTable *pTab, /* Table handle */
225520 for(i=0; i<pTab->nCol; i++){
225522 int isPK = pTab->abPK[i];
225560 SessionTable *pTab, /* Table used for PK definition */
225570 for(iCol=0; iCol<pTab->nCol; iCol++){
225571 if( pTab->abPK[iCol] ){
225684 SessionTable *pTab, /* Table change pertains to */
225705 for(i=0; i<pTab->nCol; i++){
225713 if( pTab->abPK[i] || nOld!=nNew || memcmp(aOld, aNew, nNew) ){
225714 if( pTab->abPK[i]==0 ) bRequired = 1;
225730 for(i=0; i<pTab->nCol; i++){
225739 && (pTab->abPK[i] || (nOld==nNew && 0==memcmp(aOld, aNew, nNew)))
225762 SessionTable *pTab, /* Table associated with change */
225769 if( pTab->bRowid ){
225775 for(iCol=0; iCol<pTab->nCol; iCol++){
225776 if( !pTab->abPK[iCol] ){
225848 SessionTable *pTab
225850 if( pTab->nChange==0 || pTab->nEntry>=(pTab->nChange/2) ){
225853 sqlite3_int64 nNew = 2*(sqlite3_int64)(pTab->nChange ? pTab->nChange : 128);
225859 if( pTab->nChange==0 ){
225866 for(i=0; i<pTab->nChange; i++){
225869 for(p=pTab->apChange[i]; p; p=pNext){
225871 int iHash = sessionChangeHash(pTab, bPkOnly, p->aRecord, nNew);
225878 sessionFree(pSession, pTab->apChange);
225879 pTab->nChange = nNew;
225880 pTab->apChange = apNew;
226068 SessionTable *pTab, /* Table object to initialize */
226074 if( pTab->nCol==0 ){
226076 assert( pTab->azCol==0 || pTab->abPK==0 );
226078 pTab->zName, &pTab->nCol, 0, &pTab->azCol, &pTab->azDflt, &abPK,
226079 ((pSession==0 || pSession->bImplicitPK) ? &pTab->bRowid : 0)
226083 for(i=0; i<pTab->nCol; i++){
226085 pTab->abPK = abPK;
226089 if( 0==sqlite3_stricmp("sqlite_stat1", pTab->zName) ){
226090 pTab->bStat1 = 1;
226095 1 + sessionVarintLen(pTab->nCol) + pTab->nCol + strlen(pTab->zName)+1
226103 return (rc || pTab->abPK==0);
226111 static int sessionReinitTable(sqlite3_session *pSession, SessionTable *pTab){
226121 pTab->zName, &nCol, 0, &azCol, &azDflt, &abPK,
226125 if( pTab->nCol>nCol || pTab->bRowid!=bRowid ){
226129 int nOldCol = pTab->nCol;
226131 if( ii<pTab->nCol ){
226132 if( pTab->abPK[ii]!=abPK[ii] ){
226141 const char **a = pTab->azCol;
226142 pTab->azCol = azCol;
226143 pTab->nCol = nCol;
226144 pTab->azDflt = azDflt;
226145 pTab->abPK = abPK;
226359 SessionTable *pTab, /* Table to prepare statement for */
226369 for(ii=0; ii<pTab->nCol; ii++){
226370 const char *zDflt = pTab->azDflt[ii] ? pTab->azDflt[ii] : "NULL";
226387 static int sessionUpdateChanges(sqlite3_session *pSession, SessionTable *pTab){
226391 rc = sessionPrepareDfltStmt(pSession->db, pTab, &pStmt);
226395 for(ii=0; ii<pTab->nChange; ii++){
226396 for(pp=&pTab->apChange[ii]; *pp; pp=&((*pp)->pNext)){
226397 if( (*pp)->nRecordField!=pTab->nCol ){
226398 sessionUpdateOneChange(pSession, &rc, pp, pTab->nCol, pStmt);
226453 SessionTable *pTab, /* Table that change applies to */
226458 if( pTab->bRowid ) nNew += 9;
226461 for(ii=0; ii<pTab->nCol; ii++){
226475 if( pTab->bRowid ){
226479 for(ii=pTab->bRowid; ii<pTab->nCol; ii++){
226484 pSession->hook.xNew(pSession->hook.pCtx, ii-pTab->bRowid, &p);
226529 if( bChanged && pTab->abPK[ii] ){
226537 }else if( pTab->abPK[ii] ){
226565 SessionTable *pTab /* Table that change applies to */
226576 if( sessionInitTable(pSession, pTab, pSession->db, pSession->zDb) ) return;
226581 if( (pTab->nCol-pTab->bRowid)<nExpect ){
226582 if( sessionReinitTable(pSession, pTab) ) return;
226583 if( sessionUpdateChanges(pSession, pTab) ) return;
226585 if( (pTab->nCol-pTab->bRowid)!=nExpect ){
226591 if( sessionGrowHash(pSession, 0, pTab) ){
226596 if( pTab->bStat1 ){
226619 pSession, iRowid, pTab, op==SQLITE_INSERT, &iHash, &bNull
226626 for(pC=pTab->apChange[iHash]; pC; pC=pC->pNext){
226627 if( sessionPreupdateEqual(pSession, iRowid, pTab, pC, op) ) break;
226638 pTab->nEntry++;
226642 for(i=0; i<(pTab->nCol-pTab->bRowid); i++){
226647 }else if( pTab->abPK[i] ){
226657 if( pTab->bRowid ){
226676 if( pTab->bRowid ){
226681 for(i=0; i<(pTab->nCol-pTab->bRowid); i++){
226685 }else if( pTab->abPK[i] ){
226695 pC->nRecordField = pTab->nCol;
226698 pC->pNext = pTab->apChange[iHash];
226699 pTab->apChange[iHash] = pC;
226713 rc = sessionUpdateMaxSize(op, pSession, pTab, pC);
226720 if( pTab->bStat1 ){
226785 SessionTable *pTab;
226794 pSession->rc = sessionFindTable(pSession, zName, &pTab);
226795 if( pTab ){
226798 sessionPreupdateOneChange(op, iKey1, pSession, pTab);
226800 sessionPreupdateOneChange(SQLITE_INSERT, iKey2, pSession, pTab);
226954 SessionTable *pTab,
226961 zDb1, zDb2, pTab->bRowid, pTab->zName, zExpr
226973 pDiffCtx->bRowid = pTab->bRowid;
226975 i64 iRowid = (pTab->bRowid ? sqlite3_column_int64(pStmt, 0) : 0);
226976 sessionPreupdateOneChange(op, iRowid, pSession, pTab);
226994 SessionTable *pTab
226998 for(ii=0; ii<pTab->nCol; ii++){
227000 zRet, (zRet ? ", " : ""), zDb, pTab->zName, pTab->azCol[ii]
227009 SessionTable *pTab,
227015 char *zExpr2 = sessionExprCompareOther(pTab->nCol,
227016 pSession->zDb, zFrom, pTab->zName, pTab->azCol, pTab->abPK
227021 char *z1 = sessionAllCols(pSession->zDb, pTab);
227022 char *z2 = sessionAllCols(zFrom, pTab);
227025 z1, z2, pSession->zDb, pTab->zName, zFrom, pTab->zName, zExpr, zExpr2
227036 pDiffCtx->nOldOff = pTab->nCol;
227038 i64 iRowid = (pTab->bRowid ? sqlite3_column_int64(pStmt, 0) : 0);
227039 sessionPreupdateOneChange(SQLITE_UPDATE, iRowid, pSession, pTab);
227190 SessionTable *pTab;
227192 for(pTab=pList; pTab; pTab=pNext){
227194 pNext = pTab->pNext;
227195 for(i=0; i<pTab->nChange; i++){
227198 for(p=pTab->apChange[i]; p; p=pNextChange){
227203 sqlite3_finalize(pTab->pDfltStmt);
227204 sessionFree(pSession, (char*)pTab->azCol); /* cast works around VC++ bug */
227205 sessionFree(pSession, pTab->apChange);
227206 sessionFree(pSession, pTab);
227271 SessionTable *pTab; /* New table object (if required) */
227277 for(pTab=pSession->pTable; pTab; pTab=pTab->pNext){
227278 if( 0==sqlite3_strnicmp(pTab->zName, zName, nName+1) ) break;
227281 if( !pTab ){
227284 pTab = (SessionTable*)sessionMalloc64(pSession, nByte);
227285 if( !pTab ){
227294 memset(pTab, 0, sizeof(SessionTable));
227295 pTab->zName = (char *)&pTab[1];
227296 memcpy(pTab->zName, zName, nName+1);
227298 *ppTab = pTab;
227829 SessionTable *pTab, /* Table object to append header for */
227834 sessionAppendVarint(pBuf, pTab->nCol, pRc);
227835 sessionAppendBlob(pBuf, pTab->abPK, pTab->nCol, pRc);
227836 sessionAppendBlob(pBuf, (u8 *)pTab->zName, (int)strlen(pTab->zName)+1, pRc);
227858 SessionTable *pTab; /* Used to iterate through attached tables */
227880 for(pTab=pSession->pTable; rc==SQLITE_OK && pTab; pTab=pTab->pNext){
227881 if( pTab->nEntry ){
227882 const char *zName = pTab->zName;
227887 int nOldCol = pTab->nCol;
227890 rc = sessionReinitTable(pSession, pTab);
227891 if( rc==SQLITE_OK && pTab->nCol!=nOldCol ){
227892 rc = sessionUpdateChanges(pSession, pTab);
227896 sessionAppendTableHdr(&buf, bPatchset, pTab, &rc);
227901 zName, pTab->bRowid, pTab->nCol, pTab->azCol, pTab->abPK, &pSel
227906 for(i=0; i<pTab->nChange && rc==SQLITE_OK; i++){
227909 for(p=pTab->apChange[i]; rc==SQLITE_OK && p; p=p->pNext){
227910 rc = sessionSelectBind(pSel, pTab->nCol, pTab->abPK, p);
227917 for(iCol=0; iCol<pTab->nCol; iCol++){
227921 assert( pTab->abPK!=0 );
227922 rc = sessionAppendUpdate(&buf, bPatchset, pSel, p, pTab->abPK);
227925 rc = sessionAppendDelete(&buf, bPatchset, p, pTab->nCol,pTab->abPK);
228065 SessionTable *pTab;
228068 for(pTab=pSession->pTable; pTab && ret==0; pTab=pTab->pNext){
228069 ret = (pTab->nEntry>0);
230327 SessionTable *pTab, /* Table structure */
230357 for(i=0; i<pTab->nCol; i++){
230361 }else if( pTab->abPK[i]==0 ){
230390 for(i=0; i<pTab->nCol; i++){
230393 if( *a1==0xFF || (pTab->abPK[i]==0 && bIndirect) ){
230456 if( bPatchset==0 ) sessionSkipRecord(&a1, pTab->nCol);
230457 sessionMergeRecord(&aCsr, pTab->nCol, aExist, a1);
230465 if( 0==sessionMergeUpdate(&aCsr, pTab, bPatchset, aExist, 0,aRec,0) ){
230475 sessionSkipRecord(&a1, pTab->nCol);
230476 sessionSkipRecord(&a2, pTab->nCol);
230479 if( 0==sessionMergeUpdate(&aCsr, pTab, bPatchset, aRec, aExist,a1,a2) ){
230490 sessionMergeRecord(&aCsr, pTab->nCol, aRec, aExist);
230512 SessionTable *pTab,
230516 if( pTab->azCol && nCol<pTab->nCol ){
230518 for(ii=0; ii<pTab->nCol; ii++){
230520 if( pTab->abPK[ii]!=bPK ) return 0;
230524 return (pTab->nCol==nCol && 0==memcmp(abPK, pTab->abPK, nCol));
230529 SessionTable *pTab,
230539 assert( pTab->azCol );
230540 assert( nCol<pTab->nCol );
230546 if( rc==SQLITE_OK && pTab->pDfltStmt==0 ){
230547 rc = sessionPrepareDfltStmt(pGrp->db, pTab, &pTab->pDfltStmt);
230549 for(ii=nCol; rc==SQLITE_OK && ii<pTab->nCol; ii++){
230550 int eType = sqlite3_column_type(pTab->pDfltStmt, ii);
230557 iVal = sqlite3_column_int64(pTab->pDfltStmt, ii);
230559 double rVal = sqlite3_column_int64(pTab->pDfltStmt, ii);
230570 int n = sqlite3_column_bytes(pTab->pDfltStmt, ii);
230573 const u8 *z = (const u8*)sqlite3_column_text(pTab->pDfltStmt, ii);
230576 const u8 *z = (const u8*)sqlite3_column_blob(pTab->pDfltStmt, ii);
230596 for(ii=0; ii<(pTab->nCol-nCol); ii++){
230602 for(ii=0; ii<(pTab->nCol-nCol); ii++){
230627 SessionTable *pTab = 0;
230636 for(pTab = pGrp->pList; pTab; pTab=pTab->pNext){
230637 if( 0==sqlite3_strnicmp(pTab->zName, zTab, nTab+1) ) break;
230641 if( !pTab ){
230644 pTab = sqlite3_malloc64(sizeof(SessionTable) + nCol + nTab+1);
230645 if( !pTab ){
230648 memset(pTab, 0, sizeof(SessionTable));
230649 pTab->nCol = nCol;
230650 pTab->abPK = (u8*)&pTab[1];
230651 memcpy(pTab->abPK, abPK, nCol);
230652 pTab->zName = (char*)&pTab->abPK[nCol];
230653 memcpy(pTab->zName, zTab, nTab+1);
230656 pTab->nCol = 0;
230657 rc = sessionInitTable(0, pTab, pGrp->db, pGrp->zDb);
230659 assert( pTab->azCol==0 );
230660 sqlite3_free(pTab);
230670 *ppNew = pTab;
230674 if( !sessionChangesetCheckCompat(pTab, nCol, abPK) ){
230678 *ppTab = pTab;
230699 SessionTable *pTab = 0;
230715 rc = sessionChangesetFindTable(pGrp, zTab, pIter, &pTab);
230718 if( rc==SQLITE_OK && nCol<pTab->nCol ){
230720 rc = sessionChangesetExtendRecord(pGrp, pTab, nCol, op, aRec, nRec, pBuf);
230726 if( rc==SQLITE_OK && sessionGrowHash(0, pIter->bPatchset, pTab) ){
230734 pTab, (pIter->bPatchset && op==SQLITE_DELETE), aRec, pTab->nChange
230736 for(pp=&pTab->apChange[iHash]; *pp; pp=&(*pp)->pNext){
230743 if( sessionChangeEqual(pTab, bPkOnly1, (*pp)->aRecord, bPkOnly2, aRec) ){
230746 pTab->nEntry--;
230753 rc = sessionChangeMerge(pTab, bRebase,
230758 pChange->pNext = pTab->apChange[iHash];
230759 pTab->apChange[iHash] = pChange;
230760 pTab->nEntry++;
230816 SessionTable *pTab;
230822 for(pTab=pGrp->pList; rc==SQLITE_OK && pTab; pTab=pTab->pNext){
230824 if( pTab->nEntry==0 ) continue;
230826 sessionAppendTableHdr(&buf, pGrp->bPatch, pTab, &rc);
230827 for(i=0; i<pTab->nChange; i++){
230829 for(p=pTab->apChange[i]; p; p=p->pNext){
231183 SessionTable *pTab = 0;
231192 for(pTab=p->grp.pList; pTab; pTab=pTab->pNext){
231193 if( 0==sqlite3_stricmp(pTab->zName, zTab) ) break;
231209 if( pTab && rc==SQLITE_OK ){
231210 int iHash = sessionChangeHash(pTab, 0, aRec, pTab->nChange);
231212 for(pChange=pTab->apChange[iHash]; pChange; pChange=pChange->pNext){
231213 if( sessionChangeEqual(pTab, 0, aRec, 0, pChange->aRecord) ){
249905 static int fts5IsContentless(Fts5FullTable *pTab){
249906 return pTab->p.pConfig->eContent==FTS5_CONTENT_NONE;
249912 static void fts5FreeVtab(Fts5FullTable *pTab){
249913 if( pTab ){
249914 sqlite3Fts5IndexClose(pTab->p.pIndex);
249915 sqlite3Fts5StorageClose(pTab->pStorage);
249916 sqlite3Fts5ConfigFree(pTab->p.pConfig);
249917 sqlite3_free(pTab);
249933 Fts5Table *pTab = (Fts5Table*)pVtab;
249934 int rc = sqlite3Fts5DropAll(pTab->pConfig);
249965 Fts5FullTable *pTab = 0; /* New virtual table object */
249968 pTab = (Fts5FullTable*)sqlite3Fts5MallocZero(&rc, sizeof(Fts5FullTable));
249974 pTab->p.pConfig = pConfig;
249975 pTab->pGlobal = pGlobal;
249980 rc = sqlite3Fts5IndexOpen(pConfig, bCreate, &pTab->p.pIndex, pzErr);
249986 pConfig, pTab->p.pIndex, bCreate, &pTab->pStorage, pzErr
249999 rc = sqlite3Fts5IndexLoadConfig(pTab->p.pIndex);
250000 sqlite3Fts5IndexRollback(pTab->p.pIndex);
250012 fts5FreeVtab(pTab);
250013 pTab = 0;
250015 fts5CheckTransactionState(pTab, FTS5_BEGIN, 0);
250017 *ppVTab = (sqlite3_vtab*)pTab;
250151 Fts5Table *pTab = (Fts5Table*)pVTab;
250152 Fts5Config *pConfig = pTab->pConfig;
250175 pTab->base.zErrMsg = sqlite3_mprintf(
250288 static int fts5NewTransaction(Fts5FullTable *pTab){
250290 for(pCsr=pTab->pGlobal->pCsr; pCsr; pCsr=pCsr->pNext){
250291 if( pCsr->base.pVtab==(sqlite3_vtab*)pTab ) return SQLITE_OK;
250293 return sqlite3Fts5StorageReset(pTab->pStorage);
250300 Fts5FullTable *pTab = (Fts5FullTable*)pVTab;
250301 Fts5Config *pConfig = pTab->p.pConfig;
250306 rc = fts5NewTransaction(pTab);
250311 Fts5Global *pGlobal = pTab->pGlobal;
250347 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
250355 sqlite3Fts5StorageStmtRelease(pTab->pStorage, eStmt, pCsr->pStmt);
250381 sqlite3Fts5IndexCloseReader(pTab->p.pIndex);
250392 Fts5FullTable *pTab = (Fts5FullTable*)(pCursor->pVtab);
250398 for(pp=&pTab->pGlobal->pCsr; (*pp)!=pCsr; pp=&(*pp)->pNext);
250449 static void fts5TripCursors(Fts5FullTable *pTab){
250451 for(pCsr=pTab->pGlobal->pCsr; pCsr; pCsr=pCsr->pNext){
250453 && pCsr->base.pVtab==(sqlite3_vtab*)pTab
250476 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
250480 rc = sqlite3Fts5ExprFirst(pCsr->pExpr, pTab->p.pIndex, iRowid, bDesc);
250597 Fts5FullTable *pTab,
250601 Fts5Config *pConfig = pTab->p.pConfig;
250633 assert( pTab->pSortCsr==0 );
250634 pTab->pSortCsr = pCsr;
250636 pTab->pSortCsr = 0;
250648 static int fts5CursorFirst(Fts5FullTable *pTab, Fts5Cursor *pCsr, int bDesc){
250651 rc = sqlite3Fts5ExprFirst(pExpr, pTab->p.pIndex, pCsr->iFirstRowid, bDesc);
250666 Fts5FullTable *pTab,
250677 assert( pTab->p.base.zErrMsg==0 );
250681 pCsr->iSpecial = sqlite3Fts5IndexReads(pTab->p.pIndex);
250688 pTab->p.base.zErrMsg = sqlite3_mprintf("unknown special query: %.*s", n, z);
250700 static Fts5Auxiliary *fts5FindAuxiliary(Fts5FullTable *pTab, const char *zName){
250703 for(pAux=pTab->pGlobal->pAux; pAux; pAux=pAux->pNext){
250713 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
250714 Fts5Config *pConfig = pTab->p.pConfig;
250750 pAux = fts5FindAuxiliary(pTab, zRank);
250752 assert( pTab->p.base.zErrMsg==0 );
250753 pTab->p.base.zErrMsg = sqlite3_mprintf("no such function: %s", zRank);
250828 Fts5FullTable *pTab = (Fts5FullTable*)(pCursor->pVtab);
250829 Fts5Config *pConfig = pTab->p.pConfig;
250845 pTab->p.base.zErrMsg = sqlite3_mprintf(
250862 assert( pTab->pSortCsr==0 || nVal==0 );
250864 assert( pzErrmsg==0 || pzErrmsg==&pTab->p.base.zErrMsg );
250865 pConfig->pzErrmsg = &pTab->p.base.zErrMsg;
250886 rc = fts5SpecialMatch(pTab, pCsr, &zText[1]);
250889 char **pzErr = &pTab->p.base.zErrMsg;
250948 rc = sqlite3Fts5IndexLoadConfig(pTab->p.pIndex);
250951 if( pTab->pSortCsr ){
250962 if( pTab->pSortCsr->bDesc ){
250963 pCsr->iLastRowid = pTab->pSortCsr->iFirstRowid;
250964 pCsr->iFirstRowid = pTab->pSortCsr->iLastRowid;
250966 pCsr->iLastRowid = pTab->pSortCsr->iLastRowid;
250967 pCsr->iFirstRowid = pTab->pSortCsr->iFirstRowid;
250970 pCsr->pExpr = pTab->pSortCsr->pExpr;
250971 rc = fts5CursorFirst(pTab, pCsr, bDesc);
250978 rc = fts5CursorFirstSorted(pTab, pCsr, bDesc);
250981 rc = fts5CursorFirst(pTab, pCsr, bDesc);
250994 pTab->pStorage, fts5StmtType(pCsr), &pCsr->pStmt, &pTab->p.base.zErrMsg
251080 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
251083 pTab->pStorage, eStmt, &pCsr->pStmt, (bErrormsg?&pTab->p.base.zErrMsg:0)
251085 assert( rc!=SQLITE_OK || pTab->p.base.zErrMsg==0 );
251090 Fts5Table *pTab = (Fts5Table*)(pCsr->base.pVtab);
251094 pTab->pConfig->bLock++;
251096 pTab->pConfig->bLock--;
251104 }else if( pTab->pConfig->pzErrmsg ){
251105 *pTab->pConfig->pzErrmsg = sqlite3_mprintf(
251106 "%s", sqlite3_errmsg(pTab->pConfig->db)
251138 Fts5FullTable *pTab, /* Fts5 table object */
251142 Fts5Config *pConfig = pTab->p.pConfig;
251149 fts5SetVtabError(pTab,
251155 rc = sqlite3Fts5StorageDeleteAll(pTab->pStorage);
251160 fts5SetVtabError(pTab,
251165 rc = sqlite3Fts5StorageRebuild(pTab->pStorage);
251169 rc = sqlite3Fts5StorageOptimize(pTab->pStorage);
251172 rc = sqlite3Fts5StorageMerge(pTab->pStorage, nMerge);
251175 rc = sqlite3Fts5StorageIntegrity(pTab->pStorage, iArg);
251181 rc = sqlite3Fts5FlushToDisk(&pTab->p);
251183 rc = sqlite3Fts5FlushToDisk(&pTab->p);
251185 rc = sqlite3Fts5IndexLoadConfig(pTab->p.pIndex);
251188 rc = sqlite3Fts5ConfigSetValue(pTab->p.pConfig, zCmd, pVal, &bError);
251194 rc = sqlite3Fts5StorageConfigValue(pTab->pStorage, zCmd, pVal, 0);
251200 pTab->p.pConfig->iCookie--;
251201 rc = sqlite3Fts5IndexLoadConfig(pTab->p.pIndex);
251208 Fts5FullTable *pTab,
251215 rc = sqlite3Fts5StorageDelete(pTab->pStorage, iDel, &apVal[2]);
251222 Fts5FullTable *pTab,
251228 rc = sqlite3Fts5StorageContentInsert(pTab->pStorage, apVal, piRowid);
251231 rc = sqlite3Fts5StorageIndexInsert(pTab->pStorage, apVal, *piRowid);
251256 Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
251257 Fts5Config *pConfig = pTab->p.pConfig;
251263 assert( pTab->ts.eState==1 || pTab->ts.eState==2 );
251270 assert( pTab->p.pConfig->pzErrmsg==0 );
251272 rc = sqlite3Fts5IndexLoadConfig(pTab->p.pIndex);
251276 pTab->p.pConfig->pzErrmsg = &pTab->p.base.zErrMsg;
251279 fts5TripCursors(pTab);
251291 fts5SetVtabError(pTab,
251296 rc = fts5SpecialDelete(pTab, apVal);
251300 rc = fts5SpecialInsert(pTab, z, apVal[2 + pConfig->nCol + 1]);
251329 pTab->p.base.zErrMsg = sqlite3_mprintf(
251339 rc = sqlite3Fts5StorageDelete(pTab->pStorage, iDel, 0);
251356 rc = sqlite3Fts5StorageDelete(pTab->pStorage, iNew, 0);
251359 fts5StorageInsert(&rc, pTab, apVal, pRowid);
251368 rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld, 0);
251370 rc = sqlite3Fts5StorageDelete(pTab->pStorage, iNew, 0);
251372 fts5StorageInsert(&rc, pTab, apVal, pRowid);
251374 rc = sqlite3Fts5StorageContentInsert(pTab->pStorage, apVal, pRowid);
251376 rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld, 0);
251379 rc = sqlite3Fts5StorageIndexInsert(pTab->pStorage, apVal,*pRowid);
251383 rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld, 0);
251384 fts5StorageInsert(&rc, pTab, apVal, pRowid);
251397 pTab->pStorage, "version", 0, FTS5_CURRENT_VERSION_SECUREDELETE
251404 pTab->p.pConfig->pzErrmsg = 0;
251413 Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
251414 fts5CheckTransactionState(pTab, FTS5_SYNC, 0);
251415 pTab->p.pConfig->pzErrmsg = &pTab->p.base.zErrMsg;
251416 rc = sqlite3Fts5FlushToDisk(&pTab->p);
251417 pTab->p.pConfig->pzErrmsg = 0;
251447 Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
251448 fts5CheckTransactionState(pTab, FTS5_ROLLBACK, 0);
251449 rc = sqlite3Fts5StorageRollback(pTab->pStorage);
251471 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
251472 return sqlite3Fts5StorageSize(pTab->pStorage, iCol, pnToken);
251477 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
251478 return sqlite3Fts5StorageRowCount(pTab->pStorage, pnRow);
251488 Fts5Table *pTab = (Fts5Table*)(pCsr->base.pVtab);
251490 pTab->pConfig, FTS5_TOKENIZE_AUX, pText, nText, pUserData, xToken
251512 Fts5Table *pTab = (Fts5Table*)(pCsr->base.pVtab);
251513 if( iCol<0 || iCol>=pTab->pConfig->nCol ){
251719 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
251720 Fts5Config *pConfig = pTab->p.pConfig;
251726 rc = sqlite3Fts5StorageDocsize(pTab->pStorage, iRowid, pCsr->aColumnSize);
252024 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
252033 pNew->base.pVtab = (sqlite3_vtab*)pTab;
252038 for(rc = fts5CursorFirst(pTab, pNew, 0);
252193 Fts5FullTable *pTab = (Fts5FullTable*)(pCursor->pVtab);
252194 Fts5Config *pConfig = pTab->p.pConfig;
252225 }else if( !fts5IsContentless(pTab) ){
252226 pConfig->pzErrmsg = &pTab->p.base.zErrMsg;
252254 Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
252258 pAux = fts5FindAuxiliary(pTab, zName);
252277 Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
252278 rc = sqlite3Fts5StorageRename(pTab->pStorage, zName);
252282 static int sqlite3Fts5FlushToDisk(Fts5Table *pTab){
252283 fts5TripCursors((Fts5FullTable*)pTab);
252284 return sqlite3Fts5StorageSync(((Fts5FullTable*)pTab)->pStorage);
252293 Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
252296 fts5CheckTransactionState(pTab, FTS5_SAVEPOINT, iSavepoint);
252299 pTab->iSavepoint = iSavepoint+1;
252310 Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
252312 fts5CheckTransactionState(pTab, FTS5_RELEASE, iSavepoint);
252313 if( (iSavepoint+1)<pTab->iSavepoint ){
252314 rc = sqlite3Fts5FlushToDisk(&pTab->p);
252316 pTab->iSavepoint = iSavepoint;
252328 Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
252330 fts5CheckTransactionState(pTab, FTS5_ROLLBACKTO, iSavepoint);
252331 fts5TripCursors(pTab);
252332 if( (iSavepoint+1)<=pTab->iSavepoint ){
252333 pTab->p.pConfig->pgsz = 0;
252334 rc = sqlite3Fts5StorageRollback(pTab->pStorage);
252570 Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
252575 assert( pTab->p.pConfig->pzErrmsg==0 );
252576 pTab->p.pConfig->pzErrmsg = pzErr;
252577 rc = sqlite3Fts5StorageIntegrity(pTab->pStorage, 0);
252590 sqlite3Fts5IndexCloseReader(pTab->p.pIndex);
252591 pTab->p.pConfig->pzErrmsg = 0;
256662 Fts5VocabTable *pTab = (Fts5VocabTable*)pVtab;
256663 sqlite3_free(pTab);
256671 Fts5VocabTable *pTab = (Fts5VocabTable*)pVtab;
256672 sqlite3_free(pTab);
256858 Fts5VocabTable *pTab = (Fts5VocabTable*)pVTab;
256865 if( pTab->bBusy ){
256867 "recursive definition for %s.%s", pTab->zFts5Db, pTab->zFts5Tbl
256873 pTab->zFts5Tbl, pTab->zFts5Db, pTab->zFts5Tbl, pTab->zFts5Tbl
256876 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pStmt, 0);
256882 pTab->bBusy = 1;
256885 pFts5 = sqlite3Fts5TableFromCsrid(pTab->pGlobal, iId);
256887 pTab->bBusy = 0;
256895 "no such fts5 table: %s.%s", pTab->zFts5Db, pTab->zFts5Tbl
257003 Fts5VocabTable *pTab = (Fts5VocabTable*)pCursor->pVtab;
257011 if( pTab->eType==FTS5_VOCAB_INSTANCE ){
257015 if( pTab->eType==FTS5_VOCAB_COL ){
257021 if( pTab->eType!=FTS5_VOCAB_COL || pCsr->iCol>=nCol ){
257044 assert( pTab->eType==FTS5_VOCAB_COL || pTab->eType==FTS5_VOCAB_ROW );
257054 switch( pTab->eType ){
257095 assert( pTab->eType==FTS5_VOCAB_INSTANCE );
257102 if( pTab->eType==FTS5_VOCAB_INSTANCE ) break;
257117 if( rc==SQLITE_OK && pCsr->bEof==0 && pTab->eType==FTS5_VOCAB_COL ){
257136 Fts5VocabTable *pTab = (Fts5VocabTable*)pCursor->pVtab;
257138 int eType = pTab->eType;