Lines Matching refs:zDb
8212 ** in row iRow, column zColumn, table zTable in database zDb;
8216 ** SELECT zColumn FROM zDb.zTable WHERE [rowid] = iRow;
8219 ** ^(Parameter zDb is not the filename that contains the database, but
8237 ** <li> ^(Database zDb does not exist)^,
8238 ** <li> ^(Table zTable does not exist within database zDb)^,
8291 const char *zDb,
10107 SQLITE_API int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb);
10176 ** ^If parameter zDb is NULL or points to a zero length string, then the
10188 ** ^If database zDb is the name of an attached database that is not in WAL
10190 ** zDb is not NULL (or a zero length string) and is not the name of any
10203 const char *zDb, /* Name of attached database (or NULL) */
10606 char const *zDb, /* Database name */
10809 ** This function attempts to scan the WAL file associated with database zDb
10820 SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_recover(sqlite3 *db, const char *zDb);
11132 ** database zDb, where zDb is either "main", or "temp", or the name of an
11133 ** attached database. It is not an error if database zDb is not attached
11138 const char *zDb, /* Name of db (e.g. "main") */
19343 const char *zDb; /* Make sure all objects are contained in this database */
19968 SQLITE_PRIVATE void sqlite3CodeVerifyNamedSchema(Parse*, const char *zDb);
39805 char zDb[MAX_PATHNAME+1]; /* Database file path */
39806 int nDb; /* Number of valid bytes in zDb */
39829 memcpy(zDb, zPath, nDb);
39830 zDb[nDb] = '\0';
39832 rc = getFileMode(zDb, pMode, pUid, pGid);
75769 ** Return a pointer corresponding to database zDb (i.e. "main", "temp")
75777 static Btree *findBtree(sqlite3 *pErrorDb, sqlite3 *pDb, const char *zDb){
75778 int i = sqlite3FindDbName(pDb, zDb);
75797 sqlite3ErrorWithMsg(pErrorDb, SQLITE_ERROR, "unknown database %s", zDb);
83570 const char *zDb, /* Database name */
83611 db->xPreUpdateCallback(db->pPreUpdateArg, db, op, zDb, zTbl, iKey1, iKey2);
91033 const char *zDb; /* database name - used by the update hook */
91058 zDb = db->aDb[pC->iDb].zDbSName;
91063 zDb = 0; /* Not needed. Silence a compiler warning. */
91070 sqlite3VdbePreUpdateHook(p, pC, SQLITE_INSERT, zDb, pTab, x.nKey,pOp->p2);
91106 zDb, pTab->zName, x.nKey);
91175 const char *zDb;
91202 /* If the update-hook or pre-update-hook will be invoked, set zDb to
91210 zDb = db->aDb[pC->iDb].zDbSName;
91216 zDb = 0; /* Not needed. Silence a compiler warning. */
91229 zDb, pTab, pC->movetoTarget,
91264 db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, pTab->zName,
94268 char *zDb; /* Database name */
94357 const char *zDb, /* The attached database containing the blob */
94396 pTab = sqlite3LocateTable(&sParse, 0, zTable, zDb);
94422 pBlob->zDb = db->aDb[sqlite3SchemaToIndex(db, pTab->pSchema)].zDbSName;
94659 v, v->apCsr[0], SQLITE_DELETE, p->zDb, p->pTab, iKey, -1
98763 ** Check to see if the zSpan given to this routine matches the zDb, zTab,
98764 ** and zCol. If any of zDb, zTab, and zCol are NULL then those fields will
98771 const char *zDb
98778 if( zDb && (sqlite3StrNICmp(zSpan, zDb, n)!=0 || zDb[n]!=0) ){
98852 ** The zDb variable is the name of the database (the "X"). This value may be
98855 ** value can be NULL if zDb is also NULL. If zTable is NULL it
98864 const char *zDb, /* Name of the database containing table, or NULL */
98891 /* Translate the schema name in zDb into a pointer to the corresponding
98895 if( zDb ){
98903 zDb = 0;
98907 if( sqlite3StrICmp(db->aDb[i].zDbSName,zDb)==0 ){
98912 if( i==db->nDb && sqlite3StrICmp("main", zDb)==0 ){
98916 zDb = db->aDb[0].zDbSName;
98937 if( sqlite3MatchEName(&pEList->a[j], zCol, zTab, zDb) ){
98947 if( zDb && pTab->pSchema!=pSchema ){
99000 if( cnt==0 && zDb==0 ){
99161 assert( zTab==0 && zDb==0 );
99235 if( zDb ){
99236 sqlite3ErrorMsg(pParse, "%s: %s.%s.%s", zErr, zDb, zTab, zCol);
99481 const char *zDb;
99485 zDb = 0;
99496 zDb = 0;
99499 zDb = pLeft->u.zToken;
99510 return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr);
106816 ** Generate code to verify that the schemas of database zDb and, if
106824 const char *zDb, /* Name of db to verify schema of */
106836 zDb,
106837 zDb, bTemp, zWhen, zDropColumn
106847 zDb, zWhen, zDropColumn
106875 char *zDb; /* Name of database iDb */
106893 zDb = db->aDb[iDb].zDbSName;
106903 if( sqlite3FindTable(db, zName, zDb)
106904 || sqlite3FindIndex(db, zName, zDb)
106931 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
106969 , zDb, zDb, zTabName, zName, (iDb==1), zTabName
106985 zDb,
106994 if( sqlite3FindTable(db, "sqlite_sequence", zDb) ){
106997 zDb, zName, pTab->zName);
107013 , zDb, zTabName, zName, zTabName, zDb, zName);
107030 renameTestSchema(pParse, zDb, iDb==1, "after rename", 0);
107040 ** zDb and zTab is not empty.
107044 const char *zDb, /* Schema holding the table */
107050 zErr, zDb, zTab
107066 const char *zDb; /* Database name */
107082 zDb = db->aDb[iDb].zDbSName;
107086 pTab = sqlite3FindTable(db, zTab, zDb);
107091 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
107120 sqlite3ErrorIfNotEmpty(pParse, zDb, zTab,
107124 sqlite3ErrorIfNotEmpty(pParse, zDb, zTab,
107142 sqlite3ErrorIfNotEmpty(pParse, zDb, zTab,
107148 sqlite3ErrorIfNotEmpty(pParse, zDb, zTab, "cannot add a STORED column");
107168 zDb, pNew->addColOffset, zCol, pNew->addColOffset,
107333 const char *zDb; /* Name of schema containing the table */
107348 zDb = db->aDb[iSchema].zDbSName;
107352 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
107384 zDb,
107385 zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1,
107393 zDb, pTab->zName, iCol, zNew, bQuote
107398 renameTestSchema(pParse, zDb, iSchema==1, "after rename", 0);
107819 const char *zDb, /* Name of schema SQL belongs to */
107828 db->init.iDb = bTemp ? 1 : sqlite3FindDbName(db, zDb);
107956 ** it was read from the schema of database zDb. Return SQLITE_OK if
108132 const char *zDb = (const char*)sqlite3_value_text(argv[3]);
108155 pTab = sqlite3FindTable(db, zTable, zDb);
108167 rc = renameParseSql(&sParse, zDb, db, zSql, bTemp, 0);
108240 Table *pTarget = sqlite3LocateTable(&sParse, 0, pStep->zTarget, zDb);
108342 const char *zDb = (const char*)sqlite3_value_text(argv[0]);
108364 sCtx.pTab = sqlite3FindTable(db, zOld, zDb);
108371 rc = renameParseSql(&sParse, zDb, db, zInput, bTemp, 0);
108493 ** * the table that the trigger is attached to is in database zDb.
108501 char const *zDb = (const char*)sqlite3_value_text(argv[0]);
108514 if( zDb && zInput ){
108517 rc = renameParseSql(&sParse, zDb, db, zInput, bTemp, zDropColumn);
108533 int i2 = sqlite3FindDbName(db, zDb);
108571 const char *zDb = db->aDb[iSchema].zDbSName;
108585 rc = renameParseSql(&sParse, zDb, db, zSql, iSchema==1, 0);
108630 const char *zDb; /* Database containing pTab ("main" etc.) */
108677 zDb = db->aDb[iDb].zDbSName;
108678 renameTestSchema(pParse, zDb, iDb==1, "", 0);
108683 , zDb, iDb, iCol, pTab->zName
108688 renameTestSchema(pParse, zDb, iDb==1, "after drop column", zCol);
110183 char *z, *zDb;
110210 zDb = pName2->n ? db->aDb[iDb].zDbSName : 0;
110213 if( (pIdx = sqlite3FindIndex(db, z, zDb))!=0 ){
110215 }else if( (pTab = sqlite3LocateTable(pParse, 0, z, zDb))!=0 ){
110465 const char *zDb
110467 Index *pIdx = sqlite3FindIndex(db, zName, zDb);
110469 Table *pTab = sqlite3FindTable(db, zName, zDb);
110491 const char *zDb /* Database name (e.g. "main") */
110500 zSql = sqlite3MPrintf(db, zSql1, zDb);
110521 pIdx = findIndexOrPrimaryKey(db, zIndex, zDb);
110553 zSql = sqlite3MPrintf(db, zSql2, zDb);
110568 pIdx = findIndexOrPrimaryKey(db, zIndex, zDb);
110608 static int loadStat4(sqlite3 *db, const char *zDb){
110612 if( sqlite3FindTable(db, "sqlite_stat4", zDb) ){
110616 zDb
111174 int iDb = sqlite3FindDbName(db, pFix->zDb);
111219 pFix->zDb = db->aDb[iDb].zDbSName;
111405 ** table zTab in database zDb. This function assumes that an authorization
111419 char *zDb = db->aDb[iDb].zDbSName; /* Schema name of attached database */
111423 rc = db->xAuth(db->pAuthArg, SQLITE_READ, zTab,zCol,zDb,pParse->zAuthContext
111430 if( db->nDb>2 || iDb!=0 ) z = sqlite3_mprintf("%s.%z", zDb, z);
112062 const char *zDb;
112066 zDb = pParse->db->aDb[iDb].zDbSName;
112068 zDb = p->zDatabase;
112070 return sqlite3LocateTable(pParse, flags, p->zName, zDb);
112085 SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){
112089 assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
112094 if( zDb && sqlite3DbIsNamed(db, j, zDb)==0 ) continue;
112697 char *zDb = db->aDb[iDb].zDbSName;
112698 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){
112702 zName, 0, zDb) ){
112716 char *zDb = db->aDb[iDb].zDbSName;
112720 pTable = sqlite3FindTable(db, zName, zDb);
112730 if( sqlite3FindIndex(db, zName, zDb)!=0 ){
114776 const char *zDb = db->aDb[iDb].zDbSName;
114778 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){
114799 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
114802 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
115355 const char *zDb = pDb->zDbSName;
115356 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
115361 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
115862 const char *zDb = db->aDb[iDb].zDbSName;
115864 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
115868 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
116475 ** If argument zDb is NULL, then call sqlite3CodeVerifySchema() for each
116476 ** attached database. Otherwise, invoke it for the database named zDb only.
116478 SQLITE_PRIVATE void sqlite3CodeVerifyNamedSchema(Parse *pParse, const char *zDb){
116483 if( pDb->pBt && (!zDb || 0==sqlite3StrICmp(zDb, pDb->zDbSName)) ){
116704 const char *zDb; /* Name of the database */
116737 zDb = db->aDb[iDb].zDbSName;
116738 pTab = sqlite3FindTable(db, z, zDb);
116744 pIndex = sqlite3FindIndex(db, z, zDb);
121595 const char *zDb; /* Name of database containing pTab */
121605 zDb = db->aDb[iDb].zDbSName;
121630 pTo = sqlite3FindTable(db, pFKey->zTo, zDb);
121632 pTo = sqlite3LocateTable(pParse, 0, pFKey->zTo, zDb);
127935 const char *zDb = 0; /* The database name */
127971 zDb = pId2->n>0 ? pDb->zDbSName : 0;
127972 if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){
127996 rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_PRAGMA, (void*)aFcntl);
128464 rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_MMAP_SIZE, &sz);
128695 sqlite3CodeVerifyNamedSchema(pParse, zDb);
128696 pTab = sqlite3LocateTable(pParse, LOCATE_NOERR, zRight, zDb);
128770 pIdx = sqlite3FindIndex(db, zRight, zDb);
128775 pTab = sqlite3LocateTable(pParse, LOCATE_NOERR, zRight, zDb);
128816 pTab = sqlite3FindTable(db, zRight, zDb);
128905 pTab = sqlite3FindTable(db, zRight, zDb);
128960 pTab = sqlite3LocateTable(pParse, 0, zRight, zDb);
128968 zDb = db->aDb[iDb].zDbSName;
128975 pParent = sqlite3FindTable(db, pFK->zTo, zDb);
128997 pParent = sqlite3FindTable(db, pFK->zTo, zDb);
129638 for(iDbLast = zDb?iDb:db->nDb-1; iDb<=iDbLast; iDb++){
130834 const char *zDb = db->aDb[i].zDbSName;
130835 sqlite3ErrorWithMsg(db, rc, "database schema is locked: %s", zDb);
138747 const char *zDb = db->aDb[iTabDb].zDbSName;
138748 const char *zDbTrig = isTemp ? db->aDb[1].zDbSName : zDb;
138753 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iTabDb),0,zDb)){
139114 const char *zDb;
139124 zDb = pName->a[0].zDatabase;
139126 assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
139129 if( zDb && sqlite3DbIsNamed(db, j, zDb)==0 ) continue;
139138 sqlite3CodeVerifyNamedSchema(pParse, zDb);
139174 const char *zDb = db->aDb[iDb].zDbSName;
139177 if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) ||
139178 sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
166348 const char *zDb, /* Database */
166353 sqlite3_wal_checkpoint(db, zDb);
166417 ** Checkpoint database zDb.
166421 const char *zDb, /* Name of attached database (or NULL) */
166451 if( zDb && zDb[0] ){
166452 iDb = sqlite3FindDbName(db, zDb);
166458 sqlite3ErrorWithMsg(db, SQLITE_ERROR, "unknown database: %s", zDb);
166479 ** Checkpoint database zDb. If zDb is NULL, or if the buffer zDb points
166483 SQLITE_API int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb){
166486 return sqlite3_wal_checkpoint_v2(db,zDb,SQLITE_CHECKPOINT_PASSIVE,0,0);
168548 ** Obtain a snapshot handle for the snapshot of database zDb currently
168553 const char *zDb,
168567 int iDb = sqlite3FindDbName(db, zDb);
168589 const char *zDb,
168603 iDb = sqlite3FindDbName(db, zDb);
168641 ** schema zDb of database db.
168643 SQLITE_API int sqlite3_snapshot_recover(sqlite3 *db, const char *zDb){
168655 iDb = sqlite3FindDbName(db, zDb);
169877 const char *zDb; /* logical database name */
170602 const char *zDb = p->zDb; /* Name of database (e.g. "main", "temp") */
170612 zDb, p->zName,
170613 zDb, p->zName,
170614 zDb, p->zName,
170615 zDb, p->zName,
170616 (p->zContentTbl ? "--" : ""), zDb,p->zName
170677 p->zDb, p->zName
170714 p->zDb, p->zName, zContentCols
170722 p->zDb, p->zName
170734 p->zDb, p->zName
170739 p->zDb, p->zName
170762 zSql = sqlite3_mprintf("PRAGMA %Q.page_size", p->zDb);
170920 p->zDb,
171102 const char *zDb, /* Name of db (i.e. "main", "temp" etc.) */
171113 zSql = sqlite3_mprintf("SELECT * FROM %Q.%Q", zDb, zTbl);
171418 nDb + /* zDb */
171452 /* Fill in the zName and zDb fields of the vtab structure. */
171457 p->zDb = zCsr;
173578 int res = sqlite3_table_column_metadata(p->db, p->zDb, zTbl, 0,0,0,0,0,0);
173892 p->zDb, p->zName, zName
173899 p->zDb, p->zName, zName
173905 p->zDb, p->zName, zName
173910 p->zDb, p->zName, zName
173914 p->zDb, p->zName, zName
176170 char const *zDb; /* Name of database (e.g. "main") */
176172 int nDb; /* Result of strlen(zDb) */
176187 zDb = argv[1];
176188 nDb = (int)strlen(zDb);
176190 if( nDb==4 && 0==sqlite3_strnicmp("temp", zDb, 4) ){
176191 zDb = argv[3];
176192 nDb = (int)strlen(zDb);
176211 p->pFts3Tab->zDb = (char *)&p->pFts3Tab[1];
176212 p->pFts3Tab->zName = &p->pFts3Tab->zDb[nDb+1];
176216 memcpy((char *)p->pFts3Tab->zDb, zDb, nDb);
180629 zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName, p->zWriteExprlist);
180634 zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName);
181442 p->db, p->zDb, p->zSegmentsTbl, "block", iBlockid, 0, &p->pSegments
191339 char *zDb; /* Name of database containing r-tree table */
191922 rc = sqlite3_blob_open(pRtree->db, pRtree->zDb, zTab, "data", iNode, 0,
192242 pRtree->zDb, pRtree->zName,
192243 pRtree->zDb, pRtree->zName,
192244 pRtree->zDb, pRtree->zName
194349 zSql = sqlite3_mprintf("SELECT * FROM %Q.%Q", pRtree->zDb, pRtree->zName);
194557 , pRtree->zDb, pRtree->zName, zNewName
194558 , pRtree->zDb, pRtree->zName, zNewName
194559 , pRtree->zDb, pRtree->zName, zNewName
194606 db, pRtree->zDb, "sqlite_stat1",0,0,0,0,0,0
194612 zSql = sqlite3_mprintf(zFmt, pRtree->zDb, pRtree->zName);
194683 const char *zDb,
194717 zDb, zPrefix);
194723 zDb, zPrefix);
194726 zDb, zPrefix);
194729 zDb, zPrefix, pRtree->iNodeSize);
194762 zSql = sqlite3_mprintf(zFormat, zDb, zPrefix);
194773 zDb, zPrefix);
194780 sqlite3_str_appendf(p, "UPDATE \"%w\".\"%w_rowid\"SET ", zDb, zPrefix);
194850 zSql = sqlite3_mprintf("PRAGMA %Q.page_size", pRtree->zDb);
194863 pRtree->zDb, pRtree->zName
194941 pRtree->zDb = (char *)&pRtree[1];
194942 pRtree->zName = &pRtree->zDb[nDb+1];
194944 memcpy(pRtree->zDb, argv[1], nDb);
195104 const char *zDb; /* Database containing rtree table */
195205 pCheck->zDb, pCheck->zTab
195259 azSql[bLeaf], pCheck->zDb, pCheck->zTab
195408 pCheck->zDb, pCheck->zTab, zTbl
195430 const char *zDb, /* Name of db ("main", "temp" etc.) */
195442 check.zDb = zDb;
195455 pStmt = rtreeCheckPrepare(&check, "SELECT * FROM %Q.'%q_rowid'", zDb, zTab);
195464 pStmt = rtreeCheckPrepare(&check, "SELECT * FROM %Q.%Q", zDb, zTab);
195545 const char *zDb = (const char*)sqlite3_value_text(apArg[0]);
195548 zTab = zDb;
195549 zDb = "main";
195553 rc = rtreeCheckTable(sqlite3_context_db_handle(ctx), zDb, zTab, &zReport);
196813 pRtree->zDb = (char *)&pRtree[1];
196814 pRtree->zName = &pRtree->zDb[nDb+1];
196818 memcpy(pRtree->zDb, argv[1], nDb);
205617 char *zDb; /* Name of database session is attached to */
206539 ** zThis, in schema zDb.
206565 const char *zDb, /* Name of attached database (e.g. "main") */
206587 rc = sqlite3_table_column_metadata(db, zDb, zThis, 0, 0, 0, 0, 0, 0);
206601 zPragma = sqlite3_mprintf("PRAGMA '%q'.table_info('%q')", zDb, zThis);
206683 pSession->rc = sessionTableInfo(pSession, pSession->db, pSession->zDb,
206935 char const *zDb, /* Database name */
206941 int nDb = sqlite3Strlen30(zDb);
206953 if( sqlite3_strnicmp(zDb, pSession->zDb, nDb+1) ) continue;
207148 pSession->zDb, zFrom, pTab->zName, pTab->azCol, pTab->abPK
207155 pSession->zDb, pTab->zName, zFrom, pTab->zName, zExpr, zExpr2
207185 const char *zDb = pSession->zDb;
207242 zDb, zFrom, pTo->zName, pTo->azCol, pTo->abPK
207248 rc = sessionDiffFindNew(SQLITE_INSERT, pSession, pTo, zDb, zFrom, zExpr);
207253 rc = sessionDiffFindNew(SQLITE_DELETE, pSession, pTo, zFrom, zDb, zExpr);
207272 ** database zDb attached to connection db.
207276 const char *zDb, /* Name of db (e.g. "main") */
207281 int nDb = sqlite3Strlen30(zDb); /* Length of zDb in bytes */
207291 pNew->zDb = (char *)&pNew[1];
207293 memcpy(pNew->zDb, zDb, nDb+1);
207810 ** zTab in database zDb based on its primary key. i.e.
207812 ** SELECT * FROM zDb.zTab WHERE pk1 = ? AND pk2 = ? AND ...
207816 const char *zDb, /* Database name */
207830 "idx IS (CASE WHEN ?2=X'' THEN NULL ELSE ?2 END)", zDb
207839 sessionAppendIdent(&buf, zDb, &rc);
208006 rc = sessionTableInfo(0, db, pSession->zDb, zName, &nCol, 0,&azCol,&abPK);
208017 db, pSession->zDb, zName, nCol, azCol, abPK, &pSel);
211944 char *zDb; /* Database holding FTS index (e.g. "main") */
215578 pConfig->zContent = sqlite3Fts5Mprintf(&rc, "%Q.%Q", pConfig->zDb,zArg);
215772 pRet->zDb = sqlite3Fts5Strndup(&rc, azArg[1], -1);
215845 &rc, "%Q.'%q_%s'", pRet->zDb, pRet->zName, zTail
215875 sqlite3_free(pConfig->zDb);
216155 zSql = sqlite3Fts5Mprintf(&rc, zSelect, pConfig->zDb, pConfig->zName);
220464 pConfig->zDb, p->zDataTbl, "block", iRowid, 0, &p->pReader
220557 pConfig->zDb, pConfig->zName
220581 pConfig->zDb, pConfig->zName
220603 pConfig->zDb, pConfig->zName
220818 sqlite3_mprintf("PRAGMA %Q.data_version", p->pConfig->zDb)
222158 pConfig->zDb, pConfig->zName
223917 pConfig->zDb, pConfig->zName
225487 rc = sqlite3_blob_open(pConfig->db, pConfig->zDb, p->zDataTbl,
225819 pConfig->zDb, pConfig->zName, pSeg->iSegid
227525 pConfig->zDb, pConfig->zName, zRank, pConfig->zName,
229565 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName, zBind);
229572 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName);
229630 pConfig->zDb, pConfig->zName,
229631 pConfig->zDb, pConfig->zName,
229632 pConfig->zDb, pConfig->zName
229637 pConfig->zDb, pConfig->zName
229643 pConfig->zDb, pConfig->zName
229658 pConfig->zDb, pConfig->zName, zTail, zName, zTail
229694 pConfig->zDb, pConfig->zName, zPost, zDefn,
230016 pConfig->zDb, pConfig->zName,
230017 pConfig->zDb, pConfig->zName
230022 pConfig->zDb, pConfig->zName
230218 pConfig->zDb, pConfig->zName, zSuffix
233335 const char *zDb = bDb ? argv[3] : argv[1];
233338 int nDb = (int)strlen(zDb)+1;
233357 memcpy(pRet->zFts5Db, zDb, nDb);