Lines Matching refs:zName
1482 const char *zName; /* Name of this virtual file system */ member
1484 int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,
1486 int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);
1487 int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut);
1488 int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);
1506 int (*xSetSystemCall)(sqlite3_vfs*, const char *zName, sqlite3_syscall_ptr);
1507 sqlite3_syscall_ptr (*xGetSystemCall)(sqlite3_vfs*, const char *zName);
1508 const char *(*xNextSystemCall)(sqlite3_vfs*, const char *zName);
4105 SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
5245 const char *zName,
5252 const char *zName,
5260 const void *zName,
6060 int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName,
6248 const char *zName, /* Name of the module */
6254 const char *zName, /* Name of the module */
8456 char const *zName, /* Table name */
10568 const char *zName,
10577 const char *zName,
10585 const char *zName,
13699 char *zName; /* Name of this database */ member
14105 const char *zName; /* SQL name of the function. */ member
14194 #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \ argument
14196 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, {0} }
14197 #define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \ argument
14199 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, {0} }
14200 #define DFUNCTION(zName, nArg, iArg, bNC, xFunc) \ argument
14202 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, {0} }
14203 #define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \ argument
14205 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, {0} }
14206 #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \ argument
14208 pArg, 0, xFunc, 0, #zName, }
14209 #define LIKEFUNC(zName, nArg, arg, flags) \ argument
14211 (void *)arg, 0, likeFunc, 0, #zName, {0} }
14212 #define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal) \ argument
14214 SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,#zName, {0}}
14215 #define AGGREGATE2(zName, nArg, arg, nc, xStep, xFinal, extraFlags) \ argument
14217 SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,#zName, {0}}
14226 char *zName; /* Savepoint name (nul-terminated) */ member
14248 const char *zName; /* Name passed to create_module() */ member
14259 char *zName; /* Name of this column, \000, then the type */ member
14284 char *zName; /* Name of the collating sequence, UTF-8 encoded */ member
14397 char *zName; /* Name of the table or view */ member
14667 char *zName; /* Name of this index */ member
14997 char *zName; /* Token associated with this expression */ member
15041 char *zName; /* Name of the identifier */ member
15097 char *zName; /* Name of the table */ member
15647 char *zName; /* The name of the trigger */ member
15895 char *zName; /* Name of this CTE */ member
16497 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char*zName);
17969 char *zName; /* Name of table or index */ member
20038 if( strcmp(zVfs, pVfs->zName)==0 ) break; in sqlite3_vfs_find()
25381 sqlite3StrAccumAppendAll(pAccum, pItem->zName);
25855 sqlite3XPrintf(&x, "%s", pCte->zName);
25860 sqlite3XPrintf(&x, "%c%s", cSep, pCte->pCols->a[j].zName);
25919 sqlite3XPrintf(&x, " %s.%s", pItem->zDatabase, pItem->zName);
25920 }else if( pItem->zName ){
25921 sqlite3XPrintf(&x, " %s", pItem->zName);
25924 sqlite3XPrintf(&x, " tabname=%Q", pItem->pTab->zName);
27324 return pCol->zName + strlen(pCol->zName) + 1;
29679 const char *zName; /* Name of the system call */
29852 const char *zName, /* Name of system call to override */
29859 if( zName==0 ){
29874 if( strcmp(zName, aSyscall[i].zName)==0 ){
29895 const char *zName
29901 if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
29912 static const char *unixNextSystemCall(sqlite3_vfs *p, const char *zName){
29916 if( zName ){
29918 if( strcmp(zName, aSyscall[i].zName)==0 ) break;
29922 if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
33125 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
34583 if( strcmp(pVfs->zName,"unix-excl")==0 ){
34999 const char *zName = zPath;
35015 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
35016 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
35017 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
35018 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
35041 pUnused = findReusableFd(zName, flags);
35055 assert( (flags & SQLITE_OPEN_URI) || zName[strlen(zName)+1]==0 );
35057 }else if( !zName ){
35064 zName = zTmpname;
35068 assert( zName[strlen(zName)+1]==0 );
35085 rc = findCreateFileMode(zName, flags, &openMode, &uid, &gid);
35091 fd = robust_open(zName, openFlags, openMode);
35092 OSTRACE(("OPENX %-3d %s 0%o\n", fd, zName, openFlags));
35101 fd = robust_open(zName, openFlags, openMode);
35104 rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName);
35128 zPath = zName;
35130 zPath = sqlite3_mprintf("%s", zName);
35136 osUnlink(zName);
35942 dummyVfs.zName = "dummy";
37601 const char *zName; /* Name of the system call */
38263 const char *zName, /* Name of system call to override */
38270 if( zName==0 ){
38285 if( strcmp(zName, aSyscall[i].zName)==0 ){
38306 const char *zName
38312 if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
38323 static const char *winNextSystemCall(sqlite3_vfs *p, const char *zName){
38327 if( zName ){
38329 if( strcmp(zName, aSyscall[i].zName)==0 ) break;
38333 if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
39308 LPWSTR zName;
39313 zName = winUtf8ToUnicode(zFilename);
39314 if( zName==0 ){
39324 zTok = osCharLowerW(zName);
39330 pFile->hMutex = osCreateMutexW(NULL, FALSE, zName);
39333 sqlite3_free(zName);
39345 osCharUpperW(zName);
39348 zName);
39357 sqlite3_free(zName);
40588 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
41951 const char *zName, /* Name of the file (UTF-8) */
41968 const char *zUtf8Name = zName; /* Filename in UTF-8 encoding */
42012 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
42013 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
42014 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
42015 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
42166 return winOpen(pVfs, zName, id,
42193 && (rc = winceCreateLock(zName, pFile))!=SQLITE_OK
42198 OSTRACE(("OPEN-CE-LOCK name=%s, rc=%s\n", zName, sqlite3ErrName(rc)));
42217 if( sqlite3_uri_boolean(zName, "psow", SQLITE_POWERSAFE_OVERWRITE) ){
42221 pFile->zPath = zName;
54460 static char zName[15];
54461 sqlite3_snprintf(sizeof(zName), zName, "READ-LOCK[%d]",
54463 return zName;
71091 const char *zName /* Name of table or index being scanned */
71102 pNew->zName = sqlite3DbStrDup(p->db, zName);
71610 const char *zColl = pColl ? pColl->zName : "";
71625 sqlite3XPrintf(&x, "(%.20s)", pColl->zName);
71630 sqlite3XPrintf(&x, "%s(%d)", pDef->zName, pDef->nArg);
71636 sqlite3XPrintf(&x, "%s(%d)", pDef->zName, pDef->nArg);
71696 sqlite3XPrintf(&x, "%s", pOp->p4.pTab->zName);
72499 const char *zName, /* Pointer to buffer containing name */
72507 assert( !zName || xDel!=SQLITE_DYNAMIC );
72512 rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, xDel);
72513 assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 );
73324 sqlite3DbFree(db, p->aScan[i].zName);
74909 const char *zTbl = pTab->zName;
75455 rc = db->xWalCallback(db->pWalArg, db, db->aDb[i].zName, nEntry);
75710 const char *zName = context->pFunc->zName;
75714 "unable to use function %s in the requested context", zName);
76436 SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){
76441 if( zName ){
76444 if( z && strncmp(z,zName,nName)==0 && z[nName]==0 ){
76451 SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
76452 return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName));
76815 *(const char**)pOut = pScan->zName;
79982 char *zName; /* Name of savepoint */
79991 zName = pOp->p4.z;
80010 nName = sqlite3Strlen30(zName);
80026 pNew->zName = (char *)&pNew[1];
80027 memcpy(pNew->zName, zName, nName+1);
80052 pSavepoint && sqlite3StrICmp(pSavepoint->zName, zName);
80058 sqlite3VdbeError(p, "no such savepoint: %s", zName);
81486 zDb = db->aDb[pC->iDb].zName;
81531 db->xUpdateCallback(db->pUpdateArg, op, zDb, pTab->zName, x.nKey);
81603 zDb = db->aDb[pC->iDb].zName;
81653 db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, pTab->zName,
82573 db->aDb[iDb].zName, zMaster, pOp->p4.z);
83957 sqlite3_file_control(db, db->aDb[i].zName, SQLITE_FCNTL_TRACE, zTrace);
84293 pBlob->zDb = db->aDb[sqlite3SchemaToIndex(db, pTab->pSchema)].zName;
84297 if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
84404 sqlite3VdbeChangeP4(v, 1, pTab->zName, P4_TRANSIENT);
87729 const char *zName, /* Name of the journal file */
87742 return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0);
87755 p->zJournal = zName;
88081 if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ) return 1;
88189 assert( db->aDb[i].zName );
88190 if( sqlite3StrICmp(db->aDb[i].zName,zDb)==0 ){
88206 assert( pTab!=0 && pTab->zName!=0 );
88226 const char *zTabName = pItem->zAlias ? pItem->zAlias : pTab->zName;
88236 if( sqlite3StrICmp(pCol->zName, zCol)==0 ){
88287 if( sqlite3StrICmp(pCol->zName, zCol)==0 ){
88357 char *zAs = pEList->a[j].zName;
88654 pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120;
88658 auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0, pDef->zName, 0);
88662 pDef->zName);
88772 char *zAs = pEList->a[i].zName;
89160 if( pItem->zName ) pParse->zAuthContext = pItem->zName;
89458 sSrc.a[0].zName = pTab->zName;
90448 pRet->a[i].zName = sqlite3DbStrDup(db, p->a[i].zName);
90498 pItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
90532 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
90576 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
90697 assert( pItem->zName==0 );
90698 pItem->zName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n);
90699 if( dequote ) sqlite3Dequote(pItem->zName);
90754 sqlite3DbFree(db, pItem->zName);
91248 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
91285 VdbeComment((v, "%s", pIdx->zName));
92630 (pExpr->iColumn<0 ? "rowid" : pExpr->pTab->aCol[pExpr->iColumn].zName),
94129 zWhere = whereOrName(pParse->db, zWhere, p->pFrom->zName);
94155 zWhere = whereOrName(db, zWhere, pTrig->zName);
94175 static void reloadTableSchema(Parse *pParse, Table *pTab, const char *zName){
94194 sqlite3VdbeAddOp4(v, OP_DropTrigger, iTrigDb, 0, 0, pTrig->zName, 0);
94199 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
94202 zWhere = sqlite3MPrintf(pParse->db, "tbl_name=%Q", zName);
94224 static int isSystemTable(Parse *pParse, const char *zName){
94225 if( sqlite3Strlen30(zName)>6 && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){
94226 sqlite3ErrorMsg(pParse, "table %s may not be altered", zName);
94244 char *zName = 0; /* NULL-terminated version of pName */
94263 zDb = db->aDb[iDb].zName;
94267 zName = sqlite3NameFromToken(db, pName);
94268 if( !zName ) goto exit_rename_table;
94273 if( sqlite3FindTable(db, zName, zDb) || sqlite3FindIndex(db, zName, zDb) ){
94275 "there is already another table or index with this name: %s", zName);
94282 if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
94285 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ goto
94291 sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
94298 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
94335 sqlite3VdbeLoadString(v, i, zName);
94342 zTabName = pTab->zName;
94354 "WHERE %s;", zDb, SCHEMA_TABLE(iDb), zTabName, zName, zWhere);
94378 zDb, SCHEMA_TABLE(iDb), zName, zName, zName,
94380 zName,
94382 zName, nTabName, zTabName
94392 zDb, zName, pTab->zName);
94406 "WHERE %s;", zName, zName, zWhere);
94417 reloadTableSchema(pParse, p->pFrom, pFrom->zName);
94424 reloadTableSchema(pParse, pTab, zName);
94428 sqlite3DbFree(db, zName);
94461 zDb = db->aDb[iDb].zName;
94462 zTab = &pNew->zName[16]; /* Skip the "sqlite_altertab_" prefix on the name */
94470 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
94560 reloadTableSchema(pParse, pTab, pTab->zName);
94606 if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
94629 pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
94630 if( !pNew->aCol || !pNew->zName ){
94637 pCol->zName = sqlite3DbStrDup(db, pCol->zName);
94838 const char *zName;
94869 const char *zTab = aTable[i].zName;
94871 if( (pStat = sqlite3FindTable(db, zTab, pDb->zName))==0 ){
94878 "CREATE TABLE %Q.%s(%s)", pDb->zName, zTab, aTable[i].zCols
94893 pDb->zName, zTab, zWhereType, zWhere
94907 VdbeComment((v, aTable[i].zName));
95645 if( sqlite3_strlike("sqlite_%", pTab->zName, 0)==0 ){
95654 if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,
95655 db->aDb[iDb].zName ) ){
95664 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
95669 sqlite3VdbeLoadString(v, regTabname, pTab->zName);
95682 zIdxName = pTab->zName;
95686 zIdxName = pIdx->zName;
95692 VdbeComment((v, "Analysis for %s.%s", pTab->zName, zIdxName));
95736 VdbeComment((v, "%s", pIdx->zName));
95843 VdbeComment((v, "%s", pTab->aCol[pPk->aiColumn[j]].zName));
95915 VdbeComment((v, "%s", pTab->zName));
95981 openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");
95983 openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
96045 zDb = db->aDb[iDb].zName;
96291 const char *zName,
96294 Index *pIdx = sqlite3FindIndex(db, zName, zDb);
96296 Table *pTab = sqlite3FindTable(db, zName, zDb);
96505 sInfo.zDatabase = db->aDb[iDb].zName;
96615 const char *zName;
96627 zName = (const char *)sqlite3_value_text(argv[1]);
96629 if( zName==0 ) zName = "";
96648 char *z = db->aDb[i].zName;
96649 assert( z && zName );
96650 if( sqlite3StrICmp(z, zName)==0 ){
96651 zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName);
96676 rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
96713 aNew->zName = sqlite3DbStrDup(db, zName);
96714 if( rc==SQLITE_OK && aNew->zName==0 ){
96764 rc = sqlite3UserAuthCheckLogin(db, zName, &newAuth);
96814 const char *zName = (const char *)sqlite3_value_text(argv[0]);
96822 if( zName==0 ) zName = "";
96826 if( sqlite3StrICmp(pDb->zName, zName)==0 ) break;
96830 sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
96834 sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
96843 sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
96984 pFix->zDb = db->aDb[iDb].zName;
97243 char *zDb = db->aDb[iDb].zName; /* Name of attached database */
97312 zCol = pTab->aCol[iCol].zName;
97315 zCol = pTab->aCol[pTab->iPKey].zName;
97320 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
97432 const char *zName; /* Name of the table */
97450 const char *zName /* Name of the table to be locked */
97474 p->zName = zName;
97496 p->zName, P4_STATIC);
97702 SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){
97711 if( db->auth.authLevel<UAUTH_Admin && sqlite3UserAuthTable(zName)!=0 ){
97717 if( zDatabase!=0 && sqlite3StrICmp(zDatabase, db->aDb[j].zName) ) continue;
97719 p = sqlite3HashFind(&db->aDb[j].pSchema->tblHash, zName);
97738 const char *zName, /* Name of the table we are looking for */
97749 p = sqlite3FindTable(pParse->db, zName, zDbase);
97757 Module *pMod = (Module*)sqlite3HashFind(&pParse->db->aModule, zName);
97765 sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
97767 sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
97794 zDb = pParse->db->aDb[iDb].zName;
97798 return sqlite3LocateTable(pParse, flags, p->zName, zDb);
97813 SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){
97822 if( zDb && sqlite3StrICmp(zDb, db->aDb[j].zName) ) continue;
97824 p = sqlite3HashFind(&pSchema->idxHash, zName);
97891 sqlite3DbFree(db, pDb->zName);
97892 pDb->zName = 0;
97970 sqlite3DbFree(db, pCol->zName);
98009 char *zName = pIndex->zName;
98011 &pIndex->pSchema->idxHash, zName, 0
98025 sqlite3DbFree(db, pTable->zName);
98078 char *zName;
98080 zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n);
98081 sqlite3Dequote(zName);
98083 zName = 0;
98085 return zName;
98107 SQLITE_PRIVATE int sqlite3FindDbName(sqlite3 *db, const char *zName){
98109 if( zName ){
98112 if( 0==sqlite3StrICmp(pDb->zName, zName) ) break;
98126 char *zName; /* Name we are searching for */
98127 zName = sqlite3NameFromToken(db, pName);
98128 i = sqlite3FindDbName(db, zName);
98129 sqlite3DbFree(db, zName);
98185 SQLITE_PRIVATE int sqlite3CheckObjectName(Parse *pParse, const char *zName){
98188 && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){
98189 sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s", zName);
98242 char *zName = 0; /* The name of the new table */
98251 zName = sqlite3DbStrDup(db, SCHEMA_TABLE(iDb));
98264 zName = sqlite3NameFromToken(db, pName);
98267 if( zName==0 ) return;
98268 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
98282 char *zDb = db->aDb[iDb].zName;
98287 zName, 0, zDb) ){
98301 char *zDb = db->aDb[iDb].zName;
98305 pTable = sqlite3FindTable(db, zName, zDb);
98315 if( sqlite3FindIndex(db, zName, zDb)!=0 ){
98316 sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
98328 pTable->zName = zName;
98341 if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){
98414 sqlite3DbFree(db, zName);
98423 if( sqlite3_strnicmp(pCol->zName, "__hidden__", 10)==0 ){
98450 sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
98460 if( sqlite3_stricmp(z, p->aCol[i].zName)==0 ){
98477 pCol->zName = z;
98616 pCol->zName);
98693 "table \"%s\" has more than one primary key", pTab->zName);
98711 if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zName)==0 ){
98826 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){
98832 pColl = sqlite3FindCollSeq(db, enc, zName, initbusy);
98834 pColl = sqlite3GetCollSeq(pParse, enc, pColl, zName);
98929 n += identLength(pCol->zName) + 5;
98931 n += identLength(p->zName);
98949 identPut(zStmt, &k, p->zName);
98965 identPut(zStmt, &k, pCol->zName);
99109 sqlite3TokenInit(&ipkToken, pTab->aCol[pTab->iPKey].zName);
99262 sqlite3ErrorMsg(pParse, "PRIMARY KEY missing on table %s", p->zName);
99394 db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
99396 p->zName,
99397 p->zName,
99415 pDb->zName
99423 sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName));
99433 pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p);
99444 const char *zName = (const char *)pParse->sNameToken.z;
99450 nName = (int)((const char *)pCons->z - zName);
99451 p->addColOffset = 13 + sqlite3Utf8CharLen(zName, nName);
99572 sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
99729 pParse->db->aDb[iDb].zName, SCHEMA_TABLE(iDb), iTable, r1, r1);
99802 const char *zName /* Name of index or table */
99805 const char *zDbName = pParse->db->aDb[iDb].zName;
99812 zDbName, zTab, zType, zName
99858 pDb->zName, pTab->zName
99872 pDb->zName, SCHEMA_TABLE(iDb), pTab->zName);
99881 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
99883 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
99926 const char *zDb = db->aDb[iDb].zName;
99940 zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
99949 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
99952 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
99957 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
99958 && sqlite3StrNICmp(pTab->zName, "sqlite_stat", 11)!=0 ){
99959 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
99968 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
99972 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
99983 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
100033 p->aCol[iCol].zName, pTo);
100048 nByte += sqlite3Strlen30(pToCol->a[i].zName) + 1;
100070 if( sqlite3StrICmp(p->aCol[j].zName, pFromCol->a[i].zName)==0 ){
100078 pFromCol->a[i].zName);
100085 int n = sqlite3Strlen30(pToCol->a[i].zName);
100087 memcpy(z, pToCol->a[i].zName, n);
100166 if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
100167 db->aDb[iDb].zName ) ){
100173 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
100292 char *zName = 0; /* Name of the index */
100356 pTab->zName);
100371 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
100374 && sqlite3UserAuthTable(pTab->zName)==0
100376 && sqlite3StrNICmp(&pTab->zName[7],"altertab_",9)!=0 ){
100377 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
100407 zName = sqlite3NameFromToken(db, pName);
100408 if( zName==0 ) goto exit_create_index;
100410 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
100414 if( sqlite3FindTable(db, zName, 0)!=0 ){
100415 sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
100419 if( sqlite3FindIndex(db, zName, pDb->zName)!=0 ){
100421 sqlite3ErrorMsg(pParse, "index %s already exists", zName);
100432 zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
100433 if( zName==0 ){
100442 if( IN_DECLARE_VTAB ) zName[7]++;
100449 const char *zDb = pDb->zName;
100455 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
100467 sqlite3TokenInit(&prevCol, pTab->aCol[pTab->nCol-1].zName);
100491 nName = sqlite3Strlen30(zName);
100500 pIndex->zName = zExtra;
100502 memcpy(pIndex->zName, zName, nName+1);
100701 pIndex->zName, pIndex);
100764 db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
100765 pIndex->zName,
100766 pTab->zName,
100779 sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName));
100814 sqlite3DbFree(db, zName);
100878 pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
100898 const char *zDb = db->aDb[iDb].zName;
100904 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
100916 db->aDb[iDb].zName, SCHEMA_TABLE(iDb), pIndex->zName
100918 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
100921 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
100993 pList->a[i].zName = sqlite3NameFromToken(db, pToken);
101004 sqlite3DbFree(db, pList->a[i].zName);
101014 SQLITE_PRIVATE int sqlite3IdListIndex(IdList *pList, const char *zName){
101018 if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
101153 pItem->zName = sqlite3NameFromToken(db, pTable);
101185 sqlite3DbFree(db, pItem->zName);
101381 char *zName = sqlite3NameFromToken(pParse->db, pName);
101382 if( zName ){
101388 if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
101389 sqlite3DbFree(pParse->db, zName);
101392 sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
101461 if( pDb->pBt && (!zDb || 0==sqlite3StrICmp(zDb, pDb->zName)) ){
101557 sqlite3XPrintf(&errMsg, "index '%q'", pIdx->zName);
101562 zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
101564 sqlite3XPrintf(&errMsg, "%s.%s", pTab->zName, zCol);
101586 zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
101587 pTab->aCol[pTab->iPKey].zName);
101590 zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
101708 zDb = db->aDb[iDb].zName;
101773 char *zName;
101777 zName = sqlite3NameFromToken(pParse->db, pName);
101778 if( zName && pWith ){
101781 if( sqlite3StrICmp(zName, pWith->a[i].zName)==0 ){
101782 sqlite3ErrorMsg(pParse, "duplicate WITH table name: %s", zName);
101793 assert( (pNew!=0 && zName!=0) || db->mallocFailed );
101798 sqlite3DbFree(db, zName);
101803 pNew->a[pNew->nCte].zName = zName;
101821 sqlite3DbFree(db, pCte->zName);
101852 static void callCollNeeded(sqlite3 *db, int enc, const char *zName){
101855 char *zExternal = sqlite3DbStrDup(db, zName);
101864 sqlite3ValueSetStr(pTmp, -1, zName, SQLITE_UTF8, SQLITE_STATIC);
101883 char *z = pColl->zName;
101915 const char *zName /* Collating sequence name */
101922 p = sqlite3FindCollSeq(db, enc, zName, 0);
101928 callCollNeeded(db, enc, zName);
101929 p = sqlite3FindCollSeq(db, enc, zName, 0);
101936 sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);
101954 const char *zName = pColl->zName;
101956 CollSeq *p = sqlite3GetCollSeq(pParse, ENC(db), pColl, zName);
101982 const char *zName, /* Name of the collating sequence */
101986 pColl = sqlite3HashFind(&db->aCollSeq, zName);
101989 int nName = sqlite3Strlen30(zName);
101993 pColl[0].zName = (char*)&pColl[3];
101995 pColl[1].zName = (char*)&pColl[3];
101997 pColl[2].zName = (char*)&pColl[3];
101999 memcpy(pColl[0].zName, zName, nName);
102000 pColl[0].zName[nName] = 0;
102001 pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, pColl);
102036 const char *zName,
102040 if( zName ){
102041 pColl = findCollSeqEntry(db, zName, create);
102121 if( sqlite3StrICmp(p->zName, zFunc)==0 ){
102138 const char *zName = aDef[i].zName;
102139 int nName = sqlite3Strlen30(zName);
102140 int h = (sqlite3UpperToLower[(u8)zName[0]] + nName) % SQLITE_FUNC_HASH_SZ;
102141 pOther = functionSearch(h, zName);
102177 const char *zName, /* Name of the function. zero-terminated */
102190 nName = sqlite3Strlen30(zName);
102194 p = (FuncDef*)sqlite3HashFind(&db->aFunc, zName);
102218 h = (sqlite3UpperToLower[(u8)zName[0]] + nName) % SQLITE_FUNC_HASH_SZ;
102219 p = functionSearch(h, zName);
102237 pBest->zName = (const char*)&pBest[1];
102240 memcpy((char*)&pBest[1], zName, nName+1);
102241 pOther = (FuncDef*)sqlite3HashInsert(&db->aFunc, pBest->zName, pBest);
102386 sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
102392 sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
102421 pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName);
102422 pFrom->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zName);
102609 zDb = db->aDb[iDb].zName;
102610 rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb);
102628 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
102681 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
102684 pTab->zName, P4_STATIC);
103110 VdbeModuleComment((v, "GenRowIdxDel for %s", pIdx->zName));
104870 static void setLikeOptFlag(sqlite3 *db, const char *zName, u8 flagVal){
104872 pDef = sqlite3FindFunction(db, zName, 2, SQLITE_UTF8, 0);
105056 int n = sqlite3Strlen30(p->zName);
105057 int h = p->zName[0] + n;
105058 printf(" %s(%d)", p->zName, h);
105285 if( !sqlite3StrICmp(pParent->aCol[pParent->iPKey].zName, zKey) ) return 0;
105331 zIdxCol = pParent->aCol[iCol].zName;
105349 pFKey->pFrom->zName, pFKey->zTo);
105544 if( zColl==0 ) zColl = db->pDfltColl->zName;
105652 zCol = pFKey->pFrom->aCol[iCol].zName;
105731 return (FKey *)sqlite3HashFind(&pTab->pSchema->fkeyHash, pTab->zName);
105872 if( 0==sqlite3StrICmp(pCol->zName, zKey) ) return 1;
105941 zDb = db->aDb[iDb].zName;
105955 && sqlite3_stricmp(pTab->zName, pFKey->zTo)!=0
106010 char *zCol = pTo->aCol[pIdx ? pIdx->aiColumn[i] : pTo->iPKey].zName;
106011 rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
106020 sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
106076 pItem->zName = pFKey->pFrom->zName;
106107 pItem->zName = 0;
106265 pTab->aCol[pIdx ? pIdx->aiColumn[i] : pTab->iPKey].zName);
106266 sqlite3TokenInit(&tFromCol, pFKey->pFrom->aCol[iFromCol].zName);
106323 zFrom = pFKey->pFrom->zName;
106516 (opcode==OP_OpenWrite)?1:0, pTab->zName);
106519 VdbeComment((v, "%s", pTab->zName));
106526 VdbeComment((v, "%s", pTab->zName));
106762 sqlite3VdbeLoadString(v, memId-1, p->pTab->zName);
107019 zTab = pTabList->a[0].zName;
107028 zDb = pDb->zName;
107029 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb) ){
107122 if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){
107132 if( sqlite3IsRowid(pColumn->a[i].zName) && !withoutRowid ){
107137 pTabList, 0, pColumn->a[i].zName);
107776 char *zMsg = sqlite3MPrintf(db, "%s.%s", pTab->zName,
107777 pTab->aCol[i].zName);
107816 char *zName = pCheck->a[i].zName;
107817 if( zName==0 ) zName = pTab->zName;
107820 onError, zName, P4_TRANSIENT,
107986 VdbeComment((v, "%s column %d", pIdx->zName, i));
107996 VdbeComment((v, "%s", iField<0 ? "rowid" : pTab->aCol[iField].zName));
108000 VdbeComment((v, "for %s", pIdx->zName));
108050 VdbeComment((v, "%s.%s", pTab->zName,
108051 pTab->aCol[pPk->aiColumn[i]].zName));
108252 sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
108266 VdbeComment((v, "%s", pIdx->zName));
108599 sqlite3TableLock(pParse, iDbDest, pDest->tnum, 1, pDest->zName);
108600 sqlite3TableLock(pParse, iDbSrc, pSrc->tnum, 0, pSrc->zName);
108610 VdbeComment((v, "%s", pSrcIdx->zName));
108614 VdbeComment((v, "%s", pDestIdx->zName));
108876 int (*bind_parameter_index)(sqlite3_stmt*,const char*zName);
110261 const char *const zName; /* Name of pragma */
110887 const char *zName;
110889 case OE_SetNull: zName = "SET NULL"; break;
110890 case OE_SetDflt: zName = "SET DEFAULT"; break;
110891 case OE_Cascade: zName = "CASCADE"; break;
110892 case OE_Restrict: zName = "RESTRICT"; break;
110893 default: zName = "NO ACTION";
110896 return zName;
110986 zDb = pId2->n>0 ? pDb->zName : 0;
111032 rc = sqlite3_stricmp(zLeft, aPragmaNames[mid].zName);
111652 returnSingleInt(v, pPragma->zName, (db->flags & pPragma->iArg)!=0 );
111728 pCol->zName,
111750 pTab->zName,
111757 pIdx->zName,
111792 cnum<0 ? 0 : pTab->aCol[cnum].zName);
111822 pIdx->zName,
111839 assert( db->aDb[i].zName!=0 );
111842 db->aDb[i].zName,
111857 sqlite3VdbeMultiLoad(v, 1, "is", i++, pColl->zName);
111888 pTab->aCol[pFK->aCol[j].iFrom].zName,
111940 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
111943 sqlite3VdbeLoadString(v, regResult, pTab->zName);
111948 sqlite3TableLock(pParse, iDb, pParent->tnum, 0, pParent->zName);
112131 sqlite3MPrintf(db, "*** in database %s ***\n", db->aDb[i].zName),
112175 zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName,
112176 pTab->aCol[j].zName);
112201 jmp5 = sqlite3VdbeLoadString(v, 4, pIdx->zName);
112247 sqlite3VdbeLoadString(v, 3, pIdx->zName);
112300 char *zName;
112319 returnSingleText(v, "encoding", encnames[ENC(pParse->db)].zName);
112330 for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
112331 if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){
112337 if( !pEnc->zName ){
112570 if( db->aDb[i].zName==0 ) continue;
112574 }else if( sqlite3_file_control(db, i ? db->aDb[i].zName : 0,
112578 sqlite3VdbeMultiLoad(v, 1, "ss", db->aDb[i].zName, zState);
112748 pIndex = sqlite3FindIndex(db, argv[0], db->aDb[iDb].zName);
112927 db->aDb[iDb].zName, zMasterName);
113202 const char *zDb = db->aDb[i].zName;
113658 SQLITE_PRIVATE void sqlite3SelectSetName(Select *p, const char *zName){
113659 if( p && zName ){
113660 sqlite3_snprintf(sizeof(p->zSelName), p->zSelName, "%s", zName);
113762 if( sqlite3StrICmp(pTab->aCol[i].zName, zCol)==0 ) return i;
113928 char *zName; /* Name of column in the right table */
113932 zName = pRightTab->aCol[j].zName;
113933 if( tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol) ){
113967 char *zName; /* Name of the term in the USING clause */
113972 zName = pList->a[j].zName;
113973 iRightCol = columnIndex(pRightTab, zName);
113975 || !tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol)
113978 "not present in both tables", zName);
114246 VdbeComment((v, "%s", pEList->a[i].zName));
114772 VdbeComment((v, "%s", aOutEx[i].zName ? aOutEx[i].zName : aOutEx[i].zSpan));
114951 zOrigCol = pTab->aCol[iCol].zName;
114955 zOrigTab = pTab->zName;
114958 zOrigDb = pNC->pParse->db->aDb[iDb].zName;
115074 if( pEList->a[i].zName ){
115075 char *zName = pEList->a[i].zName;
115076 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_TRANSIENT);
115091 zCol = pTab->aCol[iCol].zName;
115097 char *zName = 0;
115098 zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol);
115099 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_DYNAMIC);
115137 char *zName; /* Column name */
115158 if( (zName = pEList->a[i].zName)!=0 ){
115172 zName = iCol>=0 ? pTab->aCol[iCol].zName : "rowid";
115175 zName = pColExpr->u.zToken;
115178 zName = pEList->a[i].zSpan;
115181 zName = sqlite3MPrintf(db, "%s", zName);
115187 while( zName && sqlite3HashFind(&ht, zName)!=0 ){
115188 nName = sqlite3Strlen30(zName);
115190 for(j=nName-1; j>0 && sqlite3Isdigit(zName[j]); j--){}
115191 if( zName[j]==':' ) nName = j;
115193 zName = sqlite3MPrintf(db, "%.*z:%u", nName, zName, ++cnt);
115196 pCol->zName = zName;
115198 if( zName && sqlite3HashInsert(&ht, zName, pCol)==pCol ){
115205 sqlite3DbFree(db, aCol[j].zName);
115255 n = sqlite3Strlen30(pCol->zName);
115256 pCol->zName = sqlite3DbReallocOrFree(db, pCol->zName, n+m+2);
115257 if( pCol->zName ){
115258 memcpy(&pCol->zName[n+1], zType, m+1);
115265 pCol->zColl = sqlite3DbStrDup(db, pColl->zName);
115295 pTab->zName = 0;
115449 sqlite3ExprAddCollateString(pParse, pTerm, pColl->zName);
117004 pParse->zAuthContext = pSubitem->zName;
117083 sqlite3DbFree(db, pSubitem->zName);
117086 pSubitem->zName = 0;
117188 if( pList->a[i].zName==0 ){
117189 char *zName = sqlite3DbStrDup(db, pList->a[i].zSpan);
117190 sqlite3Dequote(zName);
117191 pList->a[i].zName = zName;
117426 pIdx && sqlite3StrICmp(pIdx->zName, zIndexedBy);
117516 sqlite3ErrorMsg(pParse, "'%s' is not a function", pFrom->zName);
117538 const char *zName;
117539 if( pItem->zDatabase==0 && (zName = pItem->zName)!=0 ){
117544 if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){
117614 sqlite3ErrorMsg(pParse, pCte->zCteErr, pCte->zName);
117623 pTab->zName = sqlite3DbStrDup(db, pCte->zName);
117640 && pItem->zName!=0
117641 && 0==sqlite3StrICmp(pItem->zName, pCte->zName)
117654 pParse, "multiple references to recursive table: %s", pCte->zName
117671 pCte->zName, pEList->nExpr, pCte->pCols->nExpr
117782 if( pFrom->zName==0 ){
117792 pTab->zName = sqlite3MPrintf(db, "sqlite_sq_%p", (void*)pTab);
117806 pTab->zName);
117820 sqlite3SelectSetName(pFrom->pSelect, pTab->zName);
117882 pNew->a[pNew->nExpr-1].zName = a[k].zName;
117884 a[k].zName = 0;
117905 zTabName = pTab->zName;
117914 zSchemaName = iDb>=0 ? db->aDb[iDb].zName : "*";
117917 char *zName = pTab->aCol[j].zName;
117922 assert( zName );
117942 && tableAndColumnIndex(pTabList, i, zName, 0, 0)
117948 if( sqlite3IdListIndex(pFrom->pUsing, zName)>=0 ){
117954 pRight = sqlite3Expr(db, TK_ID, zName);
117955 zColname = zName;
117966 zColname = sqlite3MPrintf(db, "%s.%s", zTabName, zName);
118300 pTab->zName,
118302 bCover ? pIdx->zName : ""
118421 pTab->nCol, pTab->zName, pSub->pEList->nExpr);
118533 VdbeComment((v, "%s", pItem->pTab->zName));
118562 VdbeComment((v, "materialize \"%s\"", pItem->pTab->zName));
118564 VdbeNoopComment((v, "materialize \"%s\"", pItem->pTab->zName));
118572 VdbeComment((v, "end %s", pItem->pTab->zName));
119050 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
119470 && 0==sqlite3StrICmp(pTrig->table, pTab->zName)
119503 char *zName = 0; /* Name of the trigger */
119587 zName = sqlite3NameFromToken(db, pName);
119588 if( !zName || SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
119592 if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),zName) ){
119603 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
119626 const char *zDb = db->aDb[iTabDb].zName;
119627 const char *zDbTrig = isTemp ? db->aDb[1].zName : zDb;
119629 if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
119650 pTrigger->zName = zName;
119651 zName = 0;
119652 pTrigger->table = sqlite3DbStrDup(db, pTableName->a[0].zName);
119663 sqlite3DbFree(db, zName);
119684 char *zName; /* Name of trigger */
119692 zName = pTrig->zName;
119699 sqlite3TokenInit(&nameToken, pTrig->zName);
119721 db->aDb[iDb].zName, SCHEMA_TABLE(iDb), zName,
119726 sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName));
119733 pTrig = sqlite3HashInsert(pHash, zName, pTrig);
119877 sqlite3DbFree(db, pTrigger->zName);
119896 const char *zName;
119906 zName = pName->a[0].zName;
119910 if( zDb && sqlite3StrICmp(db->aDb[j].zName, zDb) ) continue;
119912 pTrigger = sqlite3HashFind(&(db->aDb[j].pSchema->trigHash), zName);
119956 const char *zDb = db->aDb[iDb].zName;
119959 if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) ||
119972 db->aDb[iDb].zName, SCHEMA_TABLE(iDb), pTrigger->zName
119975 sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
119982 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){
119988 pTrigger = sqlite3HashInsert(pHash, zName, 0);
120014 if( sqlite3IdListIndex(pIdList, pEList->a[e].zName)>=0 ) return 1;
120072 pSrc->a[pSrc->nSrc-1].zName = sqlite3DbStrDup(db, pStep->zTarget);
120076 pSrc->a[pSrc->nSrc-1].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zName);
120213 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
120240 pSubParse->zAuthContext = pTrigger->zName;
120247 pTrigger->zName, onErrorText(orconf),
120252 pTab->zName
120256 sqlite3MPrintf(db, "-- TRIGGER %s", pTrigger->zName), P4_DYNAMIC
120282 VdbeComment((v, "End: %s.%s", pTrigger->zName, onErrorText(orconf)));
120320 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
120361 int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers));
120366 (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf)));
120578 VdbeComment((v, "%s.%s", pTab->zName, pCol->zName));
120736 if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zName)==0 ){
120748 if( pPk==0 && sqlite3IsRowid(pChanges->a[i].zName) ){
120753 sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zName);
120761 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
120762 j<0 ? "ROWID" : pTab->aCol[j].zName,
120763 db->aDb[iDb].zName);
120833 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
121520 assert( strcmp(pDb->zName,"vacuum_db")==0 );
121760 const char *zName, /* Name assigned to this module */
121769 nName = sqlite3Strlen30(zName);
121770 if( sqlite3HashFind(&db->aModule, zName) ){
121778 memcpy(zCopy, zName, nName+1);
121779 pMod->zName = zCopy;
121805 const char *zName, /* Name assigned to this module */
121810 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
121812 return createModule(db, zName, pModule, pAux, 0);
121820 const char *zName, /* Name assigned to this module */
121826 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
121828 return createModule(db, zName, pModule, pAux, xDestroy);
122053 addModuleArgument(db, pTable, sqlite3DbStrDup(db, pTable->zName));
122068 sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName,
122069 pTable->azModuleArg[0], pParse->db->aDb[iDb].zName);
122133 db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
122134 pTab->zName,
122135 pTab->zName,
122144 zWhere = sqlite3MPrintf(db, "name='%q' AND type='table'", pTab->zName);
122148 sqlite3VdbeLoadString(v, iReg, pTab->zName);
122160 const char *zName = pTab->zName;
122162 pOld = sqlite3HashInsert(&pSchema->tblHash, zName, pTab);
122223 "vtable constructor called recursively: %s", pTab->zName
122229 zModuleName = sqlite3MPrintf(db, "%s", pTab->zName);
122243 pTab->azModuleArg[1] = db->aDb[iDb].zName;
122274 *pzErr = sqlite3MPrintf(db, zFormat, pTab->zName);
122407 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
122531 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
122775 zLowerName = sqlite3DbStrDup(db, pDef->zName);
122790 + sqlite3Strlen30(pDef->zName) + 1);
122795 pNew->zName = (const char*)&pNew[1];
122796 memcpy((char*)&pNew[1], pDef->zName, sqlite3Strlen30(pDef->zName)+1);
122852 pTab->zName = sqlite3DbStrDup(db, pMod->zName);
122853 if( pTab->zName==0 ){
122863 addModuleArgument(db, pTab, sqlite3DbStrDup(db, pTab->zName));
122865 addModuleArgument(db, pTab, sqlite3DbStrDup(db, pTab->zName));
123554 return pIdx->pTable->aCol[i].zName;
123643 sqlite3XPrintf(&str, " TABLE %s", pItem->zName);
123671 sqlite3XPrintf(&str, zFmt, pIdx->zName);
123727 zObj = pLoop->u.btree.pIndex->zName;
123729 zObj = pSrclist->a[pLvl->iFrom].zName;
124008 VdbeComment((v, "begin skip-scan on %s", pIdx->zName));
124412 VdbeModuleComment((v, "Begin WHERE-loop%d: %s",iLevel,pTabItem->pTab->zName));
124443 VdbeComment((v, "next row of \"%s\"", pTabItem->pTab->zName));
126143 if( pColl==0 || sqlite3StrICmp(pColl->zName, "BINARY")==0 ) return 1;
126145 zColl1 = pColl ? pColl->zName : 0;
126147 zColl2 = pColl ? pColl->zName : 0;
126706 pTab->zName, j);
126964 if( sqlite3StrICmp(pColl->zName, pScan->zCollName) ){
127122 if( pColl && 0==sqlite3StrICmp(pColl->zName, zColl) ){
127403 "automatic index on %s(%s)", pTable->zName,
127404 pTable->aCol[iCol].zName);
127444 pIdx->zName = "auto-index";
127459 pIdx->azColl[n] = pColl ? pColl->zName : sqlite3StrBINARY;
127491 VdbeComment((v, "for %s", pTable->zName));
127502 VdbeComment((v, "next row of \"%s\"", pTabItem->pTab->zName));
127699 "table %s: xBestIndex returned an invalid plan", pTab->zName);
128306 p->zName, nEq-1, (int)a[1]));
128420 pItem->zAlias ? pItem->zAlias : pTab->zName);
128422 const char *zName;
128423 if( p->u.btree.pIndex && (zName = p->u.btree.pIndex->zName)!=0 ){
128424 if( strncmp(zName, "sqlite_autoindex_", 17)==0 ){
128425 int i = sqlite3Strlen30(zName) - 1;
128426 while( zName[i]!='_' ) i--;
128427 zName += i;
128429 sqlite3DebugPrintf(".%-16s %2d", zName, p->u.btree.nEq);
129640 sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
130137 z1 = pColl->zName;
130140 z2 = pColl->zName;
130231 if( sqlite3StrICmp(pColl->zName, pIndex->azColl[j])!=0 ) continue;
130328 static char zName[65];
130330 for(i=0; i<nLoop; i++){ zName[i] = pPath->aLoop[i]->cId; }
130331 if( pLast ) zName[i++] = pLast->cId;
130332 zName[i] = 0;
130333 return zName;
131262 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
131305 VdbeComment((v, "%s", pIx->zName));
131415 VdbeComment((v, "next skip-scan on %s", pLoop->u.btree.pIndex->zName));
131444 pWInfo->pTabList->a[pLevel->iFrom].pTab->zName));
134232 pNew->zName = pOld->zName;
134235 pOld->zName = pOld->zDatabase = 0;
137789 const char *zName = 0;
137791 for(i=0; i<2 && zName==0; i++, rc &= 0xff){
137793 case SQLITE_OK: zName = "SQLITE_OK"; break;
137794 case SQLITE_ERROR: zName = "SQLITE_ERROR"; break;
137795 case SQLITE_INTERNAL: zName = "SQLITE_INTERNAL"; break;
137796 case SQLITE_PERM: zName = "SQLITE_PERM"; break;
137797 case SQLITE_ABORT: zName = "SQLITE_ABORT"; break;
137798 case SQLITE_ABORT_ROLLBACK: zName = "SQLITE_ABORT_ROLLBACK"; break;
137799 case SQLITE_BUSY: zName = "SQLITE_BUSY"; break;
137800 case SQLITE_BUSY_RECOVERY: zName = "SQLITE_BUSY_RECOVERY"; break;
137801 case SQLITE_BUSY_SNAPSHOT: zName = "SQLITE_BUSY_SNAPSHOT"; break;
137802 case SQLITE_LOCKED: zName = "SQLITE_LOCKED"; break;
137803 case SQLITE_LOCKED_SHAREDCACHE: zName = "SQLITE_LOCKED_SHAREDCACHE";break;
137804 case SQLITE_NOMEM: zName = "SQLITE_NOMEM"; break;
137805 case SQLITE_READONLY: zName = "SQLITE_READONLY"; break;
137806 case SQLITE_READONLY_RECOVERY: zName = "SQLITE_READONLY_RECOVERY"; break;
137807 case SQLITE_READONLY_CANTLOCK: zName = "SQLITE_READONLY_CANTLOCK"; break;
137808 case SQLITE_READONLY_ROLLBACK: zName = "SQLITE_READONLY_ROLLBACK"; break;
137809 case SQLITE_READONLY_DBMOVED: zName = "SQLITE_READONLY_DBMOVED"; break;
137810 case SQLITE_INTERRUPT: zName = "SQLITE_INTERRUPT"; break;
137811 case SQLITE_IOERR: zName = "SQLITE_IOERR"; break;
137812 case SQLITE_IOERR_READ: zName = "SQLITE_IOERR_READ"; break;
137813 case SQLITE_IOERR_SHORT_READ: zName = "SQLITE_IOERR_SHORT_READ"; break;
137814 case SQLITE_IOERR_WRITE: zName = "SQLITE_IOERR_WRITE"; break;
137815 case SQLITE_IOERR_FSYNC: zName = "SQLITE_IOERR_FSYNC"; break;
137816 case SQLITE_IOERR_DIR_FSYNC: zName = "SQLITE_IOERR_DIR_FSYNC"; break;
137817 case SQLITE_IOERR_TRUNCATE: zName = "SQLITE_IOERR_TRUNCATE"; break;
137818 case SQLITE_IOERR_FSTAT: zName = "SQLITE_IOERR_FSTAT"; break;
137819 case SQLITE_IOERR_UNLOCK: zName = "SQLITE_IOERR_UNLOCK"; break;
137820 case SQLITE_IOERR_RDLOCK: zName = "SQLITE_IOERR_RDLOCK"; break;
137821 case SQLITE_IOERR_DELETE: zName = "SQLITE_IOERR_DELETE"; break;
137822 case SQLITE_IOERR_NOMEM: zName = "SQLITE_IOERR_NOMEM"; break;
137823 case SQLITE_IOERR_ACCESS: zName = "SQLITE_IOERR_ACCESS"; break;
137825 zName = "SQLITE_IOERR_CHECKRESERVEDLOCK"; break;
137826 case SQLITE_IOERR_LOCK: zName = "SQLITE_IOERR_LOCK"; break;
137827 case SQLITE_IOERR_CLOSE: zName = "SQLITE_IOERR_CLOSE"; break;
137828 case SQLITE_IOERR_DIR_CLOSE: zName = "SQLITE_IOERR_DIR_CLOSE"; break;
137829 case SQLITE_IOERR_SHMOPEN: zName = "SQLITE_IOERR_SHMOPEN"; break;
137830 case SQLITE_IOERR_SHMSIZE: zName = "SQLITE_IOERR_SHMSIZE"; break;
137831 case SQLITE_IOERR_SHMLOCK: zName = "SQLITE_IOERR_SHMLOCK"; break;
137832 case SQLITE_IOERR_SHMMAP: zName = "SQLITE_IOERR_SHMMAP"; break;
137833 case SQLITE_IOERR_SEEK: zName = "SQLITE_IOERR_SEEK"; break;
137834 case SQLITE_IOERR_DELETE_NOENT: zName = "SQLITE_IOERR_DELETE_NOENT";break;
137835 case SQLITE_IOERR_MMAP: zName = "SQLITE_IOERR_MMAP"; break;
137836 case SQLITE_IOERR_GETTEMPPATH: zName = "SQLITE_IOERR_GETTEMPPATH"; break;
137837 case SQLITE_IOERR_CONVPATH: zName = "SQLITE_IOERR_CONVPATH"; break;
137838 case SQLITE_CORRUPT: zName = "SQLITE_CORRUPT"; break;
137839 case SQLITE_CORRUPT_VTAB: zName = "SQLITE_CORRUPT_VTAB"; break;
137840 case SQLITE_NOTFOUND: zName = "SQLITE_NOTFOUND"; break;
137841 case SQLITE_FULL: zName = "SQLITE_FULL"; break;
137842 case SQLITE_CANTOPEN: zName = "SQLITE_CANTOPEN"; break;
137843 case SQLITE_CANTOPEN_NOTEMPDIR: zName = "SQLITE_CANTOPEN_NOTEMPDIR";break;
137844 case SQLITE_CANTOPEN_ISDIR: zName = "SQLITE_CANTOPEN_ISDIR"; break;
137845 case SQLITE_CANTOPEN_FULLPATH: zName = "SQLITE_CANTOPEN_FULLPATH"; break;
137846 case SQLITE_CANTOPEN_CONVPATH: zName = "SQLITE_CANTOPEN_CONVPATH"; break;
137847 case SQLITE_PROTOCOL: zName = "SQLITE_PROTOCOL"; break;
137848 case SQLITE_EMPTY: zName = "SQLITE_EMPTY"; break;
137849 case SQLITE_SCHEMA: zName = "SQLITE_SCHEMA"; break;
137850 case SQLITE_TOOBIG: zName = "SQLITE_TOOBIG"; break;
137851 case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT"; break;
137852 case SQLITE_CONSTRAINT_UNIQUE: zName = "SQLITE_CONSTRAINT_UNIQUE"; break;
137853 case SQLITE_CONSTRAINT_TRIGGER: zName = "SQLITE_CONSTRAINT_TRIGGER";break;
137855 zName = "SQLITE_CONSTRAINT_FOREIGNKEY"; break;
137856 case SQLITE_CONSTRAINT_CHECK: zName = "SQLITE_CONSTRAINT_CHECK"; break;
137858 zName = "SQLITE_CONSTRAINT_PRIMARYKEY"; break;
137859 case SQLITE_CONSTRAINT_NOTNULL: zName = "SQLITE_CONSTRAINT_NOTNULL";break;
137861 zName = "SQLITE_CONSTRAINT_COMMITHOOK"; break;
137862 case SQLITE_CONSTRAINT_VTAB: zName = "SQLITE_CONSTRAINT_VTAB"; break;
137864 zName = "SQLITE_CONSTRAINT_FUNCTION"; break;
137865 case SQLITE_CONSTRAINT_ROWID: zName = "SQLITE_CONSTRAINT_ROWID"; break;
137866 case SQLITE_MISMATCH: zName = "SQLITE_MISMATCH"; break;
137867 case SQLITE_MISUSE: zName = "SQLITE_MISUSE"; break;
137868 case SQLITE_NOLFS: zName = "SQLITE_NOLFS"; break;
137869 case SQLITE_AUTH: zName = "SQLITE_AUTH"; break;
137870 case SQLITE_FORMAT: zName = "SQLITE_FORMAT"; break;
137871 case SQLITE_RANGE: zName = "SQLITE_RANGE"; break;
137872 case SQLITE_NOTADB: zName = "SQLITE_NOTADB"; break;
137873 case SQLITE_ROW: zName = "SQLITE_ROW"; break;
137874 case SQLITE_NOTICE: zName = "SQLITE_NOTICE"; break;
137875 case SQLITE_NOTICE_RECOVER_WAL: zName = "SQLITE_NOTICE_RECOVER_WAL";break;
137877 zName = "SQLITE_NOTICE_RECOVER_ROLLBACK"; break;
137878 case SQLITE_WARNING: zName = "SQLITE_WARNING"; break;
137879 case SQLITE_WARNING_AUTOINDEX: zName = "SQLITE_WARNING_AUTOINDEX"; break;
137880 case SQLITE_DONE: zName = "SQLITE_DONE"; break;
137883 if( zName==0 ){
137886 zName = zBuf;
137888 return zName;
138296 const char *zName,
138302 if( !sqlite3SafetyCheckOk(db) || zName==0 || nArg<-2 ){
138307 if( sqlite3FindFunction(db, zName, nArg, SQLITE_UTF8, 0)==0 ){
138308 rc = sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8,
138834 const char *zName,
138863 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0);
138879 CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName);
138893 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 1);
139455 db->aDb[0].zName = "main";
139457 db->aDb[1].zName = "temp";
139657 const char *zName,
139662 return sqlite3_create_collation_v2(db, zName, enc, pCtx, xCompare, 0);
139670 const char *zName,
139679 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
139683 rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel);
139695 const void *zName,
139704 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
139708 zName8 = sqlite3Utf16to8(db, zName, -1, SQLITE_UTF16NATIVE);
139892 if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){
140418 && (zDbName==0 || sqlite3StrICmp(zDbName, db->aDb[i].zName)==0)
141668 const char *zName; /* virtual table name */
142338 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_content'", zDb, p->zName);
142340 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_segments'", zDb,p->zName);
142341 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_segdir'", zDb, p->zName);
142342 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_docsize'", zDb, p->zName);
142343 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_stat'", zDb, p->zName);
142382 zCols, p->zName, zLanguageid
142403 p->zDb, p->zName
142440 p->zDb, p->zName, zContentCols
142448 p->zDb, p->zName
142460 p->zDb, p->zName
142465 p->zDb, p->zName
142647 (p->zContentTbl ? p->zContentTbl : p->zName),
143165 p->zName = zCsr;
145196 char *zSql = sqlite3_mprintf(zFmt, p->zDb, p->zName);
145455 const char *zName, /* Name of SQL function */
145460 const char *zName;
145475 if( strcmp(zName, aOverload[i].zName)==0 ){
145490 const char *zName /* New name of table */
145514 p->zDb, p->zName, zName
145521 p->zDb, p->zName, zName
145527 p->zDb, p->zName, zName
145532 p->zDb, p->zName, zName
145536 p->zDb, p->zName, zName
147812 p->pFts3Tab->zName = &p->pFts3Tab->zDb[nDb+1];
147817 memcpy((char *)p->pFts3Tab->zName, zFts3, nFts3);
147818 sqlite3Fts3Dequote((char *)p->pFts3Tab->zName);
149374 const char *zName,
149387 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
150692 const unsigned char *zName;
150699 zName = sqlite3_value_text(argv[0]);
150706 if( zName==0 || n!=sizeof(pPtr) ){
150711 pOld = sqlite3Fts3HashInsert(pHash, (void *)zName, nName, pPtr);
150720 if( zName ){
150721 pPtr = sqlite3Fts3HashFind(pHash, zName, nName);
150724 char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
150892 const char *zName;
150914 zName = (const char *)sqlite3_value_text(argv[0]);
150919 p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
150922 char *zErr2 = sqlite3_mprintf("unknown tokenizer: %s", zName);
150974 char *zName,
150986 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
150997 char *zName,
151010 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
151097 const char *zName
151107 zTest = sqlite3_mprintf("%s_test", zName);
151108 zTest2 = sqlite3_mprintf("%s_internal_test", zName);
151115 rc = sqlite3_create_function(db, zName, 1, any, p, fts3TokenizerFunc, 0, 0);
151118 rc = sqlite3_create_function(db, zName, 2, any, p, fts3TokenizerFunc, 0, 0);
151456 const char *zName,
151461 int nName = (int)strlen(zName);
151463 p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
151465 sqlite3Fts3ErrMsg(pzErr, "unknown tokenizer: %s", zName);
152235 zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName, p->zWriteExprlist);
152239 zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName);
153043 p->zSegmentsTbl = sqlite3_mprintf("%s_segments", p->zName);
160111 char *zName; /* Name of r-tree table */
160815 pRtree->zDb, pRtree->zName,
160816 pRtree->zDb, pRtree->zName,
160817 pRtree->zDb, pRtree->zName
162810 zSql = sqlite3_mprintf("SELECT * FROM %Q.%Q", pRtree->zDb, pRtree->zName);
162822 "UNIQUE constraint failed: %s.%s", pRtree->zName, zCol
162828 "rtree constraint failed: %s.(%s<=%s)", pRtree->zName, zCol1, zCol2
162980 , pRtree->zDb, pRtree->zName, zNewName
162981 , pRtree->zDb, pRtree->zName, zNewName
162982 , pRtree->zDb, pRtree->zName, zNewName
163008 zSql = sqlite3_mprintf(zFmt, pRtree->zDb, pRtree->zName);
163193 pRtree->zDb, pRtree->zName
163254 pRtree->zName = &pRtree->zDb[nDb+1];
163259 memcpy(pRtree->zName, argv[2], nName);
163791 const char *zName, /* Name of ICU function that failed */
163795 sqlite3_snprintf(128, zBuf, "ICU error: %s(): %s", zName, u_errorName(e));
164018 const char *zName; /* SQL Collation sequence name (eg. "japanese") */
164025 zName = (const char *)sqlite3_value_text(apArg[1]);
164027 if( !zLocale || !zName ){
164038 rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator,
164052 const char *zName; /* Function name */
164082 db, p->zName, p->nArg, p->enc, p->pContext, p->xFunc, 0, 0
165019 SQLITE_API int sqlite3rbu_create_vfs(const char *zName, const char *zParent);
165029 SQLITE_API void sqlite3rbu_destroy_vfs(const char *zName);
166238 const char *zName = (const char*)sqlite3_column_name(pStmt, i);
166239 if( sqlite3_strnicmp("rbu_", zName, 4) ){
166240 char *zCopy = rbuStrndup(zName, &p->rc);
166244 else if( 0==sqlite3_stricmp("rbu_rowid", zName) ){
166271 const char *zName = (const char*)sqlite3_column_text(pStmt, 1);
166272 if( zName==0 ) break; /* An OOM - finalize() below returns S_NOMEM */
166274 if( 0==strcmp(zName, pIter->azTblCol[i]) ) break;
166279 pIter->zDataTbl, zName
167175 const char *zName,
167181 p->rc = sqlite3_open_v2(zName, &db, flags, bUseVfs ? p->zVfsName : 0);
167800 static void assertColumnName(sqlite3_stmt *pStmt, int iCol, const char *zName){
167802 assert( 0==sqlite3_stricmp(zName, zCol) );
168310 p->zVfsName = pVfs->zName;
169127 char *zOut = sqlite3_mprintf("rbu(%s)/%z", pRbuVfs->base.zName, zIn);
169292 static const char *rbuMainToWal(const char *zName, int flags){
169293 int n = (int)strlen(zName);
169294 const char *z = &zName[n];
169317 const char *zName,
169346 const char *zOpen = zName;
169353 if( zName ){
169360 pFd->zWal = rbuMainToWal(zName, flags);
169363 rbu_file *pDb = rbuFindMaindb(pRbuVfs, zName);
169370 const char *zBase = zName;
169396 && sqlite3_uri_boolean(zName, "rbu_memory", 0)
169569 SQLITE_API void sqlite3rbu_destroy_vfs(const char *zName){
169570 sqlite3_vfs *pVfs = sqlite3_vfs_find(zName);
169583 SQLITE_API int sqlite3rbu_create_vfs(const char *zName, const char *zParent){
169620 nName = strlen(zName);
169637 pNew->base.zName = (const char*)(zSpace = (char*)&pNew[1]);
169638 memcpy(zSpace, zName, nName);
169779 char *zName; /* Value of 'name' column */
170146 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
170197 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
170269 " ORDER BY name", pTab->db->aDb[pCsr->iDb].zName, zMaster);
170291 sqlite3_result_text(ctx, pCsr->zName, -1, SQLITE_TRANSIENT);
170323 sqlite3_result_text(ctx, db->aDb[iDb].zName, -1, SQLITE_STATIC);
170483 char *zName; /* Local name of table */
171353 const unsigned char *zName = sqlite3_column_text(pStmt, 1);
171354 if( zName==0 ) break;
171355 memcpy(pAlloc, zName, nName+1);
171400 pTab->zName, &pTab->nCol, 0, &pTab->azCol, &abPK
171546 const char *zName,
171550 int nName = sqlite3Strlen30(zName);
171555 if( 0==sqlite3_strnicmp(pRet->zName, zName, nName+1) ) break;
171562 || pSession->xTableFilter(pSession->pFilterCtx, zName)
171564 rc = sqlite3session_attach(pSession, zName);
171567 assert( 0==sqlite3_strnicmp(pRet->zName, zName, nName+1) );
171585 char const *zName, /* Table name */
171604 pSession->rc = sessionFindTable(pSession, zName, &pTab);
171766 char *zStmt = sessionSelectFindNew(pTab->nCol, zDb1, zDb2, pTab->zName,zExpr);
171797 pSession->zDb, zFrom, pTab->zName, pTab->azCol, pTab->abPK
171804 pSession->zDb, pTab->zName, zFrom, pTab->zName, zExpr, zExpr2
171890 zDb, zFrom, pTo->zName, pTo->azCol, pTo->abPK
172033 const char *zName /* Table name */
172038 if( !zName ){
172046 nName = sqlite3Strlen30(zName);
172048 if( 0==sqlite3_strnicmp(pTab->zName, zName, nName+1) ) break;
172064 pTab->zName = (char *)&pTab[1];
172065 memcpy(pTab->zName, zName, nName+1);
172582 sessionAppendBlob(pBuf, (u8 *)pTab->zName, (int)strlen(pTab->zName)+1, pRc);
172626 const char *zName = pTab->zName;
172636 rc = sessionTableInfo(db, pSession->zDb, zName, &nCol, 0, &azCol, &abPK);
172647 db, pSession->zDb, zName, nCol, azCol, abPK, &pSel);
174724 if( !pTab || sqlite3_stricmp(zNew, pTab->zName) ){
174731 if( 0==sqlite3_strnicmp(pTab->zName, zNew, nNew+1) ) break;
174745 pTab->zName = (char*)&pTab->abPK[nCol];
174746 memcpy(pTab->zName, zNew, nNew+1);
177148 const char *zName;
177175 const char *zName;
177185 const char *zName;
177193 rc = sqlite3_create_function(db, aFunc[i].zName, aFunc[i].nArg,
177199 rc = sqlite3_create_function(db, aAgg[i].zName, aAgg[i].nArg,
177205 rc = sqlite3_create_module(db, aMod[i].zName, aMod[i].pModule, 0);
177787 const char *zName,
177796 const char *zName,
177804 const char *zName,
177979 char *zName; /* Name of FTS index */
178421 static int sqlite3Fts5StorageRename(Fts5Storage*, const char *zName);
181021 const char *zName;
181035 for(i=0; aEnum[i].zName; i++){
181036 if( sqlite3_strnicmp(aEnum[i].zName, zEnum, nEnum)==0 ){
181365 pRet->zName = sqlite3Fts5Strndup(&rc, azArg[2], -1);
181371 if( rc==SQLITE_OK && sqlite3_stricmp(pRet->zName, FTS5_RANK_NAME)==0 ){
181372 *pzErr = sqlite3_mprintf("reserved fts5 table name: %s", pRet->zName);
181437 &rc, "%Q.'%q_%s'", pRet->zDb, pRet->zName, zTail
181468 sqlite3_free(pConfig->zName);
181499 zSql, pConfig->zName, FTS5_RANK_NAME
181746 zSql = sqlite3Fts5Mprintf(&rc, zSelect, pConfig->zDb, pConfig->zName);
185710 pConfig->zDb, pConfig->zName
185734 pConfig->zDb, pConfig->zName
185765 pConfig->zDb, pConfig->zName
187299 pConfig->zDb, pConfig->zName
189030 pConfig->zDb, pConfig->zName
190128 p->zDataTbl = sqlite3Fts5Mprintf(&rc, "%s_data", pConfig->zName);
190755 pConfig->zDb, pConfig->zName, pSeg->iSegid
191537 char *zName; /* Name of tokenizer */
192343 pConfig->zDb, pConfig->zName, zRank, pConfig->zName,
192418 static Fts5Auxiliary *fts5FindAuxiliary(Fts5Table *pTab, const char *zName){
192422 if( sqlite3_stricmp(zName, pAux->zFunc)==0 ) return pAux;
192647 "%s: table does not support scanning", pConfig->zName
192950 (nArg>1 ? "UPDATE" : "DELETE from"), pConfig->zName
193784 const char *zName, /* Name of SQL function */
193792 pAux = fts5FindAuxiliary(pTab, zName);
193808 const char *zName /* New name of table */
193811 return sqlite3Fts5StorageRename(pTab->pStorage, zName);
193858 const char *zName, /* Name of new function */
193864 int rc = sqlite3_overload_function(pGlobal->db, zName, -1);
193870 nName = (int)strlen(zName) + 1;
193876 memcpy(pAux->zFunc, zName, nName);
193897 const char *zName, /* Name of new function */
193908 nName = (int)strlen(zName) + 1;
193913 pNew->zName = (char*)&pNew[1];
193914 memcpy(pNew->zName, zName, nName);
193932 const char *zName
193936 if( zName==0 ){
193940 if( sqlite3_stricmp(zName, pMod->zName)==0 ) break;
193953 const char *zName, /* Name of new function */
193960 pMod = fts5LocateTokenizer((Fts5Global*)pApi, zName);
194288 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName, zBind);
194295 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName);
194349 pConfig->zDb, pConfig->zName,
194350 pConfig->zDb, pConfig->zName,
194351 pConfig->zDb, pConfig->zName
194356 pConfig->zDb, pConfig->zName
194362 pConfig->zDb, pConfig->zName
194372 const char *zName /* New name of FTS5 table */
194377 pConfig->zDb, pConfig->zName, zTail, zName, zTail
194382 static int sqlite3Fts5StorageRename(Fts5Storage *pStorage, const char *zName){
194386 fts5StorageRenameOne(pConfig, &rc, "data", zName);
194387 fts5StorageRenameOne(pConfig, &rc, "idx", zName);
194388 fts5StorageRenameOne(pConfig, &rc, "config", zName);
194390 fts5StorageRenameOne(pConfig, &rc, "docsize", zName);
194393 fts5StorageRenameOne(pConfig, &rc, "content", zName);
194413 pConfig->zDb, pConfig->zName, zPost, zDefn,
194422 pConfig->zName, zPost, zErr
194730 pConfig->zDb, pConfig->zName,
194731 pConfig->zDb, pConfig->zName
194736 pConfig->zDb, pConfig->zName
194933 pConfig->zDb, pConfig->zName, zSuffix
196517 const char *zName;
196530 aBuiltin[i].zName,
