Lines Matching defs:zName
1647 ** The zName field holds the name of the VFS module. The name must
1785 const char *zName; /* Name of this virtual file system */
1787 int (*xOpen)(sqlite3_vfs*, sqlite3_filename zName, sqlite3_file*,
1789 int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);
1790 int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut);
1791 int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);
1809 int (*xSetSystemCall)(sqlite3_vfs*, const char *zName, sqlite3_syscall_ptr);
1810 sqlite3_syscall_ptr (*xGetSystemCall)(sqlite3_vfs*, const char *zName);
1811 const char *(*xNextSystemCall)(sqlite3_vfs*, const char *zName);
5095 SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
6660 const char *zName,
6667 const char *zName,
6675 const void *zName,
7650 int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName,
7901 const char *zName, /* Name of the module */
7907 const char *zName, /* Name of the module */
10778 char const *zName, /* Table name */
13704 const char *zName,
13713 const char *zName,
13721 const char *zName,
17944 const char *zName; /* SQL name of the function. */
18035 ** FUNCTION(zName, nArg, iArg, bNC, xFunc)
18036 ** Used to create a scalar function definition of a function zName
18042 ** VFUNCTION(zName, nArg, iArg, bNC, xFunc)
18045 ** SFUNCTION(zName, nArg, iArg, bNC, xFunc)
18049 ** INLINE_FUNC(zName, nArg, iFuncId, mFlags)
18050 ** zName is the name of a function that is implemented by in-line
18055 ** TEST_FUNC(zName, nArg, iFuncId, mFlags)
18056 ** zName is the name of a test-only function implemented by in-line
18061 ** DFUNCTION(zName, nArg, iArg, bNC, xFunc)
18068 ** MFUNCTION(zName, nArg, xPtr, xFunc)
18071 ** PURE_DATE(zName, nArg, iArg, bNC, xFunc)
18077 ** AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal)
18083 ** WAGGREGATE(zName, nArg, iArg, xStep, xFinal, xValue, xInverse)
18089 ** LIKEFUNC(zName, nArg, pArg, flags)
18090 ** Used to create a scalar function definition of a function zName
18097 #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \
18100 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
18101 #define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \
18103 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
18104 #define SFUNCTION(zName, nArg, iArg, bNC, xFunc) \
18106 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
18107 #define MFUNCTION(zName, nArg, xPtr, xFunc) \
18109 xPtr, 0, xFunc, 0, 0, 0, #zName, {0} }
18110 #define JFUNCTION(zName, nArg, bUseCache, bWS, bRS, bJsonB, iArg, xFunc) \
18114 SQLITE_INT_TO_PTR(iArg|((bJsonB)*JSON_BLOB)),0,xFunc,0, 0, 0, #zName, {0} }
18115 #define INLINE_FUNC(zName, nArg, iArg, mFlags) \
18118 SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }
18119 #define TEST_FUNC(zName, nArg, iArg, mFlags) \
18123 SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }
18124 #define DFUNCTION(zName, nArg, iArg, bNC, xFunc) \
18126 0, 0, xFunc, 0, 0, 0, #zName, {0} }
18127 #define PURE_DATE(zName, nArg, iArg, bNC, xFunc) \
18130 (void*)&sqlite3Config, 0, xFunc, 0, 0, 0, #zName, {0} }
18131 #define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \
18134 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
18135 #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \
18138 pArg, 0, xFunc, 0, 0, 0, #zName, }
18139 #define LIKEFUNC(zName, nArg, arg, flags) \
18141 (void *)arg, 0, likeFunc, 0, 0, 0, #zName, {0} }
18142 #define WAGGREGATE(zName, nArg, arg, nc, xStep, xFinal, xValue, xInverse, f) \
18144 SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,xValue,xInverse,#zName, {0}}
18145 #define INTERNAL_FUNCTION(zName, nArg, xFunc) \
18148 0, 0, xFunc, 0, 0, 0, #zName, {0} }
18158 char *zName; /* Savepoint name (nul-terminated) */
18180 const char *zName; /* Name passed to create_module() */
18230 #define COLTYPE_CUSTOM 0 /* Type appended to zName */
18270 char *zName; /* Name of the collating sequence, UTF-8 encoded */
18392 char *zName; /* Name of the table or view */
18734 char *zName; /* Name of this index */
19152 ** also be used as the argument to a function, in which case the a.zName
19190 u16 iAlias; /* Index into Parse.aAlias[] for zName */
19225 char *zName; /* Name of the identifier */
19227 int idx; /* Index in some Table.aCol[] of a column named zName */
19265 char *zName; /* Name of the table */
19266 char *zAlias; /* The "B" part of a "A AS B" phrase. zName is the "A" */
19267 Table *pTab; /* An SQL table corresponding to zName */
19999 char *zName; /* The name of the trigger */
20094 char zName[40]; /* Name of trigger: "sqlite_returning_%p" */
20359 char *zName; /* Name of this CTE */
20413 char zName[1]; /* Name of this client data. MUST BE LAST */
20451 char *zName; /* Name of window (may be NULL) */
20850 SQLITE_PRIVATE Module *sqlite3PragmaVtabRegister(sqlite3*,const char *zName);
21174 SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName);
21265 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char*zName);
21498 SQLITE_PRIVATE int sqlite3ShadowTableName(sqlite3 *db, const char *zName);
23525 char *zName; /* Name of table or index */
24881 char zName[7]; /* Name of the transformation */
25260 && sqlite3_strnicmp(aXformType[i].zName, z, n)==0
25265 assert( strcmp(aXformType[4].zName,"month")==0 );
25278 assert( strcmp(aXformType[5].zName,"year")==0 );
26414 if( strcmp(zVfs, pVfs->zName)==0 ) break;
31243 ** %!S Like %S but prefer the zName over the zAlias
31988 }else if( pItem->zName ){
31993 sqlite3_str_appendall(pAccum, pItem->zName);
32739 sqlite3_str_appendf(&x, "%s", pCte->zName);
32782 pItem->pTab->zName, pItem->pTab->nCol, pItem->pTab,
33006 if( pWin->zName ){
33007 sqlite3TreeViewLine(pView, "OVER %s (%p)", pWin->zName, pWin);
33067 pWin->pWFunc->zName, pWin->pWFunc->nArg);
33487 char *zName = pList->a[i].zEName;
33489 if( j || zName ){
33493 if( zName ){
33496 fprintf(stdout, "AS %s ", zName);
33499 fprintf(stdout, "TABLE-ALIAS-NAME(\"%s\") ", zName);
33505 fprintf(stdout, "SPAN(\"%s\") ", zName);
33516 if( j || zName ){
33548 char *zName = pList->a[i].zName;
33550 if( zName==0 ) zName = "(null)";
33554 fprintf(stdout, "%s\n", zName);
33556 fprintf(stdout, "%s (%d)\n", zName, pList->a[i].u4.idx);
33560 fprintf(stdout, "%s (pExpr=NULL)\n", zName);
33562 fprintf(stdout, "%s\n", zName);
33858 sqlite3TreeViewLine(pView, "TRIGGER %s", pTrigger->zName);
36731 const char *zName, /* Name of symbol to add */
36732 int nName, /* Bytes of text in zName */
36733 int iVal /* Value to associate with zName */
36735 int nInt; /* number of sizeof(int) objects needed for zName */
36736 char *z; /* Pointer to where zName will be stored */
36737 int i; /* Index in pIn[] where zName is stored */
36756 memcpy(z, zName, nName);
36779 ** Return the number of the variable named zName, if it is in VList.
36782 SQLITE_PRIVATE int sqlite3VListNameToNum(VList *pIn, const char *zName, int nName){
36789 if( strncmp(z,zName,nName)==0 && z[nName]==0 ) return pIn[i];
37461 static int kvvfsDelete(sqlite3_vfs*, const char *zName, int syncDir);
37462 static int kvvfsAccess(sqlite3_vfs*, const char *zName, int flags, int *);
37463 static int kvvfsFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
37475 "kvvfs", /* zName */
38189 const char *zName,
38195 if( zName==0 ) zName = "";
38196 SQLITE_KV_LOG(("xOpen(\"%s\")\n", zName));
38197 if( strcmp(zName, "local")==0
38198 || strcmp(zName, "session")==0
38203 if( strcmp(zName, "local-journal")==0
38204 || strcmp(zName, "session-journal")==0
38211 if( zName[0]=='s' ){
38781 const char *zName; /* Name of the system call */
38972 ** system call named zName.
38976 const char *zName, /* Name of system call to override */
38983 if( zName==0 ){
38984 /* If no zName is given, restore all system calls to their default
38994 /* If zName is specified, operate on only the one system call
38998 if( strcmp(zName, aSyscall[i].zName)==0 ){
39013 ** Return the value of a system call. Return NULL if zName is not a
39019 const char *zName
39025 if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
39031 ** Return the name of the first system call after zName. If zName==NULL
39032 ** then return the name of the first system call. Return NULL if zName
39033 ** is the last system call or if zName is not the name of a valid
39036 static const char *unixNextSystemCall(sqlite3_vfs *p, const char *zName){
39040 if( zName ){
39042 if( strcmp(zName, aSyscall[i].zName)==0 ) break;
39046 if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
42401 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
44192 if( strcmp(pVfs->zName,"unix-excl")==0 ){
44653 const char *zName = zPath;
44669 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
44670 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
44671 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_SUPER_JOURNAL );
44672 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
44694 assert( zName==0 );
44699 pUnused = findReusableFd(zName, flags);
44713 assert( (flags & SQLITE_OPEN_URI) || zName[strlen(zName)+1]==0 );
44715 }else if( !zName ){
44716 /* If zName is NULL, the upper layer is requesting a temp file. */
44722 zName = zTmpname;
44726 assert( zName[strlen(zName)+1]==0 );
44743 rc = findCreateFileMode(zName, flags, &openMode, &uid, &gid);
44749 fd = robust_open(zName, openFlags, openMode);
44750 OSTRACE(("OPENX %-3d %s 0%o\n", fd, zName, openFlags));
44753 if( isNewJrnl && errno==EACCES && osAccess(zName, F_OK) ){
44765 pReadonly = findReusableFd(zName, flags);
44770 fd = robust_open(zName, openFlags, openMode);
44775 int rc2 = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName);
44809 zPath = zName;
44811 zPath = sqlite3_mprintf("%s", zName);
44817 osUnlink(zName);
44989 DbPath *pPath, /* Path under construction, to which to append zName */
44990 const char *zName, /* Name to append to pPath. Not zero-terminated */
44991 int nName /* Number of significant bytes in zName */
44994 assert( zName!=0 );
44995 if( zName[0]=='.' ){
44997 if( zName[1]=='.' && nName==2 ){
45010 memcpy(&pPath->zOut[pPath->nUsed], zName, nName);
45050 DbPath *pPath, /* Path under construction, to which to append zName */
45643 dummyVfs.zName = "dummy";
46539 VFSNAME, /* zName */ \
46602 0==strcmp(aVfs[i].zName,SQLITE_DEFAULT_UNIX_VFS));
47157 const char *zName; /* Name of the system call */
47815 ** system call named zName.
47819 const char *zName, /* Name of system call to override */
47826 if( zName==0 ){
47827 /* If no zName is given, restore all system calls to their default
47837 /* If zName is specified, operate on only the one system call
47841 if( strcmp(zName, aSyscall[i].zName)==0 ){
47856 ** Return the value of a system call. Return NULL if zName is not a
47862 const char *zName
47868 if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
47874 ** Return the name of the first system call after zName. If zName==NULL
47875 ** then return the name of the first system call. Return NULL if zName
47876 ** is the last system call or if zName is not the name of a valid
47879 static const char *winNextSystemCall(sqlite3_vfs *p, const char *zName){
47883 if( zName ){
47885 if( strcmp(zName, aSyscall[i].zName)==0 ) break;
47889 if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
48904 LPWSTR zName;
48909 zName = winUtf8ToUnicode(zFilename);
48910 if( zName==0 ){
48920 zTok = osCharLowerW(zName);
48926 pFile->hMutex = osCreateMutexW(NULL, FALSE, zName);
48929 sqlite3_free(zName);
48941 osCharUpperW(zName);
48944 zName);
48953 sqlite3_free(zName);
50217 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
50577 int nName; /* Size of zName in bytes */
51675 const char *zName, /* Name of the file (UTF-8) */
51692 const char *zUtf8Name = zName; /* Filename in UTF-8 encoding */
51736 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
51737 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
51738 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_SUPER_JOURNAL );
51739 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
51816 if( 0==sqlite3_uri_boolean(zName, "exclusive", 0) ){
51913 return winOpen(pVfs, zName, id,
51942 && (rc = winceCreateLock(zName, pFile))!=SQLITE_OK
51947 OSTRACE(("OPEN-CE-LOCK name=%s, rc=%s\n", zName, sqlite3ErrName(rc)));
51967 && sqlite3_uri_boolean(zName, "psow", SQLITE_POWERSAFE_OVERWRITE)
51972 pFile->zPath = zName;
52718 "win32", /* zName */
52743 "win32-longpath", /* zName */
52768 "win32-none", /* zName */
52793 "win32-longpath-none", /* zName */
52989 /* static int memdbDelete(sqlite3_vfs*, const char *zName, int syncDir); */
52990 static int memdbAccess(sqlite3_vfs*, const char *zName, int flags, int *);
52991 static int memdbFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
53007 "memdb", /* zName */
53409 const char *zName,
53420 szName = sqlite3Strlen30(zName);
53421 if( szName>1 && (zName[0]=='/' || zName[0]=='\\') ){
53428 if( strcmp(memdb_g.apMemStore[i]->zFName,zName)==0 ){
53453 memcpy(p->zFName, zName, szName+1);
62170 SQLITE_API sqlite3_file *sqlite3_database_file_object(const char *zName){
62173 while( zName[-1]!=0 || zName[-2]!=0 || zName[-3]!=0 || zName[-4]!=0 ){
62174 zName--;
62176 p = zName - 4 - sizeof(Pager*);
65966 static char zName[15];
65967 sqlite3_snprintf(sizeof(zName), zName, "READ-LOCK[%d]",
65969 return zName;
86031 const char *zName /* Name of table or index being scanned */
86044 pNew->zName = sqlite3DbStrDup(p->db, zName);
86744 const char *zColl = pColl ? pColl->zName : "";
86764 sqlite3_str_appendf(&x, "%.18s-%s", pColl->zName,
86770 sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg);
86775 sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg);
86829 zP4 = pOp->p4.pTab->zName;
87693 ** zName must be a pointer to a nul terminated string.
87699 ** to by zName will be freed by sqlite3DbFree() when the vdbe is destroyed.
87703 int idx, /* Index of column zName applies to */
87705 const char *zName, /* Pointer to buffer containing name */
87706 void (*xDel)(void*) /* Memory management strategy for zName */
87713 assert( !zName || xDel!=SQLITE_DYNAMIC );
87718 rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, xDel);
87719 assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 );
88571 sqlite3DbFree(db, p->aScan[i].zName);
90232 pCtx->pFunc->zName, zContext);
90314 const char *zTbl = pTab->zName;
90925 pCtx->pFunc->zName);
92278 SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){
92279 if( p==0 || zName==0 ) return 0;
92280 return sqlite3VListNameToNum(p->pVList, zName, nName);
92282 SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
92283 return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName));
92788 if( pScan->zName ){
92826 *(const char**)pOut = pScan->zName;
96416 pTab->zName, aCol[i].zCnName);
96850 char *zName; /* Name of savepoint */
96859 zName = pOp->p4.z;
96878 nName = sqlite3Strlen30(zName);
96894 pNew->zName = (char *)&pNew[1];
96895 memcpy(pNew->zName, zName, nName+1);
96921 pSavepoint && sqlite3StrICmp(pSavepoint->zName, zName);
96927 sqlite3VdbeError(p, "no such savepoint: %s", zName);
98850 zDb, pTab->zName, x.nKey);
99015 db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, pTab->zName,
101345 rc = pModule->xIntegrity(pVtab, db->aDb[pOp->p1].zDbSName, pTab->zName,
101563 ** in register P1 is passed as the zName argument to the xRename method.
102580 sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT);
105613 const char *zName; /* tables_used.name */
105711 pCur->zName = 0;
105736 if( pCur->zName ){
105737 pCur->zName = 0;
105791 pCur->zName = pTab->zName;
105796 if( pCur->zName==0 ){
105800 pCur->zName = pIdx->zName;
105878 sqlite3_result_text(ctx, pCur->zName, -1, SQLITE_STATIC);
106374 const char *zName, /* Name of the journal file */
106381 assert( zName || nSpill<0 || (flags & SQLITE_OPEN_EXCLUSIVE) );
106389 return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0);
106402 p->zJournal = zName;
106961 zLegacy = pTab->zName;
107074 assert( pTab!=0 && pTab->zName!=0 );
107147 }else if( sqlite3StrICmp(zTab, pTab->zName)!=0 ){
107255 || sqlite3StrICmp(zTab,pParse->pTriggerTab->zName)==0
107887 pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120;
107892 int auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0,pDef->zName,0);
108619 assert( pItem->zName!=0 || pItem->pSelect!=0 );/* Test of tag-20240424-1*/
108624 if( pItem->zName ) pParse->zAuthContext = pItem->zName;
108993 sSrc.a[0].zName = pTab->zName;
109339 return sqlite3StrICmp(pColl1->zName, pColl2->zName)==0;
110758 pRet->a[i].zName = sqlite3DbStrDup(db, p->a[i].zName);
110891 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
110938 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
111114 pList->a[pList->nExpr-1].zEName = pColumns->a[i].zName;
111115 pColumns->a[i].zName = 0;
112174 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
112185 "USING ROWID SEARCH ON TABLE %s FOR IN-OPERATOR",pTab->zName));
112248 if( pReq!=0 && sqlite3StrICmp(pReq->zName, pIdx->azColl[j])!=0 ){
112265 "USING INDEX %s FOR IN-OPERATOR",pIdx->zName));
112268 VdbeComment((v, "%s", pIdx->zName));
113180 VdbeComment((v, "%s.rowid", pTab->zName));
113592 VdbeComment((v,"%s.rowid",pTab->zName));
113595 pTab->zName, pTab->aCol[pCol->iColumn].zCnName));
116166 ** Parameter zName is the name of a table that is about to be altered
116171 ** Or, if zName is not a system table, zero is returned.
116174 if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7)
116182 sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName);
116274 char *zName = 0; /* NULL-terminated version of pName */
116291 zName = sqlite3NameFromToken(db, pName);
116292 if( !zName ) goto exit_rename_table;
116294 /* Check that a table or index named 'zName' does not already exist
116297 if( sqlite3FindTable(db, zName, zDb)
116298 || sqlite3FindIndex(db, zName, zDb)
116299 || sqlite3IsShadowTableOf(db, pTab, zName)
116302 "there is already another table or index with this name: %s", zName);
116312 if( SQLITE_OK!=sqlite3CheckObjectName(pParse,zName,"table",zName) ){
116318 sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
116325 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
116352 /* figure out how many UTF-8 characters are in zName */
116353 zTabName = pTab->zName;
116363 , zDb, zDb, zTabName, zName, (iDb==1), zTabName
116380 zName, zName, zName,
116391 zDb, zName, pTab->zName);
116407 , zDb, zTabName, zName, zTabName, zDb, zName);
116418 sqlite3VdbeLoadString(v, i, zName);
116428 sqlite3DbFree(db, zName);
116478 zTab = &pNew->zName[16]; /* Skip the "sqlite_altertab_" prefix on the name */
116486 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
116677 pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
116678 if( !pNew->aCol || !pNew->zName ){
116723 zType, pTab->zName
116768 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
116804 zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1,
116805 pTab->zName
116812 zDb, pTab->zName, iCol, zNew, bQuote
116832 ** * The name of a table column in Column.zName
117012 sqlite3RenameTokenRemap(pParse, 0, (const void*)pIdList->a[ii].zName);
117039 sqlite3RenameTokenRemap(pParse, 0, (void*)pSrc->a[i].zName);
117224 ** pEList->a[i].zName) that matches the string in zOld, extract the
117237 const char *zName = pEList->a[i].zEName;
117239 && ALWAYS(zName!=0)
117240 && 0==sqlite3_stricmp(zName, zOld)
117242 renameTokenFind(pParse, pCtx, (const void*)zName);
117249 ** For each name in the the id-list pIdList (i.e. each pIdList->a[i].zName)
117262 const char *zName = pIdList->a[i].zName;
117263 if( 0==sqlite3_stricmp(zName, zOld) ){
117264 renameTokenFind(pParse, pCtx, (const void*)zName);
117699 int bFKOnly = sqlite3_stricmp(zTable, sParse.pNewTable->zName);
117829 renameTokenFind(pWalker->pParse, p, pItem->zName);
117934 if( sqlite3_stricmp(zOld, pTab->zName)==0 ){
117939 renameTokenFind(&sParse, &sCtx, pTab->zName);
117945 renameTokenFind(&sParse, &sCtx, sParse.pNewIndex->zName);
117973 if( 0==sqlite3_stricmp(pItem->zName, zOld) ){
117974 renameTokenFind(&sParse, &sCtx, pItem->zName);
118350 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, zCol) ){
118360 , zDb, iDb, iCol, pTab->zName
118630 const char *zName;
118662 const char *zTab = aTable[i].zName;
118704 VdbeComment((v, aTable[i].zName));
118950 "stat_init", /* zName */
119244 "stat_push", /* zName */
119386 "stat_get", /* zName */
119416 VdbeComment((v,"%s.rowid",pIdx->zName));
119419 VdbeComment((v,"%s.expr(%d)",pIdx->zName, k));
119421 VdbeComment((v,"%s.%s", pIdx->zName, pIdx->pTable->aCol[i].zCnName));
119476 if( sqlite3_strlike("sqlite\\_%", pTab->zName, '\\')==0 ){
119485 if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,
119495 pStat1->zName = (char*)&pStat1[1];
119496 memcpy(pStat1->zName, "sqlite_stat1", 13);
119507 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
119512 sqlite3VdbeLoadString(v, regTabname, pTab->zName);
119525 zIdxName = pTab->zName;
119529 zIdxName = pIdx->zName;
119535 VdbeComment((v, "Analysis for %s.%s", pTab->zName, zIdxName));
119584 VdbeComment((v, "%s", pIdx->zName));
119818 VdbeComment((v, "%s", pTab->zName));
119892 openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");
119894 openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
120209 const char *zName,
120212 Index *pIdx = sqlite3FindIndex(db, zName, zDb);
120214 Table *pTab = sqlite3FindTable(db, zName, zDb);
120525 ** Return true if zName points to a name that may be used to refer to
120528 SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName){
120530 sqlite3StrICmp(db->aDb[iDb].zDbSName, zName)==0
120531 || (iDb==0 && sqlite3StrICmp("main", zName)==0)
120558 const char *zName;
120570 zName = (const char *)sqlite3_value_text(argv[1]);
120572 if( zName==0 ) zName = "";
120620 assert( zName );
120621 if( sqlite3DbIsNamed(db, i, zName) ){
120622 zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName);
120647 rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
120658 pNew->zDbSName = sqlite3DbStrDup(db, zName);
120709 rc = sqlite3UserAuthCheckLogin(db, zName, &newAuth);
120761 const char *zName = (const char *)sqlite3_value_text(argv[0]);
120770 if( zName==0 ) zName = "";
120774 if( sqlite3DbIsNamed(db, i, zName) ) break;
120778 sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
120782 sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
120788 sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
120901 "sqlite_detach", /* zName */
120921 "sqlite_attach", /* zName */
121282 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
121421 const char *zName /* Name of the table to be locked */
121446 p->zLockName = zName;
121457 const char *zName /* Name of the table to be locked */
121461 lockTable(pParse, iDb, iTab, isWriteLock, zName);
121720 SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){
121729 if( db->auth.authLevel<UAUTH_Admin && sqlite3UserAuthTable(zName)!=0 ){
121746 p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName);
121747 if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){
121749 if( sqlite3StrICmp(zName+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0
121750 || sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0
121751 || sqlite3StrICmp(zName+7, &LEGACY_SCHEMA_TABLE[7])==0
121757 if( sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0 ){
121765 p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash, zName);
121768 p = sqlite3HashFind(&db->aDb[0].pSchema->tblHash, zName);
121773 p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName);
121776 if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){
121777 if( sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0 ){
121779 }else if( sqlite3StrICmp(zName+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0 ){
121801 const char *zName, /* Name of the table we are looking for */
121815 p = sqlite3FindTable(db, zName, zDbase);
121818 /* If zName is the not the name of a table in the schema created using
121822 Module *pMod = (Module*)sqlite3HashFind(&db->aModule, zName);
121823 if( pMod==0 && sqlite3_strnicmp(zName, "pragma_", 7)==0 ){
121824 pMod = sqlite3PragmaVtabRegister(db, zName);
121841 sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
121843 sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
121874 return sqlite3LocateTable(pParse, flags, p->zName, zDb);
121881 SQLITE_PRIVATE const char *sqlite3PreferredTableName(const char *zName){
121882 if( sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){
121883 if( sqlite3StrICmp(zName+7, &LEGACY_SCHEMA_TABLE[7])==0 ){
121886 if( sqlite3StrICmp(zName+7, &LEGACY_TEMP_SCHEMA_TABLE[7])==0 ){
121890 return zName;
121905 SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){
121916 p = sqlite3HashFind(&pSchema->idxHash, zName);
122202 char *zName = pIndex->zName;
122204 &pIndex->pSchema->idxHash, zName, 0
122228 sqlite3DbFree(db, pTable->zName);
122281 char *zName;
122283 zName = sqlite3DbStrNDup(db, (const char*)pName->z, pName->n);
122284 sqlite3Dequote(zName);
122286 zName = 0;
122288 return zName;
122305 ** Parameter zName points to a nul-terminated buffer containing the name
122310 SQLITE_PRIVATE int sqlite3FindDbName(sqlite3 *db, const char *zName){
122312 if( zName ){
122315 if( 0==sqlite3_stricmp(pDb->zDbSName, zName) ) break;
122318 if( i==0 && 0==sqlite3_stricmp("main", zName) ) break;
122332 char *zName; /* Name we are searching for */
122333 zName = sqlite3NameFromToken(db, pName);
122334 i = sqlite3FindDbName(db, zName);
122335 sqlite3DbFree(db, zName);
122400 ** This routine is used to check if the UTF-8 string zName is a legal
122412 const char *zName, /* Name of the object to check */
122426 || sqlite3_stricmp(zName, db->init.azInit[1])
122433 if( (pParse->nested==0 && 0==sqlite3StrNICmp(zName, "sqlite_", 7))
122434 || (sqlite3ReadOnlyShadowTables(db) && sqlite3ShadowTableName(db, zName))
122437 zName);
122589 char *zName = 0; /* The name of the new table */
122598 zName = sqlite3DbStrDup(db, SCHEMA_TABLE(iDb));
122611 zName = sqlite3NameFromToken(db, pName);
122613 sqlite3RenameTokenMap(pParse, (void*)zName, pName);
122617 if( zName==0 ) return;
122618 if( sqlite3CheckObjectName(pParse, zName, isView?"view":"table", zName) ){
122637 zName, 0, zDb) ){
122655 pTable = sqlite3FindTable(db, zName, zDb);
122667 if( sqlite3FindIndex(db, zName, zDb)!=0 ){
122668 sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
122680 pTable->zName = zName;
122762 sqlite3DbFree(db, zName);
122787 sqlite3HashInsert(pHash, pRet->zName, 0);
122829 sqlite3_snprintf(sizeof(pRet->zName), pRet->zName,
122831 pRet->retTrig.zName = pRet->zName;
122842 assert( sqlite3HashFind(pHash, pRet->zName)==0
122844 if( sqlite3HashInsert(pHash, pRet->zName, &pRet->retTrig)
122873 sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
123210 "table \"%s\" has more than one primary key", pTab->zName);
123490 n += identLength(p->zName);
123508 identPut(zStmt, &k, p->zName);
123868 ** Return true if pTab is a virtual table and zName is a shadow table name
123871 SQLITE_PRIVATE int sqlite3IsShadowTableOf(sqlite3 *db, Table *pTab, const char *zName){
123872 int nName; /* Length of zName */
123876 nName = sqlite3Strlen30(pTab->zName);
123877 if( sqlite3_strnicmp(zName, pTab->zName, nName)!=0 ) return 0;
123878 if( zName[nName]!='_' ) return 0;
123883 return pMod->pModule->xShadowName(zName+nName+1);
123895 int nName; /* Length of pTab->zName */
123905 assert( pTab->zName!=0 );
123906 nName = sqlite3Strlen30(pTab->zName);
123909 assert( pOther->zName!=0 );
123912 if( sqlite3StrNICmp(pOther->zName, pTab->zName, nName)==0
123913 && pOther->zName[nName]=='_'
123914 && pMod->pModule->xShadowName(pOther->zName+nName+1)
123924 ** Return true if zName is a shadow table name in the current database
123927 ** zName is temporarily modified while this routine is running, but is
123930 SQLITE_PRIVATE int sqlite3ShadowTableName(sqlite3 *db, const char *zName){
123931 char *zTail; /* Pointer to the last "_" in zName */
123932 Table *pTab; /* Table that zName is a shadow of */
123933 zTail = strrchr(zName, '_');
123936 pTab = sqlite3FindTable(db, zName, 0);
123940 return sqlite3IsShadowTableOf(db, pTab, zName);
124010 if( pSelect==0 && sqlite3ShadowTableName(db, p->zName) ){
124050 p->zName, pCol->zCnName, sqlite3ColumnType(pCol, "")
124054 p->zName, pCol->zCnName);
124083 sqlite3ErrorMsg(pParse, "PRIMARY KEY missing on table %s", p->zName);
124261 p->zName,
124262 p->zName,
124288 sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName),0);
124295 db->aDb[iDb].zDbSName, p->zName), P4_DYNAMIC);
124306 pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p);
124320 if( strcmp(p->zName, "sqlite_sequence")==0 ){
124484 sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
124719 const char *zName /* Name of index or table */
124729 zDbName, zTab, zType, zName
124775 pDb->zDbSName, pTab->zName
124790 pDb->zDbSName, pTab->zName);
124799 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
124802 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
124828 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
124829 if( sqlite3StrNICmp(pTab->zName+7, "stat", 4)==0 ) return 0;
124830 if( sqlite3StrNICmp(pTab->zName+7, "parameters", 10)==0 ) return 0;
124897 zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
124906 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
124909 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
124915 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
124924 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
124928 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
124940 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
125137 if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
125144 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
125303 char *zName = 0; /* Name of the index */
125304 int nName; /* Number of characters in zName */
125372 pTab->zName);
125386 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
125390 && sqlite3UserAuthTable(pTab->zName)==0
125393 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
125423 zName = sqlite3NameFromToken(db, pName);
125424 if( zName==0 ) goto exit_create_index;
125426 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName,"index",pTab->zName) ){
125431 if( sqlite3FindTable(db, zName, pDb->zDbSName)!=0 ){
125432 sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
125436 if( sqlite3FindIndex(db, zName, pDb->zDbSName)!=0 ){
125438 sqlite3ErrorMsg(pParse, "index %s already exists", zName);
125451 zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
125452 if( zName==0 ){
125461 if( IN_SPECIAL_PARSE ) zName[7]++;
125474 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
125514 nName = sqlite3Strlen30(zName);
125524 pIndex->zName = zExtra;
125526 memcpy(pIndex->zName, zName, nName+1);
125751 pIndex->zName, pIndex);
125813 pIndex->zName,
125814 pTab->zName,
125827 sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName), 0);
125880 sqlite3DbFree(db, zName);
125959 pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
125986 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
125998 db->aDb[iDb].zDbSName, pIndex->zName
126000 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
126003 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
126074 pList->a[i].zName = sqlite3NameFromToken(db, pToken);
126075 if( IN_RENAME_OBJECT && pList->a[i].zName ){
126076 sqlite3RenameTokenMap(pParse, (void*)pList->a[i].zName, pToken);
126090 sqlite3DbFree(db, pList->a[i].zName);
126099 SQLITE_PRIVATE int sqlite3IdListIndex(IdList *pList, const char *zName){
126103 if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
126207 ** The SrcList.a[].zName field is filled with the table name which might
126262 pItem->zName = sqlite3NameFromToken(db, pDatabase);
126265 pItem->zName = sqlite3NameFromToken(db, pTable);
126299 if( pItem->zName ) sqlite3DbNNFreeNN(db, pItem->zName);
126354 assert( pItem->zName==0 || pDatabase!=0 );
126355 if( IN_RENAME_OBJECT && pItem->zName ){
126357 sqlite3RenameTokenMap(pParse, pItem->zName, pToken);
126558 char *zName = sqlite3NameFromToken(pParse->db, pName);
126559 if( zName ){
126565 if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
126566 sqlite3DbFree(pParse->db, zName);
126569 sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
126737 sqlite3_str_appendf(&errMsg, "index '%q'", pIdx->zName);
126744 sqlite3_str_appendall(&errMsg, pTab->zName);
126768 zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
126772 zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
126980 pNew->zName = sqlite3NameFromToken(pParse->db, pName);
126994 sqlite3DbFree(db, pCte->zName);
127019 char *zName;
127027 zName = pCte->zName;
127028 if( zName && pWith ){
127031 if( sqlite3StrICmp(zName, pWith->a[i].zName)==0 ){
127032 sqlite3ErrorMsg(pParse, "duplicate WITH table name: %s", zName);
127043 assert( (pNew!=0 && zName!=0) || db->mallocFailed );
127095 ** in the encoding enc of name zName, length nName.
127097 static void callCollNeeded(sqlite3 *db, int enc, const char *zName){
127100 char *zExternal = sqlite3DbStrDup(db, zName);
127109 sqlite3ValueSetStr(pTmp, -1, zName, SQLITE_UTF8, SQLITE_STATIC);
127128 char *z = pColl->zName;
127155 const char *zName = pColl->zName;
127157 CollSeq *p = sqlite3GetCollSeq(pParse, ENC(db), pColl, zName);
127170 ** specified by zName and nName is not found and parameter 'create' is
127183 const char *zName, /* Name of the collating sequence */
127187 pColl = sqlite3HashFind(&db->aCollSeq, zName);
127190 int nName = sqlite3Strlen30(zName) + 1;
127194 pColl[0].zName = (char*)&pColl[3];
127196 pColl[1].zName = (char*)&pColl[3];
127198 pColl[2].zName = (char*)&pColl[3];
127200 memcpy(pColl[0].zName, zName, nName);
127201 pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, pColl);
127219 ** Parameter zName points to a UTF-8 encoded string nName bytes long.
127220 ** Return the CollSeq* pointer for the collation sequence named zName
127236 const char *zName, /* Name of the collating sequence. Might be NULL */
127242 if( zName ){
127243 pColl = findCollSeqEntry(db, zName, create);
127271 ** collation sequence with name zName, length nName.
127274 ** db for collation type name zName, length nName, or NULL, if no collation
127283 const char *zName /* Collating sequence name */
127290 p = sqlite3FindCollSeq(db, enc, zName, 0);
127296 callCollNeeded(db, enc, zName);
127297 p = sqlite3FindCollSeq(db, enc, zName, 0);
127304 sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);
127312 ** encoding identified by the string zName.
127330 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){
127336 pColl = sqlite3FindCollSeq(db, enc, zName, initbusy);
127338 pColl = sqlite3GetCollSeq(pParse, enc, pColl, zName);
127416 if( sqlite3StrICmp(p->zName, zFunc)==0 ){
127433 const char *zName = aDef[i].zName;
127434 int nName = sqlite3Strlen30(zName);
127435 int h = SQLITE_FUNC_HASH(zName[0], nName);
127437 pOther = sqlite3FunctionSearch(h, zName);
127464 ** case is used to see if zName is a valid function name for some number
127473 const char *zName, /* Name of the function. zero-terminated */
127486 nName = sqlite3Strlen30(zName);
127490 p = (FuncDef*)sqlite3HashFind(&db->aFunc, zName);
127514 h = SQLITE_FUNC_HASH(sqlite3UpperToLower[(u8)zName[0]], nName);
127515 p = sqlite3FunctionSearch(h, zName);
127534 pBest->zName = (const char*)&pBest[1];
127537 memcpy((char*)&pBest[1], zName, nName+1);
127538 for(z=(u8*)pBest->zName; *z; z++) *z = sqlite3UpperToLower[*z];
127539 pOther = (FuncDef*)sqlite3HashInsert(&db->aFunc, pBest->zName, pBest);
127710 pTab->zName);
127737 sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
127744 sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
127775 pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName);
127849 const char *zName;
127851 zName = pTab->aCol[pPk->aiColumn[0]].zCnName;
127852 pLhs = sqlite3Expr(db, TK_ID, zName);
127853 pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ID, zName));
128008 rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0,
128027 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
128095 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
128098 pTab->zName, P4_STATIC);
128464 if( pParse->nested==0 || 0==sqlite3_stricmp(pTab->zName, "sqlite_stat1") ){
128537 VdbeModuleComment((v, "GenRowIdxDel for %s", pIdx->zName));
131396 int n = sqlite3Strlen30(p->zName);
131397 int h = p->zName[0] + n;
131399 printf(" %s(%d)", p->zName, h);
131692 pFKey->pFrom->zName, pFKey->zTo);
131897 if( zColl==0 ) zColl = db->pDfltColl->zName;
132085 return (FKey *)sqlite3HashFind(&pTab->pSchema->fkeyHash, pTab->zName);
132332 && sqlite3_stricmp(pTab->zName, pFKey->zTo)!=0
132390 rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
132399 sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
132455 pItem->zName = pFKey->pFrom->zName;
132488 pItem->zName = 0;
132573 if( 0==sqlite3_stricmp(pTab->zName, p->zTo) ) eRet = 2;
132731 zFrom = pFKey->pFrom->zName;
132746 pSrc->a[0].zName = sqlite3DbStrDup(db, zFrom);
132933 (opcode==OP_OpenWrite)?1:0, pTab->zName);
132937 VdbeComment((v, "%s", pTab->zName));
132944 VdbeComment((v, "%s", pTab->zName));
133384 sqlite3VdbeLoadString(v, memId-1, p->pTab->zName);
133844 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0,
133960 if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zCnName)==0 ){
133978 if( sqlite3IsRowid(pColumn->a[i].zName) && !withoutRowid ){
133983 pTabList->a, pColumn->a[i].zName);
134169 pTab->zName);
134896 char *zMsg = sqlite3MPrintf(db, "%s.%s", pTab->zName,
134966 char *zName = pCheck->a[i].zEName;
134967 assert( zName!=0 || pParse->db->mallocFailed );
134970 onError, zName, P4_TRANSIENT,
135284 VdbeNoopComment((v, "prep index %s", pIdx->zName));
135308 VdbeComment((v, "%s column %d", pIdx->zName, i));
135321 VdbeComment((v, "for %s", pIdx->zName));
135411 VdbeComment((v, "%s.%s", pTab->zName,
135779 sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
135793 VdbeComment((v, "%s", pIdx->zName));
136193 sqlite3TableLock(pParse, iDbDest, pDest->tnum, 1, pDest->zName);
136194 sqlite3TableLock(pParse, iDbSrc, pSrc->tnum, 0, pSrc->zName);
136204 VdbeComment((v, "%s", pSrcIdx->zName));
136208 VdbeComment((v, "%s", pDestIdx->zName));
136474 int (*bind_parameter_index)(sqlite3_stmt*,const char*zName);
138227 const char *const zName; /* Name of pragma */
138236 {/* zName: */ "activate_extensions",
138242 {/* zName: */ "analysis_limit",
138248 {/* zName: */ "application_id",
138255 {/* zName: */ "auto_vacuum",
138263 {/* zName: */ "automatic_index",
138270 {/* zName: */ "busy_timeout",
138276 {/* zName: */ "cache_size",
138283 {/* zName: */ "cache_spill",
138290 {/* zName: */ "case_sensitive_like",
138296 {/* zName: */ "cell_size_check",
138302 {/* zName: */ "checkpoint_fullfsync",
138309 {/* zName: */ "collation_list",
138316 {/* zName: */ "compile_options",
138323 {/* zName: */ "count_changes",
138330 {/* zName: */ "data_store_directory",
138337 {/* zName: */ "data_version",
138344 {/* zName: */ "database_list",
138351 {/* zName: */ "default_cache_size",
138359 {/* zName: */ "defer_foreign_keys",
138367 {/* zName: */ "empty_result_callbacks",
138374 {/* zName: */ "encoding",
138381 {/* zName: */ "foreign_key_check",
138388 {/* zName: */ "foreign_key_list",
138396 {/* zName: */ "foreign_keys",
138404 {/* zName: */ "freelist_count",
138411 {/* zName: */ "full_column_names",
138416 {/* zName: */ "fullfsync",
138424 {/* zName: */ "function_list",
138431 {/* zName: */ "hard_heap_limit",
138438 {/* zName: */ "ignore_check_constraints",
138446 {/* zName: */ "incremental_vacuum",
138453 {/* zName: */ "index_info",
138458 {/* zName: */ "index_list",
138463 {/* zName: */ "index_xinfo",
138470 {/* zName: */ "integrity_check",
138477 {/* zName: */ "journal_mode",
138482 {/* zName: */ "journal_size_limit",
138489 {/* zName: */ "legacy_alter_table",
138496 {/* zName: */ "lock_proxy_file",
138503 {/* zName: */ "lock_status",
138510 {/* zName: */ "locking_mode",
138515 {/* zName: */ "max_page_count",
138520 {/* zName: */ "mmap_size",
138529 {/* zName: */ "module_list",
138537 {/* zName: */ "optimize",
138543 {/* zName: */ "page_count",
138548 {/* zName: */ "page_size",
138556 {/* zName: */ "parser_trace",
138564 {/* zName: */ "pragma_list",
138571 {/* zName: */ "query_only",
138578 {/* zName: */ "quick_check",
138585 {/* zName: */ "read_uncommitted",
138590 {/* zName: */ "recursive_triggers",
138595 {/* zName: */ "reverse_unordered_selects",
138602 {/* zName: */ "schema_version",
138609 {/* zName: */ "secure_delete",
138616 {/* zName: */ "short_column_names",
138622 {/* zName: */ "shrink_memory",
138627 {/* zName: */ "soft_heap_limit",
138634 {/* zName: */ "sql_trace",
138642 {/* zName: */ "stats",
138649 {/* zName: */ "synchronous",
138656 {/* zName: */ "table_info",
138661 {/* zName: */ "table_list",
138666 {/* zName: */ "table_xinfo",
138673 {/* zName: */ "temp_store",
138678 {/* zName: */ "temp_store_directory",
138684 {/* zName: */ "threads",
138690 {/* zName: */ "trusted_schema",
138697 {/* zName: */ "user_version",
138705 {/* zName: */ "vdbe_addoptrace",
138710 {/* zName: */ "vdbe_debug",
138715 {/* zName: */ "vdbe_eqp",
138720 {/* zName: */ "vdbe_listing",
138725 {/* zName: */ "vdbe_trace",
138733 {/* zName: */ "wal_autocheckpoint",
138738 {/* zName: */ "wal_checkpoint",
138745 {/* zName: */ "writable_schema",
138929 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, pPragma->zName, SQLITE_STATIC);
138994 const char *zName;
138996 case OE_SetNull: zName = "SET NULL"; break;
138997 case OE_SetDflt: zName = "SET DEFAULT"; break;
138998 case OE_Cascade: zName = "CASCADE"; break;
138999 case OE_Restrict: zName = "RESTRICT"; break;
139000 default: zName = "NO ACTION";
139003 return zName;
139035 static const PragmaName *pragmaLocate(const char *zName){
139041 rc = sqlite3_stricmp(zName, aPragmaName[mid].zName);
139093 p->zName, isBuiltin,
140009 char *zSql = sqlite3MPrintf(db, "SELECT*FROM\"%w\"", pTab->zName);
140029 if( zRight && sqlite3_stricmp(zRight, pTab->zName)!=0 ) continue;
140041 sqlite3PreferredTableName(pTab->zName),
140061 sqlite3PreferredTableName(pTab->zName),
140068 pIdx->zName,
140137 pIdx->zName,
140166 sqlite3VdbeMultiLoad(v, 1, "is", i++, pColl->zName);
140198 sqlite3VdbeMultiLoad(v, 1, "s", pMod->zName);
140207 sqlite3VdbeMultiLoad(v, 1, "s", aPragmaName[i].zName);
140282 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
140285 sqlite3VdbeLoadString(v, regResult, pTab->zName);
140291 sqlite3TableLock(pParse, iDb, pParent->tnum, 0, pParent->zName);
140522 sqlite3VdbeLoadString(v, 4, pIdx->zName);
140601 pTab->zName);
140684 zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName,
140711 pTab->zName, pTab->aCol[j].zCnName);
140720 pTab->zName, pTab->aCol[j].zCnName);
140736 pTab->zName, pTab->aCol[j].zCnName);
140760 pTab->zName);
140785 jmp5 = sqlite3VdbeLoadString(v, 4, pIdx->zName);
140944 char *zName;
140963 returnSingleText(v, encnames[ENC(pParse->db)].zName);
140971 for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
140972 if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){
140979 if( !pEnc->zName ){
141253 if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7) ) continue;
141307 db->aDb[iDb].zDbSName, pTab->zName);
141534 sqlite3_str_appendf(&acc, "(\"%s\"", pPragma->zName);
141704 sqlite3_str_appendall(&acc, pTab->pName->zName);
141788 SQLITE_PRIVATE Module *sqlite3PragmaVtabRegister(sqlite3 *db, const char *zName){
141790 assert( sqlite3_strnicmp(zName, "pragma_", 7)==0 );
141791 pName = pragmaLocate(zName+7);
141794 assert( sqlite3HashFind(&db->aModule, zName)==0 );
141795 return sqlite3VtabCreateModule(db, zName, &pragmaVtabModule, (void*)pName, 0);
143412 char *zName; /* Name of column in the right table */
143415 zName = pRightTab->aCol[j].zCnName;
143416 if( tableAndColumnIndex(pSrc, 0, i, zName, 0, 0, 1) ){
143420 assert( pUsing->a[pUsing->nId-1].zName==0 );
143421 pUsing->a[pUsing->nId-1].zName = sqlite3DbStrDup(pParse->db, zName);
143445 char *zName; /* Name of the term in the USING clause */
143453 zName = pList->a[j].zName;
143454 iRightCol = sqlite3ColumnIndex(pRightTab, zName);
143456 || tableAndColumnIndex(pSrc, 0, i, zName, &iLeft, &iLeftCol,
143460 "not present in both tables", zName);
143468 ** contains the zName column, then this branch is a no-op.
143472 ** to zName is not also within a prior USING clause.
143475 ** non-USING references to zName on the left of an INNER or LEFT
143481 while( tableAndColumnIndex(pSrc, iLeft+1, i, zName, &iLeft, &iLeftCol,
143484 || sqlite3IdListIndex(pSrc->a[iLeft].u3.pUsing, zName)<0
143487 zName);
144879 zOrigTab = pTab->zName;
145032 char *zName = pEList->a[i].zEName;
145033 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_TRANSIENT);
145047 char *zName = 0;
145048 zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol);
145049 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_DYNAMIC);
145095 char *zName; /* Column name */
145096 int nName; /* Size of name in zName[] */
145119 if( (zName = pX->zEName)!=0 && pX->fg.eEName==ENAME_NAME ){
145135 zName = iCol>=0 ? pTab->aCol[iCol].zCnName : "rowid";
145138 zName = pColExpr->u.zToken;
145141 assert( zName==pX->zEName ); /* pointer comparison intended */
145144 if( zName && !sqlite3IsTrueOrFalse(zName) ){
145145 zName = sqlite3DbStrDup(db, zName);
145147 zName = sqlite3MPrintf(db,"column%d",i+1);
145154 while( zName && (pCollide = sqlite3HashFind(&ht, zName))!=0 ){
145158 nName = sqlite3Strlen30(zName);
145160 for(j=nName-1; j>0 && sqlite3Isdigit(zName[j]); j--){}
145161 if( zName[j]==':' ) nName = j;
145163 zName = sqlite3MPrintf(db, "%.*z:%u", nName, zName, ++cnt);
145169 pCol->zCnName = zName;
145170 pCol->hName = sqlite3StrIHash(zName);
145175 if( zName && sqlite3HashInsert(&ht, zName, pX)==pX ){
145286 sqlite3ColumnSetColl(db, pCol, pColl->zName);
145313 pTab->zName = 0;
145466 sqlite3ExprAddCollateString(pParse, pTerm, pColl->zName);
146809 (pColl ? pColl->zName : "BINARY")
147382 pParse->zAuthContext = pSubitem->zName;
147390 sqlite3DbFree(db, pSubitem->zName);
147393 pSubitem->zName = 0;
148394 pIdx && sqlite3StrICmp(pIdx->zName, zIndexedBy);
148495 sqlite3ErrorMsg(pParse, "'%s' is not a function", pFrom->zName);
148517 const char *zName = pItem->zName;
148520 assert( zName!=0 );
148524 if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){
148630 sqlite3ErrorMsg(pParse, pCte->zCteErr, pCte->zName);
148651 pTab->zName = sqlite3DbStrDup(db, pCte->zName);
148677 && pItem->zName!=0
148678 && 0==sqlite3StrICmp(pItem->zName, pCte->zName)
148685 "multiple references to recursive table: %s", pCte->zName
148728 pCte->zName, pEList->nExpr, pCte->pCols->nExpr
148790 pTab->zName = sqlite3DbStrDup(pParse->db, pFrom->zAlias);
148792 pTab->zName = sqlite3MPrintf(pParse->db, "%!S", pFrom);
148812 ** If any of those SrcItem objects have a USING clause containing zName
148816 ** contains a USING clause, or if none of the USING clauses contain zName,
148820 const char *zName, /* Name we are looking for */
148829 if( sqlite3IdListIndex(pBase->u3.pUsing, zName)>=0 ) return 1;
148909 if( pFrom->zName==0 ){
148931 pTab->zName);
148950 pTab->zName);
148961 pTab->zName);
149063 zTabName = pTab->zName;
149088 const char *zUName = pUsing->a[ii].zName;
149107 const char *zName;
149111 zName = sqlite3RowidAlias(pTab);
149112 if( zName==0 ) continue;
149114 zName = pTab->aCol[j].zCnName;
149145 assert( zName );
149150 && sqlite3IdListIndex(pFrom->u3.pUsing, zName)>=0
149157 pRight = sqlite3Expr(db, TK_ID, zName);
149161 || !inAnyUsingClause(zName,pFrom,pTabList->nSrc-i-1)
149193 zSchemaName, zTabName, zName);
149198 && sqlite3IdListIndex(pFrom->u3.pUsing, zName)>=0)
149199 || (pUsing && sqlite3IdListIndex(pUsing, zName)>=0)
149205 pX->zEName = sqlite3MPrintf(db, "%s.%s", zTabName, zName);
149208 pX->zEName = sqlite3DbStrDup(db, zName);
149382 ii, pCol->pTab ? pCol->pTab->zName : "NULL",
149582 pFunc->pFunc->zName));
149613 pFunc->pFunc->zName));
149868 pTab->zName,
149870 bCover ? pIdx->zName : ""
149969 if( pItem->zName==0 ) continue;
149973 if( sqlite3_stricmp(pItem->zName, pThis->zName)!=0 ) continue;
150283 p0->zAlias ? p0->zAlias : p0->pTab->zName
150388 pTab->nCol, pTab->zName, pSub->pEList->nExpr);
150559 if( pItem->colUsed==0 && pItem->zName!=0 ){
150560 sqlite3AuthCheck(pParse, SQLITE_READ, pItem->zName, "", pItem->zDatabase);
150618 pParse->zAuthContext = pItem->zName;
151329 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
151775 && 0==sqlite3StrICmp(pTrig->table, pTab->zName)
151786 pTrig->table = pTab->zName;
151796 printf("Triggers for %s:", pTab->zName);
151798 printf(" %s", pX->zName);
151829 char *zName = 0; /* Name of the trigger */
151905 zName = sqlite3NameFromToken(db, pName);
151906 if( zName==0 ){
151910 if( sqlite3CheckObjectName(pParse, zName, "trigger", pTab->zName) ){
151915 if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),zName) ){
151928 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
151954 if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
151975 pTrigger->zName = zName;
151976 zName = 0;
151977 pTrigger->table = sqlite3DbStrDup(db, pTableName->a[0].zName);
151983 sqlite3RenameTokenRemap(pParse, pTrigger->table, pTableName->a[0].zName);
151995 sqlite3DbFree(db, zName);
152033 char *zName; /* Name of trigger */
152041 zName = pTrig->zName;
152048 sqlite3TokenInit(&nameToken, pTrig->zName);
152082 pTrig->zName, pStep->zTarget);
152097 db->aDb[iDb].zDbSName, zName,
152102 sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName), 0);
152110 pTrig = sqlite3HashInsert(pHash, zName, pTrig);
152318 sqlite3DbFree(db, pTrigger->zName);
152337 const char *zName;
152347 zName = pName->a[0].zName;
152353 pTrigger = sqlite3HashFind(&(db->aDb[j].pSchema->trigHash), zName);
152399 if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) ||
152411 db->aDb[iDb].zDbSName, pTrigger->zName
152414 sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
152421 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){
152427 pTrigger = sqlite3HashInsert(pHash, zName, 0);
152575 char *zName = sqlite3DbStrDup(db, pStep->zTarget);
152578 assert( zName || pSrc==0 );
152581 pSrc->a[0].zName = zName;
152598 sqlite3DbFree(db, zName);
152768 sFrom.a[0].zName = pTab->zName; /* tag-20240424-1 */
152958 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
152983 sSubParse.zAuthContext = pTrigger->zName;
152991 pTrigger->zName, onErrorText(orconf),
152996 pTab->zName
152999 if( pTrigger->zName ){
153001 sqlite3MPrintf(db, "-- TRIGGER %s", pTrigger->zName), P4_DYNAMIC
153028 VdbeComment((v, "End: %s.%s", pTrigger->zName, onErrorText(orconf)));
153065 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
153107 int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers));
153112 (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf)));
153343 VdbeComment((v, "%s.%s", pTab->zName, pCol->zCnName));
153787 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
153902 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
154947 VdbeComment((v, "%s.%s", pIdx->zName,
155428 ** If there already exists a module with zName, replace it with the new one.
155429 ** If pModule==0, then delete the module zName if it exists.
155433 const char *zName, /* Name assigned to this module */
155442 zCopy = (char*)zName;
155445 int nName = sqlite3Strlen30(zName);
155452 memcpy(zCopy, zName, nName+1);
155453 pMod->zName = zCopy;
155481 const char *zName, /* Name assigned to this module */
155489 (void)sqlite3VtabCreateModule(db, zName, pModule, pAux, xDestroy);
155502 const char *zName, /* Name assigned to this module */
155507 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
155509 return createModule(db, zName, pModule, pAux, 0);
155517 const char *zName, /* Name assigned to this module */
155523 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
155525 return createModule(db, zName, pModule, pAux, xDestroy);
155542 for(ii=0; azNames[ii]!=0 && strcmp(azNames[ii],pMod->zName)!=0; ii++){}
155545 createModule(db, pMod->zName, 0, 0, 0);
155759 sqlite3ErrorMsg(pParse, "too many columns on %s", pTable->zName);
155798 addModuleArgument(pParse, pTable, sqlite3DbStrDup(db, pTable->zName));
155815 sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName,
155884 pTab->zName,
155885 pTab->zName,
155893 zWhere = sqlite3MPrintf(db, "name=%Q AND sql=%Q", pTab->zName, zStmt);
155898 sqlite3VdbeLoadString(v, iReg, pTab->zName);
155905 const char *zName = pTab->zName;
155906 assert( zName!=0 );
155908 pOld = sqlite3HashInsert(&pSchema->tblHash, zName, pTab);
155972 "vtable constructor called recursively: %s", pTab->zName
155978 zModuleName = sqlite3DbStrDup(db, pTab->zName);
156578 for(i=0; pDef->zName[i]; i++){
156579 unsigned char x = (unsigned char)pDef->zName[i];
156584 rc = pMod->xFindFunction(pVtab, nArg, pDef->zName, &xSFunc, &pArg);
156592 + sqlite3Strlen30(pDef->zName) + 1);
156597 pNew->zName = (const char*)&pNew[1];
156598 memcpy((char*)&pNew[1], pDef->zName, sqlite3Strlen30(pDef->zName)+1);
156655 pTab->zName = sqlite3DbStrDup(db, pMod->zName);
156656 if( pTab->zName==0 ){
156667 addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
156669 addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
157586 sqlite3_str_appendf(&str, zFmt, pIdx->zName);
157713 zObj = pLoop->u.btree.pIndex->zName;
157715 zObj = pSrclist->a[pLvl->iFrom].zName;
158244 VdbeComment((v, "begin skip-scan on %s", pIdx->zName));
158808 VdbeModuleComment((v, "Begin WHERE-loop%d: %s",iLevel,pTabItem->pTab->zName));
158867 VdbeComment((v, "next row of %s", pTabItem->pTab->zName));
160072 VdbeComment((v, "match against %s", pTab->zName));
160162 ExplainQueryPlan((pParse, 1, "RIGHT-JOIN %s", pTabItem->pTab->zName));
162090 pTab->zName, j);
162453 return pRet ? pRet->zName : sqlite3StrBINARY;
162522 zCollName = pColl ? pColl->zName : sqlite3StrBINARY;
162713 if( 0==sqlite3StrICmp(pColl->zName, zColl) ){
162883 sqlite3DebugPrintf("sqlite3_index_info inputs for %s:\n", pTab->zName);
162907 sqlite3DebugPrintf("sqlite3_index_info outputs for %s:\n", pTab->zName);
163019 sqlite3_str_appendf(pStr,"CREATE AUTOMATIC INDEX ON %s(", pTab->zName);
163023 const char *zName = 0;
163026 zName = pTab->aCol[iCol].zCnName;
163027 sqlite3_str_appendf(pStr, "%s%s", zSep, zName);
163121 "automatic index on %s(%s)", pTable->zName,
163166 pIdx->zName = "auto-index";
163185 pIdx->azColl[n] = pColl ? pColl->zName : sqlite3StrBINARY;
163228 VdbeComment((v, "for %s", pTable->zName));
163243 VdbeComment((v, "next row of %s", pSrc->pTab->zName));
164299 p->zName, nEq-1, (int)a[1]));
164440 pItem->zAlias ? pItem->zAlias : pTab->zName);
164446 const char *zName;
164447 if( p->u.btree.pIndex && (zName = p->u.btree.pIndex->zName)!=0 ){
164448 if( strncmp(zName, "sqlite_autoindex_", 17)==0 ){
164449 int i = sqlite3Strlen30(zName) - 1;
164450 while( zName[i]!='_' ) i--;
164451 zName += i;
164453 sqlite3DebugPrintf(".%-16s %2d", zName, p->u.btree.nEq);
165075 if( sqlite3StrICmp(pColl->zName, pIdx->azColl[i+nEq]) ) break;
165134 pProbe->pTable->zName,pProbe->zName,
165521 pProbe->pTable->zName, pProbe->zName, saved_nEq, rc));
166063 " according to whereIsCoveringIndex()\n", pProbe->zName));
166071 " according to whereIsCoveringIndex()\n", pProbe->zName));
166076 " according to whereIsCoveringIndex()\n", pProbe->zName));
166084 pProbe->zName, m==0 ? "is" : "is not"));
166296 sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
166364 sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
166424 zRet = (pC ? pC->zName : sqlite3StrBINARY);
166578 WHERETRACE(0x800, ("BEGIN %s.addVirtual()\n", pSrc->pTab->zName));
166662 WHERETRACE(0x800, ("END %s.addVirtual(), rc=%d\n", pSrc->pTab->zName, rc));
167015 if( pColl2==0 || sqlite3StrICmp(pColl1->zName, pColl2->zName) ){
167144 if( sqlite3StrICmp(pColl->zName, pIndex->azColl[j])!=0 ) continue;
167255 static char zName[65];
167257 for(i=0; i<nLoop; i++){ zName[i] = pPath->aLoop[i]->cId; }
167258 if( pLast ) zName[i++] = pLast->cId;
167259 zName[i] = 0;
167260 return zName;
168107 pLoop->cId, (double)sqlite3LogEstToInt(nSearch), pTab->zName,
168224 p->zIdxName = pIdx->zName;
168820 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
168875 VdbeComment((v, "%s", pIx->zName));
169141 VdbeComment((v, "next skip-scan on %s", pLoop->u.btree.pIndex->zName));
169187 pWInfo->pTabList->a[pLevel->iFrom].pTab->zName));
169891 ** comparison of the zName pointer. Example:
169893 ** if( pFuncDef->zName==row_valueName ){ ... }
169978 static Window *windowFind(Parse *pParse, Window *pList, const char *zName){
169981 if( sqlite3StrICmp(p->zName, zName)==0 ) break;
169984 sqlite3ErrorMsg(pParse, "no such window: %s", zName);
170012 if( pWin->zName && pWin->eFrmType==0 ){
170013 Window *p = windowFind(pParse, pList, pWin->zName);
170058 if( pFunc->zName==aUp[i].zFunc ){
170489 sqlite3DbFree(db, p->zName);
170789 if( pKeyInfo && pWin->pWFunc->zName[1]=='i' ){
170797 else if( p->zName==nth_valueName || p->zName==first_valueName ){
170805 else if( p->zName==leadName || p->zName==lagName ){
171024 if( i!=1 || pFunc->zName!=nth_valueName ){
171051 assert( pFunc->zName==nth_valueName
171052 || pFunc->zName==first_valueName
171276 if( pFunc->zName==nth_valueName
171277 || pFunc->zName==first_valueName
171284 if( pFunc->zName==nth_valueName ){
171299 else if( pFunc->zName==leadName || pFunc->zName==lagName ){
171313 int val = (pFunc->zName==leadName ? 1 : -1);
171316 int op = (pFunc->zName==leadName ? OP_Add : OP_Subtract);
171351 if( pFunc->zName==nth_valueName || pFunc->zName==first_valueName ){
171377 if( (pFunc->zName==nth_valueName)
171378 || (pFunc->zName==first_valueName)
171379 || (pFunc->zName==leadName)
171380 || (pFunc->zName==lagName)
171730 pNew->zName = sqlite3DbStrDup(db, p->zName);
176577 pNew->zName = pOld->zName;
176589 pOld->zName = pOld->zDatabase = 0;
176608 if( IN_RENAME_OBJECT && yylhsminor.yy203 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy203->a[0].zName, &yymsp[0].minor.yy0);
176615 if( IN_RENAME_OBJECT && yylhsminor.yy203 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy203->a[0].zName, &yymsp[0].minor.yy0);
177180 sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0);
177454 yymsp[-1].minor.yy211->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n);
177575 yymsp[-1].minor.yy211->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n);
178620 SQLITE_API int sqlite3_keyword_check(const char *zName, int nName){
178621 return TK_ID!=sqlite3KeywordCode((const u8*)zName, nName);
180845 assert( p==0 || p->xCmp!=binCollFunc || strcmp(p->zName,"BINARY")==0 );
181299 const char *zName = 0;
181301 for(i=0; i<2 && zName==0; i++, rc &= 0xff){
181303 case SQLITE_OK: zName = "SQLITE_OK"; break;
181304 case SQLITE_ERROR: zName = "SQLITE_ERROR"; break;
181305 case SQLITE_ERROR_SNAPSHOT: zName = "SQLITE_ERROR_SNAPSHOT"; break;
181306 case SQLITE_INTERNAL: zName = "SQLITE_INTERNAL"; break;
181307 case SQLITE_PERM: zName = "SQLITE_PERM"; break;
181308 case SQLITE_ABORT: zName = "SQLITE_ABORT"; break;
181309 case SQLITE_ABORT_ROLLBACK: zName = "SQLITE_ABORT_ROLLBACK"; break;
181310 case SQLITE_BUSY: zName = "SQLITE_BUSY"; break;
181311 case SQLITE_BUSY_RECOVERY: zName = "SQLITE_BUSY_RECOVERY"; break;
181312 case SQLITE_BUSY_SNAPSHOT: zName = "SQLITE_BUSY_SNAPSHOT"; break;
181313 case SQLITE_LOCKED: zName = "SQLITE_LOCKED"; break;
181314 case SQLITE_LOCKED_SHAREDCACHE: zName = "SQLITE_LOCKED_SHAREDCACHE";break;
181315 case SQLITE_NOMEM: zName = "SQLITE_NOMEM"; break;
181316 case SQLITE_READONLY: zName = "SQLITE_READONLY"; break;
181317 case SQLITE_READONLY_RECOVERY: zName = "SQLITE_READONLY_RECOVERY"; break;
181318 case SQLITE_READONLY_CANTINIT: zName = "SQLITE_READONLY_CANTINIT"; break;
181319 case SQLITE_READONLY_ROLLBACK: zName = "SQLITE_READONLY_ROLLBACK"; break;
181320 case SQLITE_READONLY_DBMOVED: zName = "SQLITE_READONLY_DBMOVED"; break;
181321 case SQLITE_READONLY_DIRECTORY: zName = "SQLITE_READONLY_DIRECTORY";break;
181322 case SQLITE_INTERRUPT: zName = "SQLITE_INTERRUPT"; break;
181323 case SQLITE_IOERR: zName = "SQLITE_IOERR"; break;
181324 case SQLITE_IOERR_READ: zName = "SQLITE_IOERR_READ"; break;
181325 case SQLITE_IOERR_SHORT_READ: zName = "SQLITE_IOERR_SHORT_READ"; break;
181326 case SQLITE_IOERR_WRITE: zName = "SQLITE_IOERR_WRITE"; break;
181327 case SQLITE_IOERR_FSYNC: zName = "SQLITE_IOERR_FSYNC"; break;
181328 case SQLITE_IOERR_DIR_FSYNC: zName = "SQLITE_IOERR_DIR_FSYNC"; break;
181329 case SQLITE_IOERR_TRUNCATE: zName = "SQLITE_IOERR_TRUNCATE"; break;
181330 case SQLITE_IOERR_FSTAT: zName = "SQLITE_IOERR_FSTAT"; break;
181331 case SQLITE_IOERR_UNLOCK: zName = "SQLITE_IOERR_UNLOCK"; break;
181332 case SQLITE_IOERR_RDLOCK: zName = "SQLITE_IOERR_RDLOCK"; break;
181333 case SQLITE_IOERR_DELETE: zName = "SQLITE_IOERR_DELETE"; break;
181334 case SQLITE_IOERR_NOMEM: zName = "SQLITE_IOERR_NOMEM"; break;
181335 case SQLITE_IOERR_ACCESS: zName = "SQLITE_IOERR_ACCESS"; break;
181337 zName = "SQLITE_IOERR_CHECKRESERVEDLOCK"; break;
181338 case SQLITE_IOERR_LOCK: zName = "SQLITE_IOERR_LOCK"; break;
181339 case SQLITE_IOERR_CLOSE: zName = "SQLITE_IOERR_CLOSE"; break;
181340 case SQLITE_IOERR_DIR_CLOSE: zName = "SQLITE_IOERR_DIR_CLOSE"; break;
181341 case SQLITE_IOERR_SHMOPEN: zName = "SQLITE_IOERR_SHMOPEN"; break;
181342 case SQLITE_IOERR_SHMSIZE: zName = "SQLITE_IOERR_SHMSIZE"; break;
181343 case SQLITE_IOERR_SHMLOCK: zName = "SQLITE_IOERR_SHMLOCK"; break;
181344 case SQLITE_IOERR_SHMMAP: zName = "SQLITE_IOERR_SHMMAP"; break;
181345 case SQLITE_IOERR_SEEK: zName = "SQLITE_IOERR_SEEK"; break;
181346 case SQLITE_IOERR_DELETE_NOENT: zName = "SQLITE_IOERR_DELETE_NOENT";break;
181347 case SQLITE_IOERR_MMAP: zName = "SQLITE_IOERR_MMAP"; break;
181348 case SQLITE_IOERR_GETTEMPPATH: zName = "SQLITE_IOERR_GETTEMPPATH"; break;
181349 case SQLITE_IOERR_CONVPATH: zName = "SQLITE_IOERR_CONVPATH"; break;
181350 case SQLITE_CORRUPT: zName = "SQLITE_CORRUPT"; break;
181351 case SQLITE_CORRUPT_VTAB: zName = "SQLITE_CORRUPT_VTAB"; break;
181352 case SQLITE_NOTFOUND: zName = "SQLITE_NOTFOUND"; break;
181353 case SQLITE_FULL: zName = "SQLITE_FULL"; break;
181354 case SQLITE_CANTOPEN: zName = "SQLITE_CANTOPEN"; break;
181355 case SQLITE_CANTOPEN_NOTEMPDIR: zName = "SQLITE_CANTOPEN_NOTEMPDIR";break;
181356 case SQLITE_CANTOPEN_ISDIR: zName = "SQLITE_CANTOPEN_ISDIR"; break;
181357 case SQLITE_CANTOPEN_FULLPATH: zName = "SQLITE_CANTOPEN_FULLPATH"; break;
181358 case SQLITE_CANTOPEN_CONVPATH: zName = "SQLITE_CANTOPEN_CONVPATH"; break;
181359 case SQLITE_CANTOPEN_SYMLINK: zName = "SQLITE_CANTOPEN_SYMLINK"; break;
181360 case SQLITE_PROTOCOL: zName = "SQLITE_PROTOCOL"; break;
181361 case SQLITE_EMPTY: zName = "SQLITE_EMPTY"; break;
181362 case SQLITE_SCHEMA: zName = "SQLITE_SCHEMA"; break;
181363 case SQLITE_TOOBIG: zName = "SQLITE_TOOBIG"; break;
181364 case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT"; break;
181365 case SQLITE_CONSTRAINT_UNIQUE: zName = "SQLITE_CONSTRAINT_UNIQUE"; break;
181366 case SQLITE_CONSTRAINT_TRIGGER: zName = "SQLITE_CONSTRAINT_TRIGGER";break;
181368 zName = "SQLITE_CONSTRAINT_FOREIGNKEY"; break;
181369 case SQLITE_CONSTRAINT_CHECK: zName = "SQLITE_CONSTRAINT_CHECK"; break;
181371 zName = "SQLITE_CONSTRAINT_PRIMARYKEY"; break;
181372 case SQLITE_CONSTRAINT_NOTNULL: zName = "SQLITE_CONSTRAINT_NOTNULL";break;
181374 zName = "SQLITE_CONSTRAINT_COMMITHOOK"; break;
181375 case SQLITE_CONSTRAINT_VTAB: zName = "SQLITE_CONSTRAINT_VTAB"; break;
181377 zName = "SQLITE_CONSTRAINT_FUNCTION"; break;
181378 case SQLITE_CONSTRAINT_ROWID: zName = "SQLITE_CONSTRAINT_ROWID"; break;
181379 case SQLITE_MISMATCH: zName = "SQLITE_MISMATCH"; break;
181380 case SQLITE_MISUSE: zName = "SQLITE_MISUSE"; break;
181381 case SQLITE_NOLFS: zName = "SQLITE_NOLFS"; break;
181382 case SQLITE_AUTH: zName = "SQLITE_AUTH"; break;
181383 case SQLITE_FORMAT: zName = "SQLITE_FORMAT"; break;
181384 case SQLITE_RANGE: zName = "SQLITE_RANGE"; break;
181385 case SQLITE_NOTADB: zName = "SQLITE_NOTADB"; break;
181386 case SQLITE_ROW: zName = "SQLITE_ROW"; break;
181387 case SQLITE_NOTICE: zName = "SQLITE_NOTICE"; break;
181388 case SQLITE_NOTICE_RECOVER_WAL: zName = "SQLITE_NOTICE_RECOVER_WAL";break;
181390 zName = "SQLITE_NOTICE_RECOVER_ROLLBACK"; break;
181391 case SQLITE_NOTICE_RBU: zName = "SQLITE_NOTICE_RBU"; break;
181392 case SQLITE_WARNING: zName = "SQLITE_WARNING"; break;
181393 case SQLITE_WARNING_AUTOINDEX: zName = "SQLITE_WARNING_AUTOINDEX"; break;
181394 case SQLITE_DONE: zName = "SQLITE_DONE"; break;
181397 if( zName==0 ){
181400 zName = zBuf;
181402 return zName;
181923 const char *zName = (const char*)sqlite3_user_data(context);
181927 "unable to use function %s in the requested context", zName);
181946 const char *zName,
181953 if( !sqlite3SafetyCheckOk(db) || zName==0 || nArg<-2 ){
181958 rc = sqlite3FindFunction(db, zName, nArg, SQLITE_UTF8, 0)!=0;
181961 zCopy = sqlite3_mprintf("%s", zName);
181963 return sqlite3_create_function_v2(db, zName, nArg, SQLITE_UTF8,
182538 ** Create a new collating function for database "db". The name is zName
182543 const char *zName,
182572 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0);
182588 CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName);
182602 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 1);
183249 if( sqlite3_stricmp(db->pVfs->zName, "kvvfs")==0 ){
183426 const char *zName,
183431 return sqlite3_create_collation_v2(db, zName, enc, pCtx, xCompare, 0);
183439 const char *zName,
183448 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
183452 rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel);
183464 const void *zName,
183473 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
183477 zName8 = sqlite3Utf16to8(db, zName, -1, SQLITE_UTF16NATIVE);
183533 SQLITE_API void *sqlite3_get_clientdata(sqlite3 *db, const char *zName){
183537 if( strcmp(p->zName, zName)==0 ){
183552 const char *zName, /* Name of the client data */
183559 for(p=db->pDbData; p && strcmp(p->zName,zName); p=p->pNext){
183575 size_t n = strlen(zName);
183582 memcpy(p->zName, zName, n+1);
184465 static const char *databaseName(const char *zName){
184466 while( zName[-1]!=0 || zName[-2]!=0 || zName[-3]!=0 || zName[-4]!=0 ){
184467 zName--;
184469 return zName;
186018 const char *zName; /* virtual table name */
186759 zDb, p->zName,
186760 zDb, p->zName,
186761 zDb, p->zName,
186762 zDb, p->zName,
186763 (p->zContentTbl ? "--" : ""), zDb,p->zName
186804 zCols, p->zName, zLanguageid
186825 p->zDb, p->zName
186862 p->zDb, p->zName, zContentCols
186870 p->zDb, p->zName
186882 p->zDb, p->zName
186887 p->zDb, p->zName
187069 (p->zContentTbl ? p->zContentTbl : p->zName),
187565 nName + /* zName */
187600 /* Fill in the zName and zDb fields of the vtab structure. */
187602 p->zName = zCsr;
189724 char *zTbl = sqlite3_mprintf("%s_stat", p->zName);
189987 const char *zName, /* Name of SQL function */
189992 const char *zName;
190007 if( strcmp(zName, aOverload[i].zName)==0 ){
190022 const char *zName /* New name of table */
190048 p->zDb, p->zName, zName
190055 p->zDb, p->zName, zName
190061 p->zDb, p->zName, zName
190066 p->zDb, p->zName, zName
190070 p->zDb, p->zName, zName
190092 pTab->zDb, pTab->zName, pTab->zName
190141 ** Return true if zName is the extension on one of the shadow tables used
190144 static int fts3ShadowName(const char *zName){
190150 if( sqlite3_stricmp(zName, azName[i])==0 ) return 1;
192449 p->pFts3Tab->zName = &p->pFts3Tab->zDb[nDb+1];
192454 memcpy((char *)p->pFts3Tab->zName, zFts3, nFts3);
192455 sqlite3Fts3Dequote((char *)p->pFts3Tab->zName);
195320 const unsigned char *zName;
195327 zName = sqlite3_value_text(argv[0]);
195334 if( zName==0 || n!=sizeof(pPtr) ){
195339 pOld = sqlite3Fts3HashInsert(pHash, (void *)zName, nName, pPtr);
195348 if( zName ){
195349 pPtr = sqlite3Fts3HashFind(pHash, zName, nName);
195352 char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
195522 const char *zName;
195544 zName = (const char *)sqlite3_value_text(argv[0]);
195549 p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
195552 char *zErr2 = sqlite3_mprintf("unknown tokenizer: %s", zName);
195604 char *zName,
195616 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
195627 char *zName,
195640 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
195723 ** The third argument to this function, zName, is used as the name
195729 const char *zName
195739 zTest = sqlite3_mprintf("%s_test", zName);
195740 zTest2 = sqlite3_mprintf("%s_internal_test", zName);
195747 rc = sqlite3_create_function(db, zName, 1, any, p, fts3TokenizerFunc, 0, 0);
195750 rc = sqlite3_create_function(db, zName, 2, any, p, fts3TokenizerFunc, 0, 0);
196084 ** Query FTS for the tokenizer implementation named zName.
196088 const char *zName,
196093 int nName = (int)strlen(zName);
196095 p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
196097 sqlite3Fts3ErrMsg(pzErr, "unknown tokenizer: %s", zName);
196875 zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName, p->zWriteExprlist);
196880 zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName);
197684 p->zSegmentsTbl = sqlite3_mprintf("%s_segments", p->zName);
210298 const char *zName;
210306 rc = sqlite3_create_module(db, aMod[i].zName, aMod[i].pModule, 0);
210481 char *zName; /* Name of r-tree table */
211372 pRtree->zDb, pRtree->zName,
211373 pRtree->zDb, pRtree->zName,
211374 pRtree->zDb, pRtree->zName
213363 zSql = sqlite3_mprintf("SELECT * FROM %Q.%Q", pRtree->zDb, pRtree->zName);
213375 "UNIQUE constraint failed: %s.%s", pRtree->zName, zCol
213381 "rtree constraint failed: %s.(%s<=%s)", pRtree->zName, zCol1, zCol2
213573 , pRtree->zDb, pRtree->zName, zNewName
213574 , pRtree->zDb, pRtree->zName, zNewName
213575 , pRtree->zDb, pRtree->zName, zNewName
213628 zSql = sqlite3_mprintf(zFmt, pRtree->zDb, pRtree->zName);
213645 ** Return true if zName is the extension on one of the shadow tables used
213648 static int rtreeShadowName(const char *zName){
213654 if( sqlite3_stricmp(zName, azName[i])==0 ) return 1;
213876 pRtree->zDb, pRtree->zName
213885 pRtree->zName);
213957 pRtree->zName = &pRtree->zDb[nDb+1];
213958 pRtree->zNodeName = &pRtree->zName[nName+1];
213961 memcpy(pRtree->zName, argv[2], nName);
214516 const char *zName, /* Name of the virtual table */
214524 UNUSED_PARAMETER(zName);
214526 rc = rtreeCheckTable(pRtree->db, pRtree->zDb, pRtree->zName, pzErr);
214529 pRtree->zDb, pRtree->zName, *pzErr);
215869 pRtree->zName = &pRtree->zDb[nDb+1];
215870 pRtree->zNodeName = &pRtree->zName[nName+1];
215875 memcpy(pRtree->zName, argv[2], nName);
216343 const char *zName,
216349 if( sqlite3_stricmp(zName, "geopoly_overlap")==0 ){
216354 if( sqlite3_stricmp(zName, "geopoly_within")==0 ){
216397 const char *zName;
216415 const char *zName;
216427 rc = sqlite3_create_function(db, aFunc[i].zName, aFunc[i].nArg,
216432 rc = sqlite3_create_function(db, aAgg[i].zName, 1,
216684 const char *zName, /* Name of ICU function that failed */
216688 sqlite3_snprintf(128, zBuf, "ICU error: %s(): %s", zName, u_errorName(e));
217095 const char *zName; /* SQL Collation sequence name (eg. "japanese") */
217102 zName = (const char *)sqlite3_value_text(apArg[1]);
217104 if( !zLocale || !zName ){
217117 const char *zName;
217129 if( sqlite3_stricmp(zOption,aStrength[i].zName)==0 ){
217140 sqlite3_str_appendf(pStr, " %s", aStrength[i].zName);
217147 rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator,
217162 const char *zName; /* Function name */
217190 db, p->zName, p->nArg, p->enc,
218148 ** Create an RBU VFS named zName that accesses the underlying file-system
218189 SQLITE_API int sqlite3rbu_create_vfs(const char *zName, const char *zParent);
218199 SQLITE_API void sqlite3rbu_destroy_vfs(const char *zName);
219480 const char *zName = (const char*)sqlite3_column_name(pStmt, i);
219481 if( sqlite3_strnicmp("rbu_", zName, 4) ){
219482 char *zCopy = rbuStrndup(zName, &p->rc);
219486 else if( 0==sqlite3_stricmp("rbu_rowid", zName) ){
219513 const char *zName = (const char*)sqlite3_column_text(pStmt, 1);
219514 if( zName==0 ) break; /* An OOM - finalize() below returns S_NOMEM */
219516 if( 0==strcmp(zName, pIter->azTblCol[i]) ) break;
219521 pIter->zDataTbl, zName
220775 const char *zName,
220781 p->rc = sqlite3_open_v2(zName, &db, flags, bUseVfs ? p->zVfsName : 0);
221461 ** Assert that column iCol of statement pStmt is named zName.
221463 static void assertColumnName(sqlite3_stmt *pStmt, int iCol, const char *zName){
221465 assert( 0==sqlite3_stricmp(zName, zCol) );
221994 p->zVfsName = pVfs->zName;
223014 char *zOut = sqlite3_mprintf("rbu(%s)/%z", pRbuVfs->base.zName, zIn);
223166 const char *zName,
223214 const char *zOpen = zName;
223221 if( zName ){
223228 pFd->zWal = sqlite3_filename_wal(zName);
223231 rbu_file *pDb = rbuFindMaindb(pRbuVfs, zName, 0);
223252 && sqlite3_uri_boolean(zName, "rbu_memory", 0)
223430 SQLITE_API void sqlite3rbu_destroy_vfs(const char *zName){
223431 sqlite3_vfs *pVfs = sqlite3_vfs_find(zName);
223440 ** Create an RBU VFS named zName that accesses the underlying file-system
223444 SQLITE_API int sqlite3rbu_create_vfs(const char *zName, const char *zParent){
223452 0, /* zName */
223481 nName = strlen(zName);
223498 pNew->base.zName = (const char*)(zSpace = (char*)&pNew[1]);
223499 memcpy(zSpace, zName, nName);
223669 char *zName; /* Value of 'name' column */
224169 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
224221 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
224284 const char *zName = 0; /* Only provide analysis of this table */
224305 zName = (const char*)sqlite3_value_text(argv[iArg++]);
224321 if( zName ){
224322 sqlite3_str_appendf(pSql, "WHERE name=%Q", zName);
224350 sqlite3_result_text(ctx, pCsr->zName, -1, SQLITE_TRANSIENT);
225022 char *zName; /* Local name of table */
225023 int nCol; /* Number of columns in table zName */
226019 const unsigned char *zName = sqlite3_column_text(pStmt, 1);
226022 if( zName==0 ) break;
226023 memcpy(pAlloc, zName, nName+1);
226078 pTab->zName, &pTab->nCol, 0, &pTab->azCol, &pTab->azDflt, &abPK,
226089 if( 0==sqlite3_stricmp("sqlite_stat1", pTab->zName) ){
226095 1 + sessionVarintLen(pTab->nCol) + pTab->nCol + strlen(pTab->zName)+1
226121 pTab->zName, &nCol, 0, &azCol, &azDflt, &abPK,
226730 const char *zName,
226734 int nName = sqlite3Strlen30(zName);
226739 if( 0==sqlite3_strnicmp(pRet->zName, zName, nName+1) ) break;
226746 || pSession->xTableFilter(pSession->pFilterCtx, zName)
226748 rc = sqlite3session_attach(pSession, zName);
226755 assert( 0==sqlite3_strnicmp(pRet->zName, zName, nName+1) );
226773 char const *zName, /* Table name */
226794 pSession->rc = sessionFindTable(pSession, zName, &pTab);
226961 zDb1, zDb2, pTab->bRowid, pTab->zName, zExpr
227000 zRet, (zRet ? ", " : ""), zDb, pTab->zName, pTab->azCol[ii]
227016 pSession->zDb, zFrom, pTab->zName, pTab->azCol, pTab->abPK
227025 z1, z2, pSession->zDb, pTab->zName, zFrom, pTab->zName, zExpr, zExpr2
227118 zDb, zFrom, pTo->zName, pTo->azCol, pTo->abPK
227263 const char *zName /* Table name */
227268 if( !zName ){
227272 int nName; /* Number of bytes in string zName */
227276 nName = sqlite3Strlen30(zName);
227278 if( 0==sqlite3_strnicmp(pTab->zName, zName, nName+1) ) break;
227295 pTab->zName = (char *)&pTab[1];
227296 memcpy(pTab->zName, zName, nName+1);
227836 sessionAppendBlob(pBuf, (u8 *)pTab->zName, (int)strlen(pTab->zName)+1, pRc);
227882 const char *zName = pTab->zName;
227901 zName, pTab->bRowid, pTab->nCol, pTab->azCol, pTab->abPK, &pSel
230637 if( 0==sqlite3_strnicmp(pTab->zName, zTab, nTab+1) ) break;
230652 pTab->zName = (char*)&pTab->abPK[nCol];
230653 memcpy(pTab->zName, zTab, nTab+1);
231193 if( 0==sqlite3_stricmp(pTab->zName, zTab) ) break;
232013 const char *zName,
232022 const char *zName,
232030 const char *zName,
232234 char *zName; /* Name of FTS index */
232732 static int sqlite3Fts5StorageRename(Fts5Storage*, const char *zName);
235831 const char *zName;
235845 for(i=0; aEnum[i].zName; i++){
235846 if( sqlite3_strnicmp(aEnum[i].zName, zEnum, nEnum)==0 ){
236193 pRet->zName = sqlite3Fts5Strndup(&rc, azArg[2], -1);
236199 if( rc==SQLITE_OK && sqlite3_stricmp(pRet->zName, FTS5_RANK_NAME)==0 ){
236200 *pzErr = sqlite3_mprintf("reserved fts5 table name: %s", pRet->zName);
236293 &rc, "%Q.'%q_%s'", pRet->zDb, pRet->zName, zTail
236324 sqlite3_free(pConfig->zName);
236355 zSql, pConfig->zName, FTS5_RANK_NAME
236628 zSql = sqlite3Fts5Mprintf(&rc, zSelect, pConfig->zDb, pConfig->zName);
241438 pConfig->zDb, pConfig->zName
241462 pConfig->zDb, pConfig->zName
241491 pConfig->zDb, pConfig->zName
243145 pConfig->zDb, pConfig->zName
243246 pConfig->zDb, pConfig->zName
245129 pConfig->zDb, pConfig->zName
245571 p->pConfig->zDb, p->pConfig->zName
246953 p->zDataTbl = sqlite3Fts5Mprintf(&rc, "%s_data", pConfig->zName);
248539 pConfig->zDb, pConfig->zName, pSeg->iSegid
249702 char *zName; /* Name of tokenizer */
250625 pConfig->zDb, pConfig->zName, zRank, pConfig->zName,
250696 ** Search for an auxiliary function named zName that can be used with table
250700 static Fts5Auxiliary *fts5FindAuxiliary(Fts5FullTable *pTab, const char *zName){
250704 if( sqlite3_stricmp(zName, pAux->zFunc)==0 ) return pAux;
250986 "%s: table does not support scanning", pConfig->zName
251331 (nArg>1 ? "UPDATE" : "DELETE from"), pConfig->zName
252234 "columns on fts5 contentless-delete table: %s", pConfig->zName
252250 const char *zName, /* Name of SQL function */
252258 pAux = fts5FindAuxiliary(pTab, zName);
252274 const char *zName /* New name of table */
252278 rc = sqlite3Fts5StorageRename(pTab->pStorage, zName);
252344 const char *zName, /* Name of new function */
252350 int rc = sqlite3_overload_function(pGlobal->db, zName, -1);
252353 sqlite3_int64 nName; /* Size of zName in bytes, including \0 */
252356 nName = strlen(zName) + 1;
252362 memcpy(pAux->zFunc, zName, nName);
252383 const char *zName, /* Name of new function */
252390 sqlite3_int64 nName; /* Size of zName and its \0 terminator */
252394 nName = strlen(zName) + 1;
252399 pNew->zName = (char*)&pNew[1];
252400 memcpy(pNew->zName, zName, nName);
252418 const char *zName
252422 if( zName==0 ){
252426 if( sqlite3_stricmp(zName, pMod->zName)==0 ) break;
252439 const char *zName, /* Name of new function */
252446 pMod = fts5LocateTokenizer((Fts5Global*)pApi, zName);
252544 ** Return true if zName is the extension on one of the shadow tables used
252547 static int fts5ShadowName(const char *zName){
252553 if( sqlite3_stricmp(zName, azName[i])==0 ) return 1;
252837 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName, zBind);
252844 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName,
252852 pC->zDb, pC->zName
252857 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName);
252915 pConfig->zDb, pConfig->zName,
252916 pConfig->zDb, pConfig->zName,
252917 pConfig->zDb, pConfig->zName
252922 pConfig->zDb, pConfig->zName
252928 pConfig->zDb, pConfig->zName
252938 const char *zName /* New name of FTS5 table */
252943 pConfig->zDb, pConfig->zName, zTail, zName, zTail
252948 static int sqlite3Fts5StorageRename(Fts5Storage *pStorage, const char *zName){
252952 fts5StorageRenameOne(pConfig, &rc, "data", zName);
252953 fts5StorageRenameOne(pConfig, &rc, "idx", zName);
252954 fts5StorageRenameOne(pConfig, &rc, "config", zName);
252956 fts5StorageRenameOne(pConfig, &rc, "docsize", zName);
252959 fts5StorageRenameOne(pConfig, &rc, "content", zName);
252979 pConfig->zDb, pConfig->zName, zPost, zDefn,
252988 pConfig->zName, zPost, zErr
253352 pConfig->zDb, pConfig->zName,
253353 pConfig->zDb, pConfig->zName
253358 pConfig->zDb, pConfig->zName
253554 pConfig->zDb, pConfig->zName, zSuffix
255381 const char *zName;
255395 aBuiltin[i].zName,