Lines Matching refs:zName
1641 ** The zName field holds the name of the VFS module. The name must
1779 const char *zName; /* Name of this virtual file system */
1781 int (*xOpen)(sqlite3_vfs*, sqlite3_filename zName, sqlite3_file*,
1783 int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);
1784 int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut);
1785 int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);
1803 int (*xSetSystemCall)(sqlite3_vfs*, const char *zName, sqlite3_syscall_ptr);
1804 sqlite3_syscall_ptr (*xGetSystemCall)(sqlite3_vfs*, const char *zName);
1805 const char *(*xNextSystemCall)(sqlite3_vfs*, const char *zName);
4960 SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
6393 const char *zName,
6400 const char *zName,
6408 const void *zName,
7417 int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName,
7664 const char *zName, /* Name of the module */
7670 const char *zName, /* Name of the module */
10496 char const *zName, /* Table name */
13235 const char *zName,
13244 const char *zName,
13252 const char *zName,
17316 const char *zName; /* SQL name of the function. */
17398 ** FUNCTION(zName, nArg, iArg, bNC, xFunc)
17399 ** Used to create a scalar function definition of a function zName
17405 ** VFUNCTION(zName, nArg, iArg, bNC, xFunc)
17408 ** SFUNCTION(zName, nArg, iArg, bNC, xFunc)
17412 ** INLINE_FUNC(zName, nArg, iFuncId, mFlags)
17413 ** zName is the name of a function that is implemented by in-line
17418 ** TEST_FUNC(zName, nArg, iFuncId, mFlags)
17419 ** zName is the name of a test-only function implemented by in-line
17424 ** DFUNCTION(zName, nArg, iArg, bNC, xFunc)
17431 ** MFUNCTION(zName, nArg, xPtr, xFunc)
17434 ** PURE_DATE(zName, nArg, iArg, bNC, xFunc)
17440 ** AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal)
17446 ** WAGGREGATE(zName, nArg, iArg, xStep, xFinal, xValue, xInverse)
17452 ** LIKEFUNC(zName, nArg, pArg, flags)
17453 ** Used to create a scalar function definition of a function zName
17460 #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \
17463 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
17464 #define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \
17466 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
17467 #define SFUNCTION(zName, nArg, iArg, bNC, xFunc) \
17469 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
17470 #define MFUNCTION(zName, nArg, xPtr, xFunc) \
17472 xPtr, 0, xFunc, 0, 0, 0, #zName, {0} }
17473 #define JFUNCTION(zName, nArg, iArg, xFunc) \
17476 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
17477 #define INLINE_FUNC(zName, nArg, iArg, mFlags) \
17480 SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }
17481 #define TEST_FUNC(zName, nArg, iArg, mFlags) \
17485 SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }
17486 #define DFUNCTION(zName, nArg, iArg, bNC, xFunc) \
17488 0, 0, xFunc, 0, 0, 0, #zName, {0} }
17489 #define PURE_DATE(zName, nArg, iArg, bNC, xFunc) \
17492 (void*)&sqlite3Config, 0, xFunc, 0, 0, 0, #zName, {0} }
17493 #define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \
17496 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
17497 #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \
17500 pArg, 0, xFunc, 0, 0, 0, #zName, }
17501 #define LIKEFUNC(zName, nArg, arg, flags) \
17503 (void *)arg, 0, likeFunc, 0, 0, 0, #zName, {0} }
17504 #define WAGGREGATE(zName, nArg, arg, nc, xStep, xFinal, xValue, xInverse, f) \
17506 SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,xValue,xInverse,#zName, {0}}
17507 #define INTERNAL_FUNCTION(zName, nArg, xFunc) \
17510 0, 0, xFunc, 0, 0, 0, #zName, {0} }
17520 char *zName; /* Savepoint name (nul-terminated) */
17542 const char *zName; /* Name passed to create_module() */
17592 #define COLTYPE_CUSTOM 0 /* Type appended to zName */
17632 char *zName; /* Name of the collating sequence, UTF-8 encoded */
17752 char *zName; /* Name of the table or view */
18086 char *zName; /* Name of this index */
18483 ** also be used as the argument to a function, in which case the a.zName
18521 u16 iAlias; /* Index into Parse.aAlias[] for zName */
18555 char *zName; /* Name of the identifier */
18557 int idx; /* Index in some Table.aCol[] of a column named zName */
18593 char *zName; /* Name of the table */
18594 char *zAlias; /* The "B" part of a "A AS B" phrase. zName is the "A" */
18595 Table *pTab; /* An SQL table corresponding to zName */
19310 char *zName; /* The name of the trigger */
19635 char *zName; /* Name of this CTE */
19717 char *zName; /* Name of window (may be NULL) */
20084 SQLITE_PRIVATE Module *sqlite3PragmaVtabRegister(sqlite3*,const char *zName);
20411 SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName);
20494 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char*zName);
20720 SQLITE_PRIVATE int sqlite3ShadowTableName(sqlite3 *db, const char *zName);
22806 char *zName; /* Name of table or index */
24129 char zName[7]; /* Name of the transformation */
24389 && sqlite3_strnicmp(aXformType[i].zName, z, n)==0
24395 assert( strcmp(aXformType[i].zName,"month")==0 );
24407 assert( strcmp(aXformType[i].zName,"year")==0 );
25240 if( strcmp(zVfs, pVfs->zName)==0 ) break;
30044 ** %!S Like %S but prefer the zName over the zAlias
30818 }else if( pItem->zName ){
30823 sqlite3_str_appendall(pAccum, pItem->zName);
31486 sqlite3_str_appendf(&x, "%s", pCte->zName);
31529 pItem->pTab->zName, pItem->pTab->nCol, pItem->pTab, pItem->colUsed);
31741 if( pWin->zName ){
31742 sqlite3TreeViewLine(pView, "OVER %s (%p)", pWin->zName, pWin);
31802 pWin->pWFunc->zName, pWin->pWFunc->nArg);
32208 char *zName = pList->a[i].zEName;
32210 if( j || zName ){
32214 if( zName ){
32217 fprintf(stdout, "AS %s ", zName);
32220 fprintf(stdout, "TABLE-ALIAS-NAME(\"%s\") ", zName);
32226 fprintf(stdout, "SPAN(\"%s\") ", zName);
32237 if( j || zName ){
32269 char *zName = pList->a[i].zName;
32271 if( zName==0 ) zName = "(null)";
32275 fprintf(stdout, "%s\n", zName);
32277 fprintf(stdout, "%s (%d)\n", zName, pList->a[i].u4.idx);
32281 fprintf(stdout, "%s (pExpr=NULL)\n", zName);
32283 fprintf(stdout, "%s\n", zName);
32579 sqlite3TreeViewLine(pView, "TRIGGER %s", pTrigger->zName);
35252 const char *zName, /* Name of symbol to add */
35253 int nName, /* Bytes of text in zName */
35254 int iVal /* Value to associate with zName */
35256 int nInt; /* number of sizeof(int) objects needed for zName */
35257 char *z; /* Pointer to where zName will be stored */
35258 int i; /* Index in pIn[] where zName is stored */
35277 memcpy(z, zName, nName);
35300 ** Return the number of the variable named zName, if it is in VList.
35303 SQLITE_PRIVATE int sqlite3VListNameToNum(VList *pIn, const char *zName, int nName){
35310 if( strncmp(z,zName,nName)==0 && z[nName]==0 ) return pIn[i];
35878 static int kvvfsDelete(sqlite3_vfs*, const char *zName, int syncDir);
35879 static int kvvfsAccess(sqlite3_vfs*, const char *zName, int flags, int *);
35880 static int kvvfsFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
35892 "kvvfs", /* zName */
36605 const char *zName,
36611 if( zName==0 ) zName = "";
36612 SQLITE_KV_LOG(("xOpen(\"%s\")\n", zName));
36613 if( strcmp(zName, "local")==0
36614 || strcmp(zName, "session")==0
36619 if( strcmp(zName, "local-journal")==0
36620 || strcmp(zName, "session-journal")==0
36627 if( zName[0]=='s' ){
37200 const char *zName; /* Name of the system call */
37385 ** system call named zName.
37389 const char *zName, /* Name of system call to override */
37396 if( zName==0 ){
37397 /* If no zName is given, restore all system calls to their default
37407 /* If zName is specified, operate on only the one system call
37411 if( strcmp(zName, aSyscall[i].zName)==0 ){
37426 ** Return the value of a system call. Return NULL if zName is not a
37432 const char *zName
37438 if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
37444 ** Return the name of the first system call after zName. If zName==NULL
37445 ** then return the name of the first system call. Return NULL if zName
37446 ** is the last system call or if zName is not the name of a valid
37449 static const char *unixNextSystemCall(sqlite3_vfs *p, const char *zName){
37453 if( zName ){
37455 if( strcmp(zName, aSyscall[i].zName)==0 ) break;
37459 if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
40897 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
42563 if( strcmp(pVfs->zName,"unix-excl")==0 ){
43024 const char *zName = zPath;
43040 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
43041 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
43042 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_SUPER_JOURNAL );
43043 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
43065 assert( zName==0 );
43070 pUnused = findReusableFd(zName, flags);
43084 assert( (flags & SQLITE_OPEN_URI) || zName[strlen(zName)+1]==0 );
43086 }else if( !zName ){
43087 /* If zName is NULL, the upper layer is requesting a temp file. */
43093 zName = zTmpname;
43097 assert( zName[strlen(zName)+1]==0 );
43114 rc = findCreateFileMode(zName, flags, &openMode, &uid, &gid);
43120 fd = robust_open(zName, openFlags, openMode);
43121 OSTRACE(("OPENX %-3d %s 0%o\n", fd, zName, openFlags));
43124 if( isNewJrnl && errno==EACCES && osAccess(zName, F_OK) ){
43135 fd = robust_open(zName, openFlags, openMode);
43139 int rc2 = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName);
43173 zPath = zName;
43175 zPath = sqlite3_mprintf("%s", zName);
43181 osUnlink(zName);
44056 dummyVfs.zName = "dummy";
44961 VFSNAME, /* zName */ \
45024 0==strcmp(aVfs[i].zName,SQLITE_DEFAULT_UNIX_VFS));
45579 const char *zName; /* Name of the system call */
46237 ** system call named zName.
46241 const char *zName, /* Name of system call to override */
46248 if( zName==0 ){
46249 /* If no zName is given, restore all system calls to their default
46259 /* If zName is specified, operate on only the one system call
46263 if( strcmp(zName, aSyscall[i].zName)==0 ){
46278 ** Return the value of a system call. Return NULL if zName is not a
46284 const char *zName
46290 if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
46296 ** Return the name of the first system call after zName. If zName==NULL
46297 ** then return the name of the first system call. Return NULL if zName
46298 ** is the last system call or if zName is not the name of a valid
46301 static const char *winNextSystemCall(sqlite3_vfs *p, const char *zName){
46305 if( zName ){
46307 if( strcmp(zName, aSyscall[i].zName)==0 ) break;
46311 if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
47326 LPWSTR zName;
47331 zName = winUtf8ToUnicode(zFilename);
47332 if( zName==0 ){
47342 zTok = osCharLowerW(zName);
47348 pFile->hMutex = osCreateMutexW(NULL, FALSE, zName);
47351 sqlite3_free(zName);
47363 osCharUpperW(zName);
47366 zName);
47375 sqlite3_free(zName);
48639 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
48999 int nName; /* Size of zName in bytes */
50088 const char *zName, /* Name of the file (UTF-8) */
50105 const char *zUtf8Name = zName; /* Filename in UTF-8 encoding */
50149 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
50150 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
50151 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_SUPER_JOURNAL );
50152 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
50229 if( 0==sqlite3_uri_boolean(zName, "exclusive", 0) ){
50273 rc2 = winAccess(pVfs, zName, SQLITE_ACCESS_READ, &isRO);
50290 rc2 = winAccess(pVfs, zName, SQLITE_ACCESS_READ, &isRO);
50310 rc2 = winAccess(pVfs, zName, SQLITE_ACCESS_READ, &isRO);
50326 return winOpen(pVfs, zName, id,
50355 && (rc = winceCreateLock(zName, pFile))!=SQLITE_OK
50360 OSTRACE(("OPEN-CE-LOCK name=%s, rc=%s\n", zName, sqlite3ErrName(rc)));
50380 && sqlite3_uri_boolean(zName, "psow", SQLITE_POWERSAFE_OVERWRITE)
50385 pFile->zPath = zName;
51124 "win32", /* zName */
51149 "win32-longpath", /* zName */
51174 "win32-none", /* zName */
51199 "win32-longpath-none", /* zName */
51395 /* static int memdbDelete(sqlite3_vfs*, const char *zName, int syncDir); */
51396 static int memdbAccess(sqlite3_vfs*, const char *zName, int flags, int *);
51397 static int memdbFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
51413 "memdb", /* zName */
51815 const char *zName,
51826 szName = sqlite3Strlen30(zName);
51827 if( szName>1 && (zName[0]=='/' || zName[0]=='\\') ){
51834 if( strcmp(memdb_g.apMemStore[i]->zFName,zName)==0 ){
51859 memcpy(p->zFName, zName, szName+1);
60615 SQLITE_API sqlite3_file *sqlite3_database_file_object(const char *zName){
60617 while( zName[-1]!=0 || zName[-2]!=0 || zName[-3]!=0 || zName[-4]!=0 ){
60618 zName--;
60620 pPager = *(Pager**)(zName - 4 - sizeof(Pager*));
64277 static char zName[15];
64278 sqlite3_snprintf(sizeof(zName), zName, "READ-LOCK[%d]",
64280 return zName;
83649 const char *zName /* Name of table or index being scanned */
83660 pNew->zName = sqlite3DbStrDup(p->db, zName);
84296 const char *zColl = pColl ? pColl->zName : "";
84316 sqlite3_str_appendf(&x, "%.18s-%s", pColl->zName,
84322 sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg);
84327 sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg);
84381 zP4 = pOp->p4.pTab->zName;
85259 ** zName must be a pointer to a nul terminated string.
85265 ** to by zName will be freed by sqlite3DbFree() when the vdbe is destroyed.
85269 int idx, /* Index of column zName applies to */
85271 const char *zName, /* Pointer to buffer containing name */
85272 void (*xDel)(void*) /* Memory management strategy for zName */
85279 assert( !zName || xDel!=SQLITE_DYNAMIC );
85284 rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, xDel);
85285 assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 );
86132 sqlite3DbFree(db, p->aScan[i].zName);
87742 pCtx->pFunc->zName, zContext);
87810 const char *zTbl = pTab->zName;
89610 SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){
89611 if( p==0 || zName==0 ) return 0;
89612 return sqlite3VListNameToNum(p->pVList, zName, nName);
89614 SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
89615 return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName));
90039 *(const char**)pOut = pScan->zName;
93557 pTab->zName, aCol[i].zCnName);
93982 char *zName; /* Name of savepoint */
93991 zName = pOp->p4.z;
94010 nName = sqlite3Strlen30(zName);
94026 pNew->zName = (char *)&pNew[1];
94027 memcpy(pNew->zName, zName, nName+1);
94053 pSavepoint && sqlite3StrICmp(pSavepoint->zName, zName);
94059 sqlite3VdbeError(p, "no such savepoint: %s", zName);
95975 zDb, pTab->zName, x.nKey);
96134 db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, pTab->zName,
98589 ** in register P1 is passed as the zName argument to the xRename method.
99555 sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT);
102588 const char *zName; /* tables_used.name */
102681 pCur->zName = 0;
102706 if( pCur->zName ){
102707 pCur->zName = 0;
102761 pCur->zName = pTab->zName;
102766 if( pCur->zName==0 ){
102770 pCur->zName = pIdx->zName;
102833 sqlite3_result_text(ctx, pCur->zName, -1, SQLITE_STATIC);
103327 const char *zName, /* Name of the journal file */
103334 assert( zName || nSpill<0 || (flags & SQLITE_OPEN_EXCLUSIVE) );
103342 return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0);
103355 p->zJournal = zName;
103978 assert( pTab!=0 && pTab->zName!=0 );
104038 zTabName = pItem->zAlias ? pItem->zAlias : pTab->zName;
104117 && (zTab==0 || sqlite3StrICmp(zTab,pParse->pTriggerTab->zName)==0)
104708 pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120;
104713 int auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0,pDef->zName,0);
105435 if( pItem->zName ) pParse->zAuthContext = pItem->zName;
105795 sSrc.a[0].zName = pTab->zName;
106065 return sqlite3StrICmp(pColl1->zName, pColl2->zName)==0;
107349 pRet->a[i].zName = sqlite3DbStrDup(db, p->a[i].zName);
107482 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
107527 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
107707 pList->a[pList->nExpr-1].zEName = pColumns->a[i].zName;
107708 pColumns->a[i].zName = 0;
108606 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
108617 "USING ROWID SEARCH ON TABLE %s FOR IN-OPERATOR",pTab->zName));
108681 if( pReq!=0 && sqlite3StrICmp(pReq->zName, pIdx->azColl[j])!=0 ){
108698 "USING INDEX %s FOR IN-OPERATOR",pIdx->zName));
108701 VdbeComment((v, "%s", pIdx->zName));
109605 VdbeComment((v, "%s.rowid", pTab->zName));
109951 VdbeComment((v,"%s.rowid",pTab->zName));
109954 pTab->zName, pTab->aCol[pCol->iColumn].zCnName));
112350 ** Parameter zName is the name of a table that is about to be altered
112355 ** Or, if zName is not a system table, zero is returned.
112358 if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7)
112366 sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName);
112458 char *zName = 0; /* NULL-terminated version of pName */
112475 zName = sqlite3NameFromToken(db, pName);
112476 if( !zName ) goto exit_rename_table;
112478 /* Check that a table or index named 'zName' does not already exist
112481 if( sqlite3FindTable(db, zName, zDb)
112482 || sqlite3FindIndex(db, zName, zDb)
112483 || sqlite3IsShadowTableOf(db, pTab, zName)
112486 "there is already another table or index with this name: %s", zName);
112496 if( SQLITE_OK!=sqlite3CheckObjectName(pParse,zName,"table",zName) ){
112502 sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
112509 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
112536 /* figure out how many UTF-8 characters are in zName */
112537 zTabName = pTab->zName;
112547 , zDb, zDb, zTabName, zName, (iDb==1), zTabName
112564 zName, zName, zName,
112575 zDb, zName, pTab->zName);
112591 , zDb, zTabName, zName, zTabName, zDb, zName);
112602 sqlite3VdbeLoadString(v, i, zName);
112612 sqlite3DbFree(db, zName);
112662 zTab = &pNew->zName[16]; /* Skip the "sqlite_altertab_" prefix on the name */
112670 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
112856 pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
112857 if( !pNew->aCol || !pNew->zName ){
112902 zType, pTab->zName
112947 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
112983 zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1,
112984 pTab->zName
112991 zDb, pTab->zName, iCol, zNew, bQuote
113011 ** * The name of a table column in Column.zName
113190 sqlite3RenameTokenRemap(pParse, 0, (const void*)pIdList->a[ii].zName);
113217 sqlite3RenameTokenRemap(pParse, 0, (void*)pSrc->a[i].zName);
113402 ** pEList->a[i].zName) that matches the string in zOld, extract the
113415 const char *zName = pEList->a[i].zEName;
113417 && ALWAYS(zName!=0)
113418 && 0==sqlite3_stricmp(zName, zOld)
113420 renameTokenFind(pParse, pCtx, (const void*)zName);
113427 ** For each name in the the id-list pIdList (i.e. each pIdList->a[i].zName)
113440 const char *zName = pIdList->a[i].zName;
113441 if( 0==sqlite3_stricmp(zName, zOld) ){
113442 renameTokenFind(pParse, pCtx, (const void*)zName);
113854 int bFKOnly = sqlite3_stricmp(zTable, sParse.pNewTable->zName);
113984 renameTokenFind(pWalker->pParse, p, pItem->zName);
114089 if( sqlite3_stricmp(zOld, pTab->zName)==0 ){
114094 renameTokenFind(&sParse, &sCtx, pTab->zName);
114100 renameTokenFind(&sParse, &sCtx, sParse.pNewIndex->zName);
114128 if( 0==sqlite3_stricmp(pItem->zName, zOld) ){
114129 renameTokenFind(&sParse, &sCtx, pItem->zName);
114505 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, zCol) ){
114515 , zDb, iDb, iCol, pTab->zName
114780 const char *zName;
114812 const char *zTab = aTable[i].zName;
114854 VdbeComment((v, aTable[i].zName));
115100 "stat_init", /* zName */
115390 "stat_push", /* zName */
115530 "stat_get", /* zName */
115560 VdbeComment((v,"%s.rowid",pIdx->zName));
115563 VdbeComment((v,"%s.expr(%d)",pIdx->zName, k));
115565 VdbeComment((v,"%s.%s", pIdx->zName, pIdx->pTable->aCol[i].zCnName));
115616 if( sqlite3_strlike("sqlite\\_%", pTab->zName, '\\')==0 ){
115625 if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,
115635 pStat1->zName = (char*)&pStat1[1];
115636 memcpy(pStat1->zName, "sqlite_stat1", 13);
115647 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
115652 sqlite3VdbeLoadString(v, regTabname, pTab->zName);
115665 zIdxName = pTab->zName;
115669 zIdxName = pIdx->zName;
115675 VdbeComment((v, "Analysis for %s.%s", pTab->zName, zIdxName));
115719 VdbeComment((v, "%s", pIdx->zName));
115917 VdbeComment((v, "%s", pTab->zName));
115986 openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");
115988 openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
116291 const char *zName,
116294 Index *pIdx = sqlite3FindIndex(db, zName, zDb);
116296 Table *pTab = sqlite3FindTable(db, zName, zDb);
116595 ** Return true if zName points to a name that may be used to refer to
116598 SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName){
116600 sqlite3StrICmp(db->aDb[iDb].zDbSName, zName)==0
116601 || (iDb==0 && sqlite3StrICmp("main", zName)==0)
116628 const char *zName;
116640 zName = (const char *)sqlite3_value_text(argv[1]);
116642 if( zName==0 ) zName = "";
116677 assert( zName );
116678 if( sqlite3DbIsNamed(db, i, zName) ){
116679 zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName);
116704 rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
116715 pNew->zDbSName = sqlite3DbStrDup(db, zName);
116771 if( sqlite3CodecQueryParameters(db, zName, zPath)==0 ){
116801 rc = sqlite3UserAuthCheckLogin(db, zName, &newAuth);
116853 const char *zName = (const char *)sqlite3_value_text(argv[0]);
116862 if( zName==0 ) zName = "";
116866 if( sqlite3DbIsNamed(db, i, zName) ) break;
116870 sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
116874 sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
116880 sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
116991 "sqlite_detach", /* zName */
117011 "sqlite_attach", /* zName */
117372 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
117511 const char *zName /* Name of the table to be locked */
117536 p->zLockName = zName;
117547 const char *zName /* Name of the table to be locked */
117551 lockTable(pParse, iDb, iTab, isWriteLock, zName);
117812 SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){
117821 if( db->auth.authLevel<UAUTH_Admin && sqlite3UserAuthTable(zName)!=0 ){
117838 p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName);
117839 if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){
117841 if( sqlite3StrICmp(zName+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0
117842 || sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0
117843 || sqlite3StrICmp(zName+7, &LEGACY_SCHEMA_TABLE[7])==0
117849 if( sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0 ){
117857 p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash, zName);
117860 p = sqlite3HashFind(&db->aDb[0].pSchema->tblHash, zName);
117865 p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName);
117868 if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){
117869 if( sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0 ){
117871 }else if( sqlite3StrICmp(zName+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0 ){
117893 const char *zName, /* Name of the table we are looking for */
117907 p = sqlite3FindTable(db, zName, zDbase);
117910 /* If zName is the not the name of a table in the schema created using
117914 Module *pMod = (Module*)sqlite3HashFind(&db->aModule, zName);
117915 if( pMod==0 && sqlite3_strnicmp(zName, "pragma_", 7)==0 ){
117916 pMod = sqlite3PragmaVtabRegister(db, zName);
117933 sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
117935 sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
117966 return sqlite3LocateTable(pParse, flags, p->zName, zDb);
117973 SQLITE_PRIVATE const char *sqlite3PreferredTableName(const char *zName){
117974 if( sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){
117975 if( sqlite3StrICmp(zName+7, &LEGACY_SCHEMA_TABLE[7])==0 ){
117978 if( sqlite3StrICmp(zName+7, &LEGACY_TEMP_SCHEMA_TABLE[7])==0 ){
117982 return zName;
117997 SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){
118008 p = sqlite3HashFind(&pSchema->idxHash, zName);
118294 char *zName = pIndex->zName;
118296 &pIndex->pSchema->idxHash, zName, 0
118320 sqlite3DbFree(db, pTable->zName);
118386 char *zName;
118388 zName = sqlite3DbStrNDup(db, (const char*)pName->z, pName->n);
118389 sqlite3Dequote(zName);
118391 zName = 0;
118393 return zName;
118410 ** Parameter zName points to a nul-terminated buffer containing the name
118415 SQLITE_PRIVATE int sqlite3FindDbName(sqlite3 *db, const char *zName){
118417 if( zName ){
118420 if( 0==sqlite3_stricmp(pDb->zDbSName, zName) ) break;
118423 if( i==0 && 0==sqlite3_stricmp("main", zName) ) break;
118437 char *zName; /* Name we are searching for */
118438 zName = sqlite3NameFromToken(db, pName);
118439 i = sqlite3FindDbName(db, zName);
118440 sqlite3DbFree(db, zName);
118505 ** This routine is used to check if the UTF-8 string zName is a legal
118517 const char *zName, /* Name of the object to check */
118531 || sqlite3_stricmp(zName, db->init.azInit[1])
118538 if( (pParse->nested==0 && 0==sqlite3StrNICmp(zName, "sqlite_", 7))
118539 || (sqlite3ReadOnlyShadowTables(db) && sqlite3ShadowTableName(db, zName))
118542 zName);
118694 char *zName = 0; /* The name of the new table */
118703 zName = sqlite3DbStrDup(db, SCHEMA_TABLE(iDb));
118716 zName = sqlite3NameFromToken(db, pName);
118718 sqlite3RenameTokenMap(pParse, (void*)zName, pName);
118722 if( zName==0 ) return;
118723 if( sqlite3CheckObjectName(pParse, zName, isView?"view":"table", zName) ){
118742 zName, 0, zDb) ){
118760 pTable = sqlite3FindTable(db, zName, zDb);
118772 if( sqlite3FindIndex(db, zName, zDb)!=0 ){
118773 sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
118785 pTable->zName = zName;
118867 sqlite3DbFree(db, zName);
118941 pRet->retTrig.zName = RETURNING_TRIGGER_NAME;
118982 sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
119318 "table \"%s\" has more than one primary key", pTab->zName);
119590 n += identLength(p->zName);
119608 identPut(zStmt, &k, p->zName);
119965 ** Return true if pTab is a virtual table and zName is a shadow table name
119968 SQLITE_PRIVATE int sqlite3IsShadowTableOf(sqlite3 *db, Table *pTab, const char *zName){
119969 int nName; /* Length of zName */
119973 nName = sqlite3Strlen30(pTab->zName);
119974 if( sqlite3_strnicmp(zName, pTab->zName, nName)!=0 ) return 0;
119975 if( zName[nName]!='_' ) return 0;
119980 return pMod->pModule->xShadowName(zName+nName+1);
119992 int nName; /* Length of pTab->zName */
120002 assert( pTab->zName!=0 );
120003 nName = sqlite3Strlen30(pTab->zName);
120006 assert( pOther->zName!=0 );
120009 if( sqlite3StrNICmp(pOther->zName, pTab->zName, nName)==0
120010 && pOther->zName[nName]=='_'
120011 && pMod->pModule->xShadowName(pOther->zName+nName+1)
120021 ** Return true if zName is a shadow table name in the current database
120024 ** zName is temporarily modified while this routine is running, but is
120027 SQLITE_PRIVATE int sqlite3ShadowTableName(sqlite3 *db, const char *zName){
120028 char *zTail; /* Pointer to the last "_" in zName */
120029 Table *pTab; /* Table that zName is a shadow of */
120030 zTail = strrchr(zName, '_');
120033 pTab = sqlite3FindTable(db, zName, 0);
120037 return sqlite3IsShadowTableOf(db, pTab, zName);
120106 if( pSelect==0 && sqlite3ShadowTableName(db, p->zName) ){
120146 p->zName, pCol->zCnName, sqlite3ColumnType(pCol, "")
120150 p->zName, pCol->zCnName);
120179 sqlite3ErrorMsg(pParse, "PRIMARY KEY missing on table %s", p->zName);
120357 p->zName,
120358 p->zName,
120384 sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName),0);
120394 pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p);
120408 if( strcmp(p->zName, "sqlite_sequence")==0 ){
120568 sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
120804 const char *zName /* Name of index or table */
120814 zDbName, zTab, zType, zName
120860 pDb->zDbSName, pTab->zName
120875 pDb->zDbSName, pTab->zName);
120884 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
120887 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
120913 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
120914 if( sqlite3StrNICmp(pTab->zName+7, "stat", 4)==0 ) return 0;
120915 if( sqlite3StrNICmp(pTab->zName+7, "parameters", 10)==0 ) return 0;
120982 zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
120991 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
120994 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
121000 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
121009 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
121013 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
121025 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
121222 if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
121229 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
121388 char *zName = 0; /* Name of the index */
121389 int nName; /* Number of characters in zName */
121457 pTab->zName);
121471 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
121475 && sqlite3UserAuthTable(pTab->zName)==0
121478 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
121508 zName = sqlite3NameFromToken(db, pName);
121509 if( zName==0 ) goto exit_create_index;
121511 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName,"index",pTab->zName) ){
121516 if( sqlite3FindTable(db, zName, pDb->zDbSName)!=0 ){
121517 sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
121521 if( sqlite3FindIndex(db, zName, pDb->zDbSName)!=0 ){
121523 sqlite3ErrorMsg(pParse, "index %s already exists", zName);
121536 zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
121537 if( zName==0 ){
121546 if( IN_SPECIAL_PARSE ) zName[7]++;
121559 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
121599 nName = sqlite3Strlen30(zName);
121609 pIndex->zName = zExtra;
121611 memcpy(pIndex->zName, zName, nName+1);
121836 pIndex->zName, pIndex);
121898 pIndex->zName,
121899 pTab->zName,
121912 sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName), 0);
121965 sqlite3DbFree(db, zName);
122044 pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
122071 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
122083 db->aDb[iDb].zDbSName, pIndex->zName
122085 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
122088 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
122159 pList->a[i].zName = sqlite3NameFromToken(db, pToken);
122160 if( IN_RENAME_OBJECT && pList->a[i].zName ){
122161 sqlite3RenameTokenMap(pParse, (void*)pList->a[i].zName, pToken);
122175 sqlite3DbFree(db, pList->a[i].zName);
122184 SQLITE_PRIVATE int sqlite3IdListIndex(IdList *pList, const char *zName){
122188 if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
122292 ** The SrcList.a[].zName field is filled with the table name which might
122347 pItem->zName = sqlite3NameFromToken(db, pDatabase);
122350 pItem->zName = sqlite3NameFromToken(db, pTable);
122384 if( pItem->zName ) sqlite3DbNNFreeNN(db, pItem->zName);
122439 assert( pItem->zName==0 || pDatabase!=0 );
122440 if( IN_RENAME_OBJECT && pItem->zName ){
122442 sqlite3RenameTokenMap(pParse, pItem->zName, pToken);
122643 char *zName = sqlite3NameFromToken(pParse->db, pName);
122644 if( zName ){
122650 if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
122651 sqlite3DbFree(pParse->db, zName);
122654 sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
122822 sqlite3_str_appendf(&errMsg, "index '%q'", pIdx->zName);
122829 sqlite3_str_appendall(&errMsg, pTab->zName);
122853 zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
122857 zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
123064 pNew->zName = sqlite3NameFromToken(pParse->db, pName);
123078 sqlite3DbFree(db, pCte->zName);
123103 char *zName;
123111 zName = pCte->zName;
123112 if( zName && pWith ){
123115 if( sqlite3StrICmp(zName, pWith->a[i].zName)==0 ){
123116 sqlite3ErrorMsg(pParse, "duplicate WITH table name: %s", zName);
123127 assert( (pNew!=0 && zName!=0) || db->mallocFailed );
123176 ** in the encoding enc of name zName, length nName.
123178 static void callCollNeeded(sqlite3 *db, int enc, const char *zName){
123181 char *zExternal = sqlite3DbStrDup(db, zName);
123190 sqlite3ValueSetStr(pTmp, -1, zName, SQLITE_UTF8, SQLITE_STATIC);
123209 char *z = pColl->zName;
123236 const char *zName = pColl->zName;
123238 CollSeq *p = sqlite3GetCollSeq(pParse, ENC(db), pColl, zName);
123251 ** specified by zName and nName is not found and parameter 'create' is
123264 const char *zName, /* Name of the collating sequence */
123268 pColl = sqlite3HashFind(&db->aCollSeq, zName);
123271 int nName = sqlite3Strlen30(zName) + 1;
123275 pColl[0].zName = (char*)&pColl[3];
123277 pColl[1].zName = (char*)&pColl[3];
123279 pColl[2].zName = (char*)&pColl[3];
123281 memcpy(pColl[0].zName, zName, nName);
123282 pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, pColl);
123300 ** Parameter zName points to a UTF-8 encoded string nName bytes long.
123301 ** Return the CollSeq* pointer for the collation sequence named zName
123317 const char *zName, /* Name of the collating sequence. Might be NULL */
123323 if( zName ){
123324 pColl = findCollSeqEntry(db, zName, create);
123351 ** collation sequence with name zName, length nName.
123354 ** db for collation type name zName, length nName, or NULL, if no collation
123363 const char *zName /* Collating sequence name */
123370 p = sqlite3FindCollSeq(db, enc, zName, 0);
123376 callCollNeeded(db, enc, zName);
123377 p = sqlite3FindCollSeq(db, enc, zName, 0);
123384 sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);
123392 ** encoding identified by the string zName.
123410 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){
123416 pColl = sqlite3FindCollSeq(db, enc, zName, initbusy);
123418 pColl = sqlite3GetCollSeq(pParse, enc, pColl, zName);
123496 if( sqlite3StrICmp(p->zName, zFunc)==0 ){
123513 const char *zName = aDef[i].zName;
123514 int nName = sqlite3Strlen30(zName);
123515 int h = SQLITE_FUNC_HASH(zName[0], nName);
123517 pOther = sqlite3FunctionSearch(h, zName);
123544 ** case is used to see if zName is a valid function name for some number
123553 const char *zName, /* Name of the function. zero-terminated */
123566 nName = sqlite3Strlen30(zName);
123570 p = (FuncDef*)sqlite3HashFind(&db->aFunc, zName);
123594 h = SQLITE_FUNC_HASH(sqlite3UpperToLower[(u8)zName[0]], nName);
123595 p = sqlite3FunctionSearch(h, zName);
123614 pBest->zName = (const char*)&pBest[1];
123617 memcpy((char*)&pBest[1], zName, nName+1);
123618 for(z=(u8*)pBest->zName; *z; z++) *z = sqlite3UpperToLower[*z];
123619 pOther = (FuncDef*)sqlite3HashInsert(&db->aFunc, pBest->zName, pBest);
123789 pTab->zName);
123816 sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
123821 sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
123852 pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName);
123924 const char *zName = pTab->aCol[pPk->aiColumn[0]].zCnName;
123925 pLhs = sqlite3Expr(db, TK_ID, zName);
123926 pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ID, zName));
124079 rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0,
124098 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
124166 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
124169 pTab->zName, P4_STATIC);
124534 if( pParse->nested==0 || 0==sqlite3_stricmp(pTab->zName, "sqlite_stat1") ){
124605 VdbeModuleComment((v, "GenRowIdxDel for %s", pIdx->zName));
127112 int n = sqlite3Strlen30(p->zName);
127113 int h = p->zName[0] + n;
127115 printf(" %s(%d)", p->zName, h);
127408 pFKey->pFrom->zName, pFKey->zTo);
127613 if( zColl==0 ) zColl = db->pDfltColl->zName;
127801 return (FKey *)sqlite3HashFind(&pTab->pSchema->fkeyHash, pTab->zName);
128047 && sqlite3_stricmp(pTab->zName, pFKey->zTo)!=0
128105 rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
128114 sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
128170 pItem->zName = pFKey->pFrom->zName;
128201 pItem->zName = 0;
128286 if( 0==sqlite3_stricmp(pTab->zName, p->zTo) ) eRet = 2;
128439 zFrom = pFKey->pFrom->zName;
128641 (opcode==OP_OpenWrite)?1:0, pTab->zName);
128644 VdbeComment((v, "%s", pTab->zName));
128651 VdbeComment((v, "%s", pTab->zName));
129089 sqlite3VdbeLoadString(v, memId-1, p->pTab->zName);
129359 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0,
129475 if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zCnName)==0 ){
129493 if( sqlite3IsRowid(pColumn->a[i].zName) && !withoutRowid ){
129498 pTabList->a, pColumn->a[i].zName);
129669 pTab->zName);
130396 char *zMsg = sqlite3MPrintf(db, "%s.%s", pTab->zName,
130465 char *zName = pCheck->a[i].zEName;
130466 assert( zName!=0 || pParse->db->mallocFailed );
130469 onError, zName, P4_TRANSIENT,
130783 VdbeNoopComment((v, "prep index %s", pIdx->zName));
130807 VdbeComment((v, "%s column %d", pIdx->zName, i));
130820 VdbeComment((v, "for %s", pIdx->zName));
130910 VdbeComment((v, "%s.%s", pTab->zName,
131276 sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
131290 VdbeComment((v, "%s", pIdx->zName));
131687 sqlite3TableLock(pParse, iDbDest, pDest->tnum, 1, pDest->zName);
131688 sqlite3TableLock(pParse, iDbSrc, pSrc->tnum, 0, pSrc->zName);
131698 VdbeComment((v, "%s", pSrcIdx->zName));
131702 VdbeComment((v, "%s", pDestIdx->zName));
131968 int (*bind_parameter_index)(sqlite3_stmt*,const char*zName);
133701 const char *const zName; /* Name of pragma */
133710 {/* zName: */ "activate_extensions",
133716 {/* zName: */ "analysis_limit",
133722 {/* zName: */ "application_id",
133729 {/* zName: */ "auto_vacuum",
133737 {/* zName: */ "automatic_index",
133744 {/* zName: */ "busy_timeout",
133750 {/* zName: */ "cache_size",
133757 {/* zName: */ "cache_spill",
133764 {/* zName: */ "case_sensitive_like",
133770 {/* zName: */ "cell_size_check",
133776 {/* zName: */ "checkpoint_fullfsync",
133783 {/* zName: */ "collation_list",
133790 {/* zName: */ "compile_options",
133797 {/* zName: */ "count_changes",
133804 {/* zName: */ "data_store_directory",
133811 {/* zName: */ "data_version",
133818 {/* zName: */ "database_list",
133825 {/* zName: */ "default_cache_size",
133833 {/* zName: */ "defer_foreign_keys",
133841 {/* zName: */ "empty_result_callbacks",
133848 {/* zName: */ "encoding",
133855 {/* zName: */ "foreign_key_check",
133862 {/* zName: */ "foreign_key_list",
133870 {/* zName: */ "foreign_keys",
133878 {/* zName: */ "freelist_count",
133885 {/* zName: */ "full_column_names",
133890 {/* zName: */ "fullfsync",
133898 {/* zName: */ "function_list",
133905 {/* zName: */ "hard_heap_limit",
133911 {/* zName: */ "hexkey",
133916 {/* zName: */ "hexrekey",
133924 {/* zName: */ "ignore_check_constraints",
133932 {/* zName: */ "incremental_vacuum",
133939 {/* zName: */ "index_info",
133944 {/* zName: */ "index_list",
133949 {/* zName: */ "index_xinfo",
133956 {/* zName: */ "integrity_check",
133963 {/* zName: */ "journal_mode",
133968 {/* zName: */ "journal_size_limit",
133975 {/* zName: */ "key",
133982 {/* zName: */ "legacy_alter_table",
133989 {/* zName: */ "lock_proxy_file",
133996 {/* zName: */ "lock_status",
134003 {/* zName: */ "locking_mode",
134008 {/* zName: */ "max_page_count",
134013 {/* zName: */ "mmap_size",
134022 {/* zName: */ "module_list",
134030 {/* zName: */ "optimize",
134036 {/* zName: */ "page_count",
134041 {/* zName: */ "page_size",
134049 {/* zName: */ "parser_trace",
134057 {/* zName: */ "pragma_list",
134064 {/* zName: */ "query_only",
134071 {/* zName: */ "quick_check",
134078 {/* zName: */ "read_uncommitted",
134083 {/* zName: */ "recursive_triggers",
134090 {/* zName: */ "rekey",
134097 {/* zName: */ "reverse_unordered_selects",
134104 {/* zName: */ "schema_version",
134111 {/* zName: */ "secure_delete",
134118 {/* zName: */ "short_column_names",
134124 {/* zName: */ "shrink_memory",
134129 {/* zName: */ "soft_heap_limit",
134136 {/* zName: */ "sql_trace",
134144 {/* zName: */ "stats",
134151 {/* zName: */ "synchronous",
134158 {/* zName: */ "table_info",
134163 {/* zName: */ "table_list",
134168 {/* zName: */ "table_xinfo",
134175 {/* zName: */ "temp_store",
134180 {/* zName: */ "temp_store_directory",
134187 {/* zName: */ "textkey",
134192 {/* zName: */ "textrekey",
134198 {/* zName: */ "threads",
134204 {/* zName: */ "trusted_schema",
134211 {/* zName: */ "user_version",
134219 {/* zName: */ "vdbe_addoptrace",
134224 {/* zName: */ "vdbe_debug",
134229 {/* zName: */ "vdbe_eqp",
134234 {/* zName: */ "vdbe_listing",
134239 {/* zName: */ "vdbe_trace",
134247 {/* zName: */ "wal_autocheckpoint",
134252 {/* zName: */ "wal_checkpoint",
134259 {/* zName: */ "writable_schema",
134415 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, pPragma->zName, SQLITE_STATIC);
134480 const char *zName;
134482 case OE_SetNull: zName = "SET NULL"; break;
134483 case OE_SetDflt: zName = "SET DEFAULT"; break;
134484 case OE_Cascade: zName = "CASCADE"; break;
134485 case OE_Restrict: zName = "RESTRICT"; break;
134486 default: zName = "NO ACTION";
134489 return zName;
134521 static const PragmaName *pragmaLocate(const char *zName){
134527 rc = sqlite3_stricmp(zName, aPragmaName[mid].zName);
134579 p->zName, isBuiltin,
135506 char *zSql = sqlite3MPrintf(db, "SELECT*FROM\"%w\"", pTab->zName);
135526 if( zRight && sqlite3_stricmp(zRight, pTab->zName)!=0 ) continue;
135538 sqlite3PreferredTableName(pTab->zName),
135558 sqlite3PreferredTableName(pTab->zName),
135565 pIdx->zName,
135634 pIdx->zName,
135663 sqlite3VdbeMultiLoad(v, 1, "is", i++, pColl->zName);
135695 sqlite3VdbeMultiLoad(v, 1, "s", pMod->zName);
135704 sqlite3VdbeMultiLoad(v, 1, "s", aPragmaName[i].zName);
135779 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
135782 sqlite3VdbeLoadString(v, regResult, pTab->zName);
135788 sqlite3TableLock(pParse, iDb, pParent->tnum, 0, pParent->zName);
136060 pTab->zName);
136129 zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName,
136155 pTab->zName, pTab->aCol[j].zCnName);
136164 pTab->zName, pTab->aCol[j].zCnName);
136180 pTab->zName, pTab->aCol[j].zCnName);
136204 pTab->zName);
136228 jmp5 = sqlite3VdbeLoadString(v, 4, pIdx->zName);
136268 sqlite3VdbeLoadString(v, 4, pIdx->zName);
136331 char *zName;
136350 returnSingleText(v, encnames[ENC(pParse->db)].zName);
136358 for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
136359 if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){
136366 if( !pEnc->zName ){
136625 db->aDb[iDb].zDbSName, pTab->zName);
136877 sqlite3_str_appendf(&acc, "(\"%s\"", pPragma->zName);
137045 sqlite3_str_appendall(&acc, pTab->pName->zName);
137128 SQLITE_PRIVATE Module *sqlite3PragmaVtabRegister(sqlite3 *db, const char *zName){
137130 assert( sqlite3_strnicmp(zName, "pragma_", 7)==0 );
137131 pName = pragmaLocate(zName+7);
137134 assert( sqlite3HashFind(&db->aModule, zName)==0 );
137135 return sqlite3VtabCreateModule(db, zName, &pragmaVtabModule, (void*)pName, 0);
138723 char *zName; /* Name of column in the right table */
138726 zName = pRightTab->aCol[j].zCnName;
138727 if( tableAndColumnIndex(pSrc, 0, i, zName, 0, 0, 1) ){
138731 assert( pUsing->a[pUsing->nId-1].zName==0 );
138732 pUsing->a[pUsing->nId-1].zName = sqlite3DbStrDup(pParse->db, zName);
138756 char *zName; /* Name of the term in the USING clause */
138764 zName = pList->a[j].zName;
138765 iRightCol = sqlite3ColumnIndex(pRightTab, zName);
138767 || tableAndColumnIndex(pSrc, 0, i, zName, &iLeft, &iLeftCol,
138771 "not present in both tables", zName);
138779 ** contains the zName column, then this branch is a no-op.
138783 ** to zName is not also within a prior USING clause.
138786 ** non-USING references to zName on the left of an INNER or LEFT
138792 while( tableAndColumnIndex(pSrc, iLeft+1, i, zName, &iLeft, &iLeftCol,
138795 || sqlite3IdListIndex(pSrc->a[iLeft].u3.pUsing, zName)<0
138798 zName);
140202 zOrigTab = pTab->zName;
140362 char *zName = pEList->a[i].zEName;
140363 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_TRANSIENT);
140377 char *zName = 0;
140378 zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol);
140379 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_DYNAMIC);
140425 char *zName; /* Column name */
140426 int nName; /* Size of name in zName[] */
140449 if( (zName = pX->zEName)!=0 && pX->fg.eEName==ENAME_NAME ){
140465 zName = iCol>=0 ? pTab->aCol[iCol].zCnName : "rowid";
140468 zName = pColExpr->u.zToken;
140471 assert( zName==pX->zEName ); /* pointer comparison intended */
140474 if( zName && !sqlite3IsTrueOrFalse(zName) ){
140475 zName = sqlite3DbStrDup(db, zName);
140477 zName = sqlite3MPrintf(db,"column%d",i+1);
140484 while( zName && (pCollide = sqlite3HashFind(&ht, zName))!=0 ){
140488 nName = sqlite3Strlen30(zName);
140490 for(j=nName-1; j>0 && sqlite3Isdigit(zName[j]); j--){}
140491 if( zName[j]==':' ) nName = j;
140493 zName = sqlite3MPrintf(db, "%.*z:%u", nName, zName, ++cnt);
140496 pCol->zCnName = zName;
140497 pCol->hName = sqlite3StrIHash(zName);
140502 if( zName && sqlite3HashInsert(&ht, zName, pX)==pX ){
140575 sqlite3ColumnSetColl(db, pCol, pColl->zName);
140602 pTab->zName = 0;
140755 sqlite3ExprAddCollateString(pParse, pTerm, pColl->zName);
142096 (pColl ? pColl->zName : "BINARY")
142652 pParse->zAuthContext = pSubitem->zName;
142660 sqlite3DbFree(db, pSubitem->zName);
142663 pSubitem->zName = 0;
143506 pIdx && sqlite3StrICmp(pIdx->zName, zIndexedBy);
143607 sqlite3ErrorMsg(pParse, "'%s' is not a function", pFrom->zName);
143629 const char *zName = pItem->zName;
143632 assert( zName!=0 );
143636 if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){
143743 sqlite3ErrorMsg(pParse, pCte->zCteErr, pCte->zName);
143764 pTab->zName = sqlite3DbStrDup(db, pCte->zName);
143793 && pItem->zName!=0
143794 && 0==sqlite3StrICmp(pItem->zName, pCte->zName)
143801 "multiple references to recursive table: %s", pCte->zName
143844 pCte->zName, pEList->nExpr, pCte->pCols->nExpr
143906 pTab->zName = sqlite3DbStrDup(pParse->db, pFrom->zAlias);
143908 pTab->zName = sqlite3MPrintf(pParse->db, "%!S", pFrom);
143926 ** If any of those SrcItem objects have a USING clause containing zName
143930 ** contains a USING clause, or if none of the USING clauses contain zName,
143934 const char *zName, /* Name we are looking for */
143943 if( sqlite3IdListIndex(pBase->u3.pUsing, zName)>=0 ) return 1;
144023 if( pFrom->zName==0 ){
144045 pTab->zName);
144064 pTab->zName);
144075 pTab->zName);
144169 zTabName = pTab->zName;
144193 const char *zUName = pUsing->a[ii].zName;
144208 char *zName = pTab->aCol[j].zCnName;
144211 assert( zName );
144238 && sqlite3IdListIndex(pFrom->u3.pUsing, zName)>=0
144245 pRight = sqlite3Expr(db, TK_ID, zName);
144249 || !inAnyUsingClause(zName,pFrom,pTabList->nSrc-i-1)
144279 zSchemaName, zTabName, zName);
144284 && sqlite3IdListIndex(pFrom->u3.pUsing, zName)>=0)
144285 || (pUsing && sqlite3IdListIndex(pUsing, zName)>=0)
144291 pX->zEName = sqlite3MPrintf(db, "%s.%s", zTabName, zName);
144294 pX->zEName = sqlite3DbStrDup(db, zName);
144501 pFunc->pFunc->zName));
144644 pTab->zName,
144646 bCover ? pIdx->zName : ""
144740 if( pItem->zName==0 ) continue;
144744 if( sqlite3_stricmp(pItem->zName, pThis->zName)!=0 ) continue;
144989 p0->zAlias ? p0->zAlias : p0->pTab->zName
145058 pTab->nCol, pTab->zName, pSub->pEList->nExpr);
145223 if( pItem->colUsed==0 && pItem->zName!=0 ){
145224 sqlite3AuthCheck(pParse, SQLITE_READ, pItem->zName, "", pItem->zDatabase);
145266 pParse->zAuthContext = pItem->zName;
145693 ii, pCol->pTab ? pCol->pTab->zName : "NULL",
145985 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
146425 && 0==sqlite3StrICmp(pTrig->table, pTab->zName)
146436 pTrig->table = pTab->zName;
146446 printf("Triggers for %s:", pTab->zName);
146448 printf(" %s", pX->zName);
146479 char *zName = 0; /* Name of the trigger */
146551 zName = sqlite3NameFromToken(db, pName);
146552 if( zName==0 ){
146556 if( sqlite3CheckObjectName(pParse, zName, "trigger", pTab->zName) ){
146561 if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),zName) ){
146573 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
146599 if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
146620 pTrigger->zName = zName;
146621 zName = 0;
146622 pTrigger->table = sqlite3DbStrDup(db, pTableName->a[0].zName);
146628 sqlite3RenameTokenRemap(pParse, pTrigger->table, pTableName->a[0].zName);
146640 sqlite3DbFree(db, zName);
146678 char *zName; /* Name of trigger */
146686 zName = pTrig->zName;
146693 sqlite3TokenInit(&nameToken, pTrig->zName);
146727 pTrig->zName, pStep->zTarget);
146742 db->aDb[iDb].zDbSName, zName,
146747 sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName), 0);
146755 pTrig = sqlite3HashInsert(pHash, zName, pTrig);
146963 sqlite3DbFree(db, pTrigger->zName);
146982 const char *zName;
146992 zName = pName->a[0].zName;
146998 pTrigger = sqlite3HashFind(&(db->aDb[j].pSchema->trigHash), zName);
147044 if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) ||
147056 db->aDb[iDb].zDbSName, pTrigger->zName
147059 sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
147066 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){
147072 pTrigger = sqlite3HashInsert(pHash, zName, 0);
147220 char *zName = sqlite3DbStrDup(db, pStep->zTarget);
147223 assert( zName || pSrc==0 );
147226 pSrc->a[0].zName = zName;
147243 sqlite3DbFree(db, zName);
147528 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
147553 sSubParse.zAuthContext = pTrigger->zName;
147561 pTrigger->zName, onErrorText(orconf),
147566 pTab->zName
147569 if( pTrigger->zName ){
147571 sqlite3MPrintf(db, "-- TRIGGER %s", pTrigger->zName), P4_DYNAMIC
147598 VdbeComment((v, "End: %s.%s", pTrigger->zName, onErrorText(orconf)));
147635 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
147677 int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers));
147682 (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf)));
147910 VdbeComment((v, "%s.%s", pTab->zName, pCol->zCnName));
148353 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
148468 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
149481 VdbeComment((v, "%s.%s", pIdx->zName,
149972 ** If there already exists a module with zName, replace it with the new one.
149973 ** If pModule==0, then delete the module zName if it exists.
149977 const char *zName, /* Name assigned to this module */
149986 zCopy = (char*)zName;
149989 int nName = sqlite3Strlen30(zName);
149996 memcpy(zCopy, zName, nName+1);
149997 pMod->zName = zCopy;
150025 const char *zName, /* Name assigned to this module */
150033 (void)sqlite3VtabCreateModule(db, zName, pModule, pAux, xDestroy);
150046 const char *zName, /* Name assigned to this module */
150051 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
150053 return createModule(db, zName, pModule, pAux, 0);
150061 const char *zName, /* Name assigned to this module */
150067 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
150069 return createModule(db, zName, pModule, pAux, xDestroy);
150086 for(ii=0; azNames[ii]!=0 && strcmp(azNames[ii],pMod->zName)!=0; ii++){}
150089 createModule(db, pMod->zName, 0, 0, 0);
150304 sqlite3ErrorMsg(pParse, "too many columns on %s", pTable->zName);
150343 addModuleArgument(pParse, pTable, sqlite3DbStrDup(db, pTable->zName));
150360 sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName,
150429 pTab->zName,
150430 pTab->zName,
150438 zWhere = sqlite3MPrintf(db, "name=%Q AND sql=%Q", pTab->zName, zStmt);
150443 sqlite3VdbeLoadString(v, iReg, pTab->zName);
150450 const char *zName = pTab->zName;
150451 assert( zName!=0 );
150453 pOld = sqlite3HashInsert(&pSchema->tblHash, zName, pTab);
150517 "vtable constructor called recursively: %s", pTab->zName
150523 zModuleName = sqlite3DbStrDup(db, pTab->zName);
150571 *pzErr = sqlite3MPrintf(db, zFormat, pTab->zName);
151098 for(i=0; pDef->zName[i]; i++){
151099 unsigned char x = (unsigned char)pDef->zName[i];
151104 rc = pMod->xFindFunction(pVtab, nArg, pDef->zName, &xSFunc, &pArg);
151112 + sqlite3Strlen30(pDef->zName) + 1);
151117 pNew->zName = (const char*)&pNew[1];
151118 memcpy((char*)&pNew[1], pDef->zName, sqlite3Strlen30(pDef->zName)+1);
151175 pTab->zName = sqlite3DbStrDup(db, pMod->zName);
151176 if( pTab->zName==0 ){
151187 addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
151189 addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
152101 sqlite3_str_appendf(&str, zFmt, pIdx->zName);
152222 zObj = pLoop->u.btree.pIndex->zName;
152224 zObj = pSrclist->a[pLvl->iFrom].zName;
152729 VdbeComment((v, "begin skip-scan on %s", pIdx->zName));
153274 VdbeModuleComment((v, "Begin WHERE-loop%d: %s",iLevel,pTabItem->pTab->zName));
153331 VdbeComment((v, "next row of %s", pTabItem->pTab->zName));
154537 VdbeComment((v, "match against %s", pTab->zName));
154627 ExplainQueryPlan((pParse, 1, "RIGHT-JOIN %s", pTabItem->pTab->zName));
156526 pTab->zName, j);
156914 if( sqlite3StrICmp(pColl->zName, pScan->zCollName) ){
157102 if( 0==sqlite3StrICmp(pColl->zName, zColl) ){
157435 "automatic index on %s(%s)", pTable->zName,
157476 pIdx->zName = "auto-index";
157495 pIdx->azColl[n] = pColl ? pColl->zName : sqlite3StrBINARY;
157527 VdbeComment((v, "for %s", pTable->zName));
157541 VdbeComment((v, "next row of %s", pTabItem->pTab->zName));
158572 p->zName, nEq-1, (int)a[1]));
158700 pItem->zAlias ? pItem->zAlias : pTab->zName);
158702 const char *zName;
158703 if( p->u.btree.pIndex && (zName = p->u.btree.pIndex->zName)!=0 ){
158704 if( strncmp(zName, "sqlite_autoindex_", 17)==0 ){
158705 int i = sqlite3Strlen30(zName) - 1;
158706 while( zName[i]!='_' ) i--;
158707 zName += i;
158709 sqlite3DebugPrintf(".%-16s %2d", zName, p->u.btree.nEq);
159307 if( sqlite3StrICmp(pColl->zName, pIdx->azColl[i+nEq]) ) break;
159363 pProbe->pTable->zName,pProbe->zName,
159723 pProbe->pTable->zName, pProbe->zName, saved_nEq, rc));
160303 sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
160364 sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
160424 zRet = (pC ? pC->zName : sqlite3StrBINARY);
160583 WHERETRACE(0x800, ("BEGIN %s.addVirtual()\n", pSrc->pTab->zName));
160667 WHERETRACE(0x800, ("END %s.addVirtual(), rc=%d\n", pSrc->pTab->zName, rc));
161022 if( pColl2==0 || sqlite3StrICmp(pColl1->zName, pColl2->zName) ){
161151 if( sqlite3StrICmp(pColl->zName, pIndex->azColl[j])!=0 ) continue;
161262 static char zName[65];
161264 for(i=0; i<nLoop; i++){ zName[i] = pPath->aLoop[i]->cId; }
161265 if( pLast ) zName[i++] = pLast->cId;
161266 zName[i] = 0;
161267 return zName;
162004 pLoop->cId, (double)sqlite3LogEstToInt(nSearch), pTab->zName,
162074 p->zIdxName = pIdx->zName;
162600 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
162650 VdbeComment((v, "%s", pIx->zName));
162931 VdbeComment((v, "next skip-scan on %s", pLoop->u.btree.pIndex->zName));
162969 pWInfo->pTabList->a[pLevel->iFrom].pTab->zName));
163670 ** comparison of the zName pointer. Example:
163672 ** if( pFuncDef->zName==row_valueName ){ ... }
163757 static Window *windowFind(Parse *pParse, Window *pList, const char *zName){
163760 if( sqlite3StrICmp(p->zName, zName)==0 ) break;
163763 sqlite3ErrorMsg(pParse, "no such window: %s", zName);
163791 if( pWin->zName && pWin->eFrmType==0 ){
163792 Window *p = windowFind(pParse, pList, pWin->zName);
163837 if( pFunc->zName==aUp[i].zFunc ){
164266 sqlite3DbFree(db, p->zName);
164565 if( pKeyInfo && pWin->pWFunc->zName[1]=='i' ){
164573 else if( p->zName==nth_valueName || p->zName==first_valueName ){
164581 else if( p->zName==leadName || p->zName==lagName ){
164800 if( i!=1 || pFunc->zName!=nth_valueName ){
164827 assert( pFunc->zName==nth_valueName
164828 || pFunc->zName==first_valueName
165052 if( pFunc->zName==nth_valueName
165053 || pFunc->zName==first_valueName
165060 if( pFunc->zName==nth_valueName ){
165075 else if( pFunc->zName==leadName || pFunc->zName==lagName ){
165089 int val = (pFunc->zName==leadName ? 1 : -1);
165092 int op = (pFunc->zName==leadName ? OP_Add : OP_Subtract);
165127 if( pFunc->zName==nth_valueName || pFunc->zName==first_valueName ){
165153 if( (pFunc->zName==nth_valueName)
165154 || (pFunc->zName==first_valueName)
165155 || (pFunc->zName==leadName)
165156 || (pFunc->zName==lagName)
165506 pNew->zName = sqlite3DbStrDup(db, p->zName);
170289 pNew->zName = pOld->zName;
170301 pOld->zName = pOld->zDatabase = 0;
170320 if( IN_RENAME_OBJECT && yylhsminor.yy131 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy131->a[0].zName, &yymsp[0].minor.yy0);
170327 if( IN_RENAME_OBJECT && yylhsminor.yy131 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy131->a[0].zName, &yymsp[0].minor.yy0);
170867 sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0);
171142 yymsp[-1].minor.yy41->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n);
171264 yymsp[-1].minor.yy41->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n);
172307 SQLITE_API int sqlite3_keyword_check(const char *zName, int nName){
172308 return TK_ID!=sqlite3KeywordCode((const u8*)zName, nName);
174461 assert( p==0 || p->xCmp!=binCollFunc || strcmp(p->zName,"BINARY")==0 );
174907 const char *zName = 0;
174909 for(i=0; i<2 && zName==0; i++, rc &= 0xff){
174911 case SQLITE_OK: zName = "SQLITE_OK"; break;
174912 case SQLITE_ERROR: zName = "SQLITE_ERROR"; break;
174913 case SQLITE_ERROR_SNAPSHOT: zName = "SQLITE_ERROR_SNAPSHOT"; break;
174914 case SQLITE_INTERNAL: zName = "SQLITE_INTERNAL"; break;
174915 case SQLITE_PERM: zName = "SQLITE_PERM"; break;
174916 case SQLITE_ABORT: zName = "SQLITE_ABORT"; break;
174917 case SQLITE_ABORT_ROLLBACK: zName = "SQLITE_ABORT_ROLLBACK"; break;
174918 case SQLITE_BUSY: zName = "SQLITE_BUSY"; break;
174919 case SQLITE_BUSY_RECOVERY: zName = "SQLITE_BUSY_RECOVERY"; break;
174920 case SQLITE_BUSY_SNAPSHOT: zName = "SQLITE_BUSY_SNAPSHOT"; break;
174921 case SQLITE_LOCKED: zName = "SQLITE_LOCKED"; break;
174922 case SQLITE_LOCKED_SHAREDCACHE: zName = "SQLITE_LOCKED_SHAREDCACHE";break;
174923 case SQLITE_NOMEM: zName = "SQLITE_NOMEM"; break;
174924 case SQLITE_READONLY: zName = "SQLITE_READONLY"; break;
174925 case SQLITE_READONLY_RECOVERY: zName = "SQLITE_READONLY_RECOVERY"; break;
174926 case SQLITE_READONLY_CANTINIT: zName = "SQLITE_READONLY_CANTINIT"; break;
174927 case SQLITE_READONLY_ROLLBACK: zName = "SQLITE_READONLY_ROLLBACK"; break;
174928 case SQLITE_READONLY_DBMOVED: zName = "SQLITE_READONLY_DBMOVED"; break;
174929 case SQLITE_READONLY_DIRECTORY: zName = "SQLITE_READONLY_DIRECTORY";break;
174930 case SQLITE_INTERRUPT: zName = "SQLITE_INTERRUPT"; break;
174931 case SQLITE_IOERR: zName = "SQLITE_IOERR"; break;
174932 case SQLITE_IOERR_READ: zName = "SQLITE_IOERR_READ"; break;
174933 case SQLITE_IOERR_SHORT_READ: zName = "SQLITE_IOERR_SHORT_READ"; break;
174934 case SQLITE_IOERR_WRITE: zName = "SQLITE_IOERR_WRITE"; break;
174935 case SQLITE_IOERR_FSYNC: zName = "SQLITE_IOERR_FSYNC"; break;
174936 case SQLITE_IOERR_DIR_FSYNC: zName = "SQLITE_IOERR_DIR_FSYNC"; break;
174937 case SQLITE_IOERR_TRUNCATE: zName = "SQLITE_IOERR_TRUNCATE"; break;
174938 case SQLITE_IOERR_FSTAT: zName = "SQLITE_IOERR_FSTAT"; break;
174939 case SQLITE_IOERR_UNLOCK: zName = "SQLITE_IOERR_UNLOCK"; break;
174940 case SQLITE_IOERR_RDLOCK: zName = "SQLITE_IOERR_RDLOCK"; break;
174941 case SQLITE_IOERR_DELETE: zName = "SQLITE_IOERR_DELETE"; break;
174942 case SQLITE_IOERR_NOMEM: zName = "SQLITE_IOERR_NOMEM"; break;
174943 case SQLITE_IOERR_ACCESS: zName = "SQLITE_IOERR_ACCESS"; break;
174945 zName = "SQLITE_IOERR_CHECKRESERVEDLOCK"; break;
174946 case SQLITE_IOERR_LOCK: zName = "SQLITE_IOERR_LOCK"; break;
174947 case SQLITE_IOERR_CLOSE: zName = "SQLITE_IOERR_CLOSE"; break;
174948 case SQLITE_IOERR_DIR_CLOSE: zName = "SQLITE_IOERR_DIR_CLOSE"; break;
174949 case SQLITE_IOERR_SHMOPEN: zName = "SQLITE_IOERR_SHMOPEN"; break;
174950 case SQLITE_IOERR_SHMSIZE: zName = "SQLITE_IOERR_SHMSIZE"; break;
174951 case SQLITE_IOERR_SHMLOCK: zName = "SQLITE_IOERR_SHMLOCK"; break;
174952 case SQLITE_IOERR_SHMMAP: zName = "SQLITE_IOERR_SHMMAP"; break;
174953 case SQLITE_IOERR_SEEK: zName = "SQLITE_IOERR_SEEK"; break;
174954 case SQLITE_IOERR_DELETE_NOENT: zName = "SQLITE_IOERR_DELETE_NOENT";break;
174955 case SQLITE_IOERR_MMAP: zName = "SQLITE_IOERR_MMAP"; break;
174956 case SQLITE_IOERR_GETTEMPPATH: zName = "SQLITE_IOERR_GETTEMPPATH"; break;
174957 case SQLITE_IOERR_CONVPATH: zName = "SQLITE_IOERR_CONVPATH"; break;
174958 case SQLITE_CORRUPT: zName = "SQLITE_CORRUPT"; break;
174959 case SQLITE_CORRUPT_VTAB: zName = "SQLITE_CORRUPT_VTAB"; break;
174960 case SQLITE_NOTFOUND: zName = "SQLITE_NOTFOUND"; break;
174961 case SQLITE_FULL: zName = "SQLITE_FULL"; break;
174962 case SQLITE_CANTOPEN: zName = "SQLITE_CANTOPEN"; break;
174963 case SQLITE_CANTOPEN_NOTEMPDIR: zName = "SQLITE_CANTOPEN_NOTEMPDIR";break;
174964 case SQLITE_CANTOPEN_ISDIR: zName = "SQLITE_CANTOPEN_ISDIR"; break;
174965 case SQLITE_CANTOPEN_FULLPATH: zName = "SQLITE_CANTOPEN_FULLPATH"; break;
174966 case SQLITE_CANTOPEN_CONVPATH: zName = "SQLITE_CANTOPEN_CONVPATH"; break;
174967 case SQLITE_CANTOPEN_SYMLINK: zName = "SQLITE_CANTOPEN_SYMLINK"; break;
174968 case SQLITE_PROTOCOL: zName = "SQLITE_PROTOCOL"; break;
174969 case SQLITE_EMPTY: zName = "SQLITE_EMPTY"; break;
174970 case SQLITE_SCHEMA: zName = "SQLITE_SCHEMA"; break;
174971 case SQLITE_TOOBIG: zName = "SQLITE_TOOBIG"; break;
174972 case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT"; break;
174973 case SQLITE_CONSTRAINT_UNIQUE: zName = "SQLITE_CONSTRAINT_UNIQUE"; break;
174974 case SQLITE_CONSTRAINT_TRIGGER: zName = "SQLITE_CONSTRAINT_TRIGGER";break;
174976 zName = "SQLITE_CONSTRAINT_FOREIGNKEY"; break;
174977 case SQLITE_CONSTRAINT_CHECK: zName = "SQLITE_CONSTRAINT_CHECK"; break;
174979 zName = "SQLITE_CONSTRAINT_PRIMARYKEY"; break;
174980 case SQLITE_CONSTRAINT_NOTNULL: zName = "SQLITE_CONSTRAINT_NOTNULL";break;
174982 zName = "SQLITE_CONSTRAINT_COMMITHOOK"; break;
174983 case SQLITE_CONSTRAINT_VTAB: zName = "SQLITE_CONSTRAINT_VTAB"; break;
174985 zName = "SQLITE_CONSTRAINT_FUNCTION"; break;
174986 case SQLITE_CONSTRAINT_ROWID: zName = "SQLITE_CONSTRAINT_ROWID"; break;
174987 case SQLITE_MISMATCH: zName = "SQLITE_MISMATCH"; break;
174988 case SQLITE_MISUSE: zName = "SQLITE_MISUSE"; break;
174989 case SQLITE_NOLFS: zName = "SQLITE_NOLFS"; break;
174990 case SQLITE_AUTH: zName = "SQLITE_AUTH"; break;
174991 case SQLITE_FORMAT: zName = "SQLITE_FORMAT"; break;
174992 case SQLITE_RANGE: zName = "SQLITE_RANGE"; break;
174993 case SQLITE_NOTADB: zName = "SQLITE_NOTADB"; break;
174994 case SQLITE_ROW: zName = "SQLITE_ROW"; break;
174995 case SQLITE_NOTICE: zName = "SQLITE_NOTICE"; break;
174996 case SQLITE_NOTICE_RECOVER_WAL: zName = "SQLITE_NOTICE_RECOVER_WAL";break;
174998 zName = "SQLITE_NOTICE_RECOVER_ROLLBACK"; break;
174999 case SQLITE_WARNING: zName = "SQLITE_WARNING"; break;
175000 case SQLITE_WARNING_AUTOINDEX: zName = "SQLITE_WARNING_AUTOINDEX"; break;
175001 case SQLITE_DONE: zName = "SQLITE_DONE"; break;
175004 if( zName==0 ){
175007 zName = zBuf;
175009 return zName;
175513 const char *zName = (const char*)sqlite3_user_data(context);
175517 "unable to use function %s in the requested context", zName);
175536 const char *zName,
175543 if( !sqlite3SafetyCheckOk(db) || zName==0 || nArg<-2 ){
175548 rc = sqlite3FindFunction(db, zName, nArg, SQLITE_UTF8, 0)!=0;
175551 zCopy = sqlite3_mprintf("%s", zName);
175553 return sqlite3_create_function_v2(db, zName, nArg, SQLITE_UTF8,
176122 ** Create a new collating function for database "db". The name is zName
176127 const char *zName,
176156 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0);
176172 CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName);
176186 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 1);
176865 if( sqlite3_stricmp(db->pVfs->zName, "kvvfs")==0 ){
177051 const char *zName,
177056 return sqlite3_create_collation_v2(db, zName, enc, pCtx, xCompare, 0);
177064 const char *zName,
177073 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
177077 rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel);
177089 const void *zName,
177098 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
177102 zName8 = sqlite3Utf16to8(db, zName, -1, SQLITE_UTF16NATIVE);
177964 static const char *databaseName(const char *zName){
177965 while( zName[-1]!=0 || zName[-2]!=0 || zName[-3]!=0 || zName[-4]!=0 ){
177966 zName--;
177968 return zName;
179514 const char *zName; /* virtual table name */
180250 zDb, p->zName,
180251 zDb, p->zName,
180252 zDb, p->zName,
180253 zDb, p->zName,
180254 (p->zContentTbl ? "--" : ""), zDb,p->zName
180294 zCols, p->zName, zLanguageid
180315 p->zDb, p->zName
180352 p->zDb, p->zName, zContentCols
180360 p->zDb, p->zName
180372 p->zDb, p->zName
180377 p->zDb, p->zName
180559 (p->zContentTbl ? p->zContentTbl : p->zName),
181055 nName + /* zName */
181090 /* Fill in the zName and zDb fields of the vtab structure. */
181092 p->zName = zCsr;
183214 char *zTbl = sqlite3_mprintf("%s_stat", p->zName);
183477 const char *zName, /* Name of SQL function */
183482 const char *zName;
183497 if( strcmp(zName, aOverload[i].zName)==0 ){
183512 const char *zName /* New name of table */
183536 p->zDb, p->zName, zName
183543 p->zDb, p->zName, zName
183549 p->zDb, p->zName, zName
183554 p->zDb, p->zName, zName
183558 p->zDb, p->zName, zName
183610 ** Return true if zName is the extension on one of the shadow tables used
183613 static int fts3ShadowName(const char *zName){
183619 if( sqlite3_stricmp(zName, azName[i])==0 ) return 1;
185867 p->pFts3Tab->zName = &p->pFts3Tab->zDb[nDb+1];
185872 memcpy((char *)p->pFts3Tab->zName, zFts3, nFts3);
185873 sqlite3Fts3Dequote((char *)p->pFts3Tab->zName);
188737 const unsigned char *zName;
188744 zName = sqlite3_value_text(argv[0]);
188751 if( zName==0 || n!=sizeof(pPtr) ){
188756 pOld = sqlite3Fts3HashInsert(pHash, (void *)zName, nName, pPtr);
188765 if( zName ){
188766 pPtr = sqlite3Fts3HashFind(pHash, zName, nName);
188769 char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
188939 const char *zName;
188961 zName = (const char *)sqlite3_value_text(argv[0]);
188966 p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
188969 char *zErr2 = sqlite3_mprintf("unknown tokenizer: %s", zName);
189021 char *zName,
189033 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
189044 char *zName,
189057 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
189140 ** The third argument to this function, zName, is used as the name
189146 const char *zName
189156 zTest = sqlite3_mprintf("%s_test", zName);
189157 zTest2 = sqlite3_mprintf("%s_internal_test", zName);
189164 rc = sqlite3_create_function(db, zName, 1, any, p, fts3TokenizerFunc, 0, 0);
189167 rc = sqlite3_create_function(db, zName, 2, any, p, fts3TokenizerFunc, 0, 0);
189501 ** Query FTS for the tokenizer implementation named zName.
189505 const char *zName,
189510 int nName = (int)strlen(zName);
189512 p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
189514 sqlite3Fts3ErrMsg(pzErr, "unknown tokenizer: %s", zName);
190291 zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName, p->zWriteExprlist);
190296 zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName);
191100 p->zSegmentsTbl = sqlite3_mprintf("%s_segments", p->zName);
200931 const char *zName;
200939 rc = sqlite3_create_module(db, aMod[i].zName, aMod[i].pModule, 0);
201109 char *zName; /* Name of r-tree table */
201675 char *zTab = sqlite3_mprintf("%s_node", pRtree->zName);
201997 pRtree->zDb, pRtree->zName,
201998 pRtree->zDb, pRtree->zName,
201999 pRtree->zDb, pRtree->zName
204132 zSql = sqlite3_mprintf("SELECT * FROM %Q.%Q", pRtree->zDb, pRtree->zName);
204144 "UNIQUE constraint failed: %s.%s", pRtree->zName, zCol
204150 "rtree constraint failed: %s.(%s<=%s)", pRtree->zName, zCol1, zCol2
204340 , pRtree->zDb, pRtree->zName, zNewName
204341 , pRtree->zDb, pRtree->zName, zNewName
204342 , pRtree->zDb, pRtree->zName, zNewName
204395 zSql = sqlite3_mprintf(zFmt, pRtree->zDb, pRtree->zName);
204412 ** Return true if zName is the extension on one of the shadow tables used
204415 static int rtreeShadowName(const char *zName){
204421 if( sqlite3_stricmp(zName, azName[i])==0 ) return 1;
204639 pRtree->zDb, pRtree->zName
204648 pRtree->zName);
204718 pRtree->zName = &pRtree->zDb[nDb+1];
204721 memcpy(pRtree->zName, argv[2], nName);
206600 pRtree->zName = &pRtree->zDb[nDb+1];
206605 memcpy(pRtree->zName, argv[2], nName);
207070 const char *zName,
207074 if( sqlite3_stricmp(zName, "geopoly_overlap")==0 ){
207079 if( sqlite3_stricmp(zName, "geopoly_within")==0 ){
207121 const char *zName;
207139 const char *zName;
207151 rc = sqlite3_create_function(db, aFunc[i].zName, aFunc[i].nArg,
207156 rc = sqlite3_create_function(db, aAgg[i].zName, 1,
207408 const char *zName, /* Name of ICU function that failed */
207412 sqlite3_snprintf(128, zBuf, "ICU error: %s(): %s", zName, u_errorName(e));
207819 const char *zName; /* SQL Collation sequence name (eg. "japanese") */
207826 zName = (const char *)sqlite3_value_text(apArg[1]);
207828 if( !zLocale || !zName ){
207839 rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator,
207854 const char *zName; /* Function name */
207881 db, p->zName, p->nArg, p->enc,
208839 ** Create an RBU VFS named zName that accesses the underlying file-system
208880 SQLITE_API int sqlite3rbu_create_vfs(const char *zName, const char *zParent);
208890 SQLITE_API void sqlite3rbu_destroy_vfs(const char *zName);
210169 const char *zName = (const char*)sqlite3_column_name(pStmt, i);
210170 if( sqlite3_strnicmp("rbu_", zName, 4) ){
210171 char *zCopy = rbuStrndup(zName, &p->rc);
210175 else if( 0==sqlite3_stricmp("rbu_rowid", zName) ){
210202 const char *zName = (const char*)sqlite3_column_text(pStmt, 1);
210203 if( zName==0 ) break; /* An OOM - finalize() below returns S_NOMEM */
210205 if( 0==strcmp(zName, pIter->azTblCol[i]) ) break;
210210 pIter->zDataTbl, zName
211464 const char *zName,
211470 p->rc = sqlite3_open_v2(zName, &db, flags, bUseVfs ? p->zVfsName : 0);
212134 ** Assert that column iCol of statement pStmt is named zName.
212136 static void assertColumnName(sqlite3_stmt *pStmt, int iCol, const char *zName){
212138 assert( 0==sqlite3_stricmp(zName, zCol) );
212666 p->zVfsName = pVfs->zName;
213683 char *zOut = sqlite3_mprintf("rbu(%s)/%z", pRbuVfs->base.zName, zIn);
213835 const char *zName,
213864 const char *zOpen = zName;
213871 if( zName ){
213878 pFd->zWal = sqlite3_filename_wal(zName);
213881 rbu_file *pDb = rbuFindMaindb(pRbuVfs, zName, 0);
213902 && sqlite3_uri_boolean(zName, "rbu_memory", 0)
214075 SQLITE_API void sqlite3rbu_destroy_vfs(const char *zName){
214076 sqlite3_vfs *pVfs = sqlite3_vfs_find(zName);
214085 ** Create an RBU VFS named zName that accesses the underlying file-system
214089 SQLITE_API int sqlite3rbu_create_vfs(const char *zName, const char *zParent){
214097 0, /* zName */
214126 nName = strlen(zName);
214143 pNew->base.zName = (const char*)(zSpace = (char*)&pNew[1]);
214144 memcpy(zSpace, zName, nName);
214314 char *zName; /* Value of 'name' column */
214812 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
214864 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
214927 const char *zName = 0; /* Only provide analysis of this table */
214946 zName = (const char*)sqlite3_value_text(argv[iArg++]);
214962 if( zName ){
214963 sqlite3_str_appendf(pSql, "WHERE name=%Q", zName);
214991 sqlite3_result_text(ctx, pCsr->zName, -1, SQLITE_TRANSIENT);
215637 char *zName; /* Local name of table */
215638 int nCol; /* Number of columns in table zName */
216598 const unsigned char *zName = sqlite3_column_text(pStmt, 1);
216599 if( zName==0 ) break;
216600 memcpy(pAlloc, zName, nName+1);
216645 pTab->zName, &pTab->nCol, 0, &pTab->azCol, &abPK
216655 if( 0==sqlite3_stricmp("sqlite_stat1", pTab->zName) ){
216661 1 + sessionVarintLen(pTab->nCol) + pTab->nCol + strlen(pTab->zName)+1
216966 const char *zName,
216970 int nName = sqlite3Strlen30(zName);
216975 if( 0==sqlite3_strnicmp(pRet->zName, zName, nName+1) ) break;
216982 || pSession->xTableFilter(pSession->pFilterCtx, zName)
216984 rc = sqlite3session_attach(pSession, zName);
216991 assert( 0==sqlite3_strnicmp(pRet->zName, zName, nName+1) );
217009 char const *zName, /* Table name */
217028 pSession->rc = sessionFindTable(pSession, zName, &pTab);
217190 char *zStmt = sessionSelectFindNew(pTab->nCol, zDb1, zDb2, pTab->zName,zExpr);
217221 pSession->zDb, zFrom, pTab->zName, pTab->azCol, pTab->abPK
217228 pSession->zDb, pTab->zName, zFrom, pTab->zName, zExpr, zExpr2
217315 zDb, zFrom, pTo->zName, pTo->azCol, pTo->abPK
217461 const char *zName /* Table name */
217466 if( !zName ){
217470 int nName; /* Number of bytes in string zName */
217474 nName = sqlite3Strlen30(zName);
217476 if( 0==sqlite3_strnicmp(pTab->zName, zName, nName+1) ) break;
217493 pTab->zName = (char *)&pTab[1];
217494 memcpy(pTab->zName, zName, nName+1);
218042 sessionAppendBlob(pBuf, (u8 *)pTab->zName, (int)strlen(pTab->zName)+1, pRc);
218088 const char *zName = pTab->zName;
218098 rc = sessionTableInfo(0, db, pSession->zDb, zName, &nCol, 0,&azCol,&abPK);
218109 db, pSession->zDb, zName, nCol, azCol, abPK, &pSel);
220690 if( !pTab || sqlite3_stricmp(zNew, pTab->zName) ){
220697 if( 0==sqlite3_strnicmp(pTab->zName, zNew, nNew+1) ) break;
220711 pTab->zName = (char*)&pTab->abPK[nCol];
220712 memcpy(pTab->zName, zNew, nNew+1);
221127 if( 0==sqlite3_stricmp(pTab->zName, zTab) ) break;
221896 const char *zName,
221905 const char *zName,
221913 const char *zName,
222113 char *zName; /* Name of FTS index */
222579 static int sqlite3Fts5StorageRename(Fts5Storage*, const char *zName);
225606 const char *zName;
225620 for(i=0; aEnum[i].zName; i++){
225621 if( sqlite3_strnicmp(aEnum[i].zName, zEnum, nEnum)==0 ){
225948 pRet->zName = sqlite3Fts5Strndup(&rc, azArg[2], -1);
225954 if( rc==SQLITE_OK && sqlite3_stricmp(pRet->zName, FTS5_RANK_NAME)==0 ){
225955 *pzErr = sqlite3_mprintf("reserved fts5 table name: %s", pRet->zName);
226025 &rc, "%Q.'%q_%s'", pRet->zDb, pRet->zName, zTail
226056 sqlite3_free(pConfig->zName);
226087 zSql, pConfig->zName, FTS5_RANK_NAME
226335 zSql = sqlite3Fts5Mprintf(&rc, zSelect, pConfig->zDb, pConfig->zName);
230758 pConfig->zDb, pConfig->zName
230782 pConfig->zDb, pConfig->zName
230804 pConfig->zDb, pConfig->zName
232419 pConfig->zDb, pConfig->zName
234193 pConfig->zDb, pConfig->zName
235422 p->zDataTbl = sqlite3Fts5Mprintf(&rc, "%s_data", pConfig->zName);
236101 pConfig->zDb, pConfig->zName, pSeg->iSegid
236936 char *zName; /* Name of tokenizer */
237837 pConfig->zDb, pConfig->zName, zRank, pConfig->zName,
237908 ** Search for an auxiliary function named zName that can be used with table
237912 static Fts5Auxiliary *fts5FindAuxiliary(Fts5FullTable *pTab, const char *zName){
237916 if( sqlite3_stricmp(zName, pAux->zFunc)==0 ) return pAux;
238194 "%s: table does not support scanning", pConfig->zName
238507 (nArg>1 ? "UPDATE" : "DELETE from"), pConfig->zName
239355 const char *zName, /* Name of SQL function */
239363 pAux = fts5FindAuxiliary(pTab, zName);
239379 const char *zName /* New name of table */
239382 return sqlite3Fts5StorageRename(pTab->pStorage, zName);
239430 const char *zName, /* Name of new function */
239436 int rc = sqlite3_overload_function(pGlobal->db, zName, -1);
239439 sqlite3_int64 nName; /* Size of zName in bytes, including \0 */
239442 nName = strlen(zName) + 1;
239448 memcpy(pAux->zFunc, zName, nName);
239469 const char *zName, /* Name of new function */
239476 sqlite3_int64 nName; /* Size of zName and its \0 terminator */
239480 nName = strlen(zName) + 1;
239485 pNew->zName = (char*)&pNew[1];
239486 memcpy(pNew->zName, zName, nName);
239504 const char *zName
239508 if( zName==0 ){
239512 if( sqlite3_stricmp(zName, pMod->zName)==0 ) break;
239525 const char *zName, /* Name of new function */
239532 pMod = fts5LocateTokenizer((Fts5Global*)pApi, zName);
239628 ** Return true if zName is the extension on one of the shadow tables used
239631 static int fts5ShadowName(const char *zName){
239637 if( sqlite3_stricmp(zName, azName[i])==0 ) return 1;
239880 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName, zBind);
239887 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName);
239945 pConfig->zDb, pConfig->zName,
239946 pConfig->zDb, pConfig->zName,
239947 pConfig->zDb, pConfig->zName
239952 pConfig->zDb, pConfig->zName
239958 pConfig->zDb, pConfig->zName
239968 const char *zName /* New name of FTS5 table */
239973 pConfig->zDb, pConfig->zName, zTail, zName, zTail
239978 static int sqlite3Fts5StorageRename(Fts5Storage *pStorage, const char *zName){
239982 fts5StorageRenameOne(pConfig, &rc, "data", zName);
239983 fts5StorageRenameOne(pConfig, &rc, "idx", zName);
239984 fts5StorageRenameOne(pConfig, &rc, "config", zName);
239986 fts5StorageRenameOne(pConfig, &rc, "docsize", zName);
239989 fts5StorageRenameOne(pConfig, &rc, "content", zName);
240009 pConfig->zDb, pConfig->zName, zPost, zDefn,
240018 pConfig->zName, zPost, zErr
240335 pConfig->zDb, pConfig->zName,
240336 pConfig->zDb, pConfig->zName
240341 pConfig->zDb, pConfig->zName
240537 pConfig->zDb, pConfig->zName, zSuffix
242317 const char *zName;
242331 aBuiltin[i].zName,