Lines Matching refs:pTab
15903 Table *pTab; /* Used when p4type is P4_TABLE */
17844 ((X)->op==TK_COLUMN && (X)->y.pTab->eTabType==TABTYP_VTAB)
18122 Bitmask colNotIdxed; /* Unindexed columns in pTab */
18203 Table *pTab; /* Source table */
18286 ** is a disk table or the "old.*" pseudo-table, then pTab points to the
18357 Table *pTab; /* TK_COLUMN: Table containing column. Can be NULL
18595 Table *pTab; /* An SQL table corresponding to zName */
19007 Table *pTab; /* Table this info block refers to */
19008 int iDb; /* Index in sqlite3.aDb[] of database holding pTab */
19578 struct Table *pTab; /* Table of generated column */
20394 SQLITE_PRIVATE int sqlite3ColumnIndex(Table *pTab, const char *zCol);
22932 Table *pTab; /* Schema object being upated */
22933 Index *pPk; /* PK index if pTab is WITHOUT ROWID */
31527 if( pItem->pTab ){
31529 pItem->pTab->zName, pItem->pTab->nCol, pItem->pTab, pItem->colUsed);
31562 if( pItem->pTab ){
31563 Table *pTab = pItem->pTab;
31564 sqlite3TreeViewColumnList(pView, pTab->aCol, pTab->nCol, 1);
31861 sqlite3TreeViewLine(pView, "{%d:%d} pTab=%p%s",
31863 pExpr->y.pTab, zFlgs);
84381 zP4 = pOp->p4.pTab->zName;
87802 Table *pTab, /* Modified table */
87810 const char *zTbl = pTab->zName;
87815 if( HasRowid(pTab)==0 ){
87817 preupdate.pPk = sqlite3PrimaryKeyIndex(pTab);
87828 assert( pCsr->nField==pTab->nCol
87829 || (pCsr->nField==pTab->nCol+1 && op==SQLITE_DELETE && iReg==-1)
87838 preupdate.keyinfo.nKeyField = pTab->nCol;
87842 preupdate.pTab = pTab;
89871 if( iIdx==p->pTab->iPKey ){
89875 }else if( p->pTab->aCol[iIdx].affinity==SQLITE_AFF_REAL ){
89967 if( iIdx==p->pTab->iPKey ){
89989 if( iIdx==p->pTab->iPKey ){
93485 Table *pTab;
93490 pTab = pOp->p4.pTab;
93491 assert( pTab->tabFlags & TF_Strict );
93492 assert( pTab->nNVCol==pOp->p2 );
93493 aCol = pTab->aCol;
93495 for(i=0; i<pTab->nCol; i++){
93557 pTab->zName, aCol[i].zCnName);
95903 Table *pTab; /* Table structure - used by update and pre-update hooks */
95928 pTab = pOp->p4.pTab;
95929 assert( (pOp->p5 & OPFLAG_ISNOOP) || HasRowid(pTab) );
95931 pTab = 0;
95937 if( pTab ){
95939 sqlite3VdbePreUpdateHook(p,pC,SQLITE_INSERT,zDb,pTab,x.nKey,pOp->p2,-1);
95941 if( db->xUpdateCallback==0 || pTab->aCol==0 ){
95943 pTab = 0;
95970 if( pTab ){
95972 assert( pTab->aCol!=0 );
95975 zDb, pTab->zName, x.nKey);
96045 Table *pTab;
96059 && HasRowid(pOp->p4.pTab)
96072 ** the name of the db to pass as to it. Also set local pTab to a copy
96073 ** of p4.pTab. Finally, if p5 is true, indicating that this cursor was
96078 assert( pOp->p4.pTab!=0 );
96080 pTab = pOp->p4.pTab;
96086 pTab = 0;
96091 assert( db->xPreUpdateCallback==0 || pTab==pOp->p4.pTab );
96092 if( db->xPreUpdateCallback && pTab ){
96094 || HasRowid(pTab)==0
96099 zDb, pTab, pC->movetoTarget,
96133 if( db->xUpdateCallback && ALWAYS(pTab!=0) && HasRowid(pTab) ){
96134 db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, pTab->zName,
99290 Table *pTab; /* Table object */
99392 Table *pTab;
99419 pTab = sqlite3LocateTable(&sParse, 0, zTable, zDb);
99420 if( pTab && IsVirtual(pTab) ){
99421 pTab = 0;
99424 if( pTab && !HasRowid(pTab) ){
99425 pTab = 0;
99429 if( pTab && IsView(pTab) ){
99430 pTab = 0;
99434 if( !pTab ){
99444 pBlob->pTab = pTab;
99445 pBlob->zDb = db->aDb[sqlite3SchemaToIndex(db, pTab->pSchema)].zDbSName;
99447 /* Now search pTab for the exact column. */
99448 for(iCol=0; iCol<pTab->nCol; iCol++) {
99449 if( sqlite3StrICmp(pTab->aCol[iCol].zCnName, zColumn)==0 ){
99453 if( iCol==pTab->nCol ){
99474 assert( IsOrdinaryTable(pTab) );
99475 for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){
99485 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
99533 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
99537 pTab->pSchema->schema_cookie,
99538 pTab->pSchema->iGeneration);
99553 aOp[0].p2 = pTab->tnum;
99555 sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT);
99561 ** parameter of the other to pTab->tnum. */
99563 aOp[1].p2 = pTab->tnum;
99574 aOp[1].p4.i = pTab->nCol+1;
99575 aOp[3].p2 = pTab->nCol;
99687 v, v->apCsr[0], SQLITE_DELETE, p->zDb, p->pTab, iKey, -1, p->iCol
102700 bytecodevtab *pTab = (bytecodevtab*)cur->pVtab;
102714 pTab->bTablesUsed,
102759 Table *pTab = (Table*)sqliteHashData(k);
102760 if( !IsVirtual(pTab) && pTab->tnum==iRoot ){
102761 pCur->zName = pTab->zName;
103841 pExTab = pExpr->y.pTab;
103873 pNew->y.pTab = pMatch->pTab;
103890 ** pExpr->y.pTab Points to the Table structure of X.Y (even if
103925 Table *pTab = 0; /* Table holding the row */
103926 Column *pCol; /* A column of pTab */
103977 pTab = pItem->pTab;
103978 assert( pTab!=0 && pTab->zName!=0 );
103979 assert( pTab->nCol>0 || pParse->nErr );
103992 assert( pEList->nExpr==pTab->nCol );
104035 if( pTab->pSchema!=pSchema ) continue;
104038 zTabName = pItem->zAlias ? pItem->zAlias : pTab->zName;
104045 sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab);
104049 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
104080 pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j;
104087 if( 0==cnt && VisibleRowid(pTab) ){
104095 pExpr->y.pTab = pMatch->pTab;
104099 pSchema = pExpr->y.pTab->pSchema;
104110 pTab = 0;
104120 pTab = pParse->pTriggerTab;
104124 pTab = pParse->pTriggerTab;
104127 pTab = pParse->pTriggerTab;
104135 pTab = pUpsert->pUpsertSrc->a[0].pTab;
104141 if( pTab ){
104144 pSchema = pTab->pSchema;
104146 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
104150 if( iCol==pTab->iPKey ){
104156 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
104160 if( iCol<pTab->nCol ){
104169 pExpr->y.pTab = pTab;
104173 sqlite3TableColumnToStorage(pTab, iCol);
104180 pExpr->y.pTab = pTab;
104184 pExpr->iTable = pNC->uNC.iBaseReg + (pTab->nCol+1)*pExpr->iTable +
104185 sqlite3TableColumnToStorage(pTab, iCol) + 1;
104217 && ALWAYS(VisibleRowid(pMatch->pTab))
104442 Table *pTab;
104444 pTab = p->y.pTab = pItem->pTab;
104446 if( p->y.pTab->iPKey==iCol ){
104450 if( (pTab->tabFlags & TF_HasGenerated)!=0
104451 && (pTab->aCol[iCol].colFlags & COLFLAG_GENERATED)!=0
104453 testcase( pTab->nCol==63 );
104454 testcase( pTab->nCol==64 );
104455 pItem->colUsed = pTab->nCol>=64 ? ALLBITS : MASKBIT(pTab->nCol)-1;
104563 pExpr->y.pTab = pItem->pTab;
104655 sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft);
105620 ** Expr.pTab Points to the Table object for X.Y
105779 Table *pTab, /* The table being referenced, or NULL */
105788 assert( type==0 || pTab!=0 );
105790 || type==NC_GenCol || pTab==0 );
105793 if( pTab ){
105795 sSrc.a[0].zName = pTab->zName;
105796 sSrc.a[0].pTab = pTab;
105798 if( pTab->pSchema!=pParse->db->aDb[1].pSchema ){
105837 SQLITE_PRIVATE char sqlite3TableColumnAffinity(const Table *pTab, int iCol){
105838 if( iCol<0 || NEVER(iCol>=pTab->nCol) ) return SQLITE_AFF_INTEGER;
105839 return pTab->aCol[iCol].affinity;
105871 assert( pExpr->y.pTab!=0 );
105872 return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
105992 assert( p->y.pTab!=0 );
105994 const char *zColl = sqlite3ColumnColl(&p->y.pTab->aCol[j]);
107479 Table *pTab;
107499 pTab = pNewItem->pTab = pOldItem->pTab;
107500 if( pTab ){
107501 pTab->nTabRef++;
108325 p->y.pTab==0 || /* Reference to column of index on expression */
108327 && p->y.pTab->aCol!=0 /* Possible due to prior error */
108328 && p->y.pTab->aCol[p->iColumn].notNull==0);
108399 Table *pTab;
108417 pTab = pSrc->a[0].pTab;
108418 assert( pTab!=0 );
108419 assert( !IsView(pTab) ); /* FROM clause is not a view */
108420 if( IsVirtual(pTab) ) return 0; /* FROM clause not a virtual table */
108592 Table *pTab; /* Table <table>. */
108593 int iDb; /* Database idx for pTab */
108600 pTab = p->pSrc->a[0].pTab;
108603 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
108606 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
108614 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
108617 "USING ROWID SEARCH ON TABLE %s FOR IN-OPERATOR",pTab->zName));
108631 char idxaff = sqlite3TableColumnAffinity(pTab,iCol); /* RHS table */
108652 for(pIdx=pTab->pIndex; pIdx && eType==0; pIdx=pIdx->pNext){
109569 Table *pTab, /* Table containing the generated column */
109582 sqlite3ExprCodeCopy(pParse, sqlite3ColumnExpr(pTab,pCol), regOut);
109595 Table *pTab, /* The table containing the value */
109602 assert( pTab!=0 );
109603 if( iCol<0 || iCol==pTab->iPKey ){
109605 VdbeComment((v, "%s.rowid", pTab->zName));
109609 if( IsVirtual(pTab) ){
109613 }else if( (pCol = &pTab->aCol[iCol])->colFlags & COLFLAG_VIRTUAL ){
109622 sqlite3ExprCodeGeneratedColumn(pParse, pTab, pCol, regOut);
109628 }else if( !HasRowid(pTab) ){
109629 testcase( iCol!=sqlite3TableColumnToStorage(pTab, iCol) );
109630 x = sqlite3TableColumnToIndex(sqlite3PrimaryKeyIndex(pTab), iCol);
109633 x = sqlite3TableColumnToStorage(pTab,iCol);
109638 sqlite3ColumnDefault(v, pTab, iCol, regOut);
109644 ** table pTab and store the column value in register iReg.
109646 ** There must be an open cursor to pTab in iTable when this routine
109651 Table *pTab, /* Description of the table we are reading from */
109658 sqlite3ExprCodeGetColumnOfTable(pParse->pVdbe, pTab, iTable, iColumn, iReg);
109947 Table *pTab = pCol->pTab;
109951 VdbeComment((v,"%s.rowid",pTab->zName));
109952 }else if( ALWAYS(pTab!=0) ){
109954 pTab->zName, pTab->aCol[pCol->iColumn].zCnName));
109955 if( pTab->aCol[pCol->iColumn].affinity==SQLITE_AFF_REAL ){
109977 assert( pExpr->y.pTab!=0 );
109978 aff = sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
109997 Table *pTab;
110001 pTab = pExpr->y.pTab;
110002 assert( pTab!=0 );
110004 assert( iCol<pTab->nCol );
110008 pCol = pTab->aCol + iCol;
110009 testcase( iCol!=sqlite3TableColumnToStorage(pTab,iCol) );
110010 iSrc = sqlite3TableColumnToStorage(pTab, iCol) - pParse->iSelfTab;
110020 sqlite3ExprCodeGeneratedColumn(pParse, pTab, pCol, iSrc);
110040 assert( pExpr->y.pTab!=0 );
110041 iReg = sqlite3ExprCodeGetColumn(pParse, pExpr->y.pTab,
110494 Table *pTab;
110499 pTab = pExpr->y.pTab;
110501 p1 = pExpr->iTable * (pTab->nCol+1) + 1
110502 + sqlite3TableColumnToStorage(pTab, iCol);
110505 assert( iCol>=-1 && iCol<pTab->nCol );
110506 assert( pTab->iPKey<0 || iCol!=pTab->iPKey );
110507 assert( p1>=0 && p1<(pTab->nCol*2+2) );
110512 (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zCnName)
110521 if( iCol>=0 && pTab->aCol[iCol].affinity==SQLITE_AFF_REAL ){
111729 /* The y.pTab=0 assignment in wherecode.c always happens after the
111734 && ALWAYS(pLeft->y.pTab!=0)
111735 && IsVirtual(pLeft->y.pTab))
111737 && ALWAYS(pRight->y.pTab!=0)
111738 && IsVirtual(pRight->y.pTab))
112107 pCol->pTab = pExpr->y.pTab;
112357 static int isAlterableTable(Parse *pParse, Table *pTab){
112358 if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7)
112360 || (pTab->tabFlags & TF_Eponymous)!=0
112361 || ( (pTab->tabFlags & TF_Shadow)!=0
112366 sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName);
112457 Table *pTab; /* Table being renamed */
112469 pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
112470 if( !pTab ) goto exit_rename_table;
112471 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
112483 || sqlite3IsShadowTableOf(db, pTab, zName)
112493 if( SQLITE_OK!=isAlterableTable(pParse, pTab) ){
112501 if( IsView(pTab) ){
112502 sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
112509 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
112515 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
112518 if( IsVirtual(pTab) ){
112519 pVTab = sqlite3GetVTable(db, pTab);
112537 zTabName = pTab->zName;
112575 zDb, zName, pTab->zName);
112641 Table *pTab; /* Table being altered */
112665 pTab = sqlite3FindTable(db, zTab, zDb);
112666 assert( pTab );
112670 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
112741 assert( IsOrdinaryTable(pTab) );
112806 Table *pTab;
112816 pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
112817 if( !pTab ) goto exit_begin_add_column;
112820 if( IsVirtual(pTab) ){
112827 if( IsView(pTab) ){
112831 if( SQLITE_OK!=isAlterableTable(pParse, pTab) ){
112836 assert( IsOrdinaryTable(pTab) );
112837 assert( pTab->u.tab.addColOffset>0 );
112838 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
112851 pNew->nCol = pTab->nCol;
112856 pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
112861 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
112868 pNew->u.tab.pDfltList = sqlite3ExprListDup(db, pTab->u.tab.pDfltList, 0);
112870 pNew->u.tab.addColOffset = pTab->u.tab.addColOffset;
112879 ** Parameter pTab is the subject of an ALTER TABLE ... RENAME COLUMN
112884 ** Or, if pTab is not a view or virtual table, zero is returned.
112887 static int isRealTable(Parse *pParse, Table *pTab, int bDrop){
112890 if( IsView(pTab) ){
112895 if( IsVirtual(pTab) ){
112902 zType, pTab->zName
112924 Table *pTab; /* Table being updated */
112933 pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
112934 if( !pTab ) goto exit_rename_column;
112937 if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_rename_column;
112938 if( SQLITE_OK!=isRealTable(pParse, pTab, 0) ) goto exit_rename_column;
112941 iSchema = sqlite3SchemaToIndex(db, pTab->pSchema);
112947 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
112956 for(iCol=0; iCol<pTab->nCol; iCol++){
112957 if( 0==sqlite3StrICmp(pTab->aCol[iCol].zCnName, zOld) ) break;
112959 if( iCol==pTab->nCol ){
112983 zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1,
112984 pTab->zName
112991 zDb, pTab->zName, iCol, zNew, bQuote
113037 Table *pTab; /* Table being ALTERed */
113139 sqlite3RenameTokenRemap(pParse, 0, (const void*)&pExpr->y.pTab);
113338 && pWalker->pParse->pTriggerTab==p->pTab
113344 && p->pTab==pExpr->y.pTab
113807 Table *pTab;
113818 pTab = sqlite3FindTable(db, zTable, zDb);
113819 if( pTab==0 || iCol>=pTab->nCol ){
113823 zOld = pTab->aCol[iCol].zCnName;
113825 sCtx.iCol = ((iCol==pTab->iPKey) ? -1 : iCol);
113839 sCtx.pTab = pTab;
113856 sCtx.pTab = sParse.pNewTable;
113908 if( pTarget==pTab ){
113921 if( sParse.pTriggerTab==pTab ){
113958 && p->pTab==pExpr->y.pTab
113960 renameTokenFind(pWalker->pParse, p, (void*)&pExpr->y.pTab);
113983 if( pItem->pTab==p->pTab ){
114040 sCtx.pTab = sqlite3FindTable(db, zOld, zDb);
114052 Table *pTab = sParse.pNewTable;
114054 if( IsView(pTab) ){
114056 Select *pSelect = pTab->u.view.pSelect;
114063 sqlite3SelectPrep(&sParse, pTab->u.view.pSelect, &sNC);
114067 sqlite3WalkSelect(&sWalker, pTab->u.view.pSelect);
114074 && !IsVirtual(pTab)
114077 assert( IsOrdinaryTable(pTab) );
114078 for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){
114089 if( sqlite3_stricmp(zOld, pTab->zName)==0 ){
114090 sCtx.pTab = pTab;
114092 sqlite3WalkExprList(&sWalker, pTab->pCheck);
114094 renameTokenFind(&sParse, &sCtx, pTab->zName);
114111 && sCtx.pTab->pSchema==pTrigger->pTabSchema
114399 Table *pTab;
114411 pTab = sParse.pNewTable;
114412 if( pTab==0 || pTab->nCol==1 || iCol>=pTab->nCol ){
114418 pCol = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol].zCnName);
114419 if( iCol<pTab->nCol-1 ){
114421 pEnd = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol+1].zCnName);
114424 assert( IsOrdinaryTable(pTab) );
114425 zEnd = (const char*)&zSql[pTab->u.tab.addColOffset];
114453 Table *pTab; /* Table to modify */
114454 int iDb; /* Index of db containing pTab in aDb[] */
114455 const char *zDb; /* Database containing pTab ("main" etc.) */
114457 int iCol; /* Index of column zCol in pTab->aCol[] */
114463 pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
114464 if( !pTab ) goto exit_drop_column;
114468 if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_drop_column;
114469 if( SQLITE_OK!=isRealTable(pParse, pTab, 1) ) goto exit_drop_column;
114477 iCol = sqlite3ColumnIndex(pTab, zCol);
114485 if( pTab->aCol[iCol].colFlags & (COLFLAG_PRIMKEY|COLFLAG_UNIQUE) ){
114487 (pTab->aCol[iCol].colFlags&COLFLAG_PRIMKEY) ? "PRIMARY KEY" : "UNIQUE",
114494 if( pTab->nCol<=1 ){
114500 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
114505 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, zCol) ){
114515 , zDb, iDb, iCol, pTab->zName
114523 if( pParse->nErr==0 && (pTab->aCol[iCol].colFlags & COLFLAG_VIRTUAL)==0 ){
114533 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite);
114536 if( HasRowid(pTab) ){
114538 pParse->nMem += pTab->nCol;
114540 pPk = sqlite3PrimaryKeyIndex(pTab);
114548 for(i=0; i<pTab->nCol; i++){
114549 if( i!=iCol && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ){
114559 if( i==pTab->iPKey ){
114562 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, i, regOut);
115578 Table *pTab, /* Table whose indices are to be analyzed */
115591 int iDb; /* Index of database containing pTab */
115609 if( v==0 || NEVER(pTab==0) ){
115612 if( !IsOrdinaryTable(pTab) ){
115616 if( sqlite3_strlike("sqlite\\_%", pTab->zName, '\\')==0 ){
115621 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
115625 if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,
115647 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
115651 sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
115652 sqlite3VdbeLoadString(v, regTabname, pTab->zName);
115654 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
115663 if( !HasRowid(pTab) && IsPrimaryKeyIndex(pIdx) ){
115665 zIdxName = pTab->zName;
115675 VdbeComment((v, "Analysis for %s.%s", pTab->zName, zIdxName));
115825 if( HasRowid(pTab) ){
115883 u8 seekOp = HasRowid(pTab) ? OP_NotExists : OP_NotFound;
115917 VdbeComment((v, "%s", pTab->zName));
115964 Table *pTab = (Table*)sqliteHashData(k);
115965 analyzeOneTable(pParse, pTab, 0, iStatCur, iMem, iTab);
115973 ** in pTab that should be analyzed.
115975 static void analyzeTable(Parse *pParse, Table *pTab, Index *pOnlyIdx){
115979 assert( pTab!=0 );
115981 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
115988 openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
115990 analyzeOneTable(pParse, pTab, pOnlyIdx, iStatCur,pParse->nMem+1,pParse->nTab);
116011 Table *pTab;
116042 }else if( (pTab = sqlite3LocateTable(pParse, 0, z, zDb))!=0 ){
116043 analyzeTable(pParse, pTab, 0);
116296 Table *pTab = sqlite3FindTable(db, zName, zDb);
116297 if( pTab && !HasRowid(pTab) ) pIdx = sqlite3PrimaryKeyIndex(pTab);
116487 Table *pTab = sqliteHashData(i);
116488 pTab->tabFlags &= ~TF_HasStat1;
117332 Table *pTab = 0; /* The table being read */
117349 pTab = pParse->pTriggerTab;
117354 pTab = pTabList->a[iSrc].pTab;
117360 if( pTab==0 ) return;
117363 assert( iCol<pTab->nCol );
117364 zCol = pTab->aCol[iCol].zCnName;
117365 }else if( pTab->iPKey>=0 ){
117366 assert( pTab->iPKey<pTab->nCol );
117367 zCol = pTab->aCol[pTab->iPKey].zCnName;
117372 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
118156 Table *pTab, /* The table containing the column */
118161 assert( IsOrdinaryTable(pTab) );
118162 pList = pTab->u.tab.pDfltList;
118168 pTab->u.tab.pDfltList = sqlite3ExprListAppend(pParse, pList, pExpr);
118180 SQLITE_PRIVATE Expr *sqlite3ColumnExpr(Table *pTab, Column *pCol){
118182 if( NEVER(!IsOrdinaryTable(pTab)) ) return 0;
118183 if( NEVER(pTab->u.tab.pDfltList==0) ) return 0;
118184 if( NEVER(pTab->u.tab.pDfltList->nExpr<pCol->iDflt) ) return 0;
118185 return pTab->u.tab.pDfltList->a[pCol->iDflt-1].pExpr;
118553 SQLITE_PRIVATE Index *sqlite3PrimaryKeyIndex(Table *pTab){
118555 for(p=pTab->pIndex; p && !IsPrimaryKeyIndex(p); p=p->pNext){}
118585 SQLITE_PRIVATE i16 sqlite3StorageColumnToTable(Table *pTab, i16 iCol){
118586 if( pTab->tabFlags & TF_HasVirtual ){
118589 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) iCol++;
118629 ** this routine is a no-op macro. If the pTab does not have any virtual
118633 SQLITE_PRIVATE i16 sqlite3TableColumnToStorage(Table *pTab, i16 iCol){
118636 assert( iCol<pTab->nCol );
118637 if( (pTab->tabFlags & TF_HasVirtual)==0 || iCol<0 ) return iCol;
118639 if( (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) n++;
118641 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ){
118643 return pTab->nNVCol + i - n;
118875 SQLITE_PRIVATE void sqlite3ColumnPropertiesFromName(Table *pTab, Column *pCol){
118878 if( pTab ) pTab->tabFlags |= TF_HasHidden;
118879 }else if( pTab && pCol!=pTab->aCol && (pCol[-1].colFlags & COLFLAG_HIDDEN) ){
118880 pTab->tabFlags |= TF_OOOHidden;
119311 Table *pTab = pParse->pNewTable;
119315 if( pTab==0 ) goto primary_key_exit;
119316 if( pTab->tabFlags & TF_HasPrimaryKey ){
119318 "table \"%s\" has more than one primary key", pTab->zName);
119321 pTab->tabFlags |= TF_HasPrimaryKey;
119323 iCol = pTab->nCol - 1;
119324 pCol = &pTab->aCol[iCol];
119337 for(iCol=0; iCol<pTab->nCol; iCol++){
119338 if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zCnName)==0 ){
119339 pCol = &pTab->aCol[iCol];
119354 sqlite3RenameTokenRemap(pParse, &pTab->iPKey, pCExpr);
119356 pTab->iPKey = iCol;
119357 pTab->keyConf = (u8)onError;
119359 pTab->tabFlags |= autoInc*TF_Autoincrement;
119388 Table *pTab = pParse->pNewTable;
119390 if( pTab && !IN_DECLARE_VTAB
119393 pTab->pCheck = sqlite3ExprListAppend(pParse, pTab->pCheck, pCheckExpr);
119395 sqlite3ExprListSetName(pParse, pTab->pCheck, &pParse->constraintName, 1);
119402 sqlite3ExprListSetName(pParse, pTab->pCheck, &t, 1);
119451 Table *pTab = pParse->pNewTable;
119453 if( pTab==0 ){
119457 pCol = &(pTab->aCol[pTab->nCol-1]);
119472 if( eType==COLFLAG_VIRTUAL ) pTab->nNVCol--;
119476 pTab->tabFlags |= eType;
119480 sqlite3ColumnSetExpr(pParse, pTab, pCol, pExpr);
119676 static void estimateTableWidth(Table *pTab){
119680 for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){
119683 if( pTab->iPKey<0 ) wTable++;
119684 pTab->szTabRow = sqlite3LogEst(wTable*4);
119771 Table *pTab = pIdx->pTable;
119774 if( x>=0 && (pTab->aCol[x].colFlags & COLFLAG_VIRTUAL)==0 ){
119808 static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
119820 for(i=0; i<pTab->nCol; i++){
119821 if( (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0
119822 && (pTab->aCol[i].notNull==OE_None)
119824 pTab->aCol[i].notNull = OE_Abort;
119827 pTab->tabFlags |= TF_HasNotNull;
119842 if( pTab->iPKey>=0 ){
119845 sqlite3TokenInit(&ipkToken, pTab->aCol[pTab->iPKey].zCnName);
119849 pTab->tabFlags &= ~TF_WithoutRowid;
119853 sqlite3RenameTokenRemap(pParse, pList->a[0].pExpr, &pTab->iPKey);
119856 assert( pParse->pNewTable==pTab );
119857 pTab->iPKey = -1;
119858 sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0,
119861 pTab->tabFlags &= ~TF_WithoutRowid;
119865 pPk = sqlite3PrimaryKeyIndex(pTab);
119868 pPk = sqlite3PrimaryKeyIndex(pTab);
119903 pPk->tnum = pTab->tnum;
119908 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
119942 for(i=0; i<pTab->nCol; i++){
119944 && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) nExtra++;
119947 for(i=0, j=nPk; i<pTab->nCol; i++){
119949 && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0
119958 assert( pTab->nNVCol<=j );
119965 ** Return true if pTab is a virtual table and zName is a shadow table name
119968 SQLITE_PRIVATE int sqlite3IsShadowTableOf(sqlite3 *db, Table *pTab, const char *zName){
119972 if( !IsVirtual(pTab) ) return 0;
119973 nName = sqlite3Strlen30(pTab->zName);
119974 if( sqlite3_strnicmp(zName, pTab->zName, nName)!=0 ) return 0;
119976 pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->u.vtab.azArg[0]);
119986 ** Table pTab is a virtual table. If it the virtual table implementation
119988 ** tables within the same schema looking for shadow tables of pTab, and mark
119991 SQLITE_PRIVATE void sqlite3MarkAllShadowTablesOf(sqlite3 *db, Table *pTab){
119992 int nName; /* Length of pTab->zName */
119996 assert( IsVirtual(pTab) );
119997 pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->u.vtab.azArg[0]);
120002 assert( pTab->zName!=0 );
120003 nName = sqlite3Strlen30(pTab->zName);
120004 for(k=sqliteHashFirst(&pTab->pSchema->tblHash); k; k=sqliteHashNext(k)){
120009 if( sqlite3StrNICmp(pOther->zName, pTab->zName, nName)==0
120029 Table *pTab; /* Table that zName is a shadow of */
120033 pTab = sqlite3FindTable(db, zName, 0);
120035 if( pTab==0 ) return 0;
120036 if( !IsVirtual(pTab) ) return 0;
120037 return sqlite3IsShadowTableOf(db, pTab, zName);
120662 Table *pTab = sqliteHashData(i);
120663 if( IsView(pTab) ){
120664 sqlite3DeleteColumnNames(db, pTab);
120700 Table *pTab = sqliteHashData(pElem);
120701 if( pTab->tnum==iFrom ){
120702 pTab->tnum = iTo;
120746 ** Write VDBE code to erase table pTab and all associated indices on disk.
120751 static void destroyTable(Parse *pParse, Table *pTab){
120768 Pgno iTab = pTab->tnum;
120778 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
120780 assert( pIdx->pSchema==pTab->pSchema );
120788 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
120823 SQLITE_PRIVATE void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){
120834 if( IsVirtual(pTab) ){
120843 pTrigger = sqlite3TriggerList(pParse, pTab);
120845 assert( pTrigger->pSchema==pTab->pSchema ||
120857 if( pTab->tabFlags & TF_Autoincrement ){
120860 pDb->zDbSName, pTab->zName
120875 pDb->zDbSName, pTab->zName);
120876 if( !isView && !IsVirtual(pTab) ){
120877 destroyTable(pParse, pTab);
120883 if( IsVirtual(pTab) ){
120884 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
120887 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
120912 static int tableMayNotBeDropped(sqlite3 *db, Table *pTab){
120913 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
120914 if( sqlite3StrNICmp(pTab->zName+7, "stat", 4)==0 ) return 0;
120915 if( sqlite3StrNICmp(pTab->zName+7, "parameters", 10)==0 ) return 0;
120918 if( (pTab->tabFlags & TF_Shadow)!=0 && sqlite3ReadOnlyShadowTables(db) ){
120921 if( pTab->tabFlags & TF_Eponymous ){
120932 Table *pTab;
120945 pTab = sqlite3LocateTableItem(pParse, isView, &pName->a[0]);
120948 if( pTab==0 ){
120955 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
120958 /* If pTab is a virtual table, call ViewGetColumnNames() to ensure
120961 if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){
120980 }else if( IsVirtual(pTab) ){
120982 zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
120991 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
120994 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
120999 if( tableMayNotBeDropped(db, pTab) ){
121000 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
121008 if( isView && !IsView(pTab) ){
121009 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
121012 if( !isView && IsView(pTab) ){
121013 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
121025 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
121026 sqlite3FkDropTable(pParse, pName, pTab);
121028 sqlite3CodeDropTable(pParse, pTab, iDb, isView);
121185 Table *pTab;
121187 if( (pTab = pParse->pNewTable)==0 ) return;
121188 if( NEVER(!IsOrdinaryTable(pTab)) ) return;
121189 if( (pFKey = pTab->u.tab.pFKey)==0 ) return;
121207 Table *pTab = pIndex->pTable; /* The table that is indexed */
121208 int iTab = pParse->nTab++; /* Btree cursor used for pTab */
121229 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
121248 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
121386 Table *pTab = 0; /* Table to be indexed */
121438 pTab = sqlite3SrcListLookup(pParse, pTblName);
121439 if( pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){
121451 pTab = sqlite3LocateTableItem(pParse, 0, &pTblName->a[0]);
121452 assert( db->mallocFailed==0 || pTab==0 );
121453 if( pTab==0 ) goto exit_create_index;
121454 if( iDb==1 && db->aDb[iDb].pSchema!=pTab->pSchema ){
121457 pTab->zName);
121460 if( !HasRowid(pTab) ) pPk = sqlite3PrimaryKeyIndex(pTab);
121464 pTab = pParse->pNewTable;
121465 if( !pTab ) goto exit_create_index;
121466 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
121470 assert( pTab!=0 );
121471 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
121475 && sqlite3UserAuthTable(pTab->zName)==0
121478 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
121482 if( IsView(pTab) ){
121488 if( IsVirtual(pTab) ){
121511 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName,"index",pTab->zName) ){
121535 for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
121536 zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
121559 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
121571 Column *pCol = &pTab->aCol[pTab->nCol-1];
121612 pIndex->pTable = pTab;
121619 sqlite3ResolveSelfReference(pParse, pTab, NC_PartIdx, pPIWhere, 0);
121653 sqlite3ResolveSelfReference(pParse, pTab, NC_IdxExpr, pListItem->pExpr, 0);
121657 if( pTab==pParse->pNewTable ){
121674 j = pTab->iPKey;
121676 if( pTab->aCol[j].notNull==0 ){
121679 if( pTab->aCol[j].colFlags & COLFLAG_VIRTUAL ){
121698 zColl = sqlite3ColumnColl(&pTab->aCol[j]);
121737 assert( HasRowid(pTab)
121738 || pTab->iPKey<0 || sqlite3TableColumnToIndex(pIndex, pTab->iPKey)>=0 );
121740 if( pTblName!=0 && pIndex->nColumn>=pTab->nCol ){
121742 for(j=0; j<pTab->nCol; j++){
121743 if( j==pTab->iPKey ) continue;
121750 if( pTab==pParse->pNewTable ){
121773 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
121858 else if( HasRowid(pTab) || pTblName!=0 ){
121899 pTab->zName,
121920 pIndex->pNext = pTab->pIndex;
121921 pTab->pIndex = pIndex;
121933 if( pTab ){
121934 /* Ensure all REPLACE indexes on pTab are at the end of the pIndex list.
121940 for(ppFrom=&pTab->pIndex; (pThis = *ppFrom)!=0; ppFrom=&pThis->pNext){
121955 for(pThis = pTab->pIndex; pThis; pThis=pThis->pNext){
122064 Table *pTab = pIndex->pTable;
122071 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
122388 sqlite3DeleteTable(db, pItem->pTab);
122817 Table *pTab = pIdx->pTable;
122827 zCol = pTab->aCol[pIdx->aiColumn[j]].zCnName;
122829 sqlite3_str_appendall(&errMsg, pTab->zName);
122848 Table *pTab /* The table with the non-unique rowid */
122852 if( pTab->iPKey>=0 ){
122853 zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
122854 pTab->aCol[pTab->iPKey].zCnName);
122857 zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
122884 ** Recompute all indices of pTab that use the collating sequence pColl.
122885 ** If pColl==0 then recompute all indices of pTab.
122888 static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){
122889 if( !IsVirtual(pTab) ){
122890 Index *pIndex; /* An index associated with pTab */
122892 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
122894 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
122914 Table *pTab; /* A table in the database */
122920 pTab = (Table*)sqliteHashData(k);
122921 reindexTable(pParse, pTab, zColl);
122945 Table *pTab; /* A table in the database */
122946 Index *pIndex; /* An index associated with pTab */
122978 pTab = sqlite3FindTable(db, z, zDb);
122979 if( pTab ){
122980 reindexTable(pParse, pTab, 0);
123661 Table *pTab = sqliteHashData(pElem);
123662 sqlite3DeleteTable(&xdb, pTab);
123724 ** pSrc->a[0].pTab Pointer to the Table object
123730 Table *pTab;
123732 pTab = sqlite3LocateTableItem(pParse, 0, pItem);
123733 sqlite3DeleteTable(pParse->db, pItem->pTab);
123734 pItem->pTab = pTab;
123735 if( pTab ){
123736 pTab->nTabRef++;
123738 pTab = 0;
123741 return pTab;
123754 /* Return true if table pTab is read-only.
123773 static int vtabIsReadOnly(Parse *pParse, Table *pTab){
123774 if( sqlite3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0 ){
123785 && pTab->u.vtab.p->eVtabRisk >
123789 pTab->zName);
123793 static int tabIsReadOnly(Parse *pParse, Table *pTab){
123795 if( IsVirtual(pTab) ){
123796 return vtabIsReadOnly(pParse, pTab);
123798 if( (pTab->tabFlags & (TF_Readonly|TF_Shadow))==0 ) return 0;
123800 if( (pTab->tabFlags & TF_Readonly)!=0 ){
123803 assert( pTab->tabFlags & TF_Shadow );
123810 ** If pTab is not writable -> generate an error message and return 1.
123811 ** If pTab is writable but other errors have occurred -> return 1.
123812 ** If pTab is writable and no prior errors -> return 0;
123814 SQLITE_PRIVATE int sqlite3IsReadOnly(Parse *pParse, Table *pTab, int viewOk){
123815 if( tabIsReadOnly(pParse, pTab) ){
123816 sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
123820 if( !viewOk && IsView(pTab) ){
123821 sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
123888 Table *pTab;
123915 pTab = pSrc->a[0].pTab;
123916 if( HasRowid(pTab) ){
123922 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
123924 const char *zName = pTab->aCol[pPk->aiColumn[0]].zCnName;
123930 Expr *p = sqlite3Expr(db, TK_ID, pTab->aCol[pPk->aiColumn[i]].zCnName);
123942 pSrc->a[0].pTab = 0;
123944 pSrc->a[0].pTab = pTab;
123982 Table *pTab; /* The table from which records will be deleted */
124031 pTab = sqlite3SrcListLookup(pParse, pTabList);
124032 if( pTab==0 ) goto delete_from_cleanup;
124038 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
124039 isView = IsView(pTab);
124044 bComplex = pTrigger || sqlite3FkRequired(pParse, pTab, 0, 0);
124068 /* If pTab is really a view, make sure it has been initialized.
124070 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
124074 if( sqlite3IsReadOnly(pParse, pTab, (pTrigger?1:0)) ){
124077 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
124079 rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0,
124091 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
124098 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
124115 sqlite3MaterializeView(pParse, pTab,
124160 && !IsVirtual(pTab)
124166 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
124167 if( HasRowid(pTab) ){
124168 sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt ? memCnt : -1,
124169 pTab->zName, P4_STATIC);
124171 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
124172 assert( pIdx->pSchema==pTab->pSchema );
124173 if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
124185 if( HasRowid(pTab) ){
124194 pPk = sqlite3PrimaryKeyIndex(pTab);
124215 assert( IsVirtual(pTab)==0 || eOnePass!=ONEPASS_MULTI );
124216 assert( IsVirtual(pTab) || bComplex || eOnePass!=ONEPASS_OFF );
124231 sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur,
124237 sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur, -1, iKey);
124282 testcase( IsVirtual(pTab) );
124283 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, OPFLAG_FORDELETE,
124285 assert( pPk || IsVirtual(pTab) || iDataCur==iTabCur );
124286 assert( pPk || IsVirtual(pTab) || iIdxCur==iDataCur+1 );
124297 if( !IsVirtual(pTab) && aToOpen[iDataCur-iTabCur] ){
124298 assert( pPk!=0 || IsView(pTab) );
124304 if( IsVirtual(pTab) ){
124318 if( IsVirtual(pTab) ){
124319 const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
124320 sqlite3VtabMakeWritable(pParse, pTab);
124335 sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
124401 ** 2. Read/write cursors for all indices of pTab must be open as
124432 Table *pTab, /* Table containing the row to be deleted */
124457 opSeek = HasRowid(pTab) ? OP_NotExists : OP_NotFound;
124466 if( sqlite3FkRequired(pParse, pTab, 0, 0) || pTrigger ){
124474 pParse, pTrigger, 0, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onconf
124476 mask |= sqlite3FkOldmask(pParse, pTab);
124478 pParse->nMem += (1 + pTab->nCol);
124483 for(iCol=0; iCol<pTab->nCol; iCol++){
124487 int kk = sqlite3TableColumnToStorage(pTab, iCol);
124488 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, iCol, iOld+kk+1);
124495 TK_DELETE, 0, TRIGGER_BEFORE, pTab, iOld, onconf, iLabel
124517 sqlite3FkCheck(pParse, pTab, iOld, 0, 0, 0);
124520 /* Delete the index and table entries. Skip this step if pTab is really
124526 ** be invoked unless table pTab is a system table. The difference is that
124530 if( !IsView(pTab) ){
124532 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,iIdxNoSeek);
124534 if( pParse->nested==0 || 0==sqlite3_stricmp(pTab->zName, "sqlite_stat1") ){
124535 sqlite3VdbeAppendP4(v, (char*)pTab, P4_TABLE);
124550 sqlite3FkActions(pParse, pTab, 0, iOld, 0, 0);
124554 TK_DELETE, 0, TRIGGER_AFTER, pTab, iOld, onconf, iLabel
124566 ** index entries associated with a single row of a single table, pTab
124571 ** btree for the table pTab. (This will be either the table itself
124575 ** 2. Read/write cursors for all indices of pTab must be open as
124576 ** cursor number iIdxCur+i for the i-th index. (The pTab->pIndex
124584 Table *pTab, /* Table containing the row to be deleted */
124599 pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
124600 for(i=0, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
124618 ** regOut. The key with be for index pIdx which is an index on pTab.
124619 ** iCur is the index of a cursor open on the pTab table and pointing to
124620 ** the entry that needs indexing. If pTab is a WITHOUT ROWID table, then
127446 int iDb, /* Index of database housing pTab */
127447 Table *pTab, /* Parent table of FK pFKey */
127448 Index *pIdx, /* Unique index on parent key columns in pTab */
127453 int isIgnore /* If true, pretend pTab contains all NULL values */
127485 ** column of the parent table (table pTab). */
127503 if( pTab==pFKey->pFrom && nIncr==1 ){
127508 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);
127536 if( pTab==pFKey->pFrom && nIncr==1 ){
127545 assert( aiCol[i]!=pTab->iPKey );
127546 if( pIdx->aiColumn[i]==pTab->iPKey ){
127589 ** to column iCol of table pTab.
127592 ** for pTab. regBase itself holds the rowid. regBase+1 holds the first
127597 Table *pTab, /* The table whose content is at r[regBase]... */
127598 int regBase, /* Contents of table pTab */
127599 i16 iCol /* Which column of pTab is desired */
127608 if( iCol>=0 && iCol!=pTab->iPKey ){
127609 pCol = &pTab->aCol[iCol];
127610 pExpr->iTable = regBase + sqlite3TableColumnToStorage(pTab,iCol) + 1;
127624 ** Return an Expr object that refers to column iCol of table pTab which
127629 Table *pTab, /* The table whose column is desired */
127636 pExpr->y.pTab = pTab;
127674 Table *pTab, /* The parent table */
127676 FKey *pFKey, /* The foreign key linking pSrc to pTab */
127689 assert( pIdx==0 || pIdx->pTable==pTab );
127692 assert( pIdx!=0 || HasRowid(pTab) );
127715 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
127738 if( pTab==pFKey->pFrom && nIncr>0 ){
127742 if( HasRowid(pTab) ){
127743 pLeft = exprTableRegister(pParse, pTab, regData, -1);
127744 pRight = exprTableColumn(db, pTab, pSrc->a[0].iCursor, -1);
127752 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
127753 pRight = sqlite3Expr(db, TK_ID, pTab->aCol[iCol].zCnName);
127788 ** FKey.pNextTo) holding all children of table pTab. For example,
127800 SQLITE_PRIVATE FKey *sqlite3FkReferences(Table *pTab){
127801 return (FKey *)sqlite3HashFind(&pTab->pSchema->fkeyHash, pTab->zName);
127832 Table *pTab = sqliteHashData(k);
127834 if( !IsOrdinaryTable(pTab) ) continue;
127835 for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){
127843 ** This function is called to generate code that runs when table pTab is
127846 ** table pTab.
127859 SQLITE_PRIVATE void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTab){
127861 if( (db->flags&SQLITE_ForeignKeys) && IsOrdinaryTable(pTab) ){
127866 assert( IsOrdinaryTable(pTab) );
127867 if( sqlite3FkReferences(pTab)==0 ){
127874 for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){
127912 ** for which pTab is the child table. An UPDATE statement against pTab
127923 Table *pTab, /* Table being updated */
127924 FKey *p, /* Foreign key for which pTab is the child */
127932 if( iChildKey==pTab->iPKey && bChngRowid ) return 1;
127939 ** for which pTab is the parent table. An UPDATE statement against pTab
127950 Table *pTab,
127959 for(iKey=0; iKey<pTab->nCol; iKey++){
127960 if( aChange[iKey]>=0 || (iKey==pTab->iPKey && bChngRowid) ){
127961 Column *pCol = &pTab->aCol[iKey];
127993 ** table pTab to generate VDBE code to perform foreign key constraint
127997 ** first register in an array of (pTab->nCol+1) registers containing the
128003 ** first register of an array of (pTab->nCol+1) registers containing the new
128013 Table *pTab, /* Row is being deleted from this table */
128021 int iDb; /* Index of database containing pTab */
128022 const char *zDb; /* Name of database containing pTab */
128030 if( !IsOrdinaryTable(pTab) ) return;
128032 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
128035 /* Loop through all the foreign key constraints for which pTab is the
128037 for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){
128047 && sqlite3_stricmp(pTab->zName, pFKey->zTo)!=0
128048 && fkChildIsModified(pTab, pFKey, aChange, bChngRowid)==0
128094 if( aiCol[i]==pTab->iPKey ){
128140 for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){
128145 if( aChange && fkParentIsModified(pTab, pFKey, aChange, bChngRowid)==0 ){
128158 if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ){
128169 pItem->pTab = pFKey->pFrom;
128171 pItem->pTab->nTabRef++;
128175 fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regNew, -1);
128179 fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regOld, 1);
128212 ** row contained in table pTab.
128216 Table *pTab /* Table being modified */
128219 if( pParse->db->flags&SQLITE_ForeignKeys && IsOrdinaryTable(pTab) ){
128222 for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){
128225 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
128227 sqlite3FkLocateIndex(pParse, pTab, p, &pIdx, 0);
128242 ** row contained in table pTab. If the operation is a DELETE, then
128244 ** to an array of size N, where N is the number of columns in table pTab.
128256 ** * There are any FKs for which pTab is the child and the parent table
128266 Table *pTab, /* Table being modified */
128272 if( pParse->db->flags&SQLITE_ForeignKeys && IsOrdinaryTable(pTab) ){
128277 bHaveFK = (sqlite3FkReferences(pTab) || pTab->u.tab.pFKey);
128284 for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){
128285 if( fkChildIsModified(pTab, p, aChange, chngRowid) ){
128286 if( 0==sqlite3_stricmp(pTab->zName, p->zTo) ) eRet = 2;
128292 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
128293 if( fkParentIsModified(pTab, p, aChange, chngRowid) ){
128305 ** compiled on table pTab, which is the parent table of foreign-key pFKey.
128316 ** For example, if pFKey is the foreign key and pTab is table "p" in
128334 Table *pTab, /* Table being updated or deleted from */
128361 if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ) return 0;
128374 assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKey<pTab->nCol) );
128377 pTab->aCol[pIdx ? pIdx->aiColumn[i] : pTab->iPKey].zCnName);
128443 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
128516 pTrigger->pSchema = pTab->pSchema;
128517 pTrigger->pTabSchema = pTab->pSchema;
128531 Table *pTab, /* Table being updated or deleted from */
128538 ** refer to table pTab. If there is an action associated with the FK
128543 for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){
128544 if( aChange==0 || fkParentIsModified(pTab, pFKey, aChange, bChngRowid) ){
128545 Trigger *pAct = fkActionTrigger(pParse, pTab, pFKey, pChanges);
128547 sqlite3CodeRowTriggerDirect(pParse, pAct, pTab, regOld, OE_Abort, 0);
128558 ** table pTab. Remove the deleted foreign keys from the Schema.fkeyHash
128561 SQLITE_PRIVATE void sqlite3FkDelete(sqlite3 *db, Table *pTab){
128565 assert( IsOrdinaryTable(pTab) );
128567 for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pNext){
128568 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pTab->pSchema) );
128577 sqlite3HashInsert(&pTab->pSchema->fkeyHash, z, p);
128622 ** (1) acquire a lock for table pTab then
128623 ** (2) open pTab as cursor iCur.
128625 ** If pTab is a WITHOUT ROWID table, then it is the PRIMARY KEY index
128632 Table *pTab, /* The table to be opened */
128636 assert( !IsVirtual(pTab) );
128640 sqlite3TableLock(pParse, iDb, pTab->tnum,
128641 (opcode==OP_OpenWrite)?1:0, pTab->zName);
128642 if( HasRowid(pTab) ){
128643 sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nNVCol);
128644 VdbeComment((v, "%s", pTab->zName));
128646 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
128648 assert( pPk->tnum==pTab->tnum || CORRUPT_DB );
128651 VdbeComment((v, "%s", pTab->zName));
128686 Table *pTab = pIdx->pTable;
128696 aff = pTab->aCol[x].affinity;
128720 SQLITE_PRIVATE char *sqlite3TableAffinityStr(sqlite3 *db, const Table *pTab){
128722 zColAff = (char *)sqlite3DbMallocRaw(db, pTab->nCol+1);
128725 for(i=j=0; i<pTab->nCol; i++){
128726 if( (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ){
128727 zColAff[j++] = pTab->aCol[i].affinity;
128739 ** of values that are about to be gathered into a row for table pTab.
128744 ** Compute the affinity string for table pTab, if it has not already been
128769 ** datatypes against the column definitions in pTab. If iReg==0, that
128777 SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){
128780 if( pTab->tabFlags & TF_Strict ){
128786 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
128794 sqlite3VdbeAddOp2(v, OP_TypeCheck, iReg, pTab->nNVCol);
128795 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
128799 zColAff = pTab->zColAff;
128801 zColAff = sqlite3TableAffinityStr(0, pTab);
128806 pTab->zColAff = zColAff;
128822 ** Return non-zero if the table pTab in database iDb or any of its indices
128824 ** a statement of the form "INSERT INTO <iDb, pTab> SELECT ..." can
128827 static int readsTable(Parse *p, int iDb, Table *pTab){
128832 VTable *pVTab = IsVirtual(pTab) ? sqlite3GetVTable(p->db, pTab) : 0;
128841 if( tnum==pTab->tnum ){
128844 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
128866 assert( pExpr->iColumn < pWalker->u.pTab->nCol );
128867 pWalker->eCode |= pWalker->u.pTab->aCol[pExpr->iColumn].colFlags;
128874 ** All regular columns for table pTab have been puts into registers
128883 Table *pTab /* The table */
128891 assert( pTab->tabFlags & TF_HasGenerated );
128892 testcase( pTab->tabFlags & TF_HasVirtual );
128893 testcase( pTab->tabFlags & TF_HasStored );
128898 sqlite3TableAffinity(pParse->pVdbe, pTab, iRegStore);
128899 if( (pTab->tabFlags & TF_HasStored)!=0 ){
128910 if( pTab->aCol[ii].colFlags & COLFLAG_VIRTUAL ){
128913 if( pTab->aCol[ii].colFlags & COLFLAG_STORED ){
128930 for(i=0; i<pTab->nCol; i++){
128931 if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){
128932 testcase( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL );
128933 testcase( pTab->aCol[i].colFlags & COLFLAG_STORED );
128934 pTab->aCol[i].colFlags |= COLFLAG_NOTAVAIL;
128938 w.u.pTab = pTab;
128952 for(i=0; i<pTab->nCol; i++){
128953 Column *pCol = pTab->aCol + i;
128958 sqlite3WalkExpr(&w, sqlite3ColumnExpr(pTab, pCol));
128966 x = sqlite3TableColumnToStorage(pTab, i) + iRegStore;
128967 sqlite3ExprCodeGeneratedColumn(pParse, pTab, pCol, x);
128982 ** Locate or create an AutoincInfo structure associated with table pTab
128984 ** that holds the maximum rowid. Return zero if pTab is not an AUTOINCREMENT
128991 ** first use of table pTab. On 2nd and subsequent uses, the original
128996 ** (1) The name of the pTab table.
128997 ** (2) The maximum ROWID of pTab.
128998 ** (3) The rowid in sqlite_sequence of pTab
128999 ** (4) The original value of the max ROWID in pTab, or NULL if none
129006 int iDb, /* Index of the database holding pTab */
129007 Table *pTab /* The table we are writing to */
129011 if( (pTab->tabFlags & TF_Autoincrement)!=0
129032 while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; }
129040 pInfo->pTab = pTab;
129089 sqlite3VdbeLoadString(v, memId-1, p->pTab->zName);
129294 Table *pTab; /* The table to insert into. aka TABLE */
129327 Trigger *pTrigger; /* List of triggers on pTab, if required */
129353 pTab = sqlite3SrcListLookup(pParse, pTabList);
129354 if( pTab==0 ){
129357 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
129359 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0,
129363 withoutRowid = !HasRowid(pTab);
129369 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0, &tmask);
129370 isView = IsView(pTab);
129390 /* If pTab is really a view, make sure it has been initialized.
129391 ** ViewGetColumnNames() is a no-op if pTab is not a view.
129393 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
129399 if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
129423 && xferOptimization(pParse, pTab, pSelect, onError, iDb)
129434 regAutoinc = autoIncBegin(pParse, iDb, pTab);
129440 pParse->nMem += pTab->nCol + 1;
129441 if( IsVirtual(pTab) ){
129456 ** PRIMARY KEY in the original table is pTab->iPKey.) After this
129466 bIdListInOrder = (pTab->tabFlags & (TF_OOOHidden|TF_HasStored))==0;
129474 for(j=0; j<pTab->nCol; j++){
129475 if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zCnName)==0 ){
129478 if( j==pTab->iPKey ){
129482 if( pTab->aCol[j].colFlags & (COLFLAG_STORED|COLFLAG_VIRTUAL) ){
129485 pTab->aCol[j].zCnName);
129492 if( j>=pTab->nCol ){
129523 dest.nSdst = pTab->nCol;
129543 if( pTrigger || readsTable(pParse, iDb, pTab) ){
129599 ipkColumn = pTab->iPKey;
129601 if( ipkColumn>=0 && (pTab->tabFlags & TF_HasGenerated)!=0 ){
129602 testcase( pTab->tabFlags & TF_HasVirtual );
129603 testcase( pTab->tabFlags & TF_HasStored );
129605 if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){
129606 testcase( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL );
129607 testcase( pTab->aCol[i].colFlags & COLFLAG_STORED );
129620 if( (pTab->tabFlags & (TF_HasGenerated|TF_HasHidden))!=0 ){
129621 for(i=0; i<pTab->nCol; i++){
129622 if( pTab->aCol[i].colFlags & COLFLAG_NOINSERT ) nHidden++;
129625 if( nColumn!=(pTab->nCol-nHidden) ){
129628 pTabList->a, pTab->nCol-nHidden, nColumn);
129651 nIdx = sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, -1, 0,
129657 for(i=0, pIdx=pTab->pIndex; i<nIdx; pIdx=pIdx->pNext, i++){
129667 if( IsVirtual(pTab) ){
129669 pTab->zName);
129672 if( IsView(pTab) ){
129719 sqlite3VdbeReleaseRegisters(pParse, regData, pTab->nCol, 0, 0);
129739 for(i=0; i<pTab->nCol; i++, iRegStore++){
129743 if( i==pTab->iPKey ){
129751 if( ((colFlags = pTab->aCol[i].colFlags) & COLFLAG_NOINSERT)!=0 ){
129772 sqlite3ColumnExpr(pTab, &pTab->aCol[i]),
129784 sqlite3ColumnExpr(pTab, &pTab->aCol[i]),
129792 sqlite3ColumnExpr(pTab, &pTab->aCol[i]),
129820 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
129846 assert( pTab->nNVCol>0 );
129847 sqlite3VdbeAddOp3(v, OP_Copy, regRowid+1, regCols+1, pTab->nNVCol-1);
129854 if( pTab->tabFlags & TF_HasGenerated ){
129855 testcase( pTab->tabFlags & TF_HasVirtual );
129856 testcase( pTab->tabFlags & TF_HasStored );
129857 sqlite3ComputeGeneratedColumns(pParse, regCols+1, pTab);
129867 sqlite3TableAffinity(v, pTab, regCols+1);
129872 pTab, regCols-pTab->nCol-1, onError, endOfLoop);
129874 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
129878 if( IsVirtual(pTab) ){
129890 if( pIpk->op==TK_NULL && !IsVirtual(pTab) ){
129902 if( !IsVirtual(pTab) ){
129912 }else if( IsVirtual(pTab) || withoutRowid ){
129925 if( pTab->tabFlags & TF_HasGenerated ){
129926 sqlite3ComputeGeneratedColumns(pParse, regRowid+1, pTab);
129934 if( IsVirtual(pTab) ){
129935 const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
129936 sqlite3VtabMakeWritable(pParse, pTab);
129937 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
129945 sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
129949 sqlite3FkCheck(pParse, pTab, 0, regIns, 0, 0);
129961 sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur,
129983 pTab, regData-2-pTab->nCol, onError, endOfLoop);
130179 ** on table pTab.
130183 ** pTab->nCol+1 registers in this range. The first register (the one
130210 ** at pTab->pIndex.
130213 ** main table, if pTab is a rowid table, and stores that record in the
130225 ** for the first index in the pTab->pIndex list. Cursors for other indices
130226 ** are at iIdxCur+N for the N-th element of the pTab->pIndex list.
130270 Table *pTab, /* The table being inserted or updated */
130305 Trigger *pTrigger; /* List of DELETE triggers on the table pTab */
130313 assert( !IsView(pTab) ); /* This table is not a VIEW */
130314 nCol = pTab->nCol;
130320 if( HasRowid(pTab) ){
130324 pPk = sqlite3PrimaryKeyIndex(pTab);
130334 if( pTab->tabFlags & TF_HasNotNull ){
130341 Column *pCol = &pTab->aCol[i]; /* The column to check for NOT NULL */
130345 if( i==pTab->iPKey ){
130378 testcase( i!=sqlite3TableColumnToStorage(pTab, i) );
130379 iReg = sqlite3TableColumnToStorage(pTab, i) + regNewData + 1;
130387 sqlite3ColumnExpr(pTab, pCol), iReg);
130396 char *zMsg = sqlite3MPrintf(db, "%s.%s", pTab->zName,
130422 if( nSeenReplace>0 && (pTab->tabFlags & TF_HasGenerated)!=0 ){
130427 sqlite3ComputeGeneratedColumns(pParse, regNewData+1, pTab);
130436 if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){
130437 ExprList *pCheck = pTab->pCheck;
130452 sqlite3TableAffinity(v, pTab, regNewData+1);
130509 sIdxIter.u.lx.pIdx = pTab->pIndex;
130523 }else if( pTab->pIndex!=0 ){
130531 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
130545 pIdx = pTab->pIndex;
130556 for(jj=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, jj++){
130578 ** (2) Initialize pTrigger to the list of all DELETE triggers on pTab.
130593 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
130594 regTrigCnt = pTrigger!=0 || sqlite3FkRequired(pParse, pTab, 0, 0);
130597 regTrigCnt = sqlite3FkRequired(pParse, pTab, 0, 0);
130617 onError = pTab->keyConf;
130649 && pTab->pIndex /* There exist other constraints */
130683 sqlite3RowidConstraint(pParse, onError, pTab);
130711 sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
130717 assert( HasRowid(pTab) );
130723 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
130725 if( pTab->pIndex ){
130727 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,-1);
130735 sqlite3UpsertDoUpdate(pParse, pUpsert, pTab, 0, iDataCur);
130780 sqlite3TableAffinity(v, pTab, regNewData+1);
130808 }else if( iField==XN_ROWID || iField==pTab->iPKey ){
130813 testcase( sqlite3TableColumnToStorage(pTab, iField)!=iField );
130814 x = sqlite3TableColumnToStorage(pTab, iField) + regNewData + 1;
130816 VdbeComment((v, "%s", pTab->aCol[iField].zCnName));
130868 assert( IsOrdinaryTable(pTab) );
130874 0==sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0))
130876 (0==pTab->u.tab.pFKey && 0==sqlite3FkReferences(pTab)))
130892 if( HasRowid(pTab) ){
130910 VdbeComment((v, "%s.%s", pTab->zName,
130911 pTab->aCol[pPk->aiColumn[i]].zCnName));
130934 x = sqlite3TableColumnToStorage(pTab, x);
130961 sqlite3UpsertDoUpdate(pParse, pUpsert, pTab, pIdx, iIdxCur+ix);
130985 sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
131076 sqlite3RowidConstraint(pParse, OE_Abort, pTab);
131084 if( HasRowid(pTab) ){
131086 sqlite3VdbeAddOp3(v, OP_MakeRecord, regNewData+1, pTab->nNVCol, regRec);
131087 sqlite3SetMakeRecordP5(v, pTab);
131089 sqlite3TableAffinity(v, pTab, 0);
131100 ** to be the number of columns in table pTab that must not be NULL-trimmed.
131102 ** Or if no columns of pTab may be NULL-trimmed, leave P5 at zero.
131104 SQLITE_PRIVATE void sqlite3SetMakeRecordP5(Vdbe *v, Table *pTab){
131109 if( pTab->pSchema->file_format<2 ) return;
131111 for(i=pTab->nCol-1; i>0; i--){
131112 if( pTab->aCol[i].iDflt!=0 ) break;
131113 if( pTab->aCol[i].colFlags & COLFLAG_PRIMKEY ) break;
131120 ** Table pTab is a WITHOUT ROWID table that is being written to. The cursor
131128 Table *pTab, /* Table being updated */
131134 assert( !HasRowid(pTab) );
131137 sqlite3VdbeAddOp4(v, OP_Insert, iCur, regData, r, (char*)pTab, P4_TABLE);
131156 Table *pTab, /* the table into which we are inserting */
131177 assert( !IsView(pTab) ); /* This table is not a VIEW */
131178 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
131189 if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
131193 codeWithoutRowidPreupdate(pParse, pTab, iIdxCur+i, aRegIdx[i]);
131201 if( !HasRowid(pTab) ) return;
131216 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
131222 ** Allocate cursors for the pTab table and all its indices and generate
131237 ** pTab->pIndex list.
131239 ** If pTab is a virtual table, then this routine is a no-op and the
131244 Table *pTab, /* Table to be opened */
131260 if( IsVirtual(pTab) ){
131267 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
131273 if( HasRowid(pTab) && (aToOpen==0 || aToOpen[0]) ){
131274 sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op);
131276 sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
131279 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
131281 assert( pIdx->pSchema==pTab->pSchema );
131282 if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
135420 Table *pTab;
135422 pTab = sqlite3LocateTable(pParse, LOCATE_NOERR, zRight, zDb);
135423 if( pTab ){
135427 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
135429 sqlite3ViewGetColumnNames(pParse, pTab);
135430 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
135451 for(k=1; k<=pTab->nCol && pPk->aiColumn[k-1]!=i; k++){}
135453 pColExpr = sqlite3ColumnExpr(pTab,pCol);
135502 Table *pTab;
135504 pTab = sqliteHashData(k);
135505 if( pTab->nCol==0 ){
135506 char *zSql = sqlite3MPrintf(db, "SELECT*FROM\"%w\"", pTab->zName);
135524 Table *pTab = sqliteHashData(k);
135526 if( zRight && sqlite3_stricmp(zRight, pTab->zName)!=0 ) continue;
135527 if( IsView(pTab) ){
135529 }else if( IsVirtual(pTab) ){
135531 }else if( pTab->tabFlags & TF_Shadow ){
135538 sqlite3PreferredTableName(pTab->zName),
135540 pTab->nCol,
135541 (pTab->tabFlags & TF_WithoutRowid)!=0,
135542 (pTab->tabFlags & TF_Strict)!=0
135556 Table *pTab = sqliteHashData(i);
135558 sqlite3PreferredTableName(pTab->zName),
135560 pTab->szTabRow,
135561 pTab->nRowLogEst,
135562 pTab->tabFlags);
135563 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
135578 Table *pTab;
135584 pTab = sqlite3LocateTable(pParse, LOCATE_NOERR, zRight, zDb);
135585 if( pTab && !HasRowid(pTab) ){
135586 pIdx = sqlite3PrimaryKeyIndex(pTab);
135602 pTab = pIdx->pTable;
135608 cnum<0 ? 0 : pTab->aCol[cnum].zCnName);
135623 Table *pTab;
135625 pTab = sqlite3FindTable(db, zRight, zDb);
135626 if( pTab ){
135627 int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
135630 for(pIdx=pTab->pIndex, i=0; pIdx; pIdx=pIdx->pNext, i++){
135715 Table *pTab;
135716 pTab = sqlite3FindTable(db, zRight, zDb);
135717 if( pTab && IsOrdinaryTable(pTab) ){
135718 pFK = pTab->u.tab.pFKey;
135720 int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
135731 pTab->aCol[pFK->aCol[j].iFrom].zCnName,
135750 Table *pTab; /* Child table contain "REFERENCES" keyword */
135753 int i; /* Loop counter: Foreign key number for pTab */
135758 int regRow; /* Registers to hold a row from pTab */
135769 pTab = sqlite3LocateTable(pParse, 0, zRight, zDb);
135772 pTab = (Table*)sqliteHashData(k);
135775 if( pTab==0 || !IsOrdinaryTable(pTab) || pTab->u.tab.pFKey==0 ) continue;
135776 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
135779 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
135780 if( pTab->nCol+regRow>pParse->nMem ) pParse->nMem = pTab->nCol + regRow;
135781 sqlite3OpenTable(pParse, 0, iDb, pTab, OP_OpenRead);
135782 sqlite3VdbeLoadString(v, regResult, pTab->zName);
135783 assert( IsOrdinaryTable(pTab) );
135784 for(i=1, pFK=pTab->u.tab.pFKey; pFK; i++, pFK=pFK->pNextFrom){
135806 assert( IsOrdinaryTable(pTab) );
135807 for(i=1, pFK=pTab->u.tab.pFKey; pFK; i++, pFK=pFK->pNextFrom){
135824 sqlite3ExprCodeGetColumnOfTable(v, pTab, 0, iCol, regRow+j);
135843 if( HasRowid(pTab) ){
135959 Table *pTab = sqliteHashData(x); /* Current table */
135960 Index *pIdx; /* An index on pTab */
135961 int nIdx; /* Number of indexes on pTab */
135962 if( pObjTab && pObjTab!=pTab ) continue;
135963 if( HasRowid(pTab) ) cnt++;
135964 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){ cnt++; }
135974 Table *pTab = sqliteHashData(x);
135976 if( pObjTab && pObjTab!=pTab ) continue;
135977 if( HasRowid(pTab) ) aRoot[++cnt] = pTab->tnum;
135978 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
136002 Table *pTab = sqliteHashData(x);
136012 if( !IsOrdinaryTable(pTab) ) continue;
136013 if( pObjTab && pObjTab!=pTab ) continue;
136014 if( isQuick || HasRowid(pTab) ){
136018 pPk = sqlite3PrimaryKeyIndex(pTab);
136022 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenRead, 0,
136028 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
136041 mxCol = pTab->nCol-1;
136043 && ((pTab->aCol[mxCol].colFlags & COLFLAG_VIRTUAL)!=0
136044 || pTab->iPKey==mxCol) ) mxCol--;
136046 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, mxCol, 3);
136060 pTab->zName);
136079 bStrict = (pTab->tabFlags & TF_Strict)!=0;
136080 for(j=0; j<pTab->nCol; j++){
136082 Column *pCol = pTab->aCol + j; /* The column to be checked */
136088 if( j==pTab->iPKey ) continue;
136099 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, j, 3);
136105 sqlite3ValueFromExpr(db, sqlite3ColumnExpr(pTab,pCol), ENC(db),
136113 if( !HasRowid(pTab) ){
136114 testcase( j!=sqlite3TableColumnToStorage(pTab, j) );
136115 p3 = sqlite3TableColumnToIndex(sqlite3PrimaryKeyIndex(pTab), j);
136117 p3 = sqlite3TableColumnToStorage(pTab,j);
136129 zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName,
136155 pTab->zName, pTab->aCol[j].zCnName);
136164 pTab->zName, pTab->aCol[j].zCnName);
136173 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, j, 3);
136180 pTab->zName, pTab->aCol[j].zCnName);
136188 if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){
136189 ExprList *pCheck = sqlite3ExprListDup(db, pTab->pCheck, 0);
136204 pTab->zName);
136213 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
136241 assert( iCol!=XN_ROWID && iCol<pTab->nCol );
136242 if( iCol>=0 && pTab->aCol[iCol].notNull ) continue;
136263 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
136585 Table *pTab; /* A table in the schema */
136603 pTab = (Table*)sqliteHashData(k);
136605 /* If table pTab has not been used in a way that would benefit from
136608 if( (pTab->tabFlags & TF_StatsUsed)==0 ) continue;
136611 szThreshold = pTab->nRowLogEst + 46; assert( sqlite3LogEst(25)==46 );
136612 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
136619 sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
136625 db->aDb[iDb].zDbSName, pTab->zName);
136861 PragmaVtab *pTab = 0;
136894 pTab = (PragmaVtab*)sqlite3_malloc(sizeof(PragmaVtab));
136895 if( pTab==0 ){
136898 memset(pTab, 0, sizeof(PragmaVtab));
136899 pTab->pName = pPragma;
136900 pTab->db = db;
136901 pTab->iHidden = i;
136902 pTab->nHidden = j;
136908 *ppVtab = (sqlite3_vtab*)pTab;
136916 PragmaVtab *pTab = (PragmaVtab*)pVtab;
136917 sqlite3_free(pTab);
136929 PragmaVtab *pTab = (PragmaVtab*)tab;
136935 if( pTab->nHidden==0 ){ return SQLITE_OK; }
136942 if( pConstraint->iColumn < pTab->iHidden ) continue;
136943 j = pConstraint->iColumn - pTab->iHidden;
137019 PragmaVtab *pTab = (PragmaVtab*)(pVtabCursor->pVtab);
137028 j = (pTab->pName->mPragFlg & PragFlg_Result1)!=0 ? 0 : 1;
137040 sqlite3StrAccumInit(&acc, 0, 0, 0, pTab->db->aLimit[SQLITE_LIMIT_SQL_LENGTH]);
137045 sqlite3_str_appendall(&acc, pTab->pName->zName);
137051 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pPragma, 0);
137054 pTab->base.zErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(pTab->db));
137077 PragmaVtab *pTab = (PragmaVtab*)(pVtabCursor->pVtab);
137078 if( i<pTab->iHidden ){
137081 sqlite3_result_text(ctx, pCsr->azArg[i-pTab->iHidden],-1,SQLITE_TRANSIENT);
138272 Table *pTab; /* Table definition */
138274 int nKey; /* Number of PK columns for table pTab (>=1) */
138523 SQLITE_PRIVATE int sqlite3ColumnIndex(Table *pTab, const char *zCol){
138527 for(pCol=pTab->aCol, i=0; i<pTab->nCol; pCol++, i++){
138565 int *piCol, /* Write index of pSrc->a[*piTab].pTab->aCol[] here */
138576 iCol = sqlite3ColumnIndex(pSrc->a[i].pTab, zCol);
138578 && (bIgnoreHidden==0 || IsHiddenColumn(&pSrc->a[i].pTab->aCol[iCol])==0)
138706 Table *pRightTab = pRight->pTab;
138709 if( NEVER(pLeft->pTab==0 || pRightTab==0) ) continue;
139242 Table *pTab;
139246 && (pTab = pExpr->y.pTab)!=0
139247 && IsOrdinaryTable(pTab)
139248 && (pTab->aCol[pExpr->iColumn].colFlags & COLFLAG_SORTERREF)!=0
139261 if( !HasRowid(pTab) ){
139262 pPk = sqlite3PrimaryKeyIndex(pTab);
139270 pNew->y.pTab = pExpr->y.pTab;
139275 pSort->aDefer[nDefer].pTab = pExpr->y.pTab;
139899 Table *pTab = pSort->aDefer[i].pTab;
139900 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
139901 sqlite3OpenTable(pParse, pSort->aDefer[i].iCsr, iDb, pTab, OP_OpenRead);
139971 Table *pTab = pSort->aDefer[i].pTab;
139975 if( HasRowid(pTab) ){
139982 assert( sqlite3PrimaryKeyIndex(pTab)->nKeyCol==nKey );
140130 Table *pTab = 0; /* Table structure column is extracted from */
140132 int iCol = pExpr->iColumn; /* Index of column in pTab */
140133 while( pNC && !pTab ){
140137 pTab = pTabList->a[j].pTab;
140144 if( pTab==0 ){
140165 assert( pTab && ExprUseYTab(pExpr) && pExpr->y.pTab==pTab );
140193 if( iCol<0 ) iCol = pTab->iPKey;
140194 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
140199 zOrigCol = pTab->aCol[iCol].zCnName;
140200 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
140202 zOrigTab = pTab->zName;
140203 if( pNC->pParse && pTab->pSchema ){
140204 int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
140208 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
140212 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
140327 Table *pTab;
140359 || (ExprUseYTab(p) && p->y.pTab!=0) ); /* Covering idx not yet coded */
140367 pTab = p->y.pTab;
140368 assert( pTab!=0 );
140369 if( iCol<0 ) iCol = pTab->iPKey;
140370 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
140374 zCol = pTab->aCol[iCol].zCnName;
140378 zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol);
140428 Table *pTab;
140459 && ALWAYS( pColExpr->y.pTab!=0 )
140463 pTab = pColExpr->y.pTab;
140464 if( iCol<0 ) iCol = pTab->iPKey;
140465 zName = iCol>=0 ? pTab->aCol[iCol].zCnName : "rowid";
140532 Table *pTab, /* Add column type information to this table */
140546 assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed );
140551 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
140554 pTab->tabFlags |= (pCol->colFlags & COLFLAG_NOINSERT);
140574 assert( pTab->pIndex==0 );
140578 pTab->szTabRow = 1; /* Any non-zero value works */
140586 Table *pTab;
140597 pTab = sqlite3DbMallocZero(db, sizeof(Table) );
140598 if( pTab==0 ){
140601 pTab->nTabRef = 1;
140602 pTab->zName = 0;
140603 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
140604 sqlite3ColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
140605 sqlite3SelectAddColumnTypeAndCollation(pParse, pTab, pSelect, aff);
140606 pTab->iPKey = -1;
140608 sqlite3DeleteTable(db, pTab);
140611 return pTab;
142184 if( NEVER(pSrcItem->pTab==0) ) return;
142560 || IsVirtual(pSubSrc->a[0].pTab) /* (3b) */
142706 Table *pItemTab = pSubitem->pTab;
142707 pSubitem->pTab = 0;
142715 pSubitem->pTab = pItemTab;
142740 ** complete, since there may still exist Expr.pTab entries that
142743 ** pSubitem->pTab is always non-NULL by test restrictions and tests above.
142745 if( ALWAYS(pSubitem->pTab!=0) ){
142746 Table *pTabToDel = pSubitem->pTab;
142756 pSubitem->pTab = 0;
143460 Table *pTab;
143474 pTab = p->pSrc->a[0].pTab;
143475 assert( pTab!=0 );
143476 assert( !IsView(pTab) );
143477 if( !IsOrdinaryTable(pTab) ) return 0;
143488 return pTab;
143499 Table *pTab = pFrom->pTab;
143502 assert( pTab!=0 );
143505 for(pIdx=pTab->pIndex;
143687 ** If pFrom matches a CTE according to either of these two above, pFrom->pTab
143702 assert( pFrom->pTab==0 );
143728 Table *pTab;
143748 assert( pFrom->pTab==0 );
143749 pTab = sqlite3DbMallocZero(db, sizeof(Table));
143750 if( pTab==0 ) return 2;
143757 sqlite3DbFree(db, pTab);
143762 pFrom->pTab = pTab;
143763 pTab->nTabRef = 1;
143764 pTab->zName = sqlite3DbStrDup(db, pCte->zName);
143765 pTab->iPKey = -1;
143766 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
143767 pTab->tabFlags |= TF_Ephemeral | TF_NoVisibleRowid;
143796 pItem->pTab = pTab;
143797 pTab->nTabRef++;
143852 sqlite3ColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
143893 ** allocates and populates the SrcItem.pTab object. If successful,
143899 Table *pTab;
143902 pFrom->pTab = pTab = sqlite3DbMallocZero(pParse->db, sizeof(Table));
143903 if( pTab==0 ) return SQLITE_NOMEM;
143904 pTab->nTabRef = 1;
143906 pTab->zName = sqlite3DbStrDup(pParse->db, pFrom->zAlias);
143908 pTab->zName = sqlite3MPrintf(pParse->db, "%!S", pFrom);
143911 sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol);
143912 pTab->iPKey = -1;
143913 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
143916 pTab->tabFlags |= TF_Ephemeral | TF_NoVisibleRowid;
143918 pTab->tabFlags |= TF_Ephemeral; /* Legacy compatibility mode */
143956 ** (2) Fill in the pTabList->a[].pTab fields in the SrcList that
144019 Table *pTab;
144020 assert( pFrom->fg.isRecursive==0 || pFrom->pTab!=0 );
144021 if( pFrom->pTab ) continue;
144028 assert( pFrom->pTab==0 );
144035 pTab = pFrom->pTab;
144036 assert( pTab!=0 );
144040 assert( pFrom->pTab==0 );
144041 pFrom->pTab = pTab = sqlite3LocateTableItem(pParse, 0, pFrom);
144042 if( pTab==0 ) return WRC_Abort;
144043 if( pTab->nTabRef>=0xffff ){
144045 pTab->zName);
144046 pFrom->pTab = 0;
144049 pTab->nTabRef++;
144050 if( !IsVirtual(pTab) && cannotBeFunction(pParse, pFrom) ){
144054 if( !IsOrdinaryTable(pTab) ){
144057 if( sqlite3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort;
144059 if( IsView(pTab) ){
144061 && pTab->pSchema!=db->aDb[1].pSchema
144064 pTab->zName);
144066 pFrom->pSelect = sqlite3SelectDup(db, pTab->u.view.pSelect, 0);
144069 else if( ALWAYS(IsVirtual(pTab))
144071 && ALWAYS(pTab->u.vtab.p!=0)
144072 && pTab->u.vtab.p->eVtabRisk > ((db->flags & SQLITE_TrustedSchema)!=0)
144075 pTab->zName);
144079 nCol = pTab->nCol;
144080 pTab->nCol = -1;
144084 pTab->nCol = nCol;
144161 Table *pTab = pFrom->pTab; /* Table for this data source */
144169 zTabName = pTab->zName;
144177 assert( pNestedFrom->nExpr==pTab->nCol );
144183 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
144207 for(j=0; j<pTab->nCol; j++){
144208 char *zName = pTab->aCol[j].zCnName;
144224 && IsHiddenColumn(&pTab->aCol[j])
144228 if( (pTab->aCol[j].colFlags & COLFLAG_NOEXPAND)!=0
144286 || (pTab->aCol[j].colFlags & COLFLAG_NOEXPAND)!=0
144394 Table *pTab = pFrom->pTab;
144395 assert( pTab!=0 );
144396 if( (pTab->tabFlags & TF_Ephemeral)!=0 ){
144401 sqlite3SelectAddColumnTypeAndCollation(pParse, pTab, pSel,
144633 ** count(*) query ("SELECT count(*) FROM pTab").
144638 Table *pTab, /* Table being queried */
144642 int bCover = (pIdx!=0 && (HasRowid(pTab) || !IsPrimaryKeyIndex(pIdx)));
144644 pTab->zName,
144741 assert( pItem->pTab!=0 );
144742 assert( pThis->pTab!=0 );
144743 if( pItem->pTab->pSchema!=pThis->pTab->pSchema ) continue;
144746 if( pItem->pTab->pSchema==0 && pThis->pSelect->selId!=pS1->selId ){
144869 if( p0->pTab==p1->pTab && 0==sqlite3_stricmp(p0->zAlias, p1->zAlias) ){
144989 p0->zAlias ? p0->zAlias : p0->pTab->zName
145029 Table *pTab = pItem->pTab;
145034 assert( pTab!=0 );
145056 if( pTab->nCol!=pSub->pEList->nExpr ){
145058 pTab->nCol, pTab->zName, pSub->pEList->nExpr);
145296 pItem->pTab->nRowLogEst = pSub->nSelectRow;
145344 dest.zAffSdst = sqlite3TableAffinityStr(db, pItem->pTab);
145348 pItem->pTab->nRowLogEst = pSub->nSelectRow;
145691 "agg-column[%d] pTab=%s iTable=%d iColumn=%d iMem=%d"
145693 ii, pCol->pTab ? pCol->pTab->zName : "NULL",
145962 Table *pTab;
145963 if( (pTab = isSimpleCount(p, pAggInfo))!=0 ){
145977 const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
145982 Pgno iRoot = pTab->tnum; /* Root page of scanned b-tree */
145985 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
145996 if( !HasRowid(pTab) ) pBest = sqlite3PrimaryKeyIndex(pTab);
145998 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
146000 && pIdx->szIdxRow<pTab->szTabRow
146020 explainSimpleCount(pParse, pTab, pBest);
146399 ** Given table pTab, return a list of all the triggers attached to
146402 ** All of the triggers on pTab that are in the same database as pTab
146403 ** are already attached to pTab->pTrigger. But there might be additional
146404 ** triggers on pTab in the TEMP schema. This routine prepends all
146405 ** TEMP triggers on pTab to the beginning of the pTab->pTrigger list
146409 ** that fire off of pTab. The list will include any TEMP triggers on
146410 ** pTab as well as the triggers lised in pTab->pTrigger.
146412 SQLITE_PRIVATE Trigger *sqlite3TriggerList(Parse *pParse, Table *pTab){
146413 Schema *pTmpSchema; /* Schema of the pTab table */
146420 pList = pTab->pTrigger;
146423 if( pTrig->pTabSchema==pTab->pSchema
146425 && 0==sqlite3StrICmp(pTrig->table, pTab->zName)
146436 pTrig->table = pTab->zName;
146437 pTrig->pTabSchema = pTab->pSchema;
146446 printf("Triggers for %s:", pTab->zName);
146478 Table *pTab; /* Table that the trigger fires off of */
146526 pTab = sqlite3SrcListLookup(pParse, pTableName);
146527 if( db->init.busy==0 && pName2->n==0 && pTab
146528 && pTab->pSchema==db->aDb[1].pSchema ){
146539 pTab = sqlite3SrcListLookup(pParse, pTableName);
146540 if( !pTab ){
146544 if( IsVirtual(pTab) ){
146556 if( sqlite3CheckObjectName(pParse, zName, "trigger", pTab->zName) ){
146573 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
146581 if( IsView(pTab) && tr_tm!=TK_INSTEAD ){
146586 if( !IsView(pTab) && tr_tm==TK_INSTEAD ){
146594 int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
146599 if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
146624 pTrigger->pTabSchema = pTab->pSchema;
146759 Table *pTab;
146760 pTab = sqlite3HashFind(&pLink->pTabSchema->tblHash, pLink->table);
146761 assert( pTab!=0 );
146762 pLink->pNext = pTab->pTrigger;
146763 pTab->pTrigger = pLink;
147075 Table *pTab = tableOfTrigger(pTrigger);
147076 if( pTab ){
147078 for(pp=&pTab->pTrigger; *pp; pp=&((*pp)->pNext)){
147119 ** Return a list of all triggers on table pTab if there exists at least
147126 Table *pTab, /* The table the contains the triggers */
147135 pList = sqlite3TriggerList(pParse, pTab);
147136 assert( pList==0 || IsVirtual(pTab)==0
147141 && pTab->pTrigger!=0
147146 if( pList==pTab->pTrigger ){
147150 while( ALWAYS(p->pNext) && p->pNext!=pTab->pTrigger ) p = p->pNext;
147162 if( IsVirtual(pTab) ){
147189 Table *pTab, /* The table the contains the triggers */
147194 assert( pTab!=0 );
147195 if( (pTab->pTrigger==0 && !tempTriggersExist(pParse->db))
147201 return triggersReallyExist(pParse,pTab,op,pChanges,pMask);
147268 ** clause. The table that we are returning from is pTab.
147271 ** any "*" wildcards to be the complete set of columns from pTab.
147276 Table *pTab /* The table being updated */
147287 for(jj=0; jj<pTab->nCol; jj++){
147289 if( IsHiddenColumn(pTab->aCol+jj) ) continue;
147290 pNewExpr = sqlite3Expr(db, TK_ID, pTab->aCol[jj].zCnName);
147294 pItem->zEName = sqlite3DbStrDup(db, pTab->aCol[jj].zCnName);
147319 Table *pTab, /* The table to code triggers from */
147339 sFrom.a[0].pTab = pTab;
147347 pNew = sqlite3ExpandReturning(pParse, pReturning->pReturnEL, pTab);
147359 pParse->pTriggerTab = pTab;
147515 Table *pTab, /* The table pTrigger is attached to */
147528 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
147551 sSubParse.pTriggerTab = pTab;
147566 pTab->zName
147629 Table *pTab, /* The table trigger pTrigger is attached to */
147635 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
147648 pPrg = codeRowTrigger(pParse, pTrigger, pTab, orconf);
147657 ** table pTab. The reg, orconf and ignoreJump parameters passed to this
147664 Table *pTab, /* The table to code triggers from */
147671 pPrg = getRowTrigger(pParse, p, pTab, orconf);
147695 ** on table pTab. The operation to code triggers for (INSERT, UPDATE or DELETE)
147701 ** operation on pTab, this function is a no-op.
147705 ** in the trigger program. If N is the number of columns in table pTab
147706 ** (a copy of pTab->nCol), then registers are populated as follows:
147711 ** reg+1 OLD.* value of left-most column of pTab
147713 ** reg+N OLD.* value of right-most column of pTab
147715 ** reg+N+2 NEW.* value of left-most column of pTab
147717 ** reg+N+N+1 NEW.* value of right-most column of pTab
147735 Trigger *pTrigger, /* List of triggers on table pTab */
147739 Table *pTab, /* The table to code triggers from */
147770 sqlite3CodeRowTriggerDirect(pParse, p, pTab, reg, orconf, ignoreJump);
147772 codeReturningTrigger(pParse, p, pTab, reg);
147805 Trigger *pTrigger, /* List of triggers on table pTab */
147809 Table *pTab, /* The table to code triggers from */
147826 pPrg = getRowTrigger(pParse, p, pTab, orconf);
147862 Table *pTab, /* The virtual table */
147865 int *aXRef, /* Mapping from columns of pTab to entries in pChanges */
147873 ** i-th column of table pTab. This routine sets the P4 parameter of the
147901 SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){
147903 assert( pTab!=0 );
147904 assert( pTab->nCol>i );
147905 pCol = &pTab->aCol[i];
147909 assert( !IsView(pTab) );
147910 VdbeComment((v, "%s.%s", pTab->zName, pCol->zCnName));
147911 assert( i<pTab->nCol );
147913 sqlite3ColumnExpr(pTab,pCol), enc,
147920 if( pCol->affinity==SQLITE_AFF_REAL && !IsVirtual(pTab) ){
147999 ** Or, if pLimit and pOrderBy are not NULL, and pTab is not a view:
148006 ** If pTab is a view, the GROUP BY clause is omitted.
148010 ** of table pTabList->a[0].pTab.
148045 Table *pTab = pTabList->a[0].pTab;
148069 pSrc->a[0].pTab->nTabRef--;
148070 pSrc->a[0].pTab = 0;
148082 eDest = IsVirtual(pTab) ? SRT_Table : SRT_Upfrom;
148083 }else if( IsView(pTab) ){
148084 for(i=0; i<pTab->nCol; i++){
148089 eDest = IsVirtual(pTab) ? SRT_Table : SRT_Upfrom;
148135 Table *pTab; /* The table to be updated */
148168 Trigger *pTrigger; /* List of triggers on pTab, if required */
148201 pTab = sqlite3SrcListLookup(pParse, pTabList);
148202 if( pTab==0 ) goto update_cleanup;
148203 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
148209 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask);
148210 isView = IsView(pTab);
148247 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
148250 if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
148261 pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
148262 testcase( pPk!=0 && pPk!=pTab->pIndex );
148263 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
148280 aXRef = sqlite3DbMallocRawNN(db, sizeof(int) * (pTab->nCol+nIdx+1) + nIdx+2 );
148282 aRegIdx = aXRef+pTab->nCol;
148286 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
148313 for(j=0; j<pTab->nCol; j++){
148314 if( pTab->aCol[j].hName==hCol
148315 && sqlite3StrICmp(pTab->aCol[j].zCnName, pChanges->a[i].zEName)==0
148317 if( j==pTab->iPKey ){
148321 }else if( pPk && (pTab->aCol[j].colFlags & COLFLAG_PRIMKEY)!=0 ){
148325 else if( pTab->aCol[j].colFlags & COLFLAG_GENERATED ){
148326 testcase( pTab->aCol[j].colFlags & COLFLAG_VIRTUAL );
148327 testcase( pTab->aCol[j].colFlags & COLFLAG_STORED );
148330 pTab->aCol[j].zCnName);
148338 if( j>=pTab->nCol ){
148353 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
148354 j<0 ? "ROWID" : pTab->aCol[j].zCnName,
148377 if( pTab->tabFlags & TF_HasGenerated ){
148379 testcase( pTab->tabFlags & TF_HasVirtual );
148380 testcase( pTab->tabFlags & TF_HasStored );
148383 for(i=0; i<pTab->nCol; i++){
148385 if( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)==0 ) continue;
148387 sqlite3ColumnExpr(pTab, &pTab->aCol[i]),
148403 pTabList->a[0].colUsed = IsVirtual(pTab) ? ALLBITS : 0;
148405 hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngKey);
148412 for(nAllIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nAllIdx++){
148446 if( !IsVirtual(pTab) ){
148457 pParse->nMem += pTab->nCol;
148463 pParse->nMem += pTab->nCol;
148468 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
148476 sqlite3MaterializeView(pParse, pTab,
148493 if( IsVirtual(pTab) ){
148494 updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef,
148515 if( nChangeFrom==0 && HasRowid(pTab) ){
148520 assert( pPk!=0 || HasRowid(pTab) );
148527 int nEphCol = nPk + nChangeFrom + (isView ? pTab->nCol : 0);
148599 assert( iCur!=iDataCur || !HasRowid(pTab) );
148604 if( HasRowid(pTab) ){
148623 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur,
148655 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, iBaseCur,
148733 u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0);
148735 pTrigger, pChanges, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onError
148737 for(i=0; i<pTab->nCol; i++){
148738 u32 colFlags = pTab->aCol[i].colFlags;
148739 k = sqlite3TableColumnToStorage(pTab, i) + regOld;
148745 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k);
148769 pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError
148771 for(i=0, k=regNew; i<pTab->nCol; i++, k++){
148772 if( i==pTab->iPKey ){
148774 }else if( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)!=0 ){
148775 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) k--;
148780 int nOff = (isView ? pTab->nCol : nPk);
148794 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k);
148802 if( pTab->tabFlags & TF_HasGenerated ){
148803 testcase( pTab->tabFlags & TF_HasVirtual );
148804 testcase( pTab->tabFlags & TF_HasStored );
148805 sqlite3ComputeGeneratedColumns(pParse, regNew, pTab);
148813 sqlite3TableAffinity(v, pTab, regNew);
148815 TRIGGER_BEFORE, pTab, regOldRowid, onError, labelContinue);
148841 for(i=0, k=regNew; i<pTab->nCol; i++, k++){
148842 if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){
148843 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) k--;
148844 }else if( aXRef[i]<0 && i!=pTab->iPKey ){
148845 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k);
148849 if( pTab->tabFlags & TF_HasGenerated ){
148850 testcase( pTab->tabFlags & TF_HasVirtual );
148851 testcase( pTab->tabFlags & TF_HasStored );
148852 sqlite3ComputeGeneratedColumns(pParse, regNew, pTab);
148861 sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
148879 sqlite3FkCheck(pParse, pTab, regOldRowid, 0, aXRef, chngKey);
148883 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, aRegIdx, -1);
148914 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
148923 sqlite3FkCheck(pParse, pTab, 0, regNewRowid, aXRef, chngKey);
148928 pParse, pTab, iDataCur, iIdxCur, regNewRowid, aRegIdx,
148937 sqlite3FkActions(pParse, pTab, pChanges, regOldRowid, aXRef, chngKey);
148948 TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue);
149027 Table *pTab, /* The virtual table */
149030 int *aXRef, /* Mapping from columns of pTab to entries in pChanges */
149038 const char *pVTab = (const char*)sqlite3GetVTable(db, pTab);
149040 int nArg = 2 + pTab->nCol; /* Number of arguments to VUpdate */
149061 if( HasRowid(pTab) ){
149069 pPk = sqlite3PrimaryKeyIndex(pTab);
149081 for(i=0; i<pTab->nCol; i++){
149105 for(i=0; i<pTab->nCol; i++){
149106 assert( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)==0 );
149114 if( HasRowid(pTab) ){
149124 pPk = sqlite3PrimaryKeyIndex(pTab);
149173 sqlite3VtabMakeWritable(pParse, pTab);
149286 Table *pTab; /* That table into which we are inserting */
149288 int iCursor; /* Cursor used by pTab */
149289 Index *pIdx; /* One of the indexes of pTab */
149297 assert( pTabList->a[0].pTab!=0 );
149316 pTab = pTabList->a[0].pTab;
149319 if( HasRowid(pTab)
149342 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
149448 Table *pTab, /* The table being updated */
149450 int iCur /* Cursor for pIdx (or pTab if pIdx==NULL) */
149465 if( HasRowid(pTab) ){
149472 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
149482 pTab->aCol[pPk->aiColumn[i]].zCnName));
149497 for(i=0; i<pTab->nCol; i++){
149498 if( pTab->aCol[i].affinity==SQLITE_AFF_REAL ){
149962 Table *pTab; /* The Table object to which the virtual table belongs */
150124 ** pTab is a pointer to a Table structure representing a virtual-table.
150128 SQLITE_PRIVATE VTable *sqlite3GetVTable(sqlite3 *db, Table *pTab){
150130 assert( IsVirtual(pTab) );
150131 for(pVtab=pTab->u.vtab.p; pVtab && pVtab->db!=db; pVtab=pVtab->pNext);
150385 Table *pTab = pParse->pNewTable; /* The table being constructed */
150388 if( pTab==0 ) return;
150389 assert( IsVirtual(pTab) );
150392 if( pTab->u.vtab.nArg<1 ) return;
150423 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
150429 pTab->zName,
150430 pTab->zName,
150438 zWhere = sqlite3MPrintf(db, "name=%Q AND sql=%Q", pTab->zName, zStmt);
150443 sqlite3VdbeLoadString(v, iReg, pTab->zName);
150449 Schema *pSchema = pTab->pSchema;
150450 const char *zName = pTab->zName;
150452 sqlite3MarkAllShadowTablesOf(db, pTab);
150453 pOld = sqlite3HashInsert(&pSchema->tblHash, zName, pTab);
150456 assert( pTab==pOld ); /* Malloc must have failed inside HashInsert() */
150495 Table *pTab,
150504 int nArg = pTab->u.vtab.nArg;
150510 assert( IsVirtual(pTab) );
150511 azArg = (const char *const*)pTab->u.vtab.azArg;
150515 if( pCtx->pTab==pTab ){
150517 "vtable constructor called recursively: %s", pTab->zName
150523 zModuleName = sqlite3DbStrDup(db, pTab->zName);
150538 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
150539 pTab->u.vtab.azArg[1] = db->aDb[iDb].zDbSName;
150544 sCtx.pTab = pTab;
150552 assert( sCtx.pTab==pTab );
150571 *pzErr = sqlite3MPrintf(db, zFormat, pTab->zName);
150578 ** into the linked list headed by pTab->u.vtab.p. Then loop through the
150582 pVTable->pNext = pTab->u.vtab.p;
150583 pTab->u.vtab.p = pVTable;
150585 for(iCol=0; iCol<pTab->nCol; iCol++){
150586 char *zType = sqlite3ColumnType(&pTab->aCol[iCol], "");
150608 pTab->aCol[iCol].colFlags |= COLFLAG_HIDDEN;
150609 pTab->tabFlags |= TF_HasHidden;
150612 pTab->tabFlags |= oooHidden;
150624 ** of the virtual table pTab. If an error occurs, an error code is returned
150627 ** This call is a no-op if table pTab is not a virtual table.
150629 SQLITE_PRIVATE int sqlite3VtabCallConnect(Parse *pParse, Table *pTab){
150635 assert( pTab );
150636 assert( IsVirtual(pTab) );
150637 if( sqlite3GetVTable(db, pTab) ){
150642 zMod = pTab->u.vtab.azArg[0];
150646 const char *zModule = pTab->u.vtab.azArg[0];
150651 rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xConnect, &zErr);
150704 Table *pTab;
150708 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
150709 assert( pTab && IsVirtual(pTab) && !pTab->u.vtab.p );
150712 zMod = pTab->u.vtab.azArg[0];
150723 rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr);
150728 if( rc==SQLITE_OK && ALWAYS(sqlite3GetVTable(db, pTab)) ){
150731 addToVTrans(db, sqlite3GetVTable(db, pTab));
150746 Table *pTab;
150762 pTab = pCtx->pTab;
150763 assert( IsVirtual(pTab) );
150781 if( !pTab->aCol ){
150784 pTab->aCol = pNew->aCol;
150786 pTab->nNVCol = pTab->nCol = pNew->nCol;
150787 pTab->tabFlags |= pNew->tabFlags & (TF_WithoutRowid|TF_NoVisibleRowid);
150790 assert( pTab->pIndex==0 );
150803 pTab->pIndex = pIdx;
150805 pIdx->pTable = pTab;
150839 Table *pTab;
150841 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
150842 if( ALWAYS(pTab!=0)
150843 && ALWAYS(IsVirtual(pTab))
150844 && ALWAYS(pTab->u.vtab.p!=0)
150848 for(p=pTab->u.vtab.p; p; p=p->pNext){
150854 p = vtabDisconnectAll(db, pTab);
150858 pTab->nTabRef++;
150862 assert( pTab->u.vtab.p==p && p->pNext==0 );
150864 pTab->u.vtab.p = 0;
150867 sqlite3DeleteTable(db, pTab);
151067 Table *pTab;
151079 pTab = pExpr->y.pTab;
151080 if( NEVER(pTab==0) ) return pDef;
151081 if( !IsVirtual(pTab) ) return pDef;
151082 pVtab = sqlite3GetVTable(db, pTab)->pVtab;
151126 ** Make sure virtual table pTab is contained in the pParse->apVirtualLock[]
151127 ** array so that an OP_VBegin will get generated for it. Add pTab to the
151128 ** array if it is missing. If pTab is already in the array, this routine
151131 SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){
151136 assert( IsVirtual(pTab) );
151138 if( pTab==pToplevel->apVtabLock[i] ) return;
151144 pToplevel->apVtabLock[pToplevel->nVtabLock++] = pTab;
151167 Table *pTab;
151173 pTab = sqlite3DbMallocZero(db, sizeof(Table));
151174 if( pTab==0 ) return 0;
151175 pTab->zName = sqlite3DbStrDup(db, pMod->zName);
151176 if( pTab->zName==0 ){
151177 sqlite3DbFree(db, pTab);
151180 pMod->pEpoTab = pTab;
151181 pTab->nTabRef = 1;
151182 pTab->eTabType = TABTYP_VTAB;
151183 pTab->pSchema = db->aDb[0].pSchema;
151184 assert( pTab->u.vtab.nArg==0 );
151185 pTab->iPKey = -1;
151186 pTab->tabFlags |= TF_Eponymous;
151187 addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
151188 addModuleArgument(pParse, pTab, 0);
151189 addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
151190 rc = vtabCallConstructor(db, pTab, pMod, pModule->xConnect, &zErr);
151204 Table *pTab = pMod->pEpoTab;
151205 if( pTab!=0 ){
151209 pTab->tabFlags |= TF_Ephemeral;
151210 sqlite3DeleteTable(db, pTab);
151253 assert( p->pTab==0 || IsVirtual(p->pTab) );
152000 ** Argument pLevel describes a strategy for scanning table pTab. This
152086 if( !HasRowid(pItem->pTab) && IsPrimaryKeyIndex(pIdx) ){
152107 const Table *pTab = pItem->pTab;
152108 const char *zRowid = pTab->iPKey>=0 ? pTab->aCol[pTab->iPKey].zCnName:
152182 const Table *pTab = pItem->pTab;
152183 if( pTab->iPKey>=0 ){
152184 sqlite3_str_appendf(&str, "%s=?", pTab->aCol[pTab->iPKey].zCnName);
153092 Table *pTab = pIdx->pTable;
153093 u32 *ai = (u32*)sqlite3DbMallocZero(pParse->db, sizeof(u32)*(pTab->nCol+1));
153095 ai[0] = pTab->nCol;
153098 assert( pIdx->aiColumn[i]<pTab->nCol );
153100 x2 = sqlite3TableColumnToStorage(pTab, x1);
153274 VdbeModuleComment((v, "Begin WHERE-loop%d: %s",iLevel,pTabItem->pTab->zName));
153331 VdbeComment((v, "next row of %s", pTabItem->pTab->zName));
154067 Table *pTab = pTabItem->pTab;
154112 if( HasRowid(pTab) ){
154116 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
154223 if( HasRowid(pTab) ){
154224 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, -1, regRowid);
154229 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
154238 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk);
154298 && (HasRowid(pTab) || !IsPrimaryKeyIndex(pSubLoop->u.btree.pIndex))
154509 Table *pTab;
154515 /* pTab is the right-hand table of the RIGHT JOIN. Generate code that
154520 pTab = pWInfo->pTabList->a[pLevel->iFrom].pTab;
154521 if( HasRowid(pTab) ){
154523 sqlite3ExprCodeGetColumnOfTable(v, pTab, pLevel->iTabCur, -1, r+1);
154527 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
154532 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+1+iPk);
154537 VdbeComment((v, "match against %s", pTab->zName));
154563 ** of pTab, with all tables to left begin set to NULL.
154627 ExplainQueryPlan((pParse, 1, "RIGHT-JOIN %s", pTabItem->pTab->zName));
154668 Table *pTab = pTabItem->pTab;
154669 if( HasRowid(pTab) ){
154670 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, -1, r);
154674 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
154679 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk);
154966 && ALWAYS(pLeft->y.pTab)
154967 && IsVirtual(pLeft->y.pTab)) /* Might be numeric */
155083 assert( pCol->op!=TK_COLUMN || (ExprUseYTab(pCol) && pCol->y.pTab!=0) );
155108 assert( pCol->op!=TK_COLUMN || (ExprUseYTab(pCol) && pCol->y.pTab!=0) );
155114 pVtab = sqlite3GetVTable(db, pCol->y.pTab)->pVtab;
155133 assert( pLeft->op!=TK_COLUMN || (ExprUseYTab(pLeft) && pLeft->y.pTab!=0) );
155138 || (ExprUseYTab(pRight) && pRight->y.pTab!=0) );
155683 for(pIdx=pFrom->a[i].pTab->pIndex; pIdx; pIdx=pIdx->pNext){
156305 && (p->pSrc->nSrc==1 && IsVirtual(p->pSrc->a[0].pTab)) /* 3 */
156510 Table *pTab;
156516 pTab = pItem->pTab;
156517 assert( pTab!=0 );
156523 while( k<pTab->nCol && (pTab->aCol[k].colFlags & COLFLAG_HIDDEN)==0 ){k++;}
156524 if( k>=pTab->nCol ){
156526 pTab->zName, j);
156534 pColRef->y.pTab = pTab;
157143 Table *pTab;
157153 pTab = pTabList->a[0].pTab;
157179 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
157356 aff = pSrc->pTab->aCol[pTerm->u.x.leftColumn].affinity;
157410 pTable = pSrc->pTab;
157541 VdbeComment((v, "next row of %s", pTabItem->pTab->zName));
157627 const Table *pTab;
157644 pTab = pItem->pTab;
157645 assert( pTab!=0 );
157646 sz = sqlite3LogEstToInt(pTab->nRowLogEst);
157676 assert( pIdx->pTable==pItem->pTab );
157735 const Table *pTab;
157740 pTab = pSrc->pTab;
157741 assert( pTab!=0 );
157742 assert( IsVirtual(pTab) );
157762 assert( pTerm->u.x.leftColumn<pTab->nCol );
157793 assert( pExpr->iColumn>=XN_ROWID && pExpr->iColumn<pTab->nCol );
157806 assert( pE2->iColumn>=XN_ROWID && pE2->iColumn<pTab->nCol );
157809 zColl = sqlite3ColumnColl(&pTab->aCol[pE2->iColumn]);
157944 static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){
157945 sqlite3_vtab *pVtab = sqlite3GetVTable(pParse->db, pTab)->pVtab;
158695 Table *pTab = pItem->pTab;
158700 pItem->zAlias ? pItem->zAlias : pTab->zName);
159644 assert( pSrc->pTab->szTabRow>0 );
159645 rCostIdx = pNew->nOut + 1 + (15*pProbe->szIdxRow)/pSrc->pTab->szTabRow;
159941 Table *pTab; /* Table being queried */
159947 pTab = pSrc->pTab;
159949 assert( !IsVirtual(pSrc->pTab) );
159955 }else if( !HasRowid(pTab) ){
159956 pProbe = pTab->pIndex;
159969 sPk.pTable = pTab;
159970 sPk.szIdxRow = pTab->szTabRow;
159972 aiRowEstPk[0] = pTab->nRowLogEst;
159974 pFirst = pSrc->pTab->pIndex;
159982 rSize = pTab->nRowLogEst;
159991 && HasRowid(pTab) /* Not WITHOUT ROWID table. (FIXME: Why not?) */
160018 if( !IsView(pTab) && (pTab->tabFlags & TF_Ephemeral)==0 ){
160023 ApplyCostMultiplier(pNew->rSetup, pTab->costMult);
160086 pNew->rRun = rSize + 16 - 2*((pTab->tabFlags & TF_HasStat4)!=0);
160090 if( IsView(pTab) || (pTab->tabFlags & TF_Ephemeral)!=0 ){
160093 ApplyCostMultiplier(pNew->rRun, pTab->costMult);
160113 || !HasRowid(pTab)
160118 && (pProbe->szIdxRow<pTab->szTabRow)
160129 pNew->rRun = rSize + 1 + (15*pProbe->szIdxRow)/pTab->szTabRow;
160157 ApplyCostMultiplier(pNew->rRun, pTab->costMult);
160179 pTab->tabFlags |= TF_StatsUsed;
160274 rc = vtabBestIndex(pParse, pSrc->pTab, pIdxInfo);
160303 sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
160364 sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
160569 assert( IsVirtual(pSrc->pTab) );
160583 WHERETRACE(0x800, ("BEGIN %s.addVirtual()\n", pSrc->pTab->zName));
160667 WHERETRACE(0x800, ("END %s.addVirtual(), rc=%d\n", pSrc->pTab->zName, rc));
160739 if( IsVirtual(pItem->pTab) ){
160855 if( IsVirtual(pItem->pTab) ){
161736 Table *pTab;
161744 pTab = pItem->pTab;
161745 if( IsVirtual(pTab) ) return 0;
161767 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
161993 Table *pTab = pItem->pTab;
161994 pTab->tabFlags |= TF_StatsUsed;
161995 if( nSearch > pTab->nRowLogEst
161996 && (pTab->tabFlags & TF_HasStat1)!=0
162004 pLoop->cId, (double)sqlite3LogEstToInt(nSearch), pTab->zName,
162005 (double)sqlite3LogEstToInt(pTab->nRowLogEst)));
162045 Table *pTab;
162047 pTab = pIdx->pTable;
162058 }else if( j>=0 && (pTab->aCol[j].colFlags & COLFLAG_VIRTUAL)!=0 ){
162059 pExpr = sqlite3ColumnExpr(pTab, &pTab->aCol[j]);
162520 assert( !(wsFlags & WHERE_VIRTUALTABLE) || IsVirtual(pTabList->a[0].pTab) );
162523 && !IsVirtual(pTabList->a[0].pTab)
162527 if( HasRowid(pTabList->a[0].pTab) && (wsFlags & WHERE_IDX_ONLY) ){
162540 Table *pTab; /* Table to open */
162545 pTab = pTabItem->pTab;
162546 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
162548 if( (pTab->tabFlags & TF_Ephemeral)!=0 || IsView(pTab) ){
162553 const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
162556 }else if( IsVirtual(pTab) ){
162569 sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op);
162571 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS-1 );
162572 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS );
162574 && pTab->nCol<BMS
162575 && (pTab->tabFlags & (TF_HasGenerated|TF_WithoutRowid))==0
162585 assert( n<=pTab->nCol );
162600 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
162608 if( !HasRowid(pTab) && IsPrimaryKeyIndex(pIx)
162616 Index *pJ = pTabItem->pTab->pIndex;
162636 assert( pIx->pSchema==pTab->pSchema );
162678 assert( pTab==pTabItem->pTab );
162679 if( HasRowid(pTab) ){
162689 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
162969 pWInfo->pTabList->a[pLevel->iFrom].pTab->zName));
162978 Table *pTab = pTabItem->pTab;
162979 assert( pTab!=0 );
163059 assert( pIdx->pTable==pTab );
163065 if( !HasRowid(pTab) ){
163066 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
163070 testcase( x!=sqlite3StorageColumnToTable(pTab,x) );
163071 x = sqlite3StorageColumnToTable(pTab,x);
163865 Table *pTab;
163943 pExpr->y.pTab = p->pTab;
163988 Table *pTab,
164001 sRewrite.pTab = pTab;
164102 Table *pTab;
164107 pTab = sqlite3DbMallocZero(db, sizeof(Table));
164108 if( pTab==0 ){
164147 selectWindowRewriteEList(pParse, pMWin, pSrc, p->pEList, pTab, &pSublist);
164148 selectWindowRewriteEList(pParse, pMWin, pSrc, p->pOrderBy, pTab, &pSublist);
164167 selectWindowRewriteEList(pParse, pMWin, pSrc, pArgs, pTab, &pSublist);
164218 memcpy(pTab, pTab2, sizeof(Table));
164219 pTab->tabFlags |= TF_Ephemeral;
164220 p->pSrc->a[0].pTab = pTab;
164221 pTab = pTab2;
164233 /* Defer deleting the temporary table pTab because if an error occurred,
164236 sqlite3ParserAddCleanup(pParse, sqlite3DbFree, pTab);
165915 int nInput = p->pSrc->a[0].pTab->nCol; /* Number of cols returned by sub */
174596 Table *pTab = (Table *)sqliteHashData(p);
174597 if( IsVirtual(pTab) ) sqlite3VtabDisconnect(db, pTab);
177257 Table *pTab = 0;
177282 pTab = sqlite3FindTable(db, zTableName, zDbName);
177283 if( !pTab || IsView(pTab) ){
177284 pTab = 0;
177292 for(iCol=0; iCol<pTab->nCol; iCol++){
177293 pCol = &pTab->aCol[iCol];
177298 if( iCol==pTab->nCol ){
177299 if( HasRowid(pTab) && sqlite3IsRowid(zColumnName) ){
177300 iCol = pTab->iPKey;
177301 pCol = iCol>=0 ? &pTab->aCol[iCol] : 0;
177303 pTab = 0;
177324 autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
177346 if( SQLITE_OK==rc && !pTab ){
181486 Fts3Table *pTab = (Fts3Table*)pCsr->base.pVtab;
181487 pTab->bLock++;
181491 pTab->bLock--;
181494 pTab->bLock--;
182891 Fts3Table *pTab = (Fts3Table*)pCursor->pVtab;
182892 pTab->bLock++;
182900 pTab->bLock--;
183847 Fts3Table *pTab, /* FTS Table pointer */
183893 pTab->bDescIdx, nDiff, pLeft, nLeft, &pRight, &nRight
183914 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
183925 rc = fts3TermSelect(pTab, pToken, p->iColumn, &nThis, &pThis);
183927 rc = fts3EvalPhraseMergeToken(pTab, p, iToken, pThis, nThis);
184064 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
184075 && pCsr->bDesc==pTab->bDescIdx
184078 && pTab->bNoIncrDoclist==0
184091 int iCol = (p->iColumn >= pTab->nColumn ? -1 : p->iColumn);
184096 rc = sqlite3Fts3MsrIncrStart(pTab, pSegcsr, iCol, pToken->z, pToken->n);
184214 Fts3Table *pTab,
184234 if( pTab->bDescIdx==0 || pDL->pNextDocid==0 ){
184278 Fts3Table *pTab, /* Virtual table handle */
184289 fts3EvalDlPhraseNext(pTab, &pPhrase->doclist, pbEof);
184300 pTab, pToken->pSegcsr, &p->iDocid, &p->pList, &p->nList
184336 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
184344 rc = sqlite3Fts3MsrIncrNext(pTab, p->aToken[0].pSegcsr,
184363 rc = incrPhraseTokenNext(pTab, p, i, &a[i], &bEof);
184377 rc = incrPhraseTokenNext(pTab, p, i, &a[i], &bEof);
184437 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
184441 }else if( pCsr->bDesc!=pTab->bDescIdx && pDL->nAll ){
184442 sqlite3Fts3DoclistPrev(pTab->bDescIdx, pDL->aAll, pDL->nAll,
184447 fts3EvalDlPhraseNext(pTab, pDL, pbEof);
184643 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
184658 if( pTab->zContentTbl ){
184736 rc = fts3TermSelect(pTab, pToken, pTC->iCol, &nList, &pList);
184740 pTab, pTC->pPhrase, pTC->iToken,pList,nList
184771 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
184781 if( rc==SQLITE_OK && nToken>1 && pTab->bFts4 ){
185428 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
185449 pE->aMI = (u32 *)sqlite3_malloc64(pTab->nColumn * 3 * sizeof(u32));
185451 memset(pE->aMI, 0, pTab->nColumn * 3 * sizeof(u32));
185475 fts3EvalUpdateCounts(pRoot, pTab->nColumn);
185537 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
185543 for(iCol=0; iCol<pTab->nColumn; iCol++){
185551 for(iCol=0; iCol<pTab->nColumn; iCol++){
185587 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
185595 assert( iCol>=0 && iCol<pTab->nColumn );
185596 if( (pPhrase->iColumn<pTab->nColumn && pPhrase->iColumn!=iCol) ){
185604 int bDescDoclist = pTab->bDescIdx; /* For DOCID_CMP macro */
189592 Fts3tokTable *pTab = 0;
189623 pTab = (Fts3tokTable *)sqlite3_malloc(sizeof(Fts3tokTable));
189624 if( pTab==0 ){
189630 memset(pTab, 0, sizeof(Fts3tokTable));
189631 pTab->pMod = pMod;
189632 pTab->pTok = pTok;
189633 *ppVtab = &pTab->base;
189650 Fts3tokTable *pTab = (Fts3tokTable *)pVtab;
189652 pTab->pMod->xDestroy(pTab->pTok);
189653 sqlite3_free(pTab);
189709 Fts3tokTable *pTab = (Fts3tokTable *)(pCsr->base.pVtab);
189710 pTab->pMod->xClose(pCsr->pCsr);
189739 Fts3tokTable *pTab = (Fts3tokTable *)(pCursor->pVtab);
189743 rc = pTab->pMod->xNext(pCsr->pCsr,
189768 Fts3tokTable *pTab = (Fts3tokTable *)(pCursor->pVtab);
189782 rc = pTab->pMod->xOpen(pTab->pTok, pCsr->zInput, nByte, &pCsr->pCsr);
189784 pCsr->pCsr->pTokenizer = pTab->pTok;
190320 Fts3Table *pTab, /* FTS3 table handle */
190327 rc = fts3SqlStmt(pTab, SQL_SELECT_DOCSIZE, &pStmt, 0);
190345 Fts3Table *pTab, /* Fts3 table handle */
190350 rc = fts3SqlStmt(pTab, SQL_SELECT_STAT, &pStmt, 0);
190366 Fts3Table *pTab, /* Fts3 table handle */
190370 return fts3SelectDocsize(pTab, iDocid, ppStmt);
191328 static int fts3SegReaderFirstDocid(Fts3Table *pTab, Fts3SegReader *pReader){
191332 if( pTab->bDescIdx && fts3SegReaderIsPending(pReader) ){
191361 Fts3Table *pTab,
191372 if( pTab->bDescIdx && fts3SegReaderIsPending(pReader) ){
191436 if( pTab->bDescIdx ){
196358 Fts3Table *pTab, /* FTS3 table snippet comes from */
196391 pMod = (sqlite3_tokenizer_module *)pTab->pTokenizer->pModule;
196396 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, iLangid, zDoc, nDoc, &pC);
196433 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
196456 pMod = (sqlite3_tokenizer_module *)pTab->pTokenizer->pModule;
196457 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid, zDoc,nDoc,&pC);
196496 pTab, pCsr->iLangid, nSnippet, &zDoc[iBegin], n, &iPos, &hlmask
196572 Fts3Table *pTab = (Fts3Table *)p->pCursor->base.pVtab;
196587 if( (pPhrase->iColumn>=pTab->nColumn || pPhrase->iColumn==iCol) ){
196690 Fts3Table *pTab,
196696 || (cArg==FTS3_MATCHINFO_NDOC && pTab->bFts4)
196697 || (cArg==FTS3_MATCHINFO_AVGLENGTH && pTab->bFts4)
196698 || (cArg==FTS3_MATCHINFO_LENGTH && pTab->bHasDocsize)
196744 Fts3Table *pTab,
196758 int rc = sqlite3Fts3SelectDoctotal(pTab, ppStmt);
196942 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
196959 rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &nDoc, 0, 0);
196970 rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &nDoc, &a, &pEnd);
196990 rc = sqlite3Fts3SelectDocsize(pTab, pCsr->iPrevId, &pSelectDocsize);
197032 rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &pInfo->nDoc,0,0);
197062 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
197071 sInfo.nCol = pTab->nColumn;
197097 if( fts3MatchinfoCheck(pTab, zArg[i], &zErr) ){
197150 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
197199 for(iRead=0; iRead<pTab->nColumn; iRead++){
197234 sqlite3Fts3SegmentsClose(pTab);
197297 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
197298 sqlite3_tokenizer_module const *pMod = pTab->pTokenizer->pModule;
197329 for(iCol=0; iCol<pTab->nColumn; iCol++){
197364 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid,
197402 }else if( rc==SQLITE_DONE && pTab->zContentTbl==0 ){
197418 sqlite3Fts3SegmentsClose(pTab);
197436 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
197451 sqlite3Fts3SegmentsClose(pTab);
214347 StatTable *pTab = 0;
214365 pTab = (StatTable *)sqlite3_malloc64(sizeof(StatTable));
214366 if( pTab==0 ) rc = SQLITE_NOMEM_BKPT;
214369 assert( rc==SQLITE_OK || pTab==0 );
214371 memset(pTab, 0, sizeof(StatTable));
214372 pTab->db = db;
214373 pTab->iDb = iDb;
214376 *ppVtab = (sqlite3_vtab*)pTab;
214472 StatTable *pTab = (StatTable *)pVTab;
214481 pCsr->iDb = pTab->iDb;
214693 StatTable *pTab = (StatTable *)((sqlite3_vtab_cursor *)pCsr)->pVtab;
214694 Btree *pBt = pTab->db->aDb[pTab->iDb].pBt;
214756 StatTable *pTab = (StatTable *)pCursor->pVtab;
214757 Btree *pBt = pTab->db->aDb[pCsr->iDb].pBt;
214922 StatTable *pTab = (StatTable*)(pCursor->pVtab);
214935 pCsr->iDb = sqlite3FindDbName(pTab->db, zDbase);
214942 pCsr->iDb = pTab->iDb;
214954 pSql = sqlite3_str_new(pTab->db);
214961 pTab->db->aDb[pCsr->iDb].zDbSName);
214972 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pStmt, 0);
215160 DbpageTable *pTab = 0;
215167 pTab = (DbpageTable *)sqlite3_malloc64(sizeof(DbpageTable));
215168 if( pTab==0 ) rc = SQLITE_NOMEM_BKPT;
215171 assert( rc==SQLITE_OK || pTab==0 );
215173 memset(pTab, 0, sizeof(DbpageTable));
215174 pTab->db = db;
215177 *ppVtab = (sqlite3_vtab*)pTab;
215310 DbpageTable *pTab = (DbpageTable *)pCursor->pVtab;
215312 sqlite3 *db = pTab->db;
215399 DbpageTable *pTab = (DbpageTable *)pVtab;
215410 if( pTab->db->flags & SQLITE_Defensive ){
215424 iDb = zSchema ? sqlite3FindDbName(pTab->db, zSchema) : -1;
215429 pBt = pTab->db->aDb[iDb].pBt;
215445 assert( pData!=0 || pTab->db->mallocFailed );
215466 DbpageTable *pTab = (DbpageTable *)pVtab;
215467 sqlite3 *db = pTab->db;
216031 sqlite3_session *pSession, /* Session object that owns pTab */
216032 SessionTable *pTab, /* Session table handle */
216041 assert( pTab->nCol==pSession->hook.xCount(pSession->hook.pCtx) );
216042 for(i=0; i<pTab->nCol; i++){
216043 if( pTab->abPK[i] ){
216080 assert( pTab->bStat1==0 || i!=1 );
216086 *piHash = (h % pTab->nChange);
216114 SessionTable *pTab, /* Table handle */
216123 for(i=0; i<pTab->nCol; i++){
216125 int isPK = pTab->abPK[i];
216157 ** Arguments aLeft and aRight are pointers to change records for table pTab.
216163 SessionTable *pTab, /* Table used for PK definition */
216173 for(iCol=0; iCol<pTab->nCol; iCol++){
216174 if( pTab->abPK[iCol] ){
216287 SessionTable *pTab, /* Table change pertains to */
216308 for(i=0; i<pTab->nCol; i++){
216316 if( pTab->abPK[i] || nOld!=nNew || memcmp(aOld, aNew, nNew) ){
216317 if( pTab->abPK[i]==0 ) bRequired = 1;
216333 for(i=0; i<pTab->nCol; i++){
216342 && (pTab->abPK[i] || (nOld==nNew && 0==memcmp(aOld, aNew, nNew)))
216364 SessionTable *pTab, /* Table associated with change */
216372 for(iCol=0; iCol<pTab->nCol; iCol++){
216373 if( !pTab->abPK[iCol] ){
216431 ** If required, grow the hash table used to store changes on table pTab
216444 SessionTable *pTab
216446 if( pTab->nChange==0 || pTab->nEntry>=(pTab->nChange/2) ){
216449 sqlite3_int64 nNew = 2*(sqlite3_int64)(pTab->nChange ? pTab->nChange : 128);
216455 if( pTab->nChange==0 ){
216462 for(i=0; i<pTab->nChange; i++){
216465 for(p=pTab->apChange[i]; p; p=pNext){
216467 int iHash = sessionChangeHash(pTab, bPkOnly, p->aRecord, nNew);
216474 sessionFree(pSession, pTab->apChange);
216475 pTab->nChange = nNew;
216476 pTab->apChange = apNew;
216630 ** write to table pTab, part of session pSession. If this is the first
216640 static int sessionInitTable(sqlite3_session *pSession, SessionTable *pTab){
216641 if( pTab->nCol==0 ){
216643 assert( pTab->azCol==0 || pTab->abPK==0 );
216645 pTab->zName, &pTab->nCol, 0, &pTab->azCol, &abPK
216649 for(i=0; i<pTab->nCol; i++){
216651 pTab->abPK = abPK;
216655 if( 0==sqlite3_stricmp("sqlite_stat1", pTab->zName) ){
216656 pTab->bStat1 = 1;
216661 1 + sessionVarintLen(pTab->nCol) + pTab->nCol + strlen(pTab->zName)+1
216666 return (pSession->rc || pTab->abPK==0);
216711 sqlite3_session *pSession, /* Session object pTab is attached to */
216712 SessionTable *pTab, /* Table that change applies to */
216719 for(ii=0; ii<pTab->nCol; ii++){
216733 for(ii=0; ii<pTab->nCol; ii++){
216783 if( bChanged && pTab->abPK[ii] ){
216791 }else if( pTab->abPK[ii] ){
216809 ** change on table pTab (attached to session pSession). The type of change
216813 ** to the changed-rows hash table associated with table pTab.
216817 sqlite3_session *pSession, /* Session object pTab is attached to */
216818 SessionTable *pTab /* Table that change applies to */
216828 if( sessionInitTable(pSession, pTab) ) return;
216832 if( pTab->nCol!=pSession->hook.xCount(pSession->hook.pCtx) ){
216838 if( sessionGrowHash(pSession, 0, pTab) ){
216843 if( pTab->bStat1 ){
216865 rc = sessionPreupdateHash(pSession, pTab, op==SQLITE_INSERT, &iHash, &bNull);
216871 for(pC=pTab->apChange[iHash]; pC; pC=pC->pNext){
216872 if( sessionPreupdateEqual(pSession, pTab, pC, op) ) break;
216883 pTab->nEntry++;
216887 for(i=0; i<pTab->nCol; i++){
216892 }else if( pTab->abPK[i] ){
216918 for(i=0; i<pTab->nCol; i++){
216922 }else if( pTab->abPK[i] ){
216934 pC->pNext = pTab->apChange[iHash];
216935 pTab->apChange[iHash] = pC;
216949 rc = sessionUpdateMaxSize(op, pSession, pTab, pC);
216956 if( pTab->bStat1 ){
217019 SessionTable *pTab;
217028 pSession->rc = sessionFindTable(pSession, zName, &pTab);
217029 if( pTab ){
217031 sessionPreupdateOneChange(op, pSession, pTab);
217033 sessionPreupdateOneChange(SQLITE_INSERT, pSession, pTab);
217184 SessionTable *pTab,
217190 char *zStmt = sessionSelectFindNew(pTab->nCol, zDb1, zDb2, pTab->zName,zExpr);
217202 sessionPreupdateOneChange(op, pSession, pTab);
217214 SessionTable *pTab,
217220 char *zExpr2 = sessionExprCompareOther(pTab->nCol,
217221 pSession->zDb, zFrom, pTab->zName, pTab->azCol, pTab->abPK
217228 pSession->zDb, pTab->zName, zFrom, pTab->zName, zExpr, zExpr2
217239 pDiffCtx->nOldOff = pTab->nCol;
217241 sessionPreupdateOneChange(SQLITE_UPDATE, pSession, pTab);
217387 SessionTable *pTab;
217389 for(pTab=pList; pTab; pTab=pNext){
217391 pNext = pTab->pNext;
217392 for(i=0; i<pTab->nChange; i++){
217395 for(p=pTab->apChange[i]; p; p=pNextChange){
217400 sessionFree(pSession, (char*)pTab->azCol); /* cast works around VC++ bug */
217401 sessionFree(pSession, pTab->apChange);
217402 sessionFree(pSession, pTab);
217469 SessionTable *pTab; /* New table object (if required) */
217475 for(pTab=pSession->pTable; pTab; pTab=pTab->pNext){
217476 if( 0==sqlite3_strnicmp(pTab->zName, zName, nName+1) ) break;
217479 if( !pTab ){
217482 pTab = (SessionTable*)sessionMalloc64(pSession, nByte);
217483 if( !pTab ){
217492 memset(pTab, 0, sizeof(SessionTable));
217493 pTab->zName = (char *)&pTab[1];
217494 memcpy(pTab->zName, zName, nName+1);
217496 *ppTab = pTab;
218035 SessionTable *pTab, /* Table object to append header for */
218040 sessionAppendVarint(pBuf, pTab->nCol, pRc);
218041 sessionAppendBlob(pBuf, pTab->abPK, pTab->nCol, pRc);
218042 sessionAppendBlob(pBuf, (u8 *)pTab->zName, (int)strlen(pTab->zName)+1, pRc);
218064 SessionTable *pTab; /* Used to iterate through attached tables */
218086 for(pTab=pSession->pTable; rc==SQLITE_OK && pTab; pTab=pTab->pNext){
218087 if( pTab->nEntry ){
218088 const char *zName = pTab->zName;
218093 sqlite3_stmt *pSel = 0; /* SELECT statement to query table pTab */
218099 if( !rc && (pTab->nCol!=nCol || memcmp(abPK, pTab->abPK, nCol)) ){
218104 sessionAppendTableHdr(&buf, bPatchset, pTab, &rc);
218113 for(i=0; i<pTab->nChange && rc==SQLITE_OK; i++){
218116 for(p=pTab->apChange[i]; rc==SQLITE_OK && p; p=p->pNext){
218273 SessionTable *pTab;
218276 for(pTab=pSession->pTable; pTab && ret==0; pTab=pTab->pNext){
218277 ret = (pTab->nEntry>0);
220481 SessionTable *pTab, /* Table structure */
220510 for(i=0; i<pTab->nCol; i++){
220514 }else if( pTab->abPK[i]==0 ){
220543 for(i=0; i<pTab->nCol; i++){
220546 if( *a1==0xFF || (pTab->abPK[i]==0 && bIndirect) ){
220609 if( bPatchset==0 ) sessionSkipRecord(&a1, pTab->nCol);
220610 sessionMergeRecord(&aCsr, pTab->nCol, aExist, a1);
220618 if( 0==sessionMergeUpdate(&aCsr, pTab, bPatchset, aExist, 0,aRec,0) ){
220628 sessionSkipRecord(&a1, pTab->nCol);
220629 sessionSkipRecord(&a2, pTab->nCol);
220632 if( 0==sessionMergeUpdate(&aCsr, pTab, bPatchset, aRec, aExist,a1,a2) ){
220643 sessionMergeRecord(&aCsr, pTab->nCol, aRec, aExist);
220670 SessionTable *pTab = 0;
220690 if( !pTab || sqlite3_stricmp(zNew, pTab->zName) ){
220696 for(pTab = pGrp->pList; pTab; pTab=pTab->pNext){
220697 if( 0==sqlite3_strnicmp(pTab->zName, zNew, nNew+1) ) break;
220699 if( !pTab ){
220702 pTab = sqlite3_malloc64(sizeof(SessionTable) + nCol + nNew+1);
220703 if( !pTab ){
220707 memset(pTab, 0, sizeof(SessionTable));
220708 pTab->nCol = nCol;
220709 pTab->abPK = (u8*)&pTab[1];
220710 memcpy(pTab->abPK, abPK, nCol);
220711 pTab->zName = (char*)&pTab->abPK[nCol];
220712 memcpy(pTab->zName, zNew, nNew+1);
220719 *ppTab = pTab;
220720 }else if( pTab->nCol!=nCol || memcmp(pTab->abPK, abPK, nCol) ){
220726 if( sessionGrowHash(0, pIter->bPatchset, pTab) ){
220731 pTab, (pIter->bPatchset && op==SQLITE_DELETE), aRec, pTab->nChange
220737 for(pp=&pTab->apChange[iHash]; *pp; pp=&(*pp)->pNext){
220744 if( sessionChangeEqual(pTab, bPkOnly1, (*pp)->aRecord, bPkOnly2, aRec) ){
220747 pTab->nEntry--;
220752 rc = sessionChangeMerge(pTab, bRebase,
220757 pChange->pNext = pTab->apChange[iHash];
220758 pTab->apChange[iHash] = pChange;
220759 pTab->nEntry++;
220794 SessionTable *pTab;
220800 for(pTab=pGrp->pList; rc==SQLITE_OK && pTab; pTab=pTab->pNext){
220802 if( pTab->nEntry==0 ) continue;
220804 sessionAppendTableHdr(&buf, pGrp->bPatch, pTab, &rc);
220805 for(i=0; i<pTab->nChange; i++){
220807 for(p=pTab->apChange[i]; p; p=p->pNext){
221117 SessionTable *pTab = 0;
221126 for(pTab=p->grp.pList; pTab; pTab=pTab->pNext){
221127 if( 0==sqlite3_stricmp(pTab->zName, zTab) ) break;
221143 if( pTab && rc==SQLITE_OK ){
221144 int iHash = sessionChangeHash(pTab, 0, aRec, pTab->nChange);
221146 for(pChange=pTab->apChange[iHash]; pChange; pChange=pChange->pNext){
221147 if( sessionChangeEqual(pTab, 0, aRec, 0, pChange->aRecord) ){
237135 ** Return true if pTab is a contentless table.
237137 static int fts5IsContentless(Fts5FullTable *pTab){
237138 return pTab->p.pConfig->eContent==FTS5_CONTENT_NONE;
237144 static void fts5FreeVtab(Fts5FullTable *pTab){
237145 if( pTab ){
237146 sqlite3Fts5IndexClose(pTab->p.pIndex);
237147 sqlite3Fts5StorageClose(pTab->pStorage);
237148 sqlite3Fts5ConfigFree(pTab->p.pConfig);
237149 sqlite3_free(pTab);
237165 Fts5Table *pTab = (Fts5Table*)pVtab;
237166 int rc = sqlite3Fts5DropAll(pTab->pConfig);
237197 Fts5FullTable *pTab = 0; /* New virtual table object */
237200 pTab = (Fts5FullTable*)sqlite3Fts5MallocZero(&rc, sizeof(Fts5FullTable));
237206 pTab->p.pConfig = pConfig;
237207 pTab->pGlobal = pGlobal;
237212 rc = sqlite3Fts5IndexOpen(pConfig, bCreate, &pTab->p.pIndex, pzErr);
237218 pConfig, pTab->p.pIndex, bCreate, &pTab->pStorage, pzErr
237231 rc = sqlite3Fts5IndexLoadConfig(pTab->p.pIndex);
237232 sqlite3Fts5IndexRollback(pTab->p.pIndex);
237237 fts5FreeVtab(pTab);
237238 pTab = 0;
237240 fts5CheckTransactionState(pTab, FTS5_BEGIN, 0);
237242 *ppVTab = (sqlite3_vtab*)pTab;
237376 Fts5Table *pTab = (Fts5Table*)pVTab;
237377 Fts5Config *pConfig = pTab->pConfig;
237400 pTab->base.zErrMsg = sqlite3_mprintf(
237510 static int fts5NewTransaction(Fts5FullTable *pTab){
237512 for(pCsr=pTab->pGlobal->pCsr; pCsr; pCsr=pCsr->pNext){
237513 if( pCsr->base.pVtab==(sqlite3_vtab*)pTab ) return SQLITE_OK;
237515 return sqlite3Fts5StorageReset(pTab->pStorage);
237522 Fts5FullTable *pTab = (Fts5FullTable*)pVTab;
237523 Fts5Config *pConfig = pTab->p.pConfig;
237528 rc = fts5NewTransaction(pTab);
237533 Fts5Global *pGlobal = pTab->pGlobal;
237569 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
237577 sqlite3Fts5StorageStmtRelease(pTab->pStorage, eStmt, pCsr->pStmt);
237603 sqlite3Fts5IndexCloseReader(pTab->p.pIndex);
237614 Fts5FullTable *pTab = (Fts5FullTable*)(pCursor->pVtab);
237620 for(pp=&pTab->pGlobal->pCsr; (*pp)!=pCsr; pp=&(*pp)->pNext);
237669 ** open on table pTab.
237671 static void fts5TripCursors(Fts5FullTable *pTab){
237673 for(pCsr=pTab->pGlobal->pCsr; pCsr; pCsr=pCsr->pNext){
237675 && pCsr->base.pVtab==(sqlite3_vtab*)pTab
237698 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
237702 rc = sqlite3Fts5ExprFirst(pCsr->pExpr, pTab->p.pIndex, iRowid, bDesc);
237809 Fts5FullTable *pTab,
237813 Fts5Config *pConfig = pTab->p.pConfig;
237845 assert( pTab->pSortCsr==0 );
237846 pTab->pSortCsr = pCsr;
237848 pTab->pSortCsr = 0;
237860 static int fts5CursorFirst(Fts5FullTable *pTab, Fts5Cursor *pCsr, int bDesc){
237863 rc = sqlite3Fts5ExprFirst(pExpr, pTab->p.pIndex, pCsr->iFirstRowid, bDesc);
237878 Fts5FullTable *pTab,
237889 assert( pTab->p.base.zErrMsg==0 );
237893 pCsr->iSpecial = sqlite3Fts5IndexReads(pTab->p.pIndex);
237900 pTab->p.base.zErrMsg = sqlite3_mprintf("unknown special query: %.*s", n, z);
237909 ** pTab. If one is found, return a pointer to the corresponding Fts5Auxiliary
237912 static Fts5Auxiliary *fts5FindAuxiliary(Fts5FullTable *pTab, const char *zName){
237915 for(pAux=pTab->pGlobal->pAux; pAux; pAux=pAux->pNext){
237925 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
237926 Fts5Config *pConfig = pTab->p.pConfig;
237962 pAux = fts5FindAuxiliary(pTab, zRank);
237964 assert( pTab->p.base.zErrMsg==0 );
237965 pTab->p.base.zErrMsg = sqlite3_mprintf("no such function: %s", zRank);
238040 Fts5FullTable *pTab = (Fts5FullTable*)(pCursor->pVtab);
238041 Fts5Config *pConfig = pTab->p.pConfig;
238057 pTab->p.base.zErrMsg = sqlite3_mprintf(
238074 assert( pTab->pSortCsr==0 || nVal==0 );
238076 assert( pzErrmsg==0 || pzErrmsg==&pTab->p.base.zErrMsg );
238077 pConfig->pzErrmsg = &pTab->p.base.zErrMsg;
238098 rc = fts5SpecialMatch(pTab, pCsr, &zText[1]);
238101 char **pzErr = &pTab->p.base.zErrMsg;
238160 if( pTab->pSortCsr ){
238171 if( pTab->pSortCsr->bDesc ){
238172 pCsr->iLastRowid = pTab->pSortCsr->iFirstRowid;
238173 pCsr->iFirstRowid = pTab->pSortCsr->iLastRowid;
238175 pCsr->iLastRowid = pTab->pSortCsr->iLastRowid;
238176 pCsr->iFirstRowid = pTab->pSortCsr->iFirstRowid;
238179 pCsr->pExpr = pTab->pSortCsr->pExpr;
238180 rc = fts5CursorFirst(pTab, pCsr, bDesc);
238186 rc = fts5CursorFirstSorted(pTab, pCsr, bDesc);
238189 rc = fts5CursorFirst(pTab, pCsr, bDesc);
238202 pTab->pStorage, fts5StmtType(pCsr), &pCsr->pStmt, &pTab->p.base.zErrMsg
238288 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
238291 pTab->pStorage, eStmt, &pCsr->pStmt, (bErrormsg?&pTab->p.base.zErrMsg:0)
238293 assert( rc!=SQLITE_OK || pTab->p.base.zErrMsg==0 );
238298 Fts5Table *pTab = (Fts5Table*)(pCsr->base.pVtab);
238302 pTab->pConfig->bLock++;
238304 pTab->pConfig->bLock--;
238312 }else if( pTab->pConfig->pzErrmsg ){
238313 *pTab->pConfig->pzErrmsg = sqlite3_mprintf(
238314 "%s", sqlite3_errmsg(pTab->pConfig->db)
238346 Fts5FullTable *pTab, /* Fts5 table object */
238350 Fts5Config *pConfig = pTab->p.pConfig;
238356 fts5SetVtabError(pTab,
238362 rc = sqlite3Fts5StorageDeleteAll(pTab->pStorage);
238366 fts5SetVtabError(pTab,
238371 rc = sqlite3Fts5StorageRebuild(pTab->pStorage);
238374 rc = sqlite3Fts5StorageOptimize(pTab->pStorage);
238377 rc = sqlite3Fts5StorageMerge(pTab->pStorage, nMerge);
238380 rc = sqlite3Fts5StorageIntegrity(pTab->pStorage, iArg);
238386 rc = sqlite3Fts5IndexLoadConfig(pTab->p.pIndex);
238388 rc = sqlite3Fts5ConfigSetValue(pTab->p.pConfig, zCmd, pVal, &bError);
238394 rc = sqlite3Fts5StorageConfigValue(pTab->pStorage, zCmd, pVal, 0);
238402 Fts5FullTable *pTab,
238409 rc = sqlite3Fts5StorageDelete(pTab->pStorage, iDel, &apVal[2]);
238416 Fts5FullTable *pTab,
238422 rc = sqlite3Fts5StorageContentInsert(pTab->pStorage, apVal, piRowid);
238425 rc = sqlite3Fts5StorageIndexInsert(pTab->pStorage, apVal, *piRowid);
238450 Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
238451 Fts5Config *pConfig = pTab->p.pConfig;
238456 assert( pTab->ts.eState==1 || pTab->ts.eState==2 );
238463 assert( pTab->p.pConfig->pzErrmsg==0 );
238464 pTab->p.pConfig->pzErrmsg = &pTab->p.base.zErrMsg;
238467 fts5TripCursors(pTab);
238478 rc = fts5SpecialDelete(pTab, apVal);
238480 rc = fts5SpecialInsert(pTab, z, apVal[2 + pConfig->nCol + 1]);
238504 if( eType0==SQLITE_INTEGER && fts5IsContentless(pTab) ){
238505 pTab->p.base.zErrMsg = sqlite3_mprintf(
238515 rc = sqlite3Fts5StorageDelete(pTab->pStorage, iDel, 0);
238530 rc = sqlite3Fts5StorageDelete(pTab->pStorage, iNew, 0);
238532 fts5StorageInsert(&rc, pTab, apVal, pRowid);
238541 rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld, 0);
238543 rc = sqlite3Fts5StorageDelete(pTab->pStorage, iNew, 0);
238545 fts5StorageInsert(&rc, pTab, apVal, pRowid);
238547 rc = sqlite3Fts5StorageContentInsert(pTab->pStorage, apVal, pRowid);
238549 rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld, 0);
238552 rc = sqlite3Fts5StorageIndexInsert(pTab->pStorage, apVal,*pRowid);
238556 rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld, 0);
238557 fts5StorageInsert(&rc, pTab, apVal, pRowid);
238563 pTab->p.pConfig->pzErrmsg = 0;
238572 Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
238573 fts5CheckTransactionState(pTab, FTS5_SYNC, 0);
238574 pTab->p.pConfig->pzErrmsg = &pTab->p.base.zErrMsg;
238575 fts5TripCursors(pTab);
238576 rc = sqlite3Fts5StorageSync(pTab->pStorage);
238577 pTab->p.pConfig->pzErrmsg = 0;
238607 Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
238608 fts5CheckTransactionState(pTab, FTS5_ROLLBACK, 0);
238609 rc = sqlite3Fts5StorageRollback(pTab->pStorage);
238631 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
238632 return sqlite3Fts5StorageSize(pTab->pStorage, iCol, pnToken);
238637 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
238638 return sqlite3Fts5StorageRowCount(pTab->pStorage, pnRow);
238648 Fts5Table *pTab = (Fts5Table*)(pCsr->base.pVtab);
238650 pTab->pConfig, FTS5_TOKENIZE_AUX, pText, nText, pUserData, xToken
238875 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
238876 Fts5Config *pConfig = pTab->p.pConfig;
238882 rc = sqlite3Fts5StorageDocsize(pTab->pStorage, iRowid, pCsr->aColumnSize);
239135 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
239144 pNew->base.pVtab = (sqlite3_vtab*)pTab;
239149 for(rc = fts5CursorFirst(pTab, pNew, 0);
239304 Fts5FullTable *pTab = (Fts5FullTable*)(pCursor->pVtab);
239305 Fts5Config *pConfig = pTab->p.pConfig;
239336 }else if( !fts5IsContentless(pTab) ){
239337 pConfig->pzErrmsg = &pTab->p.base.zErrMsg;
239359 Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
239363 pAux = fts5FindAuxiliary(pTab, zName);
239381 Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
239382 return sqlite3Fts5StorageRename(pTab->pStorage, zName);
239385 static int sqlite3Fts5FlushToDisk(Fts5Table *pTab){
239386 fts5TripCursors((Fts5FullTable*)pTab);
239387 return sqlite3Fts5StorageSync(((Fts5FullTable*)pTab)->pStorage);
239418 Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
239420 fts5CheckTransactionState(pTab, FTS5_ROLLBACKTO, iSavepoint);
239421 fts5TripCursors(pTab);
239422 return sqlite3Fts5StorageRollback(pTab->pStorage);
243598 Fts5VocabTable *pTab = (Fts5VocabTable*)pVtab;
243599 sqlite3_free(pTab);
243607 Fts5VocabTable *pTab = (Fts5VocabTable*)pVtab;
243608 sqlite3_free(pTab);
243794 Fts5VocabTable *pTab = (Fts5VocabTable*)pVTab;
243801 if( pTab->bBusy ){
243803 "recursive definition for %s.%s", pTab->zFts5Db, pTab->zFts5Tbl
243809 pTab->zFts5Tbl, pTab->zFts5Db, pTab->zFts5Tbl, pTab->zFts5Tbl
243812 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pStmt, 0);
243818 pTab->bBusy = 1;
243821 pFts5 = sqlite3Fts5TableFromCsrid(pTab->pGlobal, iId);
243823 pTab->bBusy = 0;
243831 "no such fts5 table: %s.%s", pTab->zFts5Db, pTab->zFts5Tbl
243939 Fts5VocabTable *pTab = (Fts5VocabTable*)pCursor->pVtab;
243947 if( pTab->eType==FTS5_VOCAB_INSTANCE ){
243951 if( pTab->eType==FTS5_VOCAB_COL ){
243957 if( pTab->eType!=FTS5_VOCAB_COL || pCsr->iCol>=nCol ){
243980 assert( pTab->eType==FTS5_VOCAB_COL || pTab->eType==FTS5_VOCAB_ROW );
243990 switch( pTab->eType ){
244031 assert( pTab->eType==FTS5_VOCAB_INSTANCE );
244038 if( pTab->eType==FTS5_VOCAB_INSTANCE ) break;
244053 if( rc==SQLITE_OK && pCsr->bEof==0 && pTab->eType==FTS5_VOCAB_COL ){
244072 Fts5VocabTable *pTab = (Fts5VocabTable*)pCursor->pVtab;
244074 int eType = pTab->eType;