Lines Matching refs:pTab
9017 Table *pTab; /* Source table */
9100 ** is a disk table or the "old.*" pseudo-table, then pTab points to the
9155 Table *pTab; /* Table for TK_COLUMN expressions. */
9318 Table *pTab; /* An SQL table corresponding to zName */
9326 Bitmask colUsed; /* Bit N (1<<N) set if column N of pTab is used */
9576 Table *pTab; /* Table this info block refers to */
9577 int iDb; /* Index in sqlite3.aDb[] of database holding pTab */
58382 Table *pTab;
58397 pTab = sqlite3LocateTable(pParse, 0, zTable, zDb);
58398 if( pTab && IsVirtual(pTab) ){
58399 pTab = 0;
58403 if( pTab && pTab->pSelect ){
58404 pTab = 0;
58408 if( !pTab ){
58419 /* Now search pTab for the exact column. */
58420 for(iCol=0; iCol < pTab->nCol; iCol++) {
58421 if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
58425 if( iCol==pTab->nCol ){
58447 for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){
58457 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
58476 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
58486 sqlite3VdbeChangeP2(v, 1, pTab->pSchema->schema_cookie);
58493 sqlite3VdbeChangeP2(v, 2, pTab->tnum);
58495 sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT);
58498 ** parameter of the other to pTab->tnum. */
58500 sqlite3VdbeChangeP2(v, 3 + flags, pTab->tnum);
58510 sqlite3VdbeChangeP4(v, 3+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32);
58511 sqlite3VdbeChangeP2(v, 7, pTab->nCol);
59421 ** pExpr->pTab Points to the Table structure of X.Y (even if
59462 pExpr->pTab = 0;
59472 Table *pTab;
59476 pTab = pItem->pTab;
59477 assert( pTab!=0 && pTab->zName!=0 );
59478 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
59479 assert( pTab->nCol>0 );
59485 char *zTabName = pTab->zName;
59496 pExpr->pTab = pTab;
59497 pSchema = pTab->pSchema;
59500 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
59505 pExpr->pTab = pTab;
59507 pSchema = pTab->pSchema;
59509 pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j;
59542 Table *pTab = 0;
59546 pTab = pParse->pTriggerTab;
59549 pTab = pParse->pTriggerTab;
59552 if( pTab ){
59554 pSchema = pTab->pSchema;
59556 for(iCol=0; iCol<pTab->nCol; iCol++){
59557 Column *pCol = &pTab->aCol[iCol];
59559 if( iCol==pTab->iPKey ){
59565 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) ){
59568 if( iCol<pTab->nCol ){
59582 pExpr->pTab = pTab;
59652 pExpr->pTab = 0;
59722 p->pTab = pItem->pTab;
59724 if( p->pTab->iPKey==iCol ){
59779 pExpr->pTab = pItem->pTab;
60419 ** Expr.pTab Points to the Table object for X.Y
60559 && pExpr->pTab!=0
60561 /* op==TK_REGISTER && pExpr->pTab!=0 happens when pExpr was originally
60565 assert( pExpr->pTab && j<pExpr->pTab->nCol );
60566 return pExpr->pTab->aCol[j].affinity;
60606 if( p->pTab!=0 && (
60609 /* op==TK_REGISTER && p->pTab!=0 happens when pExpr was originally
60615 zColl = p->pTab->aCol[j].zColl;
61401 Table *pTab;
61411 pTab = pNewItem->pTab = pOldItem->pTab;
61412 if( pTab ){
61413 pTab->nRef++;
61855 Table *pTab;
61871 pTab = pSrc->a[0].pTab;
61872 if( NEVER(pTab==0) ) return 0;
61873 assert( pTab->pSelect==0 ); /* FROM clause is not a view */
61874 if( IsVirtual(pTab) ) return 0; /* FROM clause not a virtual table */
61955 Table *pTab = p->pSrc->a[0].pTab; /* Table <table>. */
61956 int iDb; /* Database idx for pTab */
61959 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
61961 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
61975 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
61992 int affinity_ok = (pTab->aCol[iCol].affinity==aff||aff==SQLITE_AFF_NONE);
61994 for(pIdx=pTab->pIndex; pIdx && eType==0 && affinity_ok; pIdx=pIdx->pNext){
62013 if( prNotFound && !pTab->aCol[iCol].notNull ){
62597 ** table pTab and store the column value in a register. An effort
62601 ** There must be an open cursor to pTab in iTable when this routine
62606 Table *pTab, /* Description of the table we are reading from */
62625 }else if( ALWAYS(pTab!=0) ){
62626 int op = IsVirtual(pTab) ? OP_VColumn : OP_Column;
62628 sqlite3ColumnDefault(v, pTab, iColumn, iReg);
62824 inReg = sqlite3ExprCodeGetColumn(pParse, pExpr->pTab,
63244 Table *pTab = pExpr->pTab;
63245 int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn;
63248 assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
63249 assert( pTab->iPKey<0 || pExpr->iColumn!=pTab->iPKey );
63250 assert( p1>=0 && p1<(pTab->nCol*2+2) );
63255 (pExpr->iColumn<0 ? "rowid" : pExpr->pTab->aCol[pExpr->iColumn].zName),
63262 && pTab->aCol[pExpr->iColumn].affinity==SQLITE_AFF_REAL
64064 pCol->pTab = pExpr->pTab;
64523 ** tables that have foreign key constraints that refer to table pTab (i.e.
64524 ** constraints for which pTab is the parent table) from the sqlite_master
64527 static char *whereForeignKeys(Parse *pParse, Table *pTab){
64530 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
64539 ** temporary triggers on table pTab from the sqlite_temp_master table. If
64540 ** table pTab has no temporary triggers, or is itself stored in the
64543 static char *whereTempTriggers(Parse *pParse, Table *pTab){
64553 if( pTab->pSchema!=pTempSchema ){
64555 for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
64566 ** pTab from the database, including triggers and temporary triggers.
64569 ** pTab->zName if this function is being called to code part of an
64572 static void reloadTableSchema(Parse *pParse, Table *pTab, const char *zName){
64575 int iDb; /* Index of database containing pTab */
64583 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
64588 for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
64596 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
64607 if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){
64624 Table *pTab; /* Table being renamed */
64639 pTab = sqlite3LocateTable(pParse, 0, pSrc->a[0].zName, pSrc->a[0].zDatabase);
64640 if( !pTab ) goto exit_rename_table;
64641 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
64660 if( sqlite3Strlen30(pTab->zName)>6
64661 && 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7)
64663 sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName);
64671 if( pTab->pSelect ){
64672 sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
64679 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
64685 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
64688 if( IsVirtual(pTab) ){
64689 pVTab = sqlite3GetVTable(db, pTab);
64723 zTabName = pTab->zName;
64731 if( (zWhere=whereForeignKeys(pParse, pTab))!=0 ){
64773 zDb, zName, pTab->zName);
64782 if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){
64795 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
64797 if( pFrom!=pTab ){
64805 reloadTableSchema(pParse, pTab, zName);
64848 Table *pTab; /* Table being altered */
64868 pTab = sqlite3FindTable(db, zTab, zDb);
64869 assert( pTab );
64873 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
64949 reloadTableSchema(pParse, pTab, pTab->zName);
64969 Table *pTab;
64980 pTab = sqlite3LocateTable(pParse, 0, pSrc->a[0].zName, pSrc->a[0].zDatabase);
64981 if( !pTab ) goto exit_begin_add_column;
64984 if( IsVirtual(pTab) ){
64991 if( pTab->pSelect ){
64996 assert( pTab->addColOffset>0 );
64997 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
65010 pNew->dbMem = pTab->dbMem;
65011 pNew->nCol = pTab->nCol;
65016 pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
65021 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
65031 pNew->addColOffset = pTab->addColOffset;
65151 Table *pTab, /* Table whose indices are to be analyzed */
65163 int iDb; /* Index of database containing pTab */
65181 if( v==0 || NEVER(pTab==0) || pTab->pIndex==0 ){
65186 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
65189 if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,
65196 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
65199 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
65214 if( pTab->pIndex==pIdx ){
65215 sqlite3VdbeAddOp4(v, OP_String8, 0, regTabname, 0, pTab->zName, 0);
65222 ** first index in the pTab->pIndex list, then register regLast has
65224 if( pTab->pIndex==pIdx ){
65397 Table *pTab = (Table*)sqliteHashData(k);
65398 analyzeOneTable(pParse, pTab, iStatCur, iMem);
65407 static void analyzeTable(Parse *pParse, Table *pTab){
65411 assert( pTab!=0 );
65413 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
65417 openStatTable(pParse, iDb, iStatCur, pTab->zName);
65418 analyzeOneTable(pParse, pTab, iStatCur, pParse->nMem+1);
65439 Table *pTab;
65464 pTab = sqlite3LocateTable(pParse, 0, z, 0);
65466 if( pTab ){
65467 analyzeTable(pParse, pTab);
65478 pTab = sqlite3LocateTable(pParse, 0, z, zDb);
65480 if( pTab ){
65481 analyzeTable(pParse, pTab);
66373 Table *pTab = 0; /* The table being read */
66389 pTab = pParse->pTriggerTab;
66394 pTab = pTabList->a[iSrc].pTab;
66400 if( NEVER(pTab==0) ) return;
66403 assert( iCol<pTab->nCol );
66404 zCol = pTab->aCol[iCol].zName;
66405 }else if( pTab->iPKey>=0 ){
66406 assert( pTab->iPKey<pTab->nCol );
66407 zCol = pTab->aCol[pTab->iPKey].zName;
66412 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
67612 Table *pTab = pParse->pNewTable;
67615 if( pTab==0 || IN_DECLARE_VTAB ) goto primary_key_exit;
67616 if( pTab->tabFlags & TF_HasPrimaryKey ){
67618 "table \"%s\" has more than one primary key", pTab->zName);
67621 pTab->tabFlags |= TF_HasPrimaryKey;
67623 iCol = pTab->nCol - 1;
67624 pTab->aCol[iCol].isPrimKey = 1;
67627 for(iCol=0; iCol<pTab->nCol; iCol++){
67628 if( sqlite3StrICmp(pList->a[i].zName, pTab->aCol[iCol].zName)==0 ){
67632 if( iCol<pTab->nCol ){
67633 pTab->aCol[iCol].isPrimKey = 1;
67638 if( iCol>=0 && iCol<pTab->nCol ){
67639 zType = pTab->aCol[iCol].zType;
67643 pTab->iPKey = iCol;
67644 pTab->keyConf = (u8)onError;
67646 pTab->tabFlags |= autoInc*TF_Autoincrement;
67675 Table *pTab = pParse->pNewTable;
67676 if( pTab && !IN_DECLARE_VTAB ){
67677 pTab->pCheck = sqlite3ExprAnd(db, pTab->pCheck, pCheckExpr);
67955 sSrc.a[0].pTab = p;
68308 Table *pTab = sqliteHashData(i);
68309 if( pTab->pSelect ){
68310 sqliteResetColumnNames(pTab);
68343 Table *pTab = sqliteHashData(pElem);
68344 if( pTab->tnum==iFrom ){
68345 pTab->tnum = iTo;
68387 ** Write VDBE code to erase table pTab and all associated indices on disk.
68392 static void destroyTable(Parse *pParse, Table *pTab){
68395 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
68396 destroyRootPage(pParse, pTab->tnum, iDb);
68397 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
68417 int iTab = pTab->tnum;
68427 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
68429 assert( pIdx->pSchema==pTab->pSchema );
68437 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
68450 Table *pTab;
68461 pTab = sqlite3LocateTable(pParse, isView,
68465 if( pTab==0 ){
68468 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
68471 /* If pTab is a virtual table, call ViewGetColumnNames() to ensure
68474 if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){
68493 }else if( IsVirtual(pTab) ){
68495 zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
68504 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
68507 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
68512 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
68513 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
68521 if( isView && pTab->pSelect==0 ){
68522 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
68525 if( !isView && pTab->pSelect ){
68526 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
68541 if( IsVirtual(pTab) ){
68545 sqlite3FkDropTable(pParse, pName, pTab);
68551 pTrigger = sqlite3TriggerList(pParse, pTab);
68553 assert( pTrigger->pSchema==pTab->pSchema ||
68565 if( pTab->tabFlags & TF_Autoincrement ){
68568 pDb->zName, pTab->zName
68582 pDb->zName, SCHEMA_TABLE(iDb), pTab->zName);
68587 "DELETE FROM %Q.sqlite_stat1 WHERE tbl=%Q", pDb->zName, pTab->zName
68591 if( !isView && !IsVirtual(pTab) ){
68592 destroyTable(pParse, pTab);
68598 if( IsVirtual(pTab) ){
68599 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
68601 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
68748 Table *pTab;
68750 if( (pTab = pParse->pNewTable)==0 || (pFKey = pTab->pFKey)==0 ) return;
68768 Table *pTab = pIndex->pTable; /* The table that is indexed */
68769 int iTab = pParse->nTab++; /* Btree cursor used for pTab */
68788 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
68804 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
68864 Table *pTab = 0; /* Table to be indexed */
68909 pTab = sqlite3SrcListLookup(pParse, pTblName);
68910 if( pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){
68923 pTab = sqlite3LocateTable(pParse, 0, pTblName->a[0].zName,
68925 if( !pTab
68926 assert( db->aDb[iDb].pSchema==pTab->pSchema );
68929 pTab = pParse->pNewTable;
68930 if( !pTab ) goto exit_create_index;
68931 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
68935 assert( pTab!=0 );
68937 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
68938 && memcmp(&pTab->zName[7],"altertab_",9)!=0 ){
68939 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
68943 if( pTab->pSelect ){
68949 if( IsVirtual(pTab) ){
68989 for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
68990 zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
69006 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
69017 nullId.z = pTab->aCol[pTab->nCol-1].zName;
69064 pIndex->pTable = pTab;
69094 for(j=0, pTabCol=pTab->aCol; j<pTab->nCol; j++, pTabCol++){
69097 if( j>=pTab->nCol ){
69099 pTab->zName, zColName);
69118 zColl = pTab->aCol[j].zColl;
69132 if( pTab==pParse->pNewTable ){
69155 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
69262 pTab->zName,
69287 if( onError!=OE_Replace || pTab->pIndex==0
69288 || pTab->pIndex->onError==OE_Replace){
69289 pIndex->pNext = pTab->pIndex;
69290 pTab->pIndex = pIndex;
69292 Index *pOther = pTab->pIndex;
69385 Table *pTab = pIndex->pTable;
69392 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
69685 sqlite3DeleteTable(pItem->pTab);
70043 ** Recompute all indices of pTab that use the collating sequence pColl.
70044 ** If pColl==0 then recompute all indices of pTab.
70047 static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){
70048 Index *pIndex; /* An index associated with pTab */
70050 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
70052 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
70071 Table *pTab; /* A table in the database */
70076 pTab = (Table*)sqliteHashData(k);
70077 reindexTable(pParse, pTab, zColl);
70101 Table *pTab; /* A table in the database */
70102 Index *pIndex; /* An index associated with pTab */
70134 pTab = sqlite3FindTable(db, z, zDb);
70135 if( pTab ){
70136 reindexTable(pParse, pTab, 0);
70607 Table *pTab = sqliteHashData(pElem);
70608 assert( pTab->dbMem==0 );
70609 sqlite3DeleteTable(pTab);
70664 Table *pTab;
70666 pTab = sqlite3LocateTable(pParse, 0, pItem->zName, pItem->zDatabase);
70667 sqlite3DeleteTable(pItem->pTab);
70668 pItem->pTab = pTab;
70669 if( pTab ){
70670 pTab->nRef++;
70673 pTab = 0;
70675 return pTab;
70683 SQLITE_PRIVATE int sqlite3IsReadOnly(Parse *pParse, Table *pTab, int viewOk){
70694 if( ( IsVirtual(pTab)
70695 && sqlite3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0 )
70696 || ( (pTab->tabFlags & TF_Readonly)!=0
70700 sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
70705 if( !viewOk && pTab->pSelect ){
70706 sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
70860 Table *pTab; /* The table from which records will be deleted */
70861 const char *zDb; /* Name of database holding pTab */
70866 int iCur; /* VDBE Cursor number for pTab */
70891 pTab = sqlite3SrcListLookup(pParse, pTabList);
70892 if( pTab==0 ) goto delete_from_cleanup;
70898 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
70899 isView = pTab->pSelect!=0;
70909 /* If pTab is really a view, make sure it has been initialized.
70911 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
70915 if( sqlite3IsReadOnly(pParse, pTab, (pTrigger?1:0)) ){
70918 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
70921 rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb);
70932 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
70939 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
70956 sqlite3MaterializeView(pParse, pTab, pWhere, iCur);
70982 if( rcauth==SQLITE_OK && pWhere==0 && !pTrigger && !IsVirtual(pTab)
70983 && 0==sqlite3FkRequired(pParse, pTab, 0, 0)
70986 sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt,
70987 pTab->zName, P4_STATIC);
70988 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
70989 assert( pIdx->pSchema==pTab->pSchema );
71007 regRowid = sqlite3ExprCodeGetColumn(pParse, pTab, -1, iCur, iRowid);
71024 sqlite3OpenTableAndIndices(pParse, pTab, iCur, OP_OpenWrite);
71031 if( IsVirtual(pTab) ){
71032 const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
71033 sqlite3VtabMakeWritable(pParse, pTab);
71040 sqlite3GenerateRowDelete(pParse, pTab, iCur, iRowid, count, pTrigger, OE_Default);
71048 if( !isView && !IsVirtual(pTab) ){
71049 for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
71097 ** 1. A read/write cursor pointing to pTab, the table containing the row
71100 ** 2. Read/write cursors for all indices of pTab must be open as
71111 Table *pTab, /* Table containing the row to be deleted */
71133 if( sqlite3FkRequired(pParse, pTab, 0, 0) || pTrigger ){
71140 pParse, pTrigger, 0, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onconf
71142 mask |= sqlite3FkOldmask(pParse, pTab);
71144 pParse->nMem += (1 + pTab->nCol);
71149 for(iCol=0; iCol<pTab->nCol; iCol++){
71153 sqlite3ColumnDefault(v, pTab, iCol, iTarget);
71159 TK_DELETE, 0, TRIGGER_BEFORE, pTab, iOld, onconf, iLabel
71171 sqlite3FkCheck(pParse, pTab, iOld, 0);
71174 /* Delete the index and table entries. Skip this step if pTab is really
71177 if( pTab->pSelect==0 ){
71178 sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, 0);
71181 sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_STATIC);
71188 sqlite3FkActions(pParse, pTab, 0, iOld);
71192 TK_DELETE, 0, TRIGGER_AFTER, pTab, iOld, onconf, iLabel
71208 ** 1. A read/write cursor pointing to pTab, the table containing the row
71211 ** 2. Read/write cursors for all indices of pTab must be open as
71219 Table *pTab, /* Table containing the row to be deleted */
71227 for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
71236 ** regOut. The key with be for index pIdx which is an index on pTab.
71237 ** iCur is the index of a cursor open on the pTab table and pointing to
71254 Table *pTab = pIdx->pTable;
71263 if( idx==pTab->iPKey ){
71267 sqlite3ColumnDefault(v, pTab, idx, -1);
73119 int iDb, /* Index of database housing pTab */
73120 Table *pTab, /* Parent table of FK pFKey */
73121 Index *pIdx, /* Unique index on parent key columns in pTab */
73126 int isIgnore /* If true, pretend pTab contains all NULL values */
73151 ** column of the parent table (table pTab). */
73167 if( pTab==pFKey->pFrom && nIncr==1 ){
73171 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);
73193 if( pTab==pFKey->pFrom && nIncr==1 ){
73263 Table *pTab,
73278 assert( !pIdx || pIdx->pTable==pTab );
73327 if( pTab==pFKey->pFrom && nIncr>0 ){
73371 ** constraints for which table pTab is the parent table. For example,
73383 SQLITE_PRIVATE FKey *sqlite3FkReferences(Table *pTab){
73384 int nName = sqlite3Strlen30(pTab->zName);
73385 return (FKey *)sqlite3HashFind(&pTab->pSchema->fkeyHash, pTab->zName, nName);
73408 ** This function is called to generate code that runs when table pTab is
73411 ** table pTab.
73424 SQLITE_PRIVATE void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTab){
73426 if( (db->flags&SQLITE_ForeignKeys) && !IsVirtual(pTab) && !pTab->pSelect ){
73431 if( sqlite3FkReferences(pTab)==0 ){
73438 for(p=pTab->pFKey; p; p=p->pNextFrom){
73467 ** table pTab to generate VDBE code to perform foreign key constraint
73471 ** first register in an array of (pTab->nCol+1) registers containing the
73477 ** first register of an array of (pTab->nCol+1) registers containing the new
73487 Table *pTab, /* Row is being deleted from this table */
73494 int iDb; /* Index of database containing pTab */
73495 const char *zDb; /* Name of database containing pTab */
73505 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
73508 /* Loop through all the foreign key constraints for which pTab is the
73510 for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){
73541 if( aiCol[i]==pTab->iPKey ){
73579 for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){
73591 if( locateFkeyIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ){
73603 pItem->pTab = pFKey->pFrom;
73605 pItem->pTab->nRef++;
73609 fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regNew, -1);
73618 fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regOld, 1);
73631 ** row contained in table pTab.
73635 Table *pTab /* Table being modified */
73641 for(p=pTab->pFKey; p; p=p->pNextFrom){
73644 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
73646 locateFkeyIndex(pParse, pTab, p, &pIdx, 0);
73657 ** row contained in table pTab. If the operation is a DELETE, then
73659 ** to an array of size N, where N is the number of columns in table pTab.
73671 Table *pTab, /* Table being modified */
73680 return (sqlite3FkReferences(pTab) || pTab->pFKey);
73688 for(p=pTab->pFKey; p; p=p->pNextFrom){
73692 if( iChildKey==pTab->iPKey && chngRowid ) return 1;
73697 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
73701 for(iKey=0; iKey<pTab->nCol; iKey++){
73702 Column *pCol = &pTab->aCol[iKey];
73705 if( iKey==pTab->iPKey && chngRowid ) return 1;
73717 ** compiled on table pTab, which is the parent table of foreign-key pFKey.
73728 ** For example, if pFKey is the foreign key and pTab is table "p" in
73746 Table *pTab, /* Table being updated or deleted from */
73771 if( locateFkeyIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ) return 0;
73784 tToCol.z = pIdx ? pTab->aCol[pIdx->aiColumn[i]].zName : "oid";
73867 /* In the current implementation, pTab->dbMem==0 for all tables except
73869 ** tables do not have foreign key constraints. Hence, pTab->dbMem
73920 pTrigger->pSchema = pTab->pSchema;
73921 pTrigger->pTabSchema = pTab->pSchema;
73935 Table *pTab, /* Table being updated or deleted from */
73940 ** refer to table pTab. If there is an action associated with the FK
73945 for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){
73946 Trigger *pAction = fkActionTrigger(pParse, pTab, pFKey, pChanges);
73948 sqlite3CodeRowTriggerDirect(pParse, pAction, pTab, regOld, OE_Abort, 0);
73958 ** table pTab. Remove the deleted foreign keys from the Schema.fkeyHash
73961 SQLITE_PRIVATE void sqlite3FkDelete(Table *pTab){
73965 for(pFKey=pTab->pFKey; pFKey; pFKey=pNext){
73973 sqlite3HashInsert(&pTab->pSchema->fkeyHash, z, sqlite3Strlen30(z), data);
73981 fkTriggerDelete(pTab->dbMem, pFKey->apTrigger[0]);
73982 fkTriggerDelete(pTab->dbMem, pFKey->apTrigger[1]);
73991 sqlite3DbFree(pTab->dbMem, pFKey);
74020 Table *pTab, /* The table to be opened */
74024 if( IsVirtual(pTab) ) return;
74027 sqlite3TableLock(p, iDb, pTab->tnum, (opcode==OP_OpenWrite)?1:0, pTab->zName);
74028 sqlite3VdbeAddOp3(v, opcode, iCur, pTab->tnum, iDb);
74029 sqlite3VdbeChangeP4(v, -1, SQLITE_INT_TO_PTR(pTab->nCol), P4_INT32);
74030 VdbeComment((v, "%s", pTab->zName));
74064 Table *pTab = pIdx->pTable;
74072 pIdx->zColAff[n] = pTab->aCol[pIdx->aiColumn[n]].affinity;
74083 ** string for table pTab. A column affinity string has one character
74095 SQLITE_PRIVATE void sqlite3TableAffinityStr(Vdbe *v, Table *pTab){
74103 if( !pTab->zColAff ){
74108 zColAff = (char *)sqlite3Malloc(pTab->nCol+1);
74114 for(i=0; i<pTab->nCol; i++){
74115 zColAff[i] = pTab->aCol[i].affinity;
74117 zColAff[pTab->nCol] = '\0';
74119 pTab->zColAff = zColAff;
74122 sqlite3VdbeChangeP4(v, -1, pTab->zColAff, 0);
74126 ** Return non-zero if the table pTab in database iDb or any of its indices
74129 ** a statement of the form "INSERT INTO <iDb, pTab> SELECT ..." can
74132 static int readsTable(Parse *p, int iStartAddr, int iDb, Table *pTab){
74137 VTable *pVTab = IsVirtual(pTab) ? sqlite3GetVTable(p->db, pTab) : 0;
74146 if( tnum==pTab->tnum ){
74149 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
74168 ** Locate or create an AutoincInfo structure associated with table pTab
74175 ** first use of table pTab. On 2nd and subsequent uses, the original
74180 ** (1) Register to hold the name of the pTab table.
74181 ** (2) Register to hold the maximum ROWID of pTab.
74182 ** (3) Register to hold the rowid in sqlite_sequence of pTab
74189 int iDb, /* Index of the database holding pTab */
74190 Table *pTab /* The table we are writing to */
74193 if( pTab->tabFlags & TF_Autoincrement ){
74198 while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; }
74204 pInfo->pTab = pTab;
74238 sqlite3VdbeAddOp4(v, OP_String8, 0, memId-1, 0, p->pTab->zName, 0);
74436 Table *pTab; /* The table to insert into. aka TABLE */
74444 int baseCur = 0; /* VDBE Cursor number for pTab */
74470 Trigger *pTrigger; /* List of triggers on pTab, if required */
74485 pTab = sqlite3SrcListLookup(pParse, pTabList);
74486 if( pTab==0 ){
74489 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
74493 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb) ){
74501 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0, &tmask);
74502 isView = pTab->pSelect!=0;
74514 /* If pTab is really a view, make sure it has been initialized.
74515 ** ViewGetColumnNames() is a no-op if pTab is not a view (or virtual
74518 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
74526 if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
74547 if( pColumn==0 && xferOptimization(pParse, pTab, pSelect, onError, iDb) ){
74557 regAutoinc = autoIncBegin(pParse, iDb, pTab);
74624 if( pTrigger || readsTable(pParse, addrSelect, iDb, pTab) ){
74679 if( IsVirtual(pTab) ){
74680 for(i=0; i<pTab->nCol; i++){
74681 nHidden += (IsHiddenColumn(&pTab->aCol[i]) ? 1 : 0);
74684 if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){
74687 pTabList, 0, pTab->nCol-nHidden, nColumn);
74704 ** key in the original table is pTab->iPKey.)
74711 for(j=0; j<pTab->nCol; j++){
74712 if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){
74714 if( j==pTab->iPKey ){
74720 if( j>=pTab->nCol ){
74738 keyColumn = pTab->iPKey;
74753 nIdx = sqlite3OpenTableAndIndices(pParse, pTab, baseCur, OP_OpenWrite);
74795 pParse->nMem += pTab->nCol + 1;
74796 if( IsVirtual(pTab) ){
74806 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
74833 assert( !IsVirtual(pTab) );
74837 for(i=0; i<pTab->nCol; i++){
74846 sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, regCols+i+1);
74861 sqlite3VdbeAddOp2(v, OP_Affinity, regCols+1, pTab->nCol);
74862 sqlite3TableAffinityStr(v, pTab);
74867 pTab, regCols-pTab->nCol-1, onError, endOfLoop);
74869 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
74878 if( IsVirtual(pTab) ){
74891 if( ALWAYS(pOp) && pOp->opcode==OP_Null && !IsVirtual(pTab) ){
74904 if( !IsVirtual(pTab) ){
74914 }else if( IsVirtual(pTab) ){
74926 for(i=0; i<pTab->nCol; i++){
74928 if( i==pTab->iPKey ){
74937 if( IsHiddenColumn(&pTab->aCol[i]) ){
74938 assert( IsVirtual(pTab) );
74950 sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, iRegStore);
74964 if( IsVirtual(pTab) ){
74965 const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
74966 sqlite3VtabMakeWritable(pParse, pTab);
74967 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
74973 sqlite3GenerateConstraintChecks(pParse, pTab, baseCur, regIns, aRegIdx,
74976 sqlite3FkCheck(pParse, pTab, 0, regIns);
74978 pParse, pTab, baseCur, regIns, aRegIdx, 0, appendFlag, isReplace==0
74992 pTab, regData-2-pTab->nCol, onError, endOfLoop);
75008 if( !IsVirtual(pTab) && !isView ){
75011 for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
75127 ** The calling routine must open a read/write cursor for pTab with
75128 ** cursor number "baseCur". All indices of pTab must also have open
75135 Table *pTab, /* the table into which we are inserting */
75136 int baseCur, /* Index of a read/write cursor pointing at pTab */
75159 assert( pTab->pSelect==0 ); /* This table is not a VIEW */
75160 nCol = pTab->nCol;
75166 if( i==pTab->iPKey ){
75169 onError = pTab->aCol[i].notNull;
75176 if( onError==OE_Replace && pTab->aCol[i].pDflt==0 ){
75190 pTab->zName, pTab->aCol[i].zName);
75201 sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, regData+i);
75211 if( pTab->pCheck && (pParse->db->flags & SQLITE_IgnoreChecks)==0 ){
75214 sqlite3ExprIfTrue(pParse, pTab->pCheck, allOk, SQLITE_JUMPIFNULL);
75230 onError = pTab->keyConf;
75265 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
75268 if( pTrigger || sqlite3FkRequired(pParse, pTab, 0, 0) ){
75270 pParse, pTab, baseCur, regRowid, 0, pTrigger, OE_Replace
75273 sqlite3GenerateRowIndexDelete(pParse, pTab, baseCur, 0);
75294 for(iCur=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, iCur++){
75304 if( idx==pTab->iPKey ){
75355 char *zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
75377 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
75380 pParse, pTab, baseCur, regR, 0, pTrigger, OE_Replace
75406 Table *pTab, /* the table into which we are inserting */
75407 int baseCur, /* Index of a read/write cursor pointing at pTab */
75424 assert( pTab->pSelect==0 ); /* This table is not a VIEW */
75425 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
75435 sqlite3VdbeAddOp3(v, OP_MakeRecord, regData, pTab->nCol, regRec);
75436 sqlite3TableAffinityStr(v, pTab);
75437 sqlite3ExprCacheAffinityChange(pParse, regData, pTab->nCol);
75452 sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_STATIC);
75466 Table *pTab, /* Table to be opened */
75475 if( IsVirtual(pTab) ) return 0;
75476 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
75479 sqlite3OpenTable(pParse, baseCur, iDb, pTab
75480 for(i=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
75482 assert( pIdx->pSchema==pTab->pSchema );
77785 Table *pTab;
77787 pTab = sqlite3FindTable(db, zRight, zDb);
77788 if( pTab ){
77800 sqlite3ViewGetColumnNames(pParse, pTab);
77801 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
77824 Table *pTab;
77829 pTab = pIdx->pTable;
77839 assert( pTab->nCol>cnum );
77840 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pTab->aCol[cnum].zName, 0);
77848 Table *pTab;
77850 pTab = sqlite3FindTable(db, zRight, zDb);
77851 if( pTab ){
77853 pIdx = pTab->pIndex;
77911 Table *pTab;
77913 pTab = sqlite3FindTable(db, zRight, zDb);
77914 if( pTab ){
77916 pFK = pTab->pFKey;
77939 pTab->aCol[pFK->aCol[j].iFrom].zName, 0);
78038 Table *pTab = sqliteHashData(x);
78040 sqlite3VdbeAddOp2(v, OP_Integer, pTab->tnum, 2+cnt);
78042 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
78068 Table *pTab = sqliteHashData(x);
78072 if( pTab->pIndex==0 ) continue;
78076 sqlite3OpenTableAndIndices(pParse, pTab, 1, OP_OpenRead);
78080 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
78107 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
78517 Table *pTab;
78582 pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName);
78583 if( ALWAYS(pTab) ){
78584 pTab->tabFlags |= TF_Readonly;
79424 static int columnIndex(Table *pTab, const char *zCol){
79426 for(i=0; i<pTab->nCol; i++){
79427 if( sqlite3StrICmp(pTab->aCol[i].zName, zCol)==0 ) return i;
79446 int *piCol /* Write index of pSrc->a[*piTab].pTab->aCol[] here */
79453 iCol = columnIndex(pSrc->a[i].pTab, zCol);
79493 assert( pSrc->a[iLeft].pTab );
79494 assert( pSrc->a[iRight].pTab );
79570 Table *pLeftTab = pLeft->pTab;
79571 Table *pRightTab = pRight->pTab;
80157 Table *pTab = 0; /* Table structure column is extracted from */
80159 int iCol = pExpr->iColumn; /* Index of column in pTab */
80162 while( pNC && !pTab ){
80166 pTab = pTabList->a[j].pTab;
80173 if( pTab==0 ){
80194 assert( pTab && pExpr->pTab==pTab );
80212 }else if( ALWAYS(pTab->pSchema) ){
80215 if( iCol<0 ) iCol = pTab->iPKey;
80216 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
80221 zType = pTab->aCol[iCol].zType;
80222 zOriginCol = pTab->aCol[iCol].zName;
80224 zOriginTab = pTab->zName;
80226 int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
80334 Table *pTab;
80341 pTab = pTabList->a[j].pTab;
80342 if( iCol<0 ) iCol = pTab->iPKey;
80343 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
80347 zCol = pTab->aCol[iCol].zName;
80354 zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol);
80425 Table *pTab; /* Table associated with this expression */
80427 if( pColExpr->op==TK_COLUMN && ALWAYS(pColExpr->pTab!=0) ){
80430 pTab = pColExpr->pTab;
80431 if( iCol<0 ) iCol = pTab->iPKey;
80433 iCol>=0 ? pTab->aCol[iCol].zName : "rowid");
80525 Table *pTab;
80536 pTab = sqlite3DbMallocZero(db, sizeof(Table) );
80537 if( pTab==0 ){
80541 ** is disabled, so we might as well hard-code pTab->dbMem to NULL. */
80543 pTab->dbMem = 0;
80544 pTab->nRef = 1;
80545 pTab->zName = 0;
80546 selectColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
80547 selectAddColumnTypeAndCollation(pParse, pTab->nCol, pTab->aCol, pSelect);
80548 pTab->iPKey = -1;
80550 sqlite3DeleteTable(pTab);
80553 return pTab;
82021 ** complete, since there may still exist Expr.pTab entries that
82024 ** pSubitem->pTab is always non-NULL by test restrictions and tests above.
82026 if( ALWAYS(pSubitem->pTab!=0) ){
82027 Table *pTabToDel = pSubitem->pTab;
82035 pSubitem->pTab = 0;
82223 Table *pTab;
82233 pTab = p->pSrc->a[0].pTab;
82235 assert( pTab && !pTab->pSelect && pExpr );
82237 if( IsVirtual(pTab) ) return 0;
82242 return pTab;
82253 if( pFrom->pTab && pFrom->zIndex ){
82254 Table *pTab = pFrom->pTab;
82257 for(pIdx=pTab->pIndex;
82277 ** (2) Fill in the pTabList->a[].pTab fields in the SrcList that
82322 Table *pTab;
82323 if( pFrom->pTab!=0 ){
82334 assert( pFrom->pTab==0 );
82336 pFrom->pTab = pTab = sqlite3DbMallocZero(db, sizeof(Table));
82337 if( pTab==0 ) return WRC_Abort;
82338 pTab->dbMem = db->lookaside.bEnabled ? db : 0;
82339 pTab->nRef = 1;
82340 pTab->zName = sqlite3MPrintf(db, "sqlite_subquery_%p_", (void*)pTab);
82342 selectColumnsFromExprList(pParse, pSel->pEList, &pTab->nCol, &pTab->aCol);
82343 pTab->iPKey = -1;
82344 pTab->tabFlags |= TF_Ephemeral;
82348 assert( pFrom->pTab==0 );
82349 pFrom->pTab = pTab =
82351 if( pTab==0 ) return WRC_Abort;
82352 pTab->nRef++;
82354 if( pTab->pSelect || IsVirtual(pTab) ){
82356 if( sqlite3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort;
82358 pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect, 0);
82432 Table *pTab = pFrom->pTab;
82435 zTabName = pTab->zName;
82442 for(j=0; j<pTab->nCol; j++){
82444 char *zName = pTab->aCol[j].zName;
82453 if( IsHiddenColumn(&pTab->aCol[j]) ){
82454 assert(IsVirtual(pTab));
82575 Table *pTab = pFrom->pTab;
82576 if( ALWAYS(pTab!=0) && (pTab->tabFlags & TF_Ephemeral)!=0 ){
82581 selectAddColumnTypeAndCollation(pParse, pTab->nCol, pTab->aCol, pSel);
83160 pCol->pTab, pCol->iColumn, pCol->iTable, r1);
83276 Table *pTab;
83277 if( (pTab = isSimpleCount(p, &sAggInfo))!=0 ){
83291 const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
83296 int iRoot = pTab->tnum; /* Root page of scanned b-tree */
83299 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
83312 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
83317 if( pBest && pBest->nColumn<pTab->nCol ){
83490 if( pItem->pTab ){
83491 sqlite3DebugPrintf("(table: %s)", pItem->pTab->zName);
83758 ** Given table pTab, return a list of all the triggers attached to
83761 ** All of the triggers on pTab that are in the same database as pTab
83762 ** are already attached to pTab->pTrigger. But there might be additional
83763 ** triggers on pTab in the TEMP schema. This routine prepends all
83764 ** TEMP triggers on pTab to the beginning of the pTab->pTrigger list
83768 ** that fire off of pTab. The list will include any TEMP triggers on
83769 ** pTab as well as the triggers lised in pTab->pTrigger.
83771 SQLITE_PRIVATE Trigger *sqlite3TriggerList(Parse *pParse, Table *pTab){
83779 if( pTmpSchema!=pTab->pSchema ){
83783 if( pTrig->pTabSchema==pTab->pSchema
83784 && 0==sqlite3StrICmp(pTrig->table, pTab->zName)
83786 pTrig->pNext = (pList ? pList : pTab->pTrigger);
83792 return (pList ? pList : pTab->pTrigger);
83816 Table *pTab; /* Table that the trigger fires off of */
83822 int iTabDb; /* Index of the database holding pTab */
83852 pTab = sqlite3SrcListLookup(pParse, pTableName);
83853 if( pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){
83864 pTab = sqlite3SrcListLookup(pParse, pTableName);
83865 if( !pTab ){
83880 if( IsVirtual(pTab) ){
83900 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
83909 if( pTab->pSelect && tr_tm!=TK_INSTEAD ){
83914 if( !pTab->pSelect && tr_tm==TK_INSTEAD ){
83919 iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
83927 if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
83952 pTrigger->pTabSchema = pTab->pSchema;
84035 Table *pTab;
84037 pTab = sqlite3HashFind(&pLink->pTabSchema->tblHash, pLink->table, n);
84038 assert( pTab!=0 );
84039 pLink->pNext = pTab->pTrigger;
84040 pTab->pTrigger = pLink;
84307 Table *pTab = tableOfTrigger(pTrigger);
84309 for(pp=&pTab->pTrigger; *pp!=pTrigger; pp=&((*pp)->pNext));
84336 ** Return a list of all triggers on table pTab if there exists at least
84343 Table *pTab, /* The table the contains the triggers */
84349 Trigger *pList = sqlite3TriggerList(pParse, pTab);
84351 assert( pList==0 || IsVirtual(pTab)==0 );
84511 Table *pTab, /* The table pTrigger is attached to */
84524 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
84548 pSubParse->pTriggerTab = pTab;
84561 pTab->zName
84621 Table *pTab, /* The table trigger pTrigger is attached to */
84627 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
84640 pPrg = codeRowTrigger(pParse, pTrigger, pTab, orconf);
84648 ** table pTab. The reg, orconf and ignoreJump parameters passed to this
84655 Table *pTab, /* The table to code triggers from */
84662 pPrg = getRowTrigger(pParse, p, pTab, orconf);
84685 ** on table pTab. The operation to code triggers for (INSERT, UPDATE or DELETE)
84691 ** operation on pTab, this function is a no-op.
84695 ** in the trigger program. If N is the number of columns in table pTab
84696 ** (a copy of pTab->nCol), then registers are populated as follows:
84701 ** reg+1 OLD.* value of left-most column of pTab
84703 ** reg+N OLD.* value of right-most column of pTab
84705 ** reg+N+2 OLD.* value of left-most column of pTab
84707 ** reg+N+N+1 NEW.* value of right-most column of pTab
84725 Trigger *pTrigger, /* List of triggers on table pTab */
84729 Table *pTab, /* The table to code triggers from */
84755 sqlite3CodeRowTriggerDirect(pParse, p, pTab, reg, orconf, ignoreJump);
84787 Trigger *pTrigger, /* List of triggers on table pTab */
84791 Table *pTab, /* The table to code triggers from */
84804 pPrg = getRowTrigger(pParse, p, pTab, orconf);
84838 Table *pTab, /* The virtual table */
84841 int *aXRef, /* Mapping from columns of pTab to entries in pChanges */
84848 ** i-th column of table pTab. This routine sets the P4 parameter of the
84876 SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){
84877 assert( pTab!=0 );
84878 if( !pTab->pSelect ){
84881 Column *pCol = &pTab->aCol[i];
84882 VdbeComment((v, "%s.%s", pTab->zName, pCol->zName));
84883 assert( i<pTab->nCol );
84890 if( iReg>=0 && pTab->aCol[i].affinity==SQLITE_AFF_REAL ){
84912 Table *pTab; /* The table to be updated */
84918 int iCur; /* VDBE Cursor number of pTab */
84935 Trigger *pTrigger; /* List of triggers on pTab, if required */
84958 pTab = sqlite3SrcListLookup(pParse, pTabList);
84959 if( pTab==0 ) goto update_cleanup;
84960 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
84966 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask);
84967 isView = pTab->pSelect!=0;
84979 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
84982 if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
84985 aXRef = sqlite3DbMallocRaw(db, sizeof(int) * pTab->nCol );
84987 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
84995 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
85015 for(j=0; j<pTab->nCol; j++){
85016 if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zName)==0 ){
85017 if( j==pTab->iPKey ){
85025 if( j>=pTab->nCol ){
85037 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
85038 pTab->aCol[j].zName, db->aDb[iDb].zName);
85048 hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngRowid);
85055 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
85060 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
85084 if( IsVirtual(pTab) ){
85085 updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef,
85097 pParse->nMem += pTab->nCol;
85103 pParse->nMem += pTab->nCol;
85108 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
85116 sqlite3MaterializeView(pParse, pTab, pWhere, iCur);
85160 if( !okOnePass ) sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite);
85165 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
85172 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
85209 u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0);
85211 pTrigger, pChanges, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onError
85213 for(i=0; i<pTab->nCol; i++){
85216 sqlite3ColumnDefault(v, pTab, i, regOld+i);
85240 pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError
85242 for(i=0; i<pTab->nCol; i++){
85243 if( i==pTab->iPKey ){
85258 sqlite3ColumnDefault(v, pTab, i, regNew+i);
85267 sqlite3VdbeAddOp2(v, OP_Affinity, regNew, pTab->nCol);
85268 sqlite3TableAffinityStr(v, pTab);
85270 TRIGGER_BEFORE, pTab, regOldRowid, onError, addr);
85285 for(i=0; i<pTab->nCol; i++){
85286 if( aXRef[i]<0 && i!=pTab->iPKey ){
85288 sqlite3ColumnDefault(v, pTab, i, regNew+i);
85297 sqlite3GenerateConstraintChecks(pParse, pTab, iCur, regNewRowid,
85302 sqlite3FkCheck(pParse, pTab, regOldRowid, 0);
85307 sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, aRegIdx);
85316 sqlite3FkCheck(pParse, pTab, 0, regNewRowid);
85320 sqlite3CompleteInsertion(pParse, pTab, iCur, regNewRowid, aRegIdx, 1, 0, 0);
85326 sqlite3FkActions(pParse, pTab, pChanges, regOldRowid);
85337 TRIGGER_AFTER, pTab, regOldRowid, onError, addr);
85346 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
85414 Table *pTab, /* The virtual table */
85417 int *aXRef, /* Mapping from columns of pTab to entries in pChanges */
85429 const char *pVTab = (const char*)sqlite3GetVTable(db, pTab);
85440 assert( pTab->iPKey<0 );
85441 for(i=0; i<pTab->nCol; i++){
85445 pExpr = sqlite3Expr(db, TK_ID, pTab->aCol[i].zName);
85456 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, pTab->nCol+1+(pRowid!=0));
85465 pParse->nMem += pTab->nCol+1;
85469 for(i=0; i<pTab->nCol; i++){
85472 sqlite3VtabMakeWritable(pParse, pTab);
85473 sqlite3VdbeAddOp4(v, OP_VUpdate, 0, pTab->nCol+2, iReg, pVTab, P4_VTAB);
85912 ** pTab is a pointer to a Table structure representing a virtual-table.
85916 SQLITE_PRIVATE VTable *sqlite3GetVTable(sqlite3 *db, Table *pTab){
85918 assert( IsVirtual(pTab) );
85919 for(pVtab=pTab->pVTable; pVtab && pVtab->db!=db; pVtab=pVtab->pNext);
86136 Table *pTab = pParse->pNewTable; /* The table being constructed */
86139 if( pTab==0 ) return;
86142 if( pTab->nModuleArg<1 ) return;
86170 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
86176 pTab->zName,
86177 pTab->zName,
86186 zWhere = sqlite3MPrintf(db, "name='%q'", pTab->zName);
86189 pTab->zName, sqlite3Strlen30(pTab->zName) + 1);
86199 Schema *pSchema = pTab->pSchema;
86200 const char *zName = pTab->zName;
86202 pOld = sqlite3HashInsert(&pSchema->tblHash, zName, nName, pTab);
86205 assert( pTab==pOld ); /* Malloc must have failed inside HashInsert() */
86245 Table *pTab,
86252 const char *const*azArg = (const char *const*)pTab->azModuleArg;
86253 int nArg = pTab->nModuleArg;
86255 char *zModuleName = sqlite3MPrintf(db, "%s", pTab->zName);
86271 db->pVTab = pTab;
86292 *pzErr = sqlite3MPrintf(db, zFormat, pTab->zName);
86298 ** into the linked list headed by pTab->pVTable. Then loop through the
86302 pVTable->pNext = pTab->pVTable;
86303 pTab->pVTable = pVTable;
86305 for(iCol=0; iCol<pTab->nCol; iCol++){
86306 char *zType = pTab->aCol[iCol].zType;
86331 pTab->aCol[iCol].isHidden = 1;
86344 ** of the virtual table pTab. If an error occurs, an error code is returned
86347 ** This call is a no-op if table pTab is not a virtual table.
86349 SQLITE_PRIVATE int sqlite3VtabCallConnect(Parse *pParse, Table *pTab){
86355 assert( pTab );
86356 if( (pTab->tabFlags & TF_Virtual)==0 || sqlite3GetVTable(db, pTab) ){
86361 zMod = pTab->azModuleArg[0];
86365 const char *zModule = pTab->azModuleArg[0];
86370 rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xConnect, &zErr);
86414 Table *pTab;
86418 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
86419 assert( pTab && (pTab->tabFlags & TF_Virtual)!=0 && !pTab->pVTable );
86422 zMod = pTab->azModuleArg[0];
86433 rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr);
86438 if( rc==SQLITE_OK && ALWAYS(sqlite3GetVTable(db, pTab)) ){
86439 rc = addToVTrans(db, sqlite3GetVTable(db, pTab));
86454 Table *pTab;
86458 pTab = db->pVTab;
86459 if( !pTab ){
86464 assert( (pTab->tabFlags & TF_Virtual)!=0 );
86479 if( !pTab->aCol ){
86480 pTab->aCol = pParse->pNewTable->aCol;
86481 pTab->nCol = pParse->pNewTable->nCol;
86515 Table *pTab;
86517 pTab
86518 if( ALWAYS(pTab!=0 && pTab->pVTable!=0) ){
86519 VTable *p = vtabDisconnectAll(db, pTab);
86526 assert( pTab->pVTable==p && p->pNext==0 );
86528 pTab->pVTable = 0;
86673 Table *pTab;
86687 pTab = pExpr->pTab;
86688 if( NEVER(pTab==0) ) return pDef;
86689 if( (pTab->tabFlags & TF_Virtual)==0 ) return pDef;
86690 pVtab = sqlite3GetVTable(db, pTab)->pVtab;
86728 ** Make sure virtual table pTab is contained in the pParse->apVirtualLock[]
86729 ** array so that an OP_VBegin will get generated for it. Add pTab to the
86730 ** array if it is missing. If pTab is already in the array, this routine
86733 SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){
86738 assert( IsVirtual(pTab) );
86740 if( pTab==pToplevel->apVtabLock[i] ) return;
86746 pToplevel->apVtabLock[pToplevel->nVtabLock++] = pTab;
88105 ** pOrderBy is an ORDER BY clause from a SELECT statement. pTab is the
88107 ** the table has a cursor number of "base". pIdx is an index on pTab.
88412 WHERETRACE(("Recomputing index info for %s...\n", pSrc->pTab->zName));
88510 static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){
88511 sqlite3_vtab *pVtab = sqlite3GetVTable(pParse->db, pTab)->pVtab;
88515 WHERETRACE(("xBestIndex for %s\n", pTab->zName));
88535 "table %s: xBestIndex returned an invalid plan", pTab->zName);
88568 Table *pTab = pSrc->pTab;
88605 assert( pTab->azModuleArg && pTab->azModuleArg[0] );
88606 assert( sqlite3GetVTable(pParse->db, pTab) );
88650 if( vtabBestIndex(pParse, pTab, pIdxInfo) ){
89008 sPk.pTable = pSrc->pTab;
89009 pFirst = pSrc->pTab->pIndex;
89229 pSrc->pTab->zName, (pIdx ? pIdx->zName : "ipk"),
89279 ** Find the query plan for accessing table pSrc->pTab. Write the
89293 if( IsVirtual(pSrc->pTab) ){
90091 r = sqlite3ExprCodeGetColumn(pParse, pTabItem->pTab, -1, iCur,
90410 if( ALWAYS(pTabList->a[i].pTab) && IsVirtual(pTabList->a[i].pTab) ){
90516 assert( pTabItem->pTab );
90518 if( IsVirtual(pTabItem->pTab) ){
90600 Table *pTab; /* Table to open */
90633 pTab = pTabItem->pTab;
90634 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
90635 if( (pTab->tabFlags & TF_Ephemeral)!=0 || pTab->pSelect ) continue;
90638 const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
90646 sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op);
90647 if( !pWInfo->okOnePass && pTab->nCol<BMS ){
90653 assert( n<=pTab->nCol );
90656 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
90663 assert( pIx->pSchema==pTab->pSchema );
90696 if( z==0 ) z = pTabItem->pTab->zName;
90807 Table *pTab = pTabItem->pTab;
90808 assert( pTab!=0 );
90809 if( (pTab->tabFlags & TF_Ephemeral)!=0 || pTab->pSelect ) continue;
97478 Table *pTab = 0;
97497 pTab = sqlite3FindTable(db, zTableName, zDbName);
97498 if( !pTab || pTab->pSelect ){
97499 pTab = 0;
97505 iCol = pTab->iPKey;
97507 pCol = &pTab->aCol[iCol];
97510 for(iCol=0; iCol<pTab->nCol; iCol++){
97511 pCol = &pTab->aCol[iCol];
97516 if( iCol==pTab->nCol ){
97517 pTab = 0;
97537 autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
97559 if( SQLITE_OK==rc && !pTab ){
100449 ** Evaluate the full-text expression pExpr against fts3 table pTab. Store
100762 SQLITE_PRIVATE int sqlite3Fts3ExprLoadDoclist(Fts3Table *pTab, Fts3Expr *pExpr){
100763 return evalFts3Expr(pTab, pExpr, &pExpr->aDoclist, &pExpr->nDoclist, 1);
106979 Fts3Table *pTab; /* FTS3 Table */
106988 rc = sqlite3Fts3ExprLoadDoclist(p->pTab, pExpr);
107001 sCtx.pTab = (Fts3Table *)pCsr->base.pVtab;
107266 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
107283 pMod = (sqlite3_tokenizer_module *)pTab->pTokenizer->pModule;
107284 rc = pMod->xOpen(pTab->pTokenizer, zDoc, nDoc, &pC);
107364 Fts3Table *pTab; /* FTS3 Table */
107456 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
107462 g.pTab = pTab;
107463 g.nCol = pTab->nColumn;
107486 g.pTab = pTab;
107488 g.nCol = pTab->nColumn;
