Lines Matching refs:zName
1813 const char *zName; /* Name of this virtual file system */ member
1815 int (*xOpen)(sqlite3_vfs*, sqlite3_filename zName, sqlite3_file*,
1817 int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);
1818 int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut);
1819 int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);
1837 int (*xSetSystemCall)(sqlite3_vfs*, const char *zName, sqlite3_syscall_ptr);
1838 sqlite3_syscall_ptr (*xGetSystemCall)(sqlite3_vfs*, const char *zName);
1839 const char *(*xNextSystemCall)(sqlite3_vfs*, const char *zName);
5296 SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
6871 const char *zName,
6878 const char *zName,
6886 const void *zName,
7863 int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName,
8118 const char *zName, /* Name of the module */
8124 const char *zName, /* Name of the module */
11008 char const *zName, /* Table name */
14040 const char *zName,
14049 const char *zName,
14057 const char *zName,
14068 const char *zName,
14077 const char *zName,
18347 const char *zName; /* SQL name of the function. */ member
18500 #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \ argument
18503 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
18504 #define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \ argument
18506 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
18507 #define SFUNCTION(zName, nArg, iArg, bNC, xFunc) \ argument
18509 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
18510 #define MFUNCTION(zName, nArg, xPtr, xFunc) \ argument
18512 xPtr, 0, xFunc, 0, 0, 0, #zName, {0} }
18513 #define JFUNCTION(zName, nArg, bUseCache, bWS, bRS, bJsonB, iArg, xFunc) \ argument
18517 SQLITE_INT_TO_PTR(iArg|((bJsonB)*JSON_BLOB)),0,xFunc,0, 0, 0, #zName, {0} }
18518 #define INLINE_FUNC(zName, nArg, iArg, mFlags) \ argument
18521 SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }
18522 #define TEST_FUNC(zName, nArg, iArg, mFlags) \ argument
18526 SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }
18527 #define DFUNCTION(zName, nArg, iArg, bNC, xFunc) \ argument
18529 0, 0, xFunc, 0, 0, 0, #zName, {0} }
18530 #define PURE_DATE(zName, nArg, iArg, bNC, xFunc) \ argument
18533 (void*)&sqlite3Config, 0, xFunc, 0, 0, 0, #zName, {0} }
18534 #define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \ argument
18537 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
18538 #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \ argument
18541 pArg, 0, xFunc, 0, 0, 0, #zName, }
18542 #define LIKEFUNC(zName, nArg, arg, flags) \ argument
18544 (void *)arg, 0, likeFunc, 0, 0, 0, #zName, {0} }
18545 #define WAGGREGATE(zName, nArg, arg, nc, xStep, xFinal, xValue, xInverse, f) \ argument
18547 SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,xValue,xInverse,#zName, {0}}
18548 #define INTERNAL_FUNCTION(zName, nArg, xFunc) \ argument
18551 0, 0, xFunc, 0, 0, 0, #zName, {0} }
18561 char *zName; /* Savepoint name (nul-terminated) */ member
18583 const char *zName; /* Name passed to create_module() */ member
18673 char *zName; /* Name of the collating sequence, UTF-8 encoded */ member
18796 char *zName; /* Name of the table or view */ member
19146 char *zName; /* Name of this index */ member
19647 char *zName; /* Name of the identifier */ member
19710 char *zName; /* Name of the table */ member
20467 char *zName; /* The name of the trigger */ member
20562 char zName[40]; /* Name of trigger: "sqlite_returning_%p" */ member
20826 char *zName; /* Name of this CTE */ member
20884 char zName[FLEXARRAY]; /* Name of this client data. MUST BE LAST */ member
20889 #define SZ_DBCLIENTDATA(N) (offsetof(DbClientData,zName)+(N))
20926 char *zName; /* Name of window (may be NULL) */ member
21316 SQLITE_PRIVATE Module *sqlite3PragmaVtabRegister(sqlite3*,const char *zName);
21646 SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName);
21737 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char*zName);
21970 SQLITE_PRIVATE int sqlite3ShadowTableName(sqlite3 *db, const char *zName);
24016 char *zName; /* Name of table or index */ member
25380 char zName[7]; /* Name of the transformation */ member
25759 && sqlite3_strnicmp(aXformType[i].zName, z, n)==0 in parseModifier()
25764 assert( strcmp(aXformType[4].zName,"month")==0 ); in parseModifier()
25777 assert( strcmp(aXformType[5].zName,"year")==0 ); in parseModifier()
26913 if( strcmp(zVfs, pVfs->zName)==0 ) break; in sqlite3_vfs_find()
32544 }else if( pItem->zName ){ in sqlite3_str_vappendf()
32552 sqlite3_str_appendall(pAccum, pItem->zName); in sqlite3_str_vappendf()
33308 sqlite3_str_appendf(&x, "%s", pCte->zName); in sqlite3TreeViewWith()
33351 pItem->pSTab->zName, pItem->pSTab->nCol, pItem->pSTab, in sqlite3TreeViewSrcList()
33580 if( pWin->zName ){ in sqlite3TreeViewWindow()
33581 sqlite3TreeViewLine(pView, "OVER %s (%p)", pWin->zName, pWin); in sqlite3TreeViewWindow()
33641 pWin->pWFunc->zName, pWin->pWFunc->nArg); in sqlite3TreeViewWinFunc()
34063 char *zName = pList->a[i].zEName; in sqlite3TreeViewBareExprList() local
34065 if( j || zName || sortFlags ){ in sqlite3TreeViewBareExprList()
34069 if( zName ){ in sqlite3TreeViewBareExprList()
34072 fprintf(stdout, "AS %s ", zName); in sqlite3TreeViewBareExprList()
34075 fprintf(stdout, "TABLE-ALIAS-NAME(\"%s\") ", zName); in sqlite3TreeViewBareExprList()
34081 fprintf(stdout, "SPAN(\"%s\") ", zName); in sqlite3TreeViewBareExprList()
34097 if( j || zName || sortFlags ){ in sqlite3TreeViewBareExprList()
34129 char *zName = pList->a[i].zName; in sqlite3TreeViewBareIdList() local
34131 if( zName==0 ) zName = "(null)"; in sqlite3TreeViewBareIdList()
34134 fprintf(stdout, "%s\n", zName); in sqlite3TreeViewBareIdList()
34425 sqlite3TreeViewLine(pView, "TRIGGER %s", pTrigger->zName); in sqlite3TreeViewTrigger()
37312 const char *zName, /* Name of symbol to add */ in sqlite3VListAdd() argument
37337 memcpy(z, zName, nName); in sqlite3VListAdd()
37363 SQLITE_PRIVATE int sqlite3VListNameToNum(VList *pIn, const char *zName, int nName){ in sqlite3VListNameToNum() argument
37370 if( strncmp(z,zName,nName)==0 && z[nName]==0 ) return pIn[i]; in sqlite3VListNameToNum()
37946 static int kvvfsDelete(sqlite3_vfs*, const char *zName, int syncDir);
37947 static int kvvfsAccess(sqlite3_vfs*, const char *zName, int flags, int *);
37948 static int kvvfsFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
38674 const char *zName, in kvvfsOpen() argument
38680 if( zName==0 ) zName = ""; in kvvfsOpen()
38681 SQLITE_KV_LOG(("xOpen(\"%s\")\n", zName)); in kvvfsOpen()
38682 if( strcmp(zName, "local")==0 in kvvfsOpen()
38683 || strcmp(zName, "session")==0 in kvvfsOpen()
38688 if( strcmp(zName, "local-journal")==0 in kvvfsOpen()
38689 || strcmp(zName, "session-journal")==0 in kvvfsOpen()
38696 if( zName[0]=='s' ){ in kvvfsOpen()
39267 const char *zName; /* Name of the system call */ member
39462 const char *zName, /* Name of system call to override */ in unixSetSystemCall() argument
39469 if( zName==0 ){ in unixSetSystemCall()
39484 if( strcmp(zName, aSyscall[i].zName)==0 ){ in unixSetSystemCall()
39505 const char *zName in unixGetSystemCall() argument
39511 if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent; in unixGetSystemCall()
39522 static const char *unixNextSystemCall(sqlite3_vfs *p, const char *zName){ in unixNextSystemCall() argument
39526 if( zName ){ in unixNextSystemCall()
39528 if( strcmp(zName, aSyscall[i].zName)==0 ) break; in unixNextSystemCall()
39532 if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName; in unixNextSystemCall()
42874 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName); in unixFileControl()
44671 if( strcmp(pVfs->zName,"unix-excl")==0 ){ in fillInUnixFile()
45132 const char *zName = zPath; in unixOpen() local
45148 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB ); in unixOpen()
45149 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL ); in unixOpen()
45150 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_SUPER_JOURNAL ); in unixOpen()
45151 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL ); in unixOpen()
45173 assert( zName==0 ); in unixOpen()
45178 pUnused = findReusableFd(zName, flags); in unixOpen()
45192 assert( (flags & SQLITE_OPEN_URI) || zName[strlen(zName)+1]==0 ); in unixOpen()
45194 }else if( !zName ){ in unixOpen()
45201 zName = zTmpname; in unixOpen()
45205 assert( zName[strlen(zName)+1]==0 ); in unixOpen()
45222 rc = findCreateFileMode(zName, flags, &openMode, &uid, &gid); in unixOpen()
45228 fd = robust_open(zName, openFlags, openMode); in unixOpen()
45229 OSTRACE(("OPENX %-3d %s 0%o\n", fd, zName, openFlags)); in unixOpen()
45232 if( isNewJrnl && errno==EACCES && osAccess(zName, F_OK) ){ in unixOpen()
45244 pReadonly = findReusableFd(zName, flags); in unixOpen()
45249 fd = robust_open(zName, openFlags, openMode); in unixOpen()
45254 int rc2 = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName); in unixOpen()
45288 zPath = zName; in unixOpen()
45290 zPath = sqlite3_mprintf("%s", zName); in unixOpen()
45296 osUnlink(zName); in unixOpen()
45469 const char *zName, /* Name to append to pPath. Not zero-terminated */ in appendOnePathElement() argument
45473 assert( zName!=0 ); in appendOnePathElement()
45474 if( zName[0]=='.' ){ in appendOnePathElement()
45476 if( zName[1]=='.' && nName==2 ){ in appendOnePathElement()
45489 memcpy(&pPath->zOut[pPath->nUsed], zName, nName); in appendOnePathElement()
46122 dummyVfs.zName = "dummy"; in proxyCreateUnixFile()
47081 0==strcmp(aVfs[i].zName,SQLITE_DEFAULT_UNIX_VFS)); in sqlite3_os_init()
47646 const char *zName; /* Name of the system call */ member
48407 const char *zName, /* Name of system call to override */ in winSetSystemCall() argument
48414 if( zName==0 ){ in winSetSystemCall()
48429 if( strcmp(zName, aSyscall[i].zName)==0 ){ in winSetSystemCall()
48450 const char *zName in winGetSystemCall() argument
48456 if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent; in winGetSystemCall()
48467 static const char *winNextSystemCall(sqlite3_vfs *p, const char *zName){ in winNextSystemCall() argument
48471 if( zName ){ in winNextSystemCall()
48473 if( strcmp(zName, aSyscall[i].zName)==0 ) break; in winNextSystemCall()
48477 if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName; in winNextSystemCall()
49504 LPWSTR zName; in winceCreateLock() local
49509 zName = winUtf8ToUnicode(zFilename); in winceCreateLock()
49510 if( zName==0 ){ in winceCreateLock()
49520 zTok = osCharLowerW(zName); in winceCreateLock()
49526 pFile->hMutex = osCreateMutexW(NULL, FALSE, zName); in winceCreateLock()
49529 sqlite3_free(zName); in winceCreateLock()
49541 osCharUpperW(zName); in winceCreateLock()
49544 zName); in winceCreateLock()
49553 sqlite3_free(zName); in winceCreateLock()
50987 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
52528 const char *zName, /* Name of the file (UTF-8) */
52545 const char *zUtf8Name = zName; /* Filename in UTF-8 encoding */
52590 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
52591 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
52592 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_SUPER_JOURNAL );
52593 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
52670 if( 0==sqlite3_uri_boolean(zName, "exclusive", 0) ){
52767 return winOpen(pVfs, zName, id,
52796 && (rc = winceCreateLock(zName, pFile))!=SQLITE_OK
52801 OSTRACE(("OPEN-CE-LOCK name=%s, rc=%s\n", zName, sqlite3ErrName(rc)));
52821 && sqlite3_uri_boolean(zName, "psow", SQLITE_POWERSAFE_OVERWRITE)
52826 pFile->zPath = zName;
53939 static int memdbAccess(sqlite3_vfs*, const char *zName, int flags, int *);
53940 static int memdbFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
54358 const char *zName,
54369 szName = sqlite3Strlen30(zName);
54370 if( szName>1 && (zName[0]=='/' || zName[0]=='\\') ){
54377 if( strcmp(memdb_g.apMemStore[i]->zFName,zName)==0 ){
54402 memcpy(p->zFName, zName, szName+1);
63131 SQLITE_API sqlite3_file *sqlite3_database_file_object(const char *zName){
63134 while( zName[-1]!=0 || zName[-2]!=0 || zName[-3]!=0 || zName[-4]!=0 ){
63135 zName--;
63137 p = zName - 4 - sizeof(Pager*);
66941 static char zName[15]; local
66942 sqlite3_snprintf(sizeof(zName), zName, "READ-LOCK[%d]",
66944 return zName;
87091 const char *zName /* Name of table or index being scanned */
87104 pNew->zName = sqlite3DbStrDup(p->db, zName);
87813 const char *zColl = pColl ? pColl->zName : "";
87833 sqlite3_str_appendf(&x, "%.18s-%s", pColl->zName,
87839 sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg);
87844 sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg);
87898 zP4 = pOp->p4.pTab->zName;
88786 const char *zName, /* Pointer to buffer containing name */
88794 assert( !zName || xDel!=SQLITE_DYNAMIC );
88799 rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, xDel);
88800 assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 );
89652 sqlite3DbFree(db, p->aScan[i].zName);
91307 pCtx->pFunc->zName, zContext);
91389 const char *zTbl = pTab->zName;
92008 pCtx->pFunc->zName);
93379 SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){
93380 if( p==0 || zName==0 ) return 0;
93381 return sqlite3VListNameToNum(p->pVList, zName, nName);
93383 SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
93384 return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName));
93926 if( pScan->zName ){
93964 *(const char**)pOut = pScan->zName;
97673 pTab->zName, aCol[i].zCnName);
98108 char *zName; /* Name of savepoint */
98117 zName = pOp->p4.z;
98136 nName = sqlite3Strlen30(zName);
98152 pNew->zName = (char *)&pNew[1];
98153 memcpy(pNew->zName, zName, nName+1);
98179 pSavepoint && sqlite3StrICmp(pSavepoint->zName, zName);
98185 sqlite3VdbeError(p, "no such savepoint: %s", zName);
100114 zDb, pTab->zName, x.nKey);
100279 db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, pTab->zName,
102622 rc = pModule->xIntegrity(pVtab, db->aDb[pOp->p1].zDbSName, pTab->zName,
103878 sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT);
106921 const char *zName; /* tables_used.name */
107019 pCur->zName = 0;
107044 if( pCur->zName ){
107045 pCur->zName = 0;
107099 pCur->zName = pTab->zName;
107104 if( pCur->zName==0 ){
107108 pCur->zName = pIdx->zName;
107186 sqlite3_result_text(ctx, pCur->zName, -1, SQLITE_STATIC);
107682 const char *zName, /* Name of the journal file */
107689 assert( zName || nSpill<0 || (flags & SQLITE_OPEN_EXCLUSIVE) );
107697 return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0);
107710 p->zJournal = zName;
108271 zLegacy = pTab->zName;
108382 assert( pTab!=0 && pTab->zName!=0 );
108459 }else if( sqlite3StrICmp(zTab, pTab->zName)!=0 ){
108562 || sqlite3StrICmp(zTab,pParse->pTriggerTab->zName)==0
109191 pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120;
109196 int auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0,pDef->zName,0);
109945 assert( pItem->zName!=0
109953 if( pItem->zName ) pParse->zAuthContext = pItem->zName;
110327 pSrc->a[0].zName = pTab->zName;
110679 return sqlite3StrICmp(pColl1->zName, pColl2->zName)==0;
112098 pRet->a[i].zName = sqlite3DbStrDup(db, p->a[i].zName);
112247 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
112287 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
112460 pList->a[pList->nExpr-1].zEName = pColumns->a[i].zName;
112461 pColumns->a[i].zName = 0;
113538 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
113549 "USING ROWID SEARCH ON TABLE %s FOR IN-OPERATOR",pTab->zName));
113612 if( pReq!=0 && sqlite3StrICmp(pReq->zName, pIdx->azColl[j])!=0 ){
113630 "USING INDEX %s FOR IN-OPERATOR",pIdx->zName));
113633 VdbeComment((v, "%s", pIdx->zName));
114641 VdbeComment((v, "%s.rowid", pTab->zName));
115121 VdbeComment((v,"%s.rowid",pTab->zName));
115124 pTab->zName, pTab->aCol[pCol->iColumn].zCnName));
117800 if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7)
117808 sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName);
117900 char *zName = 0; /* NULL-terminated version of pName */
117917 zName = sqlite3NameFromToken(db, pName);
117918 if( !zName ) goto exit_rename_table;
117923 if( sqlite3FindTable(db, zName, zDb)
117924 || sqlite3FindIndex(db, zName, zDb)
117925 || sqlite3IsShadowTableOf(db, pTab, zName)
117928 "there is already another table or index with this name: %s", zName);
117938 if( SQLITE_OK!=sqlite3CheckObjectName(pParse,zName,"table",zName) ){
117944 sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
117951 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
117979 zTabName = pTab->zName;
117989 , zDb, zDb, zTabName, zName, (iDb==1), zTabName
118006 zName, zName, zName,
118017 zDb, zName, pTab->zName);
118033 , zDb, zTabName, zName, zTabName, zDb, zName);
118044 sqlite3VdbeLoadString(v, i, zName);
118054 sqlite3DbFree(db, zName);
118104 zTab = &pNew->zName[16]; /* Skip the "sqlite_altertab_" prefix on the name */
118112 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
118303 pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
118304 if( !pNew->aCol || !pNew->zName ){
118349 zType, pTab->zName
118394 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
118428 zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1,
118429 pTab->zName
118436 zDb, pTab->zName, iCol, zNew, bQuote
118636 sqlite3RenameTokenRemap(pParse, 0, (const void*)pIdList->a[ii].zName);
118663 sqlite3RenameTokenRemap(pParse, 0, (void*)pSrc->a[i].zName);
118861 const char *zName = pEList->a[i].zEName;
118863 && ALWAYS(zName!=0)
118864 && 0==sqlite3_stricmp(zName, zOld)
118866 renameTokenFind(pParse, pCtx, (const void*)zName);
118886 const char *zName = pIdList->a[i].zName;
118887 if( 0==sqlite3_stricmp(zName, zOld) ){
118888 renameTokenFind(pParse, pCtx, (const void*)zName);
119343 int bFKOnly = sqlite3_stricmp(zTable, sParse.pNewTable->zName);
119473 renameTokenFind(pWalker->pParse, p, pItem->zName);
119578 if( sqlite3_stricmp(zOld, pTab->zName)==0 ){
119583 renameTokenFind(&sParse, &sCtx, pTab->zName);
119589 renameTokenFind(&sParse, &sCtx, sParse.pNewIndex->zName);
119617 if( 0==sqlite3_stricmp(pItem->zName, zOld) ){
119618 renameTokenFind(&sParse, &sCtx, pItem->zName);
119994 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, zCol) ){
120004 , zDb, iDb, iCol, pTab->zName
120274 const char *zName;
120306 const char *zTab = aTable[i].zName;
120349 VdbeComment((v, aTable[i].zName));
121061 VdbeComment((v,"%s.rowid",pIdx->zName));
121064 VdbeComment((v,"%s.expr(%d)",pIdx->zName, k));
121066 VdbeComment((v,"%s.%s", pIdx->zName, pIdx->pTable->aCol[i].zCnName));
121121 if( sqlite3_strlike("sqlite\\_%", pTab->zName, '\\')==0 ){
121130 if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,
121140 pStat1->zName = (char*)&pStat1[1];
121141 memcpy(pStat1->zName, "sqlite_stat1", 13);
121152 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
121157 sqlite3VdbeLoadString(v, regTabname, pTab->zName);
121170 zIdxName = pTab->zName;
121174 zIdxName = pIdx->zName;
121180 VdbeComment((v, "Analysis for %s.%s", pTab->zName, zIdxName));
121229 VdbeComment((v, "%s", pIdx->zName));
121463 VdbeComment((v, "%s", pTab->zName));
121537 openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");
121539 openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
121844 const char *zName,
121847 Index *pIdx = sqlite3FindIndex(db, zName, zDb);
121849 Table *pTab = sqlite3FindTable(db, zName, zDb);
122167 SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName){
122169 sqlite3StrICmp(db->aDb[iDb].zDbSName, zName)==0
122170 || (iDb==0 && sqlite3StrICmp("main", zName)==0)
122197 const char *zName;
122209 zName = (const char *)sqlite3_value_text(argv[1]);
122211 if( zName==0 ) zName = "";
122259 assert( zName );
122260 if( sqlite3DbIsNamed(db, i, zName) ){
122261 zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName);
122286 rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
122303 pNew->zDbSName = sqlite3DbStrDup(db, zName);
122404 const char *zName = (const char *)sqlite3_value_text(argv[0]);
122413 if( zName==0 ) zName = "";
122417 if( sqlite3DbIsNamed(db, i, zName) ) break;
122421 sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
122425 sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
122431 sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
122922 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
123057 const char *zName /* Name of the table to be locked */
123083 p->zLockName = zName;
123094 const char *zName /* Name of the table to be locked */
123098 lockTable(pParse, iDb, iTab, isWriteLock, zName);
123340 SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){
123359 p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName);
123360 if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){
123362 if( sqlite3StrICmp(zName+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0
123363 || sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0
123364 || sqlite3StrICmp(zName+7, &LEGACY_SCHEMA_TABLE[7])==0
123370 if( sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0 ){
123378 p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash, zName);
123381 p = sqlite3HashFind(&db->aDb[0].pSchema->tblHash, zName);
123386 p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName);
123389 if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){
123390 if( sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0 ){
123392 }else if( sqlite3StrICmp(zName+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0 ){
123414 const char *zName, /* Name of the table we are looking for */
123428 p = sqlite3FindTable(db, zName, zDbase);
123435 Module *pMod = (Module*)sqlite3HashFind(&db->aModule, zName);
123436 if( pMod==0 && sqlite3_strnicmp(zName, "pragma_", 7)==0 ){
123437 pMod = sqlite3PragmaVtabRegister(db, zName);
123454 sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
123456 sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
123487 return sqlite3LocateTable(pParse, flags, p->zName, zDb);
123494 SQLITE_PRIVATE const char *sqlite3PreferredTableName(const char *zName){
123495 if( sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){
123496 if( sqlite3StrICmp(zName+7, &LEGACY_SCHEMA_TABLE[7])==0 ){
123499 if( sqlite3StrICmp(zName+7, &LEGACY_TEMP_SCHEMA_TABLE[7])==0 ){
123503 return zName;
123518 SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){
123529 p = sqlite3HashFind(&pSchema->idxHash, zName);
123815 char *zName = pIndex->zName;
123817 &pIndex->pSchema->idxHash, zName, 0
123841 sqlite3DbFree(db, pTable->zName);
123894 char *zName;
123896 zName = sqlite3DbStrNDup(db, (const char*)pName->z, pName->n);
123897 sqlite3Dequote(zName);
123899 zName = 0;
123901 return zName;
123923 SQLITE_PRIVATE int sqlite3FindDbName(sqlite3 *db, const char *zName){
123925 if( zName ){
123928 if( 0==sqlite3_stricmp(pDb->zDbSName, zName) ) break;
123931 if( i==0 && 0==sqlite3_stricmp("main", zName) ) break;
123945 char *zName; /* Name we are searching for */
123946 zName = sqlite3NameFromToken(db, pName);
123947 i = sqlite3FindDbName(db, zName);
123948 sqlite3DbFree(db, zName);
124025 const char *zName, /* Name of the object to check */
124039 || sqlite3_stricmp(zName, db->init.azInit[1])
124046 if( (pParse->nested==0 && 0==sqlite3StrNICmp(zName, "sqlite_", 7))
124047 || (sqlite3ReadOnlyShadowTables(db) && sqlite3ShadowTableName(db, zName))
124050 zName);
124208 char *zName = 0; /* The name of the new table */
124217 zName = sqlite3DbStrDup(db, SCHEMA_TABLE(iDb));
124230 zName = sqlite3NameFromToken(db, pName);
124232 sqlite3RenameTokenMap(pParse, (void*)zName, pName);
124236 if( zName==0 ) return;
124237 if( sqlite3CheckObjectName(pParse, zName, isView?"view":"table", zName) ){
124256 zName, 0, zDb) ){
124274 pTable = sqlite3FindTable(db, zName, zDb);
124286 if( sqlite3FindIndex(db, zName, zDb)!=0 ){
124287 sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
124299 pTable->zName = zName;
124382 sqlite3DbFree(db, zName);
124407 sqlite3HashInsert(pHash, pRet->zName, 0);
124450 sqlite3_snprintf(sizeof(pRet->zName), pRet->zName,
124452 pRet->retTrig.zName = pRet->zName;
124463 assert( sqlite3HashFind(pHash, pRet->zName)==0
124465 if( sqlite3HashInsert(pHash, pRet->zName, &pRet->retTrig)
124493 sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
124832 "table \"%s\" has more than one primary key", pTab->zName);
125111 n += identLength(p->zName);
125130 identPut(zStmt, &k, p->zName);
125503 SQLITE_PRIVATE int sqlite3IsShadowTableOf(sqlite3 *db, Table *pTab, const char *zName){
125508 nName = sqlite3Strlen30(pTab->zName);
125509 if( sqlite3_strnicmp(zName, pTab->zName, nName)!=0 ) return 0;
125510 if( zName[nName]!='_' ) return 0;
125515 return pMod->pModule->xShadowName(zName+nName+1);
125537 assert( pTab->zName!=0 );
125538 nName = sqlite3Strlen30(pTab->zName);
125541 assert( pOther->zName!=0 );
125544 if( sqlite3StrNICmp(pOther->zName, pTab->zName, nName)==0
125545 && pOther->zName[nName]=='_'
125546 && pMod->pModule->xShadowName(pOther->zName+nName+1)
125562 SQLITE_PRIVATE int sqlite3ShadowTableName(sqlite3 *db, const char *zName){
125565 zTail = strrchr(zName, '_');
125568 pTab = sqlite3FindTable(db, zName, 0);
125572 return sqlite3IsShadowTableOf(db, pTab, zName);
125642 if( pSelect==0 && sqlite3ShadowTableName(db, p->zName) ){
125682 p->zName, pCol->zCnName, sqlite3ColumnType(pCol, "")
125686 p->zName, pCol->zCnName);
125715 sqlite3ErrorMsg(pParse, "PRIMARY KEY missing on table %s", p->zName);
125895 p->zName,
125896 p->zName,
125922 sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName),0);
125929 db->aDb[iDb].zDbSName, p->zName), P4_DYNAMIC);
125940 pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p);
125954 if( strcmp(p->zName, "sqlite_sequence")==0 ){
126118 sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
126353 const char *zName /* Name of index or table */
126363 zDbName, zTab, zType, zName
126409 pDb->zDbSName, pTab->zName
126424 pDb->zDbSName, pTab->zName);
126433 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
126436 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
126462 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
126463 if( sqlite3StrNICmp(pTab->zName+7, "stat", 4)==0 ) return 0;
126464 if( sqlite3StrNICmp(pTab->zName+7, "parameters", 10)==0 ) return 0;
126533 zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
126542 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
126545 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
126551 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
126560 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
126564 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
126576 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
126773 if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
126780 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
126941 char *zName = 0; /* Name of the index */
127010 pTab->zName);
127024 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
127028 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
127058 zName = sqlite3NameFromToken(db, pName);
127059 if( zName==0 ) goto exit_create_index;
127061 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName,"index",pTab->zName) ){
127066 if( sqlite3FindTable(db, zName, pDb->zDbSName)!=0 ){
127067 sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
127071 if( sqlite3FindIndex(db, zName, pDb->zDbSName)!=0 ){
127073 sqlite3ErrorMsg(pParse, "index %s already exists", zName);
127086 zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
127087 if( zName==0 ){
127096 if( IN_SPECIAL_PARSE ) zName[7]++;
127109 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
127149 nName = sqlite3Strlen30(zName);
127159 pIndex->zName = zExtra;
127161 memcpy(pIndex->zName, zName, nName+1);
127386 pIndex->zName, pIndex);
127448 pIndex->zName,
127449 pTab->zName,
127462 sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName), 0);
127515 sqlite3DbFree(db, zName);
127596 pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].u4.zDatabase);
127623 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
127635 db->aDb[iDb].zDbSName, pIndex->zName
127637 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
127640 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
127710 pList->a[i].zName = sqlite3NameFromToken(db, pToken);
127711 if( IN_RENAME_OBJECT && pList->a[i].zName ){
127712 sqlite3RenameTokenMap(pParse, (void*)pList->a[i].zName, pToken);
127725 sqlite3DbFree(db, pList->a[i].zName);
127734 SQLITE_PRIVATE int sqlite3IdListIndex(IdList *pList, const char *zName){
127738 if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
127898 pItem->zName = sqlite3NameFromToken(db, pDatabase);
127901 pItem->zName = sqlite3NameFromToken(db, pTable);
127969 if( pItem->zName ) sqlite3DbNNFreeNN(db, pItem->zName);
128076 assert( pItem->zName==0 || pDatabase!=0 );
128077 if( IN_RENAME_OBJECT && pItem->zName ){
128079 sqlite3RenameTokenMap(pParse, pItem->zName, pToken);
128282 char *zName = sqlite3NameFromToken(pParse->db, pName);
128283 if( zName ){
128289 if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
128290 sqlite3DbFree(pParse->db, zName);
128293 sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
128461 sqlite3_str_appendf(&errMsg, "index '%q'", pIdx->zName);
128468 sqlite3_str_appendall(&errMsg, pTab->zName);
128492 zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
128496 zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
128704 pNew->zName = sqlite3NameFromToken(pParse->db, pName);
128718 sqlite3DbFree(db, pCte->zName);
128743 char *zName;
128751 zName = pCte->zName;
128752 if( zName && pWith ){
128755 if( sqlite3StrICmp(zName, pWith->a[i].zName)==0 ){
128756 sqlite3ErrorMsg(pParse, "duplicate WITH table name: %s", zName);
128766 assert( (pNew!=0 && zName!=0) || db->mallocFailed );
128820 static void callCollNeeded(sqlite3 *db, int enc, const char *zName){
128823 char *zExternal = sqlite3DbStrDup(db, zName);
128832 sqlite3ValueSetStr(pTmp, -1, zName, SQLITE_UTF8, SQLITE_STATIC);
128851 char *z = pColl->zName;
128878 const char *zName = pColl->zName;
128880 CollSeq *p = sqlite3GetCollSeq(pParse, ENC(db), pColl, zName);
128906 const char *zName, /* Name of the collating sequence */
128910 pColl = sqlite3HashFind(&db->aCollSeq, zName);
128913 int nName = sqlite3Strlen30(zName) + 1;
128917 pColl[0].zName = (char*)&pColl[3];
128919 pColl[1].zName = (char*)&pColl[3];
128921 pColl[2].zName = (char*)&pColl[3];
128923 memcpy(pColl[0].zName, zName, nName);
128924 pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, pColl);
128959 const char *zName, /* Name of the collating sequence. Might be NULL */
128965 if( zName ){
128966 pColl = findCollSeqEntry(db, zName, create);
129006 const char *zName /* Collating sequence name */
129013 p = sqlite3FindCollSeq(db, enc, zName, 0);
129019 callCollNeeded(db, enc, zName);
129020 p = sqlite3FindCollSeq(db, enc, zName, 0);
129027 sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);
129053 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){
129059 pColl = sqlite3FindCollSeq(db, enc, zName, initbusy);
129061 pColl = sqlite3GetCollSeq(pParse, enc, pColl, zName);
129145 if( sqlite3StrICmp(p->zName, zFunc)==0 ){
129162 const char *zName = aDef[i].zName;
129163 int nName = sqlite3Strlen30(zName);
129164 int h = SQLITE_FUNC_HASH(zName[0], nName);
129166 pOther = sqlite3FunctionSearch(h, zName);
129202 const char *zName, /* Name of the function. zero-terminated */
129215 nName = sqlite3Strlen30(zName);
129219 p = (FuncDef*)sqlite3HashFind(&db->aFunc, zName);
129243 h = SQLITE_FUNC_HASH(sqlite3UpperToLower[(u8)zName[0]], nName);
129244 p = sqlite3FunctionSearch(h, zName);
129263 pBest->zName = (const char*)&pBest[1];
129266 memcpy((char*)&pBest[1], zName, nName+1);
129267 for(z=(u8*)pBest->zName; *z; z++) *z = sqlite3UpperToLower[*z];
129268 pOther = (FuncDef*)sqlite3HashInsert(&db->aFunc, pBest->zName, pBest);
129440 pTab->zName);
129467 sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
129474 sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
129505 pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName);
129580 const char *zName;
129582 zName = pTab->aCol[pPk->aiColumn[0]].zCnName;
129583 pLhs = sqlite3Expr(db, TK_ID, zName);
129584 pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ID, zName));
129739 rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0,
129758 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
129826 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
129829 pTab->zName, P4_STATIC);
130195 if( pParse->nested==0 || 0==sqlite3_stricmp(pTab->zName, "sqlite_stat1") ){
130268 VdbeModuleComment((v, "GenRowIdxDel for %s", pIdx->zName));
133092 zVfs = pVfs->zName;
133102 sqlite3_str_appendf(pResult, ", vfs=%Q", pVfs ? pVfs->zName: 0);
133315 int n = sqlite3Strlen30(p->zName);
133316 int h = p->zName[0] + n;
133318 printf(" %s(%d)", p->zName, h);
133611 pFKey->pFrom->zName, pFKey->zTo);
133816 if( zColl==0 ) zColl = db->pDfltColl->zName;
134004 return (FKey *)sqlite3HashFind(&pTab->pSchema->fkeyHash, pTab->zName);
134251 && sqlite3_stricmp(pTab->zName, pFKey->zTo)!=0
134309 rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
134318 sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
134374 pItem->zName = pFKey->pFrom->zName;
134407 pItem->zName = 0;
134492 if( 0==sqlite3_stricmp(pTab->zName, p->zTo) ) eRet = 2;
134650 zFrom = pFKey->pFrom->zName;
134666 pSrc->a[0].zName = sqlite3DbStrDup(db, zFrom);
134854 (opcode==OP_OpenWrite)?1:0, pTab->zName);
134858 VdbeComment((v, "%s", pTab->zName));
134865 VdbeComment((v, "%s", pTab->zName));
135305 sqlite3VdbeLoadString(v, memId-1, p->pTab->zName);
135780 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0,
135892 j = sqlite3ColumnIndex(pTab, pColumn->a[i].zName);
135908 if( sqlite3IsRowid(pColumn->a[i].zName) && !withoutRowid ){
135913 pTabList->a, pColumn->a[i].zName);
136104 pTab->zName);
136834 char *zMsg = sqlite3MPrintf(db, "%s.%s", pTab->zName,
136904 char *zName = pCheck->a[i].zEName;
136905 assert( zName!=0 || pParse->db->mallocFailed );
136908 onError, zName, P4_TRANSIENT,
137222 VdbeNoopComment((v, "prep index %s", pIdx->zName));
137246 VdbeComment((v, "%s column %d", pIdx->zName, i));
137259 VdbeComment((v, "for %s", pIdx->zName));
137349 VdbeComment((v, "%s.%s", pTab->zName,
137717 sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
137731 VdbeComment((v, "%s", pIdx->zName));
138131 sqlite3TableLock(pParse, iDbDest, pDest->tnum, 1, pDest->zName);
138132 sqlite3TableLock(pParse, iDbSrc, pSrc->tnum, 0, pSrc->zName);
138142 VdbeComment((v, "%s", pSrcIdx->zName));
138146 VdbeComment((v, "%s", pDestIdx->zName));
138412 int (*bind_parameter_index)(sqlite3_stmt*,const char*zName);
140171 const char *const zName; /* Name of pragma */
140873 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, pPragma->zName, SQLITE_STATIC);
140938 const char *zName;
140940 case OE_SetNull: zName = "SET NULL"; break;
140941 case OE_SetDflt: zName = "SET DEFAULT"; break;
140942 case OE_Cascade: zName = "CASCADE"; break;
140943 case OE_Restrict: zName = "RESTRICT"; break;
140944 default: zName = "NO ACTION";
140947 return zName;
140979 static const PragmaName *pragmaLocate(const char *zName){
140985 rc = sqlite3_stricmp(zName, aPragmaName[mid].zName);
141037 p->zName, isBuiltin,
141950 char *zSql = sqlite3MPrintf(db, "SELECT*FROM\"%w\"", pTab->zName);
141971 if( zRight && sqlite3_stricmp(zRight, pTab->zName)!=0 ) continue;
141983 sqlite3PreferredTableName(pTab->zName),
142003 sqlite3PreferredTableName(pTab->zName),
142010 pIdx->zName,
142079 pIdx->zName,
142108 sqlite3VdbeMultiLoad(v, 1, "is", i++, pColl->zName);
142140 sqlite3VdbeMultiLoad(v, 1, "s", pMod->zName);
142149 sqlite3VdbeMultiLoad(v, 1, "s", aPragmaName[i].zName);
142224 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
142227 sqlite3VdbeLoadString(v, regResult, pTab->zName);
142233 sqlite3TableLock(pParse, iDb, pParent->tnum, 0, pParent->zName);
142465 sqlite3VdbeLoadString(v, 4, pIdx->zName);
142544 pTab->zName);
142627 zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName,
142654 pTab->zName, pTab->aCol[j].zCnName);
142663 pTab->zName, pTab->aCol[j].zCnName);
142679 pTab->zName, pTab->aCol[j].zCnName);
142703 pTab->zName);
142728 jmp5 = sqlite3VdbeLoadString(v, 4, pIdx->zName);
142887 char *zName;
142906 returnSingleText(v, encnames[ENC(pParse->db)].zName);
142914 for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
142915 if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){
142922 if( !pEnc->zName ){
143196 if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7) ) continue;
143250 db->aDb[iDb].zDbSName, pTab->zName);
143477 sqlite3_str_appendf(&acc, "(\"%s\"", pPragma->zName);
143647 sqlite3_str_appendall(&acc, pTab->pName->zName);
143731 SQLITE_PRIVATE Module *sqlite3PragmaVtabRegister(sqlite3 *db, const char *zName){
143733 assert( sqlite3_strnicmp(zName, "pragma_", 7)==0 );
143734 pName = pragmaLocate(zName+7);
143737 assert( sqlite3HashFind(&db->aModule, zName)==0 );
143738 return sqlite3VtabCreateModule(db, zName, &pragmaVtabModule, (void*)pName, 0);
145385 char *zName; /* Name of column in the right table */
145388 zName = pRightTab->aCol[j].zCnName;
145389 if( tableAndColumnIndex(pSrc, 0, i, zName, 0, 0, 1) ){
145393 assert( pUsing->a[pUsing->nId-1].zName==0 );
145394 pUsing->a[pUsing->nId-1].zName = sqlite3DbStrDup(pParse->db, zName);
145418 char *zName; /* Name of the term in the USING clause */
145426 zName = pList->a[j].zName;
145427 iRightCol = sqlite3ColumnIndex(pRightTab, zName);
145429 || tableAndColumnIndex(pSrc, 0, i, zName, &iLeft, &iLeftCol,
145433 "not present in both tables", zName);
145456 while( tableAndColumnIndex(pSrc, iLeft+1, i, zName, &iLeft, &iLeftCol,
145459 || sqlite3IdListIndex(pSrc->a[iLeft].u3.pUsing, zName)<0
145462 zName);
146870 zOrigTab = pTab->zName;
147023 char *zName = pEList->a[i].zEName;
147024 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_TRANSIENT);
147038 char *zName = 0;
147039 zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol);
147040 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_DYNAMIC);
147086 char *zName; /* Column name */
147110 if( (zName = pX->zEName)!=0 && pX->fg.eEName==ENAME_NAME ){
147126 zName = iCol>=0 ? pTab->aCol[iCol].zCnName : "rowid";
147129 zName = pColExpr->u.zToken;
147132 assert( zName==pX->zEName ); /* pointer comparison intended */
147135 if( zName && !sqlite3IsTrueOrFalse(zName) ){
147136 zName = sqlite3DbStrDup(db, zName);
147138 zName = sqlite3MPrintf(db,"column%d",i+1);
147145 while( zName && (pCollide = sqlite3HashFind(&ht, zName))!=0 ){
147149 nName = sqlite3Strlen30(zName);
147151 for(j=nName-1; j>0 && sqlite3Isdigit(zName[j]); j--){}
147152 if( zName[j]==':' ) nName = j;
147154 zName = sqlite3MPrintf(db, "%.*z:%u", nName, zName, ++cnt);
147160 pCol->zCnName = zName;
147161 pCol->hName = sqlite3StrIHash(zName);
147166 if( zName && sqlite3HashInsert(&ht, zName, pX)==pX ){
147277 sqlite3ColumnSetColl(db, pCol, pColl->zName);
147304 pTab->zName = 0;
147457 sqlite3ExprAddCollateString(pParse, pTerm, pColl->zName);
148800 (pColl ? pColl->zName : "BINARY")
149384 pParse->zAuthContext = pSubitem->zName;
149398 sqlite3DbFree(db, pSubitem->zName);
149400 pSubitem->zName = 0;
150410 pIdx && sqlite3StrICmp(pIdx->zName, zIndexedBy);
150515 sqlite3ErrorMsg(pParse, "'%s' is not a function", pFrom->zName);
150537 const char *zName = pItem->zName;
150540 assert( zName!=0 );
150544 if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){
150651 sqlite3ErrorMsg(pParse, pCte->zCteErr, pCte->zName);
150672 pTab->zName = sqlite3DbStrDup(db, pCte->zName);
150700 if( pItem->zName!=0
150704 && 0==sqlite3StrICmp(pItem->zName, pCte->zName)
150711 "multiple references to recursive table: %s", pCte->zName
150754 pCte->zName, pEList->nExpr, pCte->pCols->nExpr
150819 pTab->zName = sqlite3DbStrDup(pParse->db, pFrom->zAlias);
150821 pTab->zName = sqlite3MPrintf(pParse->db, "%!S", pFrom);
150849 const char *zName, /* Name we are looking for */
150858 if( sqlite3IdListIndex(pBase->u3.pUsing, zName)>=0 ) return 1;
150938 if( pFrom->zName==0 ){
150962 pTab->zName);
150981 pTab->zName);
150992 pTab->zName);
151096 zTabName = pTab->zName;
151122 const char *zUName = pUsing->a[ii].zName;
151141 const char *zName;
151145 zName = sqlite3RowidAlias(pTab);
151146 if( zName==0 ) continue;
151148 zName = pTab->aCol[j].zCnName;
151179 assert( zName );
151184 && sqlite3IdListIndex(pFrom->u3.pUsing, zName)>=0
151191 pRight = sqlite3Expr(db, TK_ID, zName);
151195 || !inAnyUsingClause(zName,pFrom,pTabList->nSrc-i-1)
151227 zSchemaName, zTabName, zName);
151232 && sqlite3IdListIndex(pFrom->u3.pUsing, zName)>=0)
151233 || (pUsing && sqlite3IdListIndex(pUsing, zName)>=0)
151239 pX->zEName = sqlite3MPrintf(db, "%s.%s", zTabName, zName);
151242 pX->zEName = sqlite3DbStrDup(db, zName);
151414 ii, pCol->pTab ? pCol->pTab->zName : "NULL",
151614 pFunc->pFunc->zName));
151645 pFunc->pFunc->zName));
151903 pTab->zName,
151905 bCover ? pIdx->zName : ""
152007 if( pItem->zName==0 ) continue;
152011 if( sqlite3_stricmp(pItem->zName, pThis->zName)!=0 ) continue;
152362 p0->zAlias ? p0->zAlias : p0->pSTab->zName
152469 pTab->nCol, pTab->zName, pSub->pEList->nExpr);
152652 if( pItem->colUsed==0 && pItem->zName!=0 ){
152662 sqlite3AuthCheck(pParse, SQLITE_READ, pItem->zName, "", zDb);
152724 pParse->zAuthContext = pItem->zName;
153477 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
153926 && 0==sqlite3StrICmp(pTrig->table, pTab->zName)
153938 pTrig->table = pTab->zName;
153948 printf("Triggers for %s:", pTab->zName);
153950 printf(" %s", pX->zName);
153981 char *zName = 0; /* Name of the trigger */
154059 zName = sqlite3NameFromToken(db, pName);
154060 if( zName==0 ){
154064 if( sqlite3CheckObjectName(pParse, zName, "trigger", pTab->zName) ){
154069 if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),zName) ){
154082 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
154108 if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
154129 pTrigger->zName = zName;
154130 zName = 0;
154131 pTrigger->table = sqlite3DbStrDup(db, pTableName->a[0].zName);
154137 sqlite3RenameTokenRemap(pParse, pTrigger->table, pTableName->a[0].zName);
154149 sqlite3DbFree(db, zName);
154187 char *zName; /* Name of trigger */
154195 zName = pTrig->zName;
154202 sqlite3TokenInit(&nameToken, pTrig->zName);
154236 pTrig->zName, pStep->zTarget);
154251 db->aDb[iDb].zDbSName, zName,
154256 sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName), 0);
154264 pTrig = sqlite3HashInsert(pHash, zName, pTrig);
154472 sqlite3DbFree(db, pTrigger->zName);
154491 const char *zName;
154502 zName = pName->a[0].zName;
154508 pTrigger = sqlite3HashFind(&(db->aDb[j].pSchema->trigHash), zName);
154554 if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) ||
154566 db->aDb[iDb].zDbSName, pTrigger->zName
154569 sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
154576 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){
154582 pTrigger = sqlite3HashInsert(pHash, zName, 0);
154730 char *zName = sqlite3DbStrDup(db, pStep->zTarget);
154733 assert( zName || pSrc==0 );
154736 pSrc->a[0].zName = zName;
154755 sqlite3DbFree(db, zName);
154928 pFrom->a[0].zName = pTab->zName; /* tag-20240424-1 */
155118 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
155143 sSubParse.zAuthContext = pTrigger->zName;
155153 pTrigger->zName, onErrorText(orconf),
155158 pTab->zName
155161 if( pTrigger->zName ){
155163 sqlite3MPrintf(db, "-- TRIGGER %s", pTrigger->zName), P4_DYNAMIC
155190 VdbeComment((v, "End: %s.%s", pTrigger->zName, onErrorText(orconf)));
155227 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
155269 int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers));
155274 (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf)));
155505 VdbeComment((v, "%s.%s", pTab->zName, pCol->zCnName));
155943 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
156058 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
157103 VdbeComment((v, "%s.%s", pIdx->zName,
157594 const char *zName, /* Name assigned to this module */
157603 zCopy = (char*)zName;
157606 int nName = sqlite3Strlen30(zName);
157613 memcpy(zCopy, zName, nName+1);
157614 pMod->zName = zCopy;
157642 const char *zName, /* Name assigned to this module */
157650 (void)sqlite3VtabCreateModule(db, zName, pModule, pAux, xDestroy);
157663 const char *zName, /* Name assigned to this module */
157668 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
157670 return createModule(db, zName, pModule, pAux, 0);
157678 const char *zName, /* Name assigned to this module */
157684 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
157686 return createModule(db, zName, pModule, pAux, xDestroy);
157703 for(ii=0; azNames[ii]!=0 && strcmp(azNames[ii],pMod->zName)!=0; ii++){}
157706 createModule(db, pMod->zName, 0, 0, 0);
157920 sqlite3ErrorMsg(pParse, "too many columns on %s", pTable->zName);
157959 addModuleArgument(pParse, pTable, sqlite3DbStrDup(db, pTable->zName));
157976 sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName,
158046 pTab->zName,
158047 pTab->zName,
158055 zWhere = sqlite3MPrintf(db, "name=%Q AND sql=%Q", pTab->zName, zStmt);
158060 sqlite3VdbeLoadString(v, iReg, pTab->zName);
158067 const char *zName = pTab->zName;
158068 assert( zName!=0 );
158070 pOld = sqlite3HashInsert(&pSchema->tblHash, zName, pTab);
158134 "vtable constructor called recursively: %s", pTab->zName
158140 zModuleName = sqlite3DbStrDup(db, pTab->zName);
158743 for(i=0; pDef->zName[i]; i++){
158744 unsigned char x = (unsigned char)pDef->zName[i];
158749 rc = pMod->xFindFunction(pVtab, nArg, pDef->zName, &xSFunc, &pArg);
158757 + sqlite3Strlen30(pDef->zName) + 1);
158762 pNew->zName = (const char*)&pNew[1];
158763 memcpy((char*)&pNew[1], pDef->zName, sqlite3Strlen30(pDef->zName)+1);
158820 pTab->zName = sqlite3DbStrDup(db, pMod->zName);
158821 if( pTab->zName==0 ){
158832 addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
158834 addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
159776 sqlite3_str_appendf(&str, zFmt, pIdx->zName);
159945 zObj = pLoop->u.btree.pIndex->zName;
159947 zObj = pSrclist->a[pLvl->iFrom].zName;
160532 VdbeComment((v, "begin skip-scan on %s", pIdx->zName));
161097 iLevel, pTabItem->pSTab->zName));
161160 VdbeComment((v, "next row of %s", pTabItem->pSTab->zName));
162368 VdbeComment((v, "match against %s", pTab->zName));
162459 ExplainQueryPlan((pParse, 1, "RIGHT-JOIN %s", pTabItem->pSTab->zName));
164441 pTab->zName, j);
164809 return pRet ? pRet->zName : sqlite3StrBINARY;
164878 zCollName = pColl ? pColl->zName : sqlite3StrBINARY;
165069 if( 0==sqlite3StrICmp(pColl->zName, zColl) ){
165245 sqlite3DebugPrintf("sqlite3_index_info inputs for %s:\n", pTab->zName);
165269 sqlite3DebugPrintf("sqlite3_index_info outputs for %s:\n", pTab->zName);
165423 sqlite3_str_appendf(pStr,"CREATE AUTOMATIC INDEX ON %s(", pTab->zName);
165427 const char *zName = 0;
165430 zName = pTab->aCol[iCol].zCnName;
165431 sqlite3_str_appendf(pStr, "%s%s", zSep, zName);
165525 "automatic index on %s(%s)", pTable->zName,
165586 pIdx->zName = "auto-index";
165605 pIdx->azColl[n] = pColl ? pColl->zName : sqlite3StrBINARY;
165650 VdbeComment((v, "for %s", pTable->zName));
165670 VdbeComment((v, "next row of %s", pSrc->pSTab->zName));
166774 p->zName, nEq-1, (int)a[1]));
166919 pItem->zAlias ? pItem->zAlias : pTab->zName);
166926 const char *zName;
166927 if( p->u.btree.pIndex && (zName = p->u.btree.pIndex->zName)!=0 ){
166928 if( strncmp(zName, "sqlite_autoindex_", 17)==0 ){
166929 int i = sqlite3Strlen30(zName) - 1;
166930 while( zName[i]!='_' ) i--;
166931 zName += i;
166933 sqlite3DebugPrintf(".%-16s %2d", zName, p->u.btree.nEq);
167560 if( sqlite3StrICmp(pColl->zName, pIdx->azColl[i+nEq]) ) break;
167619 pProbe->pTable->zName,pProbe->zName,
168017 pProbe->pTable->zName, pProbe->zName, saved_nEq, rc));
168564 " according to whereIsCoveringIndex()\n", pProbe->zName));
168572 " according to whereIsCoveringIndex()\n", pProbe->zName));
168577 " according to whereIsCoveringIndex()\n", pProbe->zName));
168585 pProbe->zName, m==0 ? "is" : "is not"));
168797 sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pSTab->zName);
168860 sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pSTab->zName);
168921 zRet = (pC ? pC->zName : sqlite3StrBINARY);
169077 WHERETRACE(0x800, ("BEGIN %s.addVirtual()\n", pSrc->pSTab->zName));
169159 WHERETRACE(0x800, ("END %s.addVirtual(), rc=%d\n", pSrc->pSTab->zName, rc));
169601 if( pColl2==0 || sqlite3StrICmp(pColl1->zName, pColl2->zName) ){
169739 if( sqlite3StrICmp(pColl->zName, pIndex->azColl[j])!=0 ) continue;
169850 static char zName[65];
169852 for(i=0; i<nLoop; i++){ zName[i] = pPath->aLoop[i]->cId; }
169853 if( pLast ) zName[i++] = pLast->cId;
169854 zName[i] = 0;
169855 return zName;
170087 pDim->zAlias ? pDim->zAlias: pDim->pSTab->zName, pWLoop->iTab,
170088 pFactTab->zAlias ? pFactTab->zAlias : pFactTab->pSTab->zName,
170951 pLoop->cId, (double)sqlite3LogEstToInt(nSearch), pTab->zName,
171010 p->zIdxName = pIdx->zName;
171605 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
171660 VdbeComment((v, "%s", pIx->zName));
171932 VdbeComment((v, "next skip-scan on %s", pLoop->u.btree.pIndex->zName));
171979 pWInfo->pTabList->a[pLevel->iFrom].pSTab->zName));
172785 static Window *windowFind(Parse *pParse, Window *pList, const char *zName){
172788 if( sqlite3StrICmp(p->zName, zName)==0 ) break;
172791 sqlite3ErrorMsg(pParse, "no such window: %s", zName);
172819 if( pWin->zName && pWin->eFrmType==0 ){
172820 Window *p = windowFind(pParse, pList, pWin->zName);
172865 if( pFunc->zName==aUp[i].zFunc ){
173295 sqlite3DbFree(db, p->zName);
173600 if( pKeyInfo && pWin->pWFunc->zName[1]=='i' ){
173608 else if( p->zName==nth_valueName || p->zName==first_valueName ){
173616 else if( p->zName==leadName || p->zName==lagName ){
173836 if( i!=1 || pFunc->zName!=nth_valueName ){
173876 assert( pFunc->zName==nth_valueName
173877 || pFunc->zName==first_valueName
174089 if( pFunc->zName==nth_valueName
174090 || pFunc->zName==first_valueName
174097 if( pFunc->zName==nth_valueName ){
174112 else if( pFunc->zName==leadName || pFunc->zName==lagName ){
174126 int val = (pFunc->zName==leadName ? 1 : -1);
174129 int op = (pFunc->zName==leadName ? OP_Add : OP_Subtract);
174164 if( pFunc->zName==nth_valueName || pFunc->zName==first_valueName ){
174190 if( (pFunc->zName==nth_valueName)
174191 || (pFunc->zName==first_valueName)
174192 || (pFunc->zName==leadName)
174193 || (pFunc->zName==lagName)
174543 pNew->zName = sqlite3DbStrDup(db, p->zName);
179429 pNew->zName = pOld->zName;
179450 pOld->zName = 0;
179468 …& yylhsminor.yy563 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy563->a[0].zName, &yymsp[0].minor.y…
179475 …& yylhsminor.yy563 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy563->a[0].zName, &yymsp[0].minor.y…
180049 sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0);
180327 …yymsp[-1].minor.yy483->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor…
180448 …yymsp[-1].minor.yy483->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.y…
181493 SQLITE_API int sqlite3_keyword_check(const char *zName, int nName){
181494 return TK_ID!=sqlite3KeywordCode((const u8*)zName, nName);
183716 assert( p==0 || p->xCmp!=binCollFunc || strcmp(p->zName,"BINARY")==0 );
184166 const char *zName = 0;
184168 for(i=0; i<2 && zName==0; i++, rc &= 0xff){
184170 case SQLITE_OK: zName = "SQLITE_OK"; break;
184171 case SQLITE_ERROR: zName = "SQLITE_ERROR"; break;
184172 case SQLITE_ERROR_SNAPSHOT: zName = "SQLITE_ERROR_SNAPSHOT"; break;
184173 case SQLITE_INTERNAL: zName = "SQLITE_INTERNAL"; break;
184174 case SQLITE_PERM: zName = "SQLITE_PERM"; break;
184175 case SQLITE_ABORT: zName = "SQLITE_ABORT"; break;
184176 case SQLITE_ABORT_ROLLBACK: zName = "SQLITE_ABORT_ROLLBACK"; break;
184177 case SQLITE_BUSY: zName = "SQLITE_BUSY"; break;
184178 case SQLITE_BUSY_RECOVERY: zName = "SQLITE_BUSY_RECOVERY"; break;
184179 case SQLITE_BUSY_SNAPSHOT: zName = "SQLITE_BUSY_SNAPSHOT"; break;
184180 case SQLITE_LOCKED: zName = "SQLITE_LOCKED"; break;
184181 case SQLITE_LOCKED_SHAREDCACHE: zName = "SQLITE_LOCKED_SHAREDCACHE";break;
184182 case SQLITE_NOMEM: zName = "SQLITE_NOMEM"; break;
184183 case SQLITE_READONLY: zName = "SQLITE_READONLY"; break;
184184 case SQLITE_READONLY_RECOVERY: zName = "SQLITE_READONLY_RECOVERY"; break;
184185 case SQLITE_READONLY_CANTINIT: zName = "SQLITE_READONLY_CANTINIT"; break;
184186 case SQLITE_READONLY_ROLLBACK: zName = "SQLITE_READONLY_ROLLBACK"; break;
184187 case SQLITE_READONLY_DBMOVED: zName = "SQLITE_READONLY_DBMOVED"; break;
184188 case SQLITE_READONLY_DIRECTORY: zName = "SQLITE_READONLY_DIRECTORY";break;
184189 case SQLITE_INTERRUPT: zName = "SQLITE_INTERRUPT"; break;
184190 case SQLITE_IOERR: zName = "SQLITE_IOERR"; break;
184191 case SQLITE_IOERR_READ: zName = "SQLITE_IOERR_READ"; break;
184192 case SQLITE_IOERR_SHORT_READ: zName = "SQLITE_IOERR_SHORT_READ"; break;
184193 case SQLITE_IOERR_WRITE: zName = "SQLITE_IOERR_WRITE"; break;
184194 case SQLITE_IOERR_FSYNC: zName = "SQLITE_IOERR_FSYNC"; break;
184195 case SQLITE_IOERR_DIR_FSYNC: zName = "SQLITE_IOERR_DIR_FSYNC"; break;
184196 case SQLITE_IOERR_TRUNCATE: zName = "SQLITE_IOERR_TRUNCATE"; break;
184197 case SQLITE_IOERR_FSTAT: zName = "SQLITE_IOERR_FSTAT"; break;
184198 case SQLITE_IOERR_UNLOCK: zName = "SQLITE_IOERR_UNLOCK"; break;
184199 case SQLITE_IOERR_RDLOCK: zName = "SQLITE_IOERR_RDLOCK"; break;
184200 case SQLITE_IOERR_DELETE: zName = "SQLITE_IOERR_DELETE"; break;
184201 case SQLITE_IOERR_NOMEM: zName = "SQLITE_IOERR_NOMEM"; break;
184202 case SQLITE_IOERR_ACCESS: zName = "SQLITE_IOERR_ACCESS"; break;
184204 zName = "SQLITE_IOERR_CHECKRESERVEDLOCK"; break;
184205 case SQLITE_IOERR_LOCK: zName = "SQLITE_IOERR_LOCK"; break;
184206 case SQLITE_IOERR_CLOSE: zName = "SQLITE_IOERR_CLOSE"; break;
184207 case SQLITE_IOERR_DIR_CLOSE: zName = "SQLITE_IOERR_DIR_CLOSE"; break;
184208 case SQLITE_IOERR_SHMOPEN: zName = "SQLITE_IOERR_SHMOPEN"; break;
184209 case SQLITE_IOERR_SHMSIZE: zName = "SQLITE_IOERR_SHMSIZE"; break;
184210 case SQLITE_IOERR_SHMLOCK: zName = "SQLITE_IOERR_SHMLOCK"; break;
184211 case SQLITE_IOERR_SHMMAP: zName = "SQLITE_IOERR_SHMMAP"; break;
184212 case SQLITE_IOERR_SEEK: zName = "SQLITE_IOERR_SEEK"; break;
184213 case SQLITE_IOERR_DELETE_NOENT: zName = "SQLITE_IOERR_DELETE_NOENT";break;
184214 case SQLITE_IOERR_MMAP: zName = "SQLITE_IOERR_MMAP"; break;
184215 case SQLITE_IOERR_GETTEMPPATH: zName = "SQLITE_IOERR_GETTEMPPATH"; break;
184216 case SQLITE_IOERR_CONVPATH: zName = "SQLITE_IOERR_CONVPATH"; break;
184217 case SQLITE_CORRUPT: zName = "SQLITE_CORRUPT"; break;
184218 case SQLITE_CORRUPT_VTAB: zName = "SQLITE_CORRUPT_VTAB"; break;
184219 case SQLITE_NOTFOUND: zName = "SQLITE_NOTFOUND"; break;
184220 case SQLITE_FULL: zName = "SQLITE_FULL"; break;
184221 case SQLITE_CANTOPEN: zName = "SQLITE_CANTOPEN"; break;
184222 case SQLITE_CANTOPEN_NOTEMPDIR: zName = "SQLITE_CANTOPEN_NOTEMPDIR";break;
184223 case SQLITE_CANTOPEN_ISDIR: zName = "SQLITE_CANTOPEN_ISDIR"; break;
184224 case SQLITE_CANTOPEN_FULLPATH: zName = "SQLITE_CANTOPEN_FULLPATH"; break;
184225 case SQLITE_CANTOPEN_CONVPATH: zName = "SQLITE_CANTOPEN_CONVPATH"; break;
184226 case SQLITE_CANTOPEN_SYMLINK: zName = "SQLITE_CANTOPEN_SYMLINK"; break;
184227 case SQLITE_PROTOCOL: zName = "SQLITE_PROTOCOL"; break;
184228 case SQLITE_EMPTY: zName = "SQLITE_EMPTY"; break;
184229 case SQLITE_SCHEMA: zName = "SQLITE_SCHEMA"; break;
184230 case SQLITE_TOOBIG: zName = "SQLITE_TOOBIG"; break;
184231 case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT"; break;
184232 case SQLITE_CONSTRAINT_UNIQUE: zName = "SQLITE_CONSTRAINT_UNIQUE"; break;
184233 case SQLITE_CONSTRAINT_TRIGGER: zName = "SQLITE_CONSTRAINT_TRIGGER";break;
184235 zName = "SQLITE_CONSTRAINT_FOREIGNKEY"; break;
184236 case SQLITE_CONSTRAINT_CHECK: zName = "SQLITE_CONSTRAINT_CHECK"; break;
184238 zName = "SQLITE_CONSTRAINT_PRIMARYKEY"; break;
184239 case SQLITE_CONSTRAINT_NOTNULL: zName = "SQLITE_CONSTRAINT_NOTNULL";break;
184241 zName = "SQLITE_CONSTRAINT_COMMITHOOK"; break;
184242 case SQLITE_CONSTRAINT_VTAB: zName = "SQLITE_CONSTRAINT_VTAB"; break;
184244 zName = "SQLITE_CONSTRAINT_FUNCTION"; break;
184245 case SQLITE_CONSTRAINT_ROWID: zName = "SQLITE_CONSTRAINT_ROWID"; break;
184246 case SQLITE_MISMATCH: zName = "SQLITE_MISMATCH"; break;
184247 case SQLITE_MISUSE: zName = "SQLITE_MISUSE"; break;
184248 case SQLITE_NOLFS: zName = "SQLITE_NOLFS"; break;
184249 case SQLITE_AUTH: zName = "SQLITE_AUTH"; break;
184250 case SQLITE_FORMAT: zName = "SQLITE_FORMAT"; break;
184251 case SQLITE_RANGE: zName = "SQLITE_RANGE"; break;
184252 case SQLITE_NOTADB: zName = "SQLITE_NOTADB"; break;
184253 case SQLITE_ROW: zName = "SQLITE_ROW"; break;
184254 case SQLITE_NOTICE: zName = "SQLITE_NOTICE"; break;
184255 case SQLITE_NOTICE_RECOVER_WAL: zName = "SQLITE_NOTICE_RECOVER_WAL";break;
184257 zName = "SQLITE_NOTICE_RECOVER_ROLLBACK"; break;
184258 case SQLITE_NOTICE_RBU: zName = "SQLITE_NOTICE_RBU"; break;
184259 case SQLITE_WARNING: zName = "SQLITE_WARNING"; break;
184260 case SQLITE_WARNING_AUTOINDEX: zName = "SQLITE_WARNING_AUTOINDEX"; break;
184261 case SQLITE_DONE: zName = "SQLITE_DONE"; break;
184264 if( zName==0 ){
184267 zName = zBuf;
184269 return zName;
184831 const char *zName = (const char*)sqlite3_user_data(context);
184835 "unable to use function %s in the requested context", zName);
184854 const char *zName,
184861 if( !sqlite3SafetyCheckOk(db) || zName==0 || nArg<-2 ){
184866 rc = sqlite3FindFunction(db, zName, nArg, SQLITE_UTF8, 0)!=0;
184869 zCopy = sqlite3_mprintf("%s", zName);
184871 return sqlite3_create_function_v2(db, zName, nArg, SQLITE_UTF8,
185451 const char *zName,
185480 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0);
185496 CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName);
185510 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 1);
186161 if( sqlite3_stricmp(db->pVfs->zName, "kvvfs")==0 ){
186338 const char *zName,
186343 return sqlite3_create_collation_v2(db, zName, enc, pCtx, xCompare, 0);
186351 const char *zName,
186360 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
186364 rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel);
186376 const void *zName,
186385 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
186389 zName8 = sqlite3Utf16to8(db, zName, -1, SQLITE_UTF16NATIVE);
186445 SQLITE_API void *sqlite3_get_clientdata(sqlite3 *db, const char *zName){
186449 if( strcmp(p->zName, zName)==0 ){
186464 const char *zName, /* Name of the client data */
186471 for(p=db->pDbData; p && strcmp(p->zName,zName); p=p->pNext){
186487 size_t n = strlen(zName);
186494 memcpy(p->zName, zName, n+1);
187367 static const char *databaseName(const char *zName){
187368 while( zName[-1]!=0 || zName[-2]!=0 || zName[-3]!=0 || zName[-4]!=0 ){
187369 zName--;
187371 return zName;
188944 const char *zName; /* virtual table name */
189684 zDb, p->zName,
189685 zDb, p->zName,
189686 zDb, p->zName,
189687 zDb, p->zName,
189688 (p->zContentTbl ? "--" : ""), zDb,p->zName
189729 zCols, p->zName, zLanguageid
189750 p->zDb, p->zName
189787 p->zDb, p->zName, zContentCols
189795 p->zDb, p->zName
189807 p->zDb, p->zName
189812 p->zDb, p->zName
189994 (p->zContentTbl ? p->zContentTbl : p->zName),
190527 p->zName = zCsr;
192654 char *zTbl = sqlite3_mprintf("%s_stat", p->zName);
192917 const char *zName, /* Name of SQL function */
192922 const char *zName;
192937 if( strcmp(zName, aOverload[i].zName)==0 ){
192952 const char *zName /* New name of table */
192978 p->zDb, p->zName, zName
192985 p->zDb, p->zName, zName
192991 p->zDb, p->zName, zName
192996 p->zDb, p->zName, zName
193000 p->zDb, p->zName, zName
193022 pTab->zDb, pTab->zName, pTab->zName
193074 static int fts3ShadowName(const char *zName){
193080 if( sqlite3_stricmp(zName, azName[i])==0 ) return 1;
195397 p->pFts3Tab->zName = &p->pFts3Tab->zDb[nDb+1];
195402 memcpy((char *)p->pFts3Tab->zName, zFts3, nFts3);
195403 sqlite3Fts3Dequote((char *)p->pFts3Tab->zName);
198291 const unsigned char *zName;
198298 zName = sqlite3_value_text(argv[0]);
198305 if( zName==0 || n!=sizeof(pPtr) ){
198310 pOld = sqlite3Fts3HashInsert(pHash, (void *)zName, nName, pPtr);
198319 if( zName ){
198320 pPtr = sqlite3Fts3HashFind(pHash, zName, nName);
198323 char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
198489 const char *zName;
198511 zName = (const char *)sqlite3_value_text(argv[0]);
198516 p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
198519 char *zErr2 = sqlite3_mprintf("unknown tokenizer: %s", zName);
198571 char *zName,
198583 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
198594 char *zName,
198607 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
198696 const char *zName
198706 zTest = sqlite3_mprintf("%s_test", zName);
198707 zTest2 = sqlite3_mprintf("%s_internal_test", zName);
198714 rc = sqlite3_create_function(db, zName, 1, any, p, fts3TokenizerFunc, 0, 0);
198717 rc = sqlite3_create_function(db, zName, 2, any, p, fts3TokenizerFunc, 0, 0);
199055 const char *zName,
199060 int nName = (int)strlen(zName);
199062 p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
199064 sqlite3Fts3ErrMsg(pzErr, "unknown tokenizer: %s", zName);
199842 zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName, p->zWriteExprlist);
199847 zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName);
200651 p->zSegmentsTbl = sqlite3_mprintf("%s_segments", p->zName);
213440 const char *zName;
213448 rc = sqlite3_create_module(db, aMod[i].zName, aMod[i].pModule, 0);
213633 char *zName; /* Name of r-tree table */
214528 pRtree->zDb, pRtree->zName,
214529 pRtree->zDb, pRtree->zName,
214530 pRtree->zDb, pRtree->zName
216519 zSql = sqlite3_mprintf("SELECT * FROM %Q.%Q", pRtree->zDb, pRtree->zName);
216531 "UNIQUE constraint failed: %s.%s", pRtree->zName, zCol
216537 "rtree constraint failed: %s.(%s<=%s)", pRtree->zName, zCol1, zCol2
216729 , pRtree->zDb, pRtree->zName, zNewName
216730 , pRtree->zDb, pRtree->zName, zNewName
216731 , pRtree->zDb, pRtree->zName, zNewName
216784 zSql = sqlite3_mprintf(zFmt, pRtree->zDb, pRtree->zName);
216804 static int rtreeShadowName(const char *zName){
216810 if( sqlite3_stricmp(zName, azName[i])==0 ) return 1;
217032 pRtree->zDb, pRtree->zName
217041 pRtree->zName);
217113 pRtree->zName = &pRtree->zDb[nDb+1];
217114 pRtree->zNodeName = &pRtree->zName[nName+1];
217117 memcpy(pRtree->zName, argv[2], nName);
217672 const char *zName, /* Name of the virtual table */
217680 UNUSED_PARAMETER(zName);
217682 rc = rtreeCheckTable(pRtree->db, pRtree->zDb, pRtree->zName, pzErr);
217685 pRtree->zDb, pRtree->zName, *pzErr);
219025 pRtree->zName = &pRtree->zDb[nDb+1];
219026 pRtree->zNodeName = &pRtree->zName[nName+1];
219031 memcpy(pRtree->zName, argv[2], nName);
219499 const char *zName,
219505 if( sqlite3_stricmp(zName, "geopoly_overlap")==0 ){
219510 if( sqlite3_stricmp(zName, "geopoly_within")==0 ){
219553 const char *zName;
219571 const char *zName;
219583 rc = sqlite3_create_function(db, aFunc[i].zName, aFunc[i].nArg,
219588 rc = sqlite3_create_function(db, aAgg[i].zName, 1,
219839 const char *zName, /* Name of ICU function that failed */
219843 sqlite3_snprintf(128, zBuf, "ICU error: %s(): %s", zName, u_errorName(e));
220250 const char *zName; /* SQL Collation sequence name (eg. "japanese") */
220257 zName = (const char *)sqlite3_value_text(apArg[1]);
220259 if( !zLocale || !zName ){
220272 const char *zName;
220284 if( sqlite3_stricmp(zOption,aStrength[i].zName)==0 ){
220295 sqlite3_str_appendf(pStr, " %s", aStrength[i].zName);
220302 rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator,
220317 const char *zName; /* Function name */
220345 db, p->zName, p->nArg, p->enc,
221344 SQLITE_API int sqlite3rbu_create_vfs(const char *zName, const char *zParent);
221354 SQLITE_API void sqlite3rbu_destroy_vfs(const char *zName);
222657 const char *zName = (const char*)sqlite3_column_name(pStmt, i);
222658 if( sqlite3_strnicmp("rbu_", zName, 4) ){
222659 char *zCopy = rbuStrndup(zName, &p->rc);
222663 else if( 0==sqlite3_stricmp("rbu_rowid", zName) ){
222690 const char *zName = (const char*)sqlite3_column_text(pStmt, 1);
222691 if( zName==0 ) break; /* An OOM - finalize() below returns S_NOMEM */
222693 if( 0==strcmp(zName, pIter->azTblCol[i]) ) break;
222698 pIter->zDataTbl, zName
223952 const char *zName,
223958 p->rc = sqlite3_open_v2(zName, &db, flags, bUseVfs ? p->zVfsName : 0);
224642 static void assertColumnName(sqlite3_stmt *pStmt, int iCol, const char *zName){
224644 assert( 0==sqlite3_stricmp(zName, zCol) );
225173 p->zVfsName = pVfs->zName;
226195 char *zOut = sqlite3_mprintf("rbu(%s)/%z", pRbuVfs->base.zName, zIn);
226347 const char *zName,
226395 const char *zOpen = zName;
226402 if( zName ){
226409 pFd->zWal = sqlite3_filename_wal(zName);
226412 rbu_file *pDb = rbuFindMaindb(pRbuVfs, zName, 0);
226433 && sqlite3_uri_boolean(zName, "rbu_memory", 0)
226614 SQLITE_API void sqlite3rbu_destroy_vfs(const char *zName){
226615 sqlite3_vfs *pVfs = sqlite3_vfs_find(zName);
226628 SQLITE_API int sqlite3rbu_create_vfs(const char *zName, const char *zParent){
226665 nName = strlen(zName);
226682 pNew->base.zName = (const char*)(zSpace = (char*)&pNew[1]);
226683 memcpy(zSpace, zName, nName);
226853 char *zName; /* Value of 'name' column */
227354 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
227406 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
227469 const char *zName = 0; /* Only provide analysis of this table */
227490 zName = (const char*)sqlite3_value_text(argv[iArg++]);
227506 if( zName ){
227507 sqlite3_str_appendf(pSql, "WHERE name=%Q", zName);
227535 sqlite3_result_text(ctx, pCsr->zName, -1, SQLITE_TRANSIENT);
228276 char *zName; /* Local name of table */
229285 const unsigned char *zName = sqlite3_column_text(pStmt, 1);
229288 if( zName==0 ) break;
229289 memcpy(pAlloc, zName, nName+1);
229350 pTab->zName, &pTab->nCol, &pTab->nTotalCol, 0, &pTab->azCol,
229362 if( 0==sqlite3_stricmp("sqlite_stat1", pTab->zName) ){
229368 1 + sessionVarintLen(pTab->nCol) + pTab->nCol + strlen(pTab->zName)+1
229396 pTab->zName, &nCol, &nTotalCol, 0, &azCol, &azDflt, &aiIdx, &abPK,
230013 const char *zName,
230017 int nName = sqlite3Strlen30(zName);
230022 if( 0==sqlite3_strnicmp(pRet->zName, zName, nName+1) ) break;
230029 || pSession->xTableFilter(pSession->pFilterCtx, zName)
230031 rc = sqlite3session_attach(pSession, zName);
230038 assert( 0==sqlite3_strnicmp(pRet->zName, zName, nName+1) );
230056 char const *zName, /* Table name */
230077 pSession->rc = sessionFindTable(pSession, zName, &pTab);
230244 zDb1, zDb2, pTab->bRowid, pTab->zName, zExpr
230283 zRet, (zRet ? ", " : ""), zDb, pTab->zName, pTab->azCol[ii]
230299 pSession->zDb, zFrom, pTab->zName, pTab->azCol, pTab->abPK
230308 z1, z2, pSession->zDb, pTab->zName, zFrom, pTab->zName, zExpr, zExpr2
230430 zDb, zFrom, pTo->zName, pTo->azCol, pTo->abPK
230575 const char *zName /* Table name */
230580 if( !zName ){
230588 nName = sqlite3Strlen30(zName);
230590 if( 0==sqlite3_strnicmp(pTab->zName, zName, nName+1) ) break;
230607 pTab->zName = (char *)&pTab[1];
230608 memcpy(pTab->zName, zName, nName+1);
231158 sessionAppendBlob(pBuf, (u8 *)pTab->zName, (int)strlen(pTab->zName)+1, pRc);
231204 const char *zName = pTab->zName;
231223 zName, pTab->bRowid, pTab->nCol, pTab->azCol, pTab->abPK, &pSel
233971 if( 0==sqlite3_strnicmp(pTab->zName, zTab, nTab+1) ) break;
233986 pTab->zName = (char*)&pTab->abPK[nCol];
233987 memcpy(pTab->zName, zTab, nTab+1);
234535 if( 0==sqlite3_stricmp(pTab->zName, zTab) ) break;
235491 const char *zName,
235500 const char *zName,
235508 const char *zName,
235519 const char *zName,
235528 const char *zName,
235776 char *zName; /* Name of FTS index */
236288 static int sqlite3Fts5StorageRename(Fts5Storage*, const char *zName);
239459 const char *zName;
239473 for(i=0; aEnum[i].zName; i++){
239474 if( sqlite3_strnicmp(aEnum[i].zName, zEnum, nEnum)==0 ){
239847 pRet->zName = sqlite3Fts5Strndup(&rc, azArg[2], -1);
239853 if( rc==SQLITE_OK && sqlite3_stricmp(pRet->zName, FTS5_RANK_NAME)==0 ){
239854 *pzErr = sqlite3_mprintf("reserved fts5 table name: %s", pRet->zName);
239956 &rc, "%Q.'%q_%s'", pRet->zDb, pRet->zName, zTail
239992 sqlite3_free(pConfig->zName);
240023 zSql, pConfig->zName, FTS5_RANK_NAME
240323 zSql = sqlite3Fts5Mprintf(&rc, zSelect, pConfig->zDb, pConfig->zName);
245191 pConfig->zDb, pConfig->zName
245215 pConfig->zDb, pConfig->zName
245244 pConfig->zDb, pConfig->zName
246892 pConfig->zDb, pConfig->zName
246993 pConfig->zDb, pConfig->zName
248875 pConfig->zDb, pConfig->zName
249330 p->pConfig->zDb, p->pConfig->zName
249761 pConfig->zDb, pConfig->zName, FTS5_CURRENT_VERSION_SECUREDELETE
251074 p->zDataTbl = sqlite3Fts5Mprintf(&rc, "%s_data", pConfig->zName);
252674 pConfig->zDb, pConfig->zName, pSeg->iSegid
253862 char *zName; /* Name of tokenizer */
254799 pConfig->zDb, pConfig->zName, zRank, pConfig->zName,
254874 static Fts5Auxiliary *fts5FindAuxiliary(Fts5FullTable *pTab, const char *zName){
254878 if( sqlite3_stricmp(zName, pAux->zFunc)==0 ) return pAux;
255308 fts5SetVtabError(pTab,"%s: table does not support scanning",pConfig->zName);
255603 , "cannot UPDATE", pConfig->zName
255701 "cannot DELETE from contentless fts5 table: %s", pConfig->zName
256803 const char *zName, /* Name of SQL function */
256811 pAux = fts5FindAuxiliary(pTab, zName);
256827 const char *zName /* New name of table */
256831 rc = sqlite3Fts5StorageRename(pTab->pStorage, zName);
256897 const char *zName, /* Name of new function */
256903 int rc = sqlite3_overload_function(pGlobal->db, zName, -1);
256909 nName = strlen(zName) + 1;
256915 memcpy(pAux->zFunc, zName, nName);
256947 const char *zName, /* Name of new function */
256957 nName = strlen(zName) + 1;
256961 pNew->zName = (char*)&pNew[1];
256962 memcpy(pNew->zName, zName, nName);
257077 const char *zName, /* Name of new function */
257089 rc = fts5NewTokenizerModule(pGlobal, zName, pUserData, xDestroy, &pNew);
257107 const char *zName, /* Name of new function */
257116 (Fts5Global*)pApi, zName, pUserData, xDestroy, &pNew
257134 const char *zName /* Name of tokenizer module to find */
257138 if( zName==0 ){
257142 if( sqlite3_stricmp(zName, pMod->zName)==0 ) break;
257155 const char *zName, /* Name of tokenizer */
257162 pMod = fts5LocateTokenizer((Fts5Global*)pApi, zName);
257185 const char *zName, /* Name of new function */
257192 pMod = fts5LocateTokenizer((Fts5Global*)pApi, zName);
257392 static int fts5ShadowName(const char *zName){
257398 if( sqlite3_stricmp(zName, azName[i])==0 ) return 1;
257756 zSql = sqlite3Fts5Mprintf(&rc, azStmt[eStmt], pC->zDb, pC->zName,zBind);
257762 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName,
257770 pC->zDb, pC->zName
257775 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName);
257838 pConfig->zDb, pConfig->zName,
257839 pConfig->zDb, pConfig->zName,
257840 pConfig->zDb, pConfig->zName
257845 pConfig->zDb, pConfig->zName
257851 pConfig->zDb, pConfig->zName
257861 const char *zName /* New name of FTS5 table */
257866 pConfig->zDb, pConfig->zName, zTail, zName, zTail
257871 static int sqlite3Fts5StorageRename(Fts5Storage *pStorage, const char *zName){
257875 fts5StorageRenameOne(pConfig, &rc, "data", zName);
257876 fts5StorageRenameOne(pConfig, &rc, "idx", zName);
257877 fts5StorageRenameOne(pConfig, &rc, "config", zName);
257879 fts5StorageRenameOne(pConfig, &rc, "docsize", zName);
257882 fts5StorageRenameOne(pConfig, &rc, "content", zName);
257902 pConfig->zDb, pConfig->zName, zPost, zDefn,
257911 pConfig->zName, zPost, zErr
258394 pConfig->zDb, pConfig->zName,
258395 pConfig->zDb, pConfig->zName
258399 "DELETE FROM %Q.'%q_docsize';", pConfig->zDb, pConfig->zName
258405 "DELETE FROM %Q.'%q_content';", pConfig->zDb, pConfig->zName
258693 pConfig->zDb, pConfig->zName, zSuffix
260570 const char *zName;
260583 aBuiltin[i].zName,