Lines Matching refs:zName
1738 const char *zName; /* Name of this virtual file system */ member
1740 int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,
1742 int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);
1743 int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut);
1744 int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);
1762 int (*xSetSystemCall)(sqlite3_vfs*, const char *zName, sqlite3_syscall_ptr);
1763 sqlite3_syscall_ptr (*xGetSystemCall)(sqlite3_vfs*, const char *zName);
1764 const char *(*xNextSystemCall)(sqlite3_vfs*, const char *zName);
4897 SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
6310 const char *zName,
6317 const char *zName,
6325 const void *zName,
7269 int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName,
7484 const char *zName, /* Name of the module */
7490 const char *zName, /* Name of the module */
10025 char const *zName, /* Table name */
12764 const char *zName,
12773 const char *zName,
12781 const char *zName,
16756 const char *zName; /* SQL name of the function. */ member
16899 #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \ argument
16902 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
16903 #define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \ argument
16905 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
16906 #define SFUNCTION(zName, nArg, iArg, bNC, xFunc) \ argument
16908 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
16909 #define MFUNCTION(zName, nArg, xPtr, xFunc) \ argument
16911 xPtr, 0, xFunc, 0, 0, 0, #zName, {0} }
16912 #define INLINE_FUNC(zName, nArg, iArg, mFlags) \ argument
16915 SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }
16916 #define TEST_FUNC(zName, nArg, iArg, mFlags) \ argument
16920 SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }
16921 #define DFUNCTION(zName, nArg, iArg, bNC, xFunc) \ argument
16923 0, 0, xFunc, 0, 0, 0, #zName, {0} }
16924 #define PURE_DATE(zName, nArg, iArg, bNC, xFunc) \ argument
16927 (void*)&sqlite3Config, 0, xFunc, 0, 0, 0, #zName, {0} }
16928 #define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \ argument
16931 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
16932 #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \ argument
16935 pArg, 0, xFunc, 0, 0, 0, #zName, }
16936 #define LIKEFUNC(zName, nArg, arg, flags) \ argument
16938 (void *)arg, 0, likeFunc, 0, 0, 0, #zName, {0} }
16939 #define WAGGREGATE(zName, nArg, arg, nc, xStep, xFinal, xValue, xInverse, f) \ argument
16941 SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,xValue,xInverse,#zName, {0}}
16942 #define INTERNAL_FUNCTION(zName, nArg, xFunc) \ argument
16945 0, 0, xFunc, 0, 0, 0, #zName, {0} }
16955 char *zName; /* Savepoint name (nul-terminated) */ member
16977 const char *zName; /* Name passed to create_module() */ member
17066 char *zName; /* Name of the collating sequence, UTF-8 encoded */ member
17186 char *zName; /* Name of the table or view */ member
17503 char *zName; /* Name of this index */ member
17959 char *zName; /* Name of the identifier */ member
17979 char *zName; /* Name of the table */ member
18662 char *zName; /* The name of the trigger */ member
18981 char *zName; /* Name of this CTE */ member
19063 char *zName; /* Name of window (may be NULL) */ member
19390 SQLITE_PRIVATE Module *sqlite3PragmaVtabRegister(sqlite3*,const char *zName);
19703 SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName);
19790 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char*zName);
20014 SQLITE_PRIVATE int sqlite3ShadowTableName(sqlite3 *db, const char *zName);
22037 char *zName; /* Name of table or index */
23313 char *zName; /* Name of the transformation */
23517 && sqlite3_strnicmp(aXformType[i].zName, z, n)==0
24289 if( strcmp(zVfs, pVfs->zName)==0 ) break;
29780 }else if( pItem->zName ){
29785 sqlite3_str_appendall(pAccum, pItem->zName);
30353 sqlite3_str_appendf(&x, "%s", pCte->zName);
30390 pItem->pTab->zName, pItem->pTab->nCol, pItem->pTab, pItem->colUsed);
30579 if( pWin->zName ){
30580 sqlite3TreeViewLine(pView, "OVER %s (%p)", pWin->zName, pWin);
30639 pWin->pFunc->zName, pWin->pFunc->nArg);
31032 char *zName = pList->a[i].zEName;
31034 if( pList->a[i].eEName!=ENAME_NAME ) zName = 0;
31035 if( j || zName ){
31039 if( zName ){
31040 fprintf(stdout, "AS %s ", zName);
31049 if( j || zName ){
33698 const char *zName, /* Name of symbol to add */
33723 memcpy(z, zName, nName);
33749 SQLITE_PRIVATE int sqlite3VListNameToNum(VList *pIn, const char *zName, int nName){
33756 if( strncmp(z,zName,nName)==0 && z[nName]==0 ) return pIn[i];
34621 const char *zName; /* Name of the system call */
34810 const char *zName, /* Name of system call to override */
34817 if( zName==0 ){
34832 if( strcmp(zName, aSyscall[i].zName)==0 ){
34853 const char *zName
34859 if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
34870 static const char *unixNextSystemCall(sqlite3_vfs *p, const char *zName){
34874 if( zName ){
34876 if( strcmp(zName, aSyscall[i].zName)==0 ) break;
34880 if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
38243 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
39893 if( strcmp(pVfs->zName,"unix-excl")==0 ){
40342 const char *zName = zPath;
40358 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
40359 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
40360 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_SUPER_JOURNAL );
40361 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
40383 assert( zName==0 );
40388 pUnused = findReusableFd(zName, flags);
40402 assert( (flags & SQLITE_OPEN_URI) || zName[strlen(zName)+1]==0 );
40404 }else if( !zName ){
40411 zName = zTmpname;
40415 assert( zName[strlen(zName)+1]==0 );
40432 rc = findCreateFileMode(zName, flags, &openMode, &uid, &gid);
40438 fd = robust_open(zName, openFlags, openMode);
40439 OSTRACE(("OPENX %-3d %s 0%o\n", fd, zName, openFlags));
40442 if( isNewJrnl && errno==EACCES && osAccess(zName, F_OK) ){
40453 fd = robust_open(zName, openFlags, openMode);
40457 int rc2 = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName);
40491 zPath = zName;
40493 zPath = sqlite3_mprintf("%s", zName);
40499 osUnlink(zName);
41368 dummyVfs.zName = "dummy";
42874 const char *zName; /* Name of the system call */
43536 const char *zName, /* Name of system call to override */
43543 if( zName==0 ){
43558 if( strcmp(zName, aSyscall[i].zName)==0 ){
43579 const char *zName
43585 if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
43596 static const char *winNextSystemCall(sqlite3_vfs *p, const char *zName){
43600 if( zName ){
43602 if( strcmp(zName, aSyscall[i].zName)==0 ) break;
43606 if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
44614 LPWSTR zName;
44619 zName = winUtf8ToUnicode(zFilename);
44620 if( zName==0 ){
44630 zTok = osCharLowerW(zName);
44636 pFile->hMutex = osCreateMutexW(NULL, FALSE, zName);
44639 sqlite3_free(zName);
44651 osCharUpperW(zName);
44654 zName);
44663 sqlite3_free(zName);
45927 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
47356 const char *zName, /* Name of the file (UTF-8) */
47373 const char *zUtf8Name = zName; /* Filename in UTF-8 encoding */
47417 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
47418 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
47419 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_SUPER_JOURNAL );
47420 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
47497 if( 0==sqlite3_uri_boolean(zName, "exclusive", 0) ){
47541 rc2 = winAccess(pVfs, zName, SQLITE_ACCESS_READ, &isRO);
47558 rc2 = winAccess(pVfs, zName, SQLITE_ACCESS_READ, &isRO);
47578 rc2 = winAccess(pVfs, zName, SQLITE_ACCESS_READ, &isRO);
47594 return winOpen(pVfs, zName, id,
47623 && (rc = winceCreateLock(zName, pFile))!=SQLITE_OK
47628 OSTRACE(("OPEN-CE-LOCK name=%s, rc=%s\n", zName, sqlite3ErrName(rc)));
47648 && sqlite3_uri_boolean(zName, "psow", SQLITE_POWERSAFE_OVERWRITE)
47653 pFile->zPath = zName;
48649 static int memdbAccess(sqlite3_vfs*, const char *zName, int flags, int *);
48650 static int memdbFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
49026 const char *zName,
49037 szName = sqlite3Strlen30(zName);
49038 if( szName>1 && zName[0]=='/' ){
49045 if( strcmp(memdb_g.apMemStore[i]->zFName,zName)==0 ){
49070 memcpy(p->zFName, zName, szName+1);
57687 SQLITE_API sqlite3_file *sqlite3_database_file_object(const char *zName){
57689 while( zName[-1]!=0 || zName[-2]!=0 || zName[-3]!=0 || zName[-4]!=0 ){
57690 zName--;
57692 pPager = *(Pager**)(zName - 4 - sizeof(Pager*));
61290 static char zName[15];
61291 sqlite3_snprintf(sizeof(zName), zName, "READ-LOCK[%d]",
61293 return zName;
80202 const char *zName /* Name of table or index being scanned */
80213 pNew->zName = sqlite3DbStrDup(p->db, zName);
80823 const char *zColl = pColl ? pColl->zName : "";
80843 sqlite3_str_appendf(&x, "%.18s-%s", pColl->zName,
80849 sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg);
80854 sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg);
80912 zP4 = pOp->p4.pTab->zName;
81783 const char *zName, /* Pointer to buffer containing name */
81791 assert( !zName || xDel!=SQLITE_DYNAMIC );
81796 rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, xDel);
81797 assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 );
82648 sqlite3DbFree(db, p->aScan[i].zName);
84319 pCtx->pFunc->zName, zContext);
84386 const char *zTbl = pTab->zName;
86049 SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){
86050 if( p==0 || zName==0 ) return 0;
86051 return sqlite3VListNameToNum(p->pVList, zName, nName);
86053 SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
86054 return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName));
86476 *(const char**)pOut = pScan->zName;
89706 pTab->zName, aCol[i].zCnName);
90091 char *zName; /* Name of savepoint */
90100 zName = pOp->p4.z;
90119 nName = sqlite3Strlen30(zName);
90135 pNew->zName = (char *)&pNew[1];
90136 memcpy(pNew->zName, zName, nName+1);
90162 pSavepoint && sqlite3StrICmp(pSavepoint->zName, zName);
90168 sqlite3VdbeError(p, "no such savepoint: %s", zName);
92027 zDb, pTab->zName, x.nKey);
92186 db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, pTab->zName,
95474 sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT);
98504 const char *zName; /* tables_used.name */
98597 pCur->zName = 0;
98622 if( pCur->zName ){
98623 pCur->zName = 0;
98677 pCur->zName = pTab->zName;
98682 if( pCur->zName==0 ){
98686 pCur->zName = pIdx->zName;
98749 sqlite3_result_text(ctx, pCur->zName, -1, SQLITE_STATIC);
99241 const char *zName, /* Name of the journal file */
99254 return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0);
99267 p->zJournal = zName;
99716 if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ) return 1;
99894 assert( pTab!=0 && pTab->zName!=0 );
99914 const char *zTabName = pItem->zAlias ? pItem->zAlias : pTab->zName;
99976 && (zTab==0 || sqlite3StrICmp(zTab,pParse->pTriggerTab->zName)==0)
100538 pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120;
100543 int auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0,pDef->zName,0);
100547 pDef->zName);
101261 if( pItem->zName ) pParse->zAuthContext = pItem->zName;
101620 sSrc.a[0].zName = pTab->zName;
101894 return sqlite3StrICmp(pColl1->zName, pColl2->zName)==0;
102754 sqlite3ErrorMsg(pParse, "unsafe use of %s()", pDef->zName);
103153 pRet->a[i].zName = sqlite3DbStrDup(db, p->a[i].zName);
103288 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
103335 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
103515 pList->a[pList->nExpr-1].zEName = pColumns->a[i].zName;
103516 pColumns->a[i].zName = 0;
104373 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
104384 "USING ROWID SEARCH ON TABLE %s FOR IN-OPERATOR",pTab->zName));
104449 if( pReq!=0 && sqlite3StrICmp(pReq->zName, pIdx->azColl[j])!=0 ){
104466 "USING INDEX %s FOR IN-OPERATOR",pIdx->zName));
104469 VdbeComment((v, "%s", pIdx->zName));
105653 VdbeComment((v,"%s.rowid",pTab->zName));
105656 pTab->zName, pTab->aCol[pCol->iColumn].zCnName));
108024 if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7)
108032 sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName);
108124 char *zName = 0; /* NULL-terminated version of pName */
108141 zName = sqlite3NameFromToken(db, pName);
108142 if( !zName ) goto exit_rename_table;
108147 if( sqlite3FindTable(db, zName, zDb)
108148 || sqlite3FindIndex(db, zName, zDb)
108149 || sqlite3IsShadowTableOf(db, pTab, zName)
108152 "there is already another table or index with this name: %s", zName);
108162 if( SQLITE_OK!=sqlite3CheckObjectName(pParse,zName,"table",zName) ){
108168 sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
108175 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
108203 zTabName = pTab->zName;
108213 , zDb, zDb, zTabName, zName, (iDb==1), zTabName
108230 zName, zName, zName,
108241 zDb, zName, pTab->zName);
108257 , zDb, zTabName, zName, zTabName, zDb, zName);
108268 sqlite3VdbeLoadString(v, i, zName);
108278 sqlite3DbFree(db, zName);
108326 zTab = &pNew->zName[16]; /* Skip the "sqlite_altertab_" prefix on the name */
108334 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
108520 pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
108521 if( !pNew->aCol || !pNew->zName ){
108566 zType, pTab->zName
108611 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
108647 zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1,
108648 pTab->zName
108655 zDb, pTab->zName, iCol, zNew, bQuote
108852 sqlite3RenameTokenRemap(pParse, 0, (const void*)pIdList->a[ii].zName);
108880 sqlite3RenameTokenRemap(pParse, 0, (void*)pSrc->a[i].zName);
109075 const char *zName = pEList->a[i].zEName;
109077 && ALWAYS(zName!=0)
109078 && 0==sqlite3_stricmp(zName, zOld)
109080 renameTokenFind(pParse, pCtx, (const void*)zName);
109100 const char *zName = pIdList->a[i].zName;
109101 if( 0==sqlite3_stricmp(zName, zOld) ){
109102 renameTokenFind(pParse, pCtx, (const void*)zName);
109509 int bFKOnly = sqlite3_stricmp(zTable, sParse.pNewTable->zName);
109637 renameTokenFind(pWalker->pParse, p, pItem->zName);
109742 if( sqlite3_stricmp(zOld, pTab->zName)==0 ){
109747 renameTokenFind(&sParse, &sCtx, pTab->zName);
109753 renameTokenFind(&sParse, &sCtx, sParse.pNewIndex->zName);
110136 , zDb, iDb, iCol, pTab->zName
110401 const char *zName;
110433 const char *zTab = aTable[i].zName;
110475 VdbeComment((v, aTable[i].zName));
111175 VdbeComment((v,"%s.rowid",pIdx->zName));
111177 VdbeComment((v,"%s.expr(%d)",pIdx->zName, k));
111179 VdbeComment((v,"%s.%s", pIdx->zName, pIdx->pTable->aCol[i].zCnName));
111230 if( sqlite3_strlike("sqlite\\_%", pTab->zName, '\\')==0 ){
111239 if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,
111249 pStat1->zName = (char*)&pStat1[1];
111250 memcpy(pStat1->zName, "sqlite_stat1", 13);
111261 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
111266 sqlite3VdbeLoadString(v, regTabname, pTab->zName);
111279 zIdxName = pTab->zName;
111283 zIdxName = pIdx->zName;
111289 VdbeComment((v, "Analysis for %s.%s", pTab->zName, zIdxName));
111333 VdbeComment((v, "%s", pIdx->zName));
111531 VdbeComment((v, "%s", pTab->zName));
111600 openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");
111602 openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
111905 const char *zName,
111908 Index *pIdx = sqlite3FindIndex(db, zName, zDb);
111910 Table *pTab = sqlite3FindTable(db, zName, zDb);
112212 SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName){
112214 sqlite3StrICmp(db->aDb[iDb].zDbSName, zName)==0
112215 || (iDb==0 && sqlite3StrICmp("main", zName)==0)
112242 const char *zName;
112254 zName = (const char *)sqlite3_value_text(argv[1]);
112256 if( zName==0 ) zName = "";
112291 assert( zName );
112292 if( sqlite3DbIsNamed(db, i, zName) ){
112293 zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName);
112318 rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
112329 pNew->zDbSName = sqlite3DbStrDup(db, zName);
112380 rc = sqlite3UserAuthCheckLogin(db, zName, &newAuth);
112432 const char *zName = (const char *)sqlite3_value_text(argv[0]);
112441 if( zName==0 ) zName = "";
112445 if( sqlite3DbIsNamed(db, i, zName) ) break;
112449 sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
112453 sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
112459 sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
112947 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
113086 const char *zName /* Name of the table to be locked */
113111 p->zLockName = zName;
113122 const char *zName /* Name of the table to be locked */
113126 lockTable(pParse, iDb, iTab, isWriteLock, zName);
113393 SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){
113402 if( db->auth.authLevel<UAUTH_Admin && sqlite3UserAuthTable(zName)!=0 ){
113419 p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName);
113420 if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){
113422 if( sqlite3StrICmp(zName+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0
113423 || sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0
113424 || sqlite3StrICmp(zName+7, &LEGACY_SCHEMA_TABLE[7])==0
113430 if( sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0 ){
113438 p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash, zName);
113441 p = sqlite3HashFind(&db->aDb[0].pSchema->tblHash, zName);
113446 p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName);
113449 if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){
113450 if( sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0 ){
113452 }else if( sqlite3StrICmp(zName+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0 ){
113474 const char *zName, /* Name of the table we are looking for */
113488 p = sqlite3FindTable(db, zName, zDbase);
113495 Module *pMod = (Module*)sqlite3HashFind(&db->aModule, zName);
113496 if( pMod==0 && sqlite3_strnicmp(zName, "pragma_", 7)==0 ){
113497 pMod = sqlite3PragmaVtabRegister(db, zName);
113514 sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
113516 sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
113547 return sqlite3LocateTable(pParse, flags, p->zName, zDb);
113554 SQLITE_PRIVATE const char *sqlite3PreferredTableName(const char *zName){
113555 if( sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){
113556 if( sqlite3StrICmp(zName+7, &LEGACY_SCHEMA_TABLE[7])==0 ){
113559 if( sqlite3StrICmp(zName+7, &LEGACY_TEMP_SCHEMA_TABLE[7])==0 ){
113563 return zName;
113578 SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){
113589 p = sqlite3HashFind(&pSchema->idxHash, zName);
113873 char *zName = pIndex->zName;
113875 &pIndex->pSchema->idxHash, zName, 0
113899 sqlite3DbFree(db, pTable->zName);
113948 char *zName;
113950 zName = sqlite3DbStrNDup(db, (const char*)pName->z, pName->n);
113951 sqlite3Dequote(zName);
113953 zName = 0;
113955 return zName;
113977 SQLITE_PRIVATE int sqlite3FindDbName(sqlite3 *db, const char *zName){
113979 if( zName ){
113982 if( 0==sqlite3_stricmp(pDb->zDbSName, zName) ) break;
113985 if( i==0 && 0==sqlite3_stricmp("main", zName) ) break;
113999 char *zName; /* Name we are searching for */
114000 zName = sqlite3NameFromToken(db, pName);
114001 i = sqlite3FindDbName(db, zName);
114002 sqlite3DbFree(db, zName);
114079 const char *zName, /* Name of the object to check */
114093 || sqlite3_stricmp(zName, db->init.azInit[1])
114100 if( (pParse->nested==0 && 0==sqlite3StrNICmp(zName, "sqlite_", 7))
114101 || (sqlite3ReadOnlyShadowTables(db) && sqlite3ShadowTableName(db, zName))
114104 zName);
114256 char *zName = 0; /* The name of the new table */
114265 zName = sqlite3DbStrDup(db, SCHEMA_TABLE(iDb));
114278 zName = sqlite3NameFromToken(db, pName);
114280 sqlite3RenameTokenMap(pParse, (void*)zName, pName);
114284 if( zName==0 ) return;
114285 if( sqlite3CheckObjectName(pParse, zName, isView?"view":"table", zName) ){
114304 zName, 0, zDb) ){
114322 pTable = sqlite3FindTable(db, zName, zDb);
114333 if( sqlite3FindIndex(db, zName, zDb)!=0 ){
114334 sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
114346 pTable->zName = zName;
114428 sqlite3DbFree(db, zName);
114502 pRet->retTrig.zName = RETURNING_TRIGGER_NAME;
114543 sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
114879 "table \"%s\" has more than one primary key", pTab->zName);
115151 n += identLength(p->zName);
115169 identPut(zStmt, &k, p->zName);
115527 SQLITE_PRIVATE int sqlite3IsShadowTableOf(sqlite3 *db, Table *pTab, const char *zName){
115532 nName = sqlite3Strlen30(pTab->zName);
115533 if( sqlite3_strnicmp(zName, pTab->zName, nName)!=0 ) return 0;
115534 if( zName[nName]!='_' ) return 0;
115539 return pMod->pModule->xShadowName(zName+nName+1);
115561 assert( pTab->zName!=0 );
115562 nName = sqlite3Strlen30(pTab->zName);
115565 assert( pOther->zName!=0 );
115568 if( sqlite3StrNICmp(pOther->zName, pTab->zName, nName)==0
115569 && pOther->zName[nName]=='_'
115570 && pMod->pModule->xShadowName(pOther->zName+nName+1)
115586 SQLITE_PRIVATE int sqlite3ShadowTableName(sqlite3 *db, const char *zName){
115589 zTail = strrchr(zName, '_');
115592 pTab = sqlite3FindTable(db, zName, 0);
115596 return sqlite3IsShadowTableOf(db, pTab, zName);
115665 if( pSelect==0 && sqlite3ShadowTableName(db, p->zName) ){
115705 p->zName, pCol->zCnName, sqlite3ColumnType(pCol, "")
115709 p->zName, pCol->zCnName);
115738 sqlite3ErrorMsg(pParse, "PRIMARY KEY missing on table %s", p->zName);
115911 p->zName,
115912 p->zName,
115938 sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName),0);
115948 pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p);
115962 if( strcmp(p->zName, "sqlite_sequence")==0 ){
116122 sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
116351 const char *zName /* Name of index or table */
116361 zDbName, zTab, zType, zName
116407 pDb->zDbSName, pTab->zName
116422 pDb->zDbSName, pTab->zName);
116431 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
116434 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
116460 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
116461 if( sqlite3StrNICmp(pTab->zName+7, "stat", 4)==0 ) return 0;
116462 if( sqlite3StrNICmp(pTab->zName+7, "parameters", 10)==0 ) return 0;
116529 zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
116538 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
116541 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
116547 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
116556 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
116560 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
116572 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
116769 if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
116776 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
116935 char *zName = 0; /* Name of the index */
117002 pTab->zName);
117017 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
117021 && sqlite3UserAuthTable(pTab->zName)==0
117024 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
117054 zName = sqlite3NameFromToken(db, pName);
117055 if( zName==0 ) goto exit_create_index;
117057 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName,"index",pTab->zName) ){
117062 if( sqlite3FindTable(db, zName, 0)!=0 ){
117063 sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
117067 if( sqlite3FindIndex(db, zName, pDb->zDbSName)!=0 ){
117069 sqlite3ErrorMsg(pParse, "index %s already exists", zName);
117082 zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
117083 if( zName==0 ){
117092 if( IN_SPECIAL_PARSE ) zName[7]++;
117105 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
117145 nName = sqlite3Strlen30(zName);
117155 pIndex->zName = zExtra;
117157 memcpy(pIndex->zName, zName, nName+1);
117380 pIndex->zName, pIndex);
117442 pIndex->zName,
117443 pTab->zName,
117456 sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName), 0);
117509 sqlite3DbFree(db, zName);
117588 pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
117615 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
117627 db->aDb[iDb].zDbSName, pIndex->zName
117629 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
117632 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
117704 pList->a[i].zName = sqlite3NameFromToken(db, pToken);
117705 if( IN_RENAME_OBJECT && pList->a[i].zName ){
117706 sqlite3RenameTokenMap(pParse, (void*)pList->a[i].zName, pToken);
117718 sqlite3DbFree(db, pList->a[i].zName);
117728 SQLITE_PRIVATE int sqlite3IdListIndex(IdList *pList, const char *zName){
117732 if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
117891 pItem->zName = sqlite3NameFromToken(db, pDatabase);
117894 pItem->zName = sqlite3NameFromToken(db, pTable);
117927 sqlite3DbFree(db, pItem->zName);
117980 assert( pItem->zName==0 || pDatabase!=0 );
117981 if( IN_RENAME_OBJECT && pItem->zName ){
117983 sqlite3RenameTokenMap(pParse, pItem->zName, pToken);
118151 char *zName = sqlite3NameFromToken(pParse->db, pName);
118152 if( zName ){
118158 if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
118159 sqlite3DbFree(pParse->db, zName);
118162 sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
118330 sqlite3_str_appendf(&errMsg, "index '%q'", pIdx->zName);
118337 sqlite3_str_appendall(&errMsg, pTab->zName);
118361 zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
118365 zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
118572 pNew->zName = sqlite3NameFromToken(pParse->db, pName);
118586 sqlite3DbFree(db, pCte->zName);
118611 char *zName;
118619 zName = pCte->zName;
118620 if( zName && pWith ){
118623 if( sqlite3StrICmp(zName, pWith->a[i].zName)==0 ){
118624 sqlite3ErrorMsg(pParse, "duplicate WITH table name: %s", zName);
118635 assert( (pNew!=0 && zName!=0) || db->mallocFailed );
118686 static void callCollNeeded(sqlite3 *db, int enc, const char *zName){
118689 char *zExternal = sqlite3DbStrDup(db, zName);
118698 sqlite3ValueSetStr(pTmp, -1, zName, SQLITE_UTF8, SQLITE_STATIC);
118717 char *z = pColl->zName;
118744 const char *zName = pColl->zName;
118746 CollSeq *p = sqlite3GetCollSeq(pParse, ENC(db), pColl, zName);
118772 const char *zName, /* Name of the collating sequence */
118776 pColl = sqlite3HashFind(&db->aCollSeq, zName);
118779 int nName = sqlite3Strlen30(zName) + 1;
118783 pColl[0].zName = (char*)&pColl[3];
118785 pColl[1].zName = (char*)&pColl[3];
118787 pColl[2].zName = (char*)&pColl[3];
118789 memcpy(pColl[0].zName, zName, nName);
118790 pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, pColl);
118825 const char *zName, /* Name of the collating sequence. Might be NULL */
118831 if( zName ){
118832 pColl = findCollSeqEntry(db, zName, create);
118871 const char *zName /* Collating sequence name */
118878 p = sqlite3FindCollSeq(db, enc, zName, 0);
118884 callCollNeeded(db, enc, zName);
118885 p = sqlite3FindCollSeq(db, enc, zName, 0);
118892 sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);
118918 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){
118924 pColl = sqlite3FindCollSeq(db, enc, zName, initbusy);
118926 pColl = sqlite3GetCollSeq(pParse, enc, pColl, zName);
119004 if( sqlite3StrICmp(p->zName, zFunc)==0 ){
119021 const char *zName = aDef[i].zName;
119022 int nName = sqlite3Strlen30(zName);
119023 int h = SQLITE_FUNC_HASH(zName[0], nName);
119024 assert( zName[0]>='a' && zName[0]<='z' );
119026 pOther = sqlite3FunctionSearch(h, zName);
119062 const char *zName, /* Name of the function. zero-terminated */
119075 nName = sqlite3Strlen30(zName);
119079 p = (FuncDef*)sqlite3HashFind(&db->aFunc, zName);
119103 h = SQLITE_FUNC_HASH(sqlite3UpperToLower[(u8)zName[0]], nName);
119104 p = sqlite3FunctionSearch(h, zName);
119123 pBest->zName = (const char*)&pBest[1];
119126 memcpy((char*)&pBest[1], zName, nName+1);
119127 for(z=(u8*)pBest->zName; *z; z++) *z = sqlite3UpperToLower[*z];
119128 pOther = (FuncDef*)sqlite3HashInsert(&db->aFunc, pBest->zName, pBest);
119287 sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
119292 sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
119323 pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName);
119395 const char *zName = pTab->aCol[pPk->aiColumn[0]].zCnName;
119396 pLhs = sqlite3Expr(db, TK_ID, zName);
119397 pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ID, zName));
119541 rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0,
119560 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
119628 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
119631 pTab->zName, P4_STATIC);
119997 if( pParse->nested==0 || 0==sqlite3_stricmp(pTab->zName, "sqlite_stat1") ){
120068 VdbeModuleComment((v, "GenRowIdxDel for %s", pIdx->zName));
122530 int n = sqlite3Strlen30(p->zName);
122531 int h = p->zName[0] + n;
122533 printf(" %s(%d)", p->zName, h);
122826 pFKey->pFrom->zName, pFKey->zTo);
123033 if( zColl==0 ) zColl = db->pDfltColl->zName;
123225 return (FKey *)sqlite3HashFind(&pTab->pSchema->fkeyHash, pTab->zName);
123471 && sqlite3_stricmp(pTab->zName, pFKey->zTo)!=0
123529 rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
123538 sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
123594 pItem->zName = pFKey->pFrom->zName;
123625 pItem->zName = 0;
123710 if( 0==sqlite3_stricmp(pTab->zName, p->zTo) ) eRet = 2;
123863 zFrom = pFKey->pFrom->zName;
124059 (opcode==OP_OpenWrite)?1:0, pTab->zName);
124062 VdbeComment((v, "%s", pTab->zName));
124069 VdbeComment((v, "%s", pTab->zName));
124495 sqlite3VdbeLoadString(v, memId-1, p->pTab->zName);
124763 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0,
124865 if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zCnName)==0 ){
124883 if( sqlite3IsRowid(pColumn->a[i].zName) && !withoutRowid ){
124888 pTabList->a, pColumn->a[i].zName);
125057 pTab->zName);
125778 char *zMsg = sqlite3MPrintf(db, "%s.%s", pTab->zName,
125847 char *zName = pCheck->a[i].zEName;
125848 assert( zName!=0 || pParse->db->mallocFailed );
125851 onError, zName, P4_TRANSIENT,
126165 VdbeNoopComment((v, "prep index %s", pIdx->zName));
126189 VdbeComment((v, "%s column %d", pIdx->zName, i));
126202 VdbeComment((v, "for %s", pIdx->zName));
126292 VdbeComment((v, "%s.%s", pTab->zName,
126658 sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
126672 VdbeComment((v, "%s", pIdx->zName));
127074 sqlite3TableLock(pParse, iDbDest, pDest->tnum, 1, pDest->zName);
127075 sqlite3TableLock(pParse, iDbSrc, pSrc->tnum, 0, pSrc->zName);
127085 VdbeComment((v, "%s", pSrcIdx->zName));
127089 VdbeComment((v, "%s", pDestIdx->zName));
127355 int (*bind_parameter_index)(sqlite3_stmt*,const char*zName);
129012 const char *const zName; /* Name of pragma */
129686 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, pPragma->zName, SQLITE_STATIC);
129751 const char *zName;
129753 case OE_SetNull: zName = "SET NULL"; break;
129754 case OE_SetDflt: zName = "SET DEFAULT"; break;
129755 case OE_Cascade: zName = "CASCADE"; break;
129756 case OE_Restrict: zName = "RESTRICT"; break;
129757 default: zName = "NO ACTION";
129760 return zName;
129792 static const PragmaName *pragmaLocate(const char *zName){
129798 rc = sqlite3_stricmp(zName, aPragmaName[mid].zName);
129849 p->zName, isBuiltin,
130755 char *zSql = sqlite3MPrintf(db, "SELECT*FROM\"%w\"", pTab->zName);
130771 if( zRight && sqlite3_stricmp(zRight, pTab->zName)!=0 ) continue;
130783 sqlite3PreferredTableName(pTab->zName),
130803 sqlite3PreferredTableName(pTab->zName),
130810 pIdx->zName,
130879 pIdx->zName,
130908 sqlite3VdbeMultiLoad(v, 1, "is", i++, pColl->zName);
130940 sqlite3VdbeMultiLoad(v, 1, "s", pMod->zName);
130949 sqlite3VdbeMultiLoad(v, 1, "s", aPragmaName[i].zName);
131026 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
131029 sqlite3VdbeLoadString(v, regResult, pTab->zName);
131035 sqlite3TableLock(pParse, iDb, pParent->tnum, 0, pParent->zName);
131295 zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName,
131313 pTab->zName, pTab->aCol[j].zCnName);
131337 pTab->zName);
131361 jmp5 = sqlite3VdbeLoadString(v, 4, pIdx->zName);
131401 sqlite3VdbeLoadString(v, 4, pIdx->zName);
131461 char *zName;
131480 returnSingleText(v, encnames[ENC(pParse->db)].zName);
131488 for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
131489 if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){
131496 if( !pEnc->zName ){
131750 db->aDb[iDb].zDbSName, pTab->zName);
131961 sqlite3_str_appendf(&acc, "(\"%s\"", pPragma->zName);
132129 sqlite3_str_appendall(&acc, pTab->pName->zName);
132212 SQLITE_PRIVATE Module *sqlite3PragmaVtabRegister(sqlite3 *db, const char *zName){
132214 assert( sqlite3_strnicmp(zName, "pragma_", 7)==0 );
132215 pName = pragmaLocate(zName+7);
132218 assert( sqlite3HashFind(&db->aModule, zName)==0 );
132219 return sqlite3VtabCreateModule(db, zName, &pragmaVtabModule, (void*)pName, 0);
133733 char *zName; /* Name of column in the right table */
133738 zName = pRightTab->aCol[j].zCnName;
133739 if( tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol, 1) ){
133773 char *zName; /* Name of the term in the USING clause */
133778 zName = pList->a[j].zName;
133779 iRightCol = sqlite3ColumnIndex(pRightTab, zName);
133781 || !tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol, 0)
133784 "not present in both tables", zName);
135113 zOrigTab = pTab->zName;
135273 char *zName = pEList->a[i].zEName;
135274 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_TRANSIENT);
135288 char *zName = 0;
135289 zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol);
135290 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_DYNAMIC);
135336 char *zName; /* Column name */
135358 if( (zName = pEList->a[i].zEName)!=0 && pEList->a[i].eEName==ENAME_NAME ){
135373 zName = iCol>=0 ? pTab->aCol[iCol].zCnName : "rowid";
135376 zName = pColExpr->u.zToken;
135379 zName = pEList->a[i].zEName;
135382 if( zName && !sqlite3IsTrueOrFalse(zName) ){
135383 zName = sqlite3DbStrDup(db, zName);
135385 zName = sqlite3MPrintf(db,"column%d",i+1);
135392 while( zName && sqlite3HashFind(&ht, zName)!=0 ){
135393 nName = sqlite3Strlen30(zName);
135395 for(j=nName-1; j>0 && sqlite3Isdigit(zName[j]); j--){}
135396 if( zName[j]==':' ) nName = j;
135398 zName = sqlite3MPrintf(db, "%.*z:%u", nName, zName, ++cnt);
135401 pCol->zCnName = zName;
135402 pCol->hName = sqlite3StrIHash(zName);
135404 if( zName && sqlite3HashInsert(&ht, zName, pCol)==pCol ){
135477 sqlite3ColumnSetColl(db, pCol, pColl->zName);
135504 pTab->zName = 0;
135657 sqlite3ExprAddCollateString(pParse, pTerm, pColl->zName);
136942 (pColl ? pColl->zName : "BINARY")
137451 pParse->zAuthContext = pSubitem->zName;
137459 sqlite3DbFree(db, pSubitem->zName);
137462 pSubitem->zName = 0;
138264 pIdx && sqlite3StrICmp(pIdx->zName, zIndexedBy);
138365 sqlite3ErrorMsg(pParse, "'%s' is not a function", pFrom->zName);
138387 const char *zName = pItem->zName;
138390 assert( zName!=0 );
138394 if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){
138501 sqlite3ErrorMsg(pParse, pCte->zCteErr, pCte->zName);
138522 pTab->zName = sqlite3DbStrDup(db, pCte->zName);
138551 && pItem->zName!=0
138552 && 0==sqlite3StrICmp(pItem->zName, pCte->zName)
138559 "multiple references to recursive table: %s", pCte->zName
138602 pCte->zName, pEList->nExpr, pCte->pCols->nExpr
138664 pTab->zName = sqlite3DbStrDup(pParse->db, pFrom->zAlias);
138666 pTab->zName = sqlite3MPrintf(pParse->db, "subquery_%u", pSel->selId);
138757 if( pFrom->zName==0 ){
138779 pTab->zName);
138798 pTab->zName);
138809 pTab->zName);
138900 zTabName = pTab->zName;
138912 char *zName = pTab->aCol[j].zCnName;
138917 assert( zName );
138937 && tableAndColumnIndex(pTabList, i, zName, 0, 0, 1)
138943 if( sqlite3IdListIndex(pFrom->pUsing, zName)>=0 ){
138949 pRight = sqlite3Expr(db, TK_ID, zName);
138950 zColname = zName;
138961 zColname = sqlite3MPrintf(db, "%s.%s", zTabName, zName);
139179 pFunc->pFunc->zName));
139322 pTab->zName,
139324 bCover ? pIdx->zName : ""
139418 if( pItem->zName==0 ) continue;
139422 if( sqlite3_stricmp(pItem->zName, pThis->zName)!=0 ) continue;
139639 p0->zAlias ? p0->zAlias : p0->pTab->zName
139707 pTab->nCol, pTab->zName, pSub->pEList->nExpr);
139870 if( pItem->colUsed==0 && pItem->zName!=0 ){
139871 sqlite3AuthCheck(pParse, SQLITE_READ, pItem->zName, "", pItem->zDatabase);
139914 pParse->zAuthContext = pItem->zName;
140609 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
141049 && 0==sqlite3StrICmp(pTrig->table, pTab->zName)
141061 pTrig->table = pTab->zName;
141071 printf("Triggers for %s:", pTab->zName);
141073 printf(" %s", pX->zName);
141104 char *zName = 0; /* Name of the trigger */
141176 zName = sqlite3NameFromToken(db, pName);
141177 if( zName==0 ){
141181 if( sqlite3CheckObjectName(pParse, zName, "trigger", pTab->zName) ){
141186 if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),zName) ){
141198 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
141224 if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
141245 pTrigger->zName = zName;
141246 zName = 0;
141247 pTrigger->table = sqlite3DbStrDup(db, pTableName->a[0].zName);
141253 sqlite3RenameTokenRemap(pParse, pTrigger->table, pTableName->a[0].zName);
141265 sqlite3DbFree(db, zName);
141303 char *zName; /* Name of trigger */
141311 zName = pTrig->zName;
141318 sqlite3TokenInit(&nameToken, pTrig->zName);
141350 db->aDb[iDb].zDbSName, zName,
141355 sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName), 0);
141363 pTrig = sqlite3HashInsert(pHash, zName, pTrig);
141570 sqlite3DbFree(db, pTrigger->zName);
141589 const char *zName;
141599 zName = pName->a[0].zName;
141605 pTrigger = sqlite3HashFind(&(db->aDb[j].pSchema->trigHash), zName);
141651 if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) ||
141663 db->aDb[iDb].zDbSName, pTrigger->zName
141666 sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
141673 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){
141679 pTrigger = sqlite3HashInsert(pHash, zName, 0);
141802 char *zName = sqlite3DbStrDup(db, pStep->zTarget);
141805 assert( zName || pSrc==0 );
141808 pSrc->a[0].zName = zName;
141817 sqlite3DbFree(db, zName);
142097 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
142124 pSubParse->zAuthContext = pTrigger->zName;
142132 pTrigger->zName, onErrorText(orconf),
142137 pTab->zName
142140 if( pTrigger->zName ){
142142 sqlite3MPrintf(db, "-- TRIGGER %s", pTrigger->zName), P4_DYNAMIC
142169 VdbeComment((v, "End: %s.%s", pTrigger->zName, onErrorText(orconf)));
142205 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
142246 int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers));
142251 (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf)));
142476 VdbeComment((v, "%s.%s", pTab->zName, pCol->zCnName));
142909 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
143024 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
144036 VdbeComment((v, "%s.%s", pIdx->zName,
144515 const char *zName, /* Name assigned to this module */
144524 zCopy = (char*)zName;
144527 int nName = sqlite3Strlen30(zName);
144534 memcpy(zCopy, zName, nName+1);
144535 pMod->zName = zCopy;
144563 const char *zName, /* Name assigned to this module */
144571 (void)sqlite3VtabCreateModule(db, zName, pModule, pAux, xDestroy);
144584 const char *zName, /* Name assigned to this module */
144589 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
144591 return createModule(db, zName, pModule, pAux, 0);
144599 const char *zName, /* Name assigned to this module */
144605 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
144607 return createModule(db, zName, pModule, pAux, xDestroy);
144624 for(ii=0; azNames[ii]!=0 && strcmp(azNames[ii],pMod->zName)!=0; ii++){}
144627 createModule(db, pMod->zName, 0, 0, 0);
144841 sqlite3ErrorMsg(pParse, "too many columns on %s", pTable->zName);
144880 addModuleArgument(pParse, pTable, sqlite3DbStrDup(db, pTable->zName));
144897 sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName,
144966 pTab->zName,
144967 pTab->zName,
144975 zWhere = sqlite3MPrintf(db, "name=%Q AND sql=%Q", pTab->zName, zStmt);
144980 sqlite3VdbeLoadString(v, iReg, pTab->zName);
144987 const char *zName = pTab->zName;
144988 assert( zName!=0 );
144990 pOld = sqlite3HashInsert(&pSchema->tblHash, zName, pTab);
145054 "vtable constructor called recursively: %s", pTab->zName
145060 zModuleName = sqlite3DbStrDup(db, pTab->zName);
145108 *pzErr = sqlite3MPrintf(db, zFormat, pTab->zName);
145634 for(i=0; pDef->zName[i]; i++){
145635 unsigned char x = (unsigned char)pDef->zName[i];
145640 rc = pMod->xFindFunction(pVtab, nArg, pDef->zName, &xSFunc, &pArg);
145648 + sqlite3Strlen30(pDef->zName) + 1);
145653 pNew->zName = (const char*)&pNew[1];
145654 memcpy((char*)&pNew[1], pDef->zName, sqlite3Strlen30(pDef->zName)+1);
145711 pTab->zName = sqlite3DbStrDup(db, pMod->zName);
145712 if( pTab->zName==0 ){
145723 addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
145725 addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
146607 sqlite3_str_appendf(&str, zFmt, pIdx->zName);
146667 zObj = pLoop->u.btree.pIndex->zName;
146669 zObj = pSrclist->a[pLvl->iFrom].zName;
147167 VdbeComment((v, "begin skip-scan on %s", pIdx->zName));
147772 VdbeModuleComment((v, "Begin WHERE-loop%d: %s",iLevel,pTabItem->pTab->zName));
147826 VdbeComment((v, "next row of %s", pTabItem->pTab->zName));
150617 pTab->zName, j);
150966 if( sqlite3StrICmp(pColl->zName, pScan->zCollName) ){
151154 if( 0==sqlite3StrICmp(pColl->zName, zColl) ){
151451 "automatic index on %s(%s)", pTable->zName,
151492 pIdx->zName = "auto-index";
151511 pIdx->azColl[n] = pColl ? pColl->zName : sqlite3StrBINARY;
151543 VdbeComment((v, "for %s", pTable->zName));
151553 VdbeComment((v, "next row of %s", pTabItem->pTab->zName));
152381 p->zName, nEq-1, (int)a[1]));
152509 pItem->zAlias ? pItem->zAlias : pTab->zName);
152511 const char *zName;
152512 if( p->u.btree.pIndex && (zName = p->u.btree.pIndex->zName)!=0 ){
152513 if( strncmp(zName, "sqlite_autoindex_", 17)==0 ){
152514 int i = sqlite3Strlen30(zName) - 1;
152515 while( zName[i]!='_' ) i--;
152516 zName += i;
152518 sqlite3DebugPrintf(".%-16s %2d", zName, p->u.btree.nEq);
153102 if( sqlite3StrICmp(pColl->zName, pIdx->azColl[i+nEq]) ) break;
153158 pProbe->pTable->zName,pProbe->zName,
153517 pProbe->pTable->zName, pProbe->zName, saved_nEq, rc));
153980 sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
154020 sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
154072 zRet = (pC ? pC->zName : sqlite3StrBINARY);
154140 WHERETRACE(0x800, ("BEGIN %s.addVirtual()\n", pSrc->pTab->zName));
154216 WHERETRACE(0x800, ("END %s.addVirtual(), rc=%d\n", pSrc->pTab->zName, rc));
154545 if( pColl2==0 || sqlite3StrICmp(pColl1->zName, pColl2->zName) ){
154674 if( sqlite3StrICmp(pColl->zName, pIndex->azColl[j])!=0 ) continue;
154783 static char zName[65];
154785 for(i=0; i<nLoop; i++){ zName[i] = pPath->aLoop[i]->cId; }
154786 if( pLast ) zName[i++] = pLast->cId;
154787 zName[i] = 0;
154788 return zName;
155929 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
155975 VdbeComment((v, "%s", pIx->zName));
156176 VdbeComment((v, "next skip-scan on %s", pLoop->u.btree.pIndex->zName));
156214 pWInfo->pTabList->a[pLevel->iFrom].pTab->zName));
156988 static Window *windowFind(Parse *pParse, Window *pList, const char *zName){
156991 if( sqlite3StrICmp(p->zName, zName)==0 ) break;
156994 sqlite3ErrorMsg(pParse, "no such window: %s", zName);
157022 if( pWin->zName && pWin->eFrmType==0 ){
157023 Window *p = windowFind(pParse, pList, pWin->zName);
157068 if( pFunc->zName==aUp[i].zFunc ){
157498 sqlite3DbFree(db, p->zName);
157797 if( pKeyInfo && pWin->pFunc->zName[1]=='i' ){
157805 else if( p->zName==nth_valueName || p->zName==first_valueName ){
157813 else if( p->zName==leadName || p->zName==lagName ){
158032 if( i!=1 || pFunc->zName!=nth_valueName ){
158059 assert( pFunc->zName==nth_valueName
158060 || pFunc->zName==first_valueName
158284 if( pFunc->zName==nth_valueName
158285 || pFunc->zName==first_valueName
158292 if( pFunc->zName==nth_valueName ){
158307 else if( pFunc->zName==leadName || pFunc->zName==lagName ){
158321 int val = (pFunc->zName==leadName ? 1 : -1);
158324 int op = (pFunc->zName==leadName ? OP_Add : OP_Subtract);
158359 if( pFunc->zName==nth_valueName || pFunc->zName==first_valueName ){
158385 if( (pFunc->zName==nth_valueName)
158386 || (pFunc->zName==first_valueName)
158387 || (pFunc->zName==leadName)
158388 || (pFunc->zName==lagName)
158739 pNew->zName = sqlite3DbStrDup(db, p->zName);
163493 pNew->zName = pOld->zName;
163502 pOld->zName = pOld->zDatabase = 0;
163521 …& yylhsminor.yy607 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy607->a[0].zName, &yymsp[0].minor.y…
163528 …& yylhsminor.yy607 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy607->a[0].zName, &yymsp[0].minor.y…
164037 sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0);
164312 …yymsp[-1].minor.yy375->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor…
164434 …yymsp[-1].minor.yy375->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.y…
165476 SQLITE_API int sqlite3_keyword_check(const char *zName, int nName){
165477 return TK_ID!=sqlite3KeywordCode((const u8*)zName, nName);
167619 assert( p==0 || p->xCmp!=binCollFunc || strcmp(p->zName,"BINARY")==0 );
168065 const char *zName = 0;
168067 for(i=0; i<2 && zName==0; i++, rc &= 0xff){
168069 case SQLITE_OK: zName = "SQLITE_OK"; break;
168070 case SQLITE_ERROR: zName = "SQLITE_ERROR"; break;
168071 case SQLITE_ERROR_SNAPSHOT: zName = "SQLITE_ERROR_SNAPSHOT"; break;
168072 case SQLITE_INTERNAL: zName = "SQLITE_INTERNAL"; break;
168073 case SQLITE_PERM: zName = "SQLITE_PERM"; break;
168074 case SQLITE_ABORT: zName = "SQLITE_ABORT"; break;
168075 case SQLITE_ABORT_ROLLBACK: zName = "SQLITE_ABORT_ROLLBACK"; break;
168076 case SQLITE_BUSY: zName = "SQLITE_BUSY"; break;
168077 case SQLITE_BUSY_RECOVERY: zName = "SQLITE_BUSY_RECOVERY"; break;
168078 case SQLITE_BUSY_SNAPSHOT: zName = "SQLITE_BUSY_SNAPSHOT"; break;
168079 case SQLITE_LOCKED: zName = "SQLITE_LOCKED"; break;
168080 case SQLITE_LOCKED_SHAREDCACHE: zName = "SQLITE_LOCKED_SHAREDCACHE";break;
168081 case SQLITE_NOMEM: zName = "SQLITE_NOMEM"; break;
168082 case SQLITE_READONLY: zName = "SQLITE_READONLY"; break;
168083 case SQLITE_READONLY_RECOVERY: zName = "SQLITE_READONLY_RECOVERY"; break;
168084 case SQLITE_READONLY_CANTINIT: zName = "SQLITE_READONLY_CANTINIT"; break;
168085 case SQLITE_READONLY_ROLLBACK: zName = "SQLITE_READONLY_ROLLBACK"; break;
168086 case SQLITE_READONLY_DBMOVED: zName = "SQLITE_READONLY_DBMOVED"; break;
168087 case SQLITE_READONLY_DIRECTORY: zName = "SQLITE_READONLY_DIRECTORY";break;
168088 case SQLITE_INTERRUPT: zName = "SQLITE_INTERRUPT"; break;
168089 case SQLITE_IOERR: zName = "SQLITE_IOERR"; break;
168090 case SQLITE_IOERR_READ: zName = "SQLITE_IOERR_READ"; break;
168091 case SQLITE_IOERR_SHORT_READ: zName = "SQLITE_IOERR_SHORT_READ"; break;
168092 case SQLITE_IOERR_WRITE: zName = "SQLITE_IOERR_WRITE"; break;
168093 case SQLITE_IOERR_FSYNC: zName = "SQLITE_IOERR_FSYNC"; break;
168094 case SQLITE_IOERR_DIR_FSYNC: zName = "SQLITE_IOERR_DIR_FSYNC"; break;
168095 case SQLITE_IOERR_TRUNCATE: zName = "SQLITE_IOERR_TRUNCATE"; break;
168096 case SQLITE_IOERR_FSTAT: zName = "SQLITE_IOERR_FSTAT"; break;
168097 case SQLITE_IOERR_UNLOCK: zName = "SQLITE_IOERR_UNLOCK"; break;
168098 case SQLITE_IOERR_RDLOCK: zName = "SQLITE_IOERR_RDLOCK"; break;
168099 case SQLITE_IOERR_DELETE: zName = "SQLITE_IOERR_DELETE"; break;
168100 case SQLITE_IOERR_NOMEM: zName = "SQLITE_IOERR_NOMEM"; break;
168101 case SQLITE_IOERR_ACCESS: zName = "SQLITE_IOERR_ACCESS"; break;
168103 zName = "SQLITE_IOERR_CHECKRESERVEDLOCK"; break;
168104 case SQLITE_IOERR_LOCK: zName = "SQLITE_IOERR_LOCK"; break;
168105 case SQLITE_IOERR_CLOSE: zName = "SQLITE_IOERR_CLOSE"; break;
168106 case SQLITE_IOERR_DIR_CLOSE: zName = "SQLITE_IOERR_DIR_CLOSE"; break;
168107 case SQLITE_IOERR_SHMOPEN: zName = "SQLITE_IOERR_SHMOPEN"; break;
168108 case SQLITE_IOERR_SHMSIZE: zName = "SQLITE_IOERR_SHMSIZE"; break;
168109 case SQLITE_IOERR_SHMLOCK: zName = "SQLITE_IOERR_SHMLOCK"; break;
168110 case SQLITE_IOERR_SHMMAP: zName = "SQLITE_IOERR_SHMMAP"; break;
168111 case SQLITE_IOERR_SEEK: zName = "SQLITE_IOERR_SEEK"; break;
168112 case SQLITE_IOERR_DELETE_NOENT: zName = "SQLITE_IOERR_DELETE_NOENT";break;
168113 case SQLITE_IOERR_MMAP: zName = "SQLITE_IOERR_MMAP"; break;
168114 case SQLITE_IOERR_GETTEMPPATH: zName = "SQLITE_IOERR_GETTEMPPATH"; break;
168115 case SQLITE_IOERR_CONVPATH: zName = "SQLITE_IOERR_CONVPATH"; break;
168116 case SQLITE_CORRUPT: zName = "SQLITE_CORRUPT"; break;
168117 case SQLITE_CORRUPT_VTAB: zName = "SQLITE_CORRUPT_VTAB"; break;
168118 case SQLITE_NOTFOUND: zName = "SQLITE_NOTFOUND"; break;
168119 case SQLITE_FULL: zName = "SQLITE_FULL"; break;
168120 case SQLITE_CANTOPEN: zName = "SQLITE_CANTOPEN"; break;
168121 case SQLITE_CANTOPEN_NOTEMPDIR: zName = "SQLITE_CANTOPEN_NOTEMPDIR";break;
168122 case SQLITE_CANTOPEN_ISDIR: zName = "SQLITE_CANTOPEN_ISDIR"; break;
168123 case SQLITE_CANTOPEN_FULLPATH: zName = "SQLITE_CANTOPEN_FULLPATH"; break;
168124 case SQLITE_CANTOPEN_CONVPATH: zName = "SQLITE_CANTOPEN_CONVPATH"; break;
168125 case SQLITE_CANTOPEN_SYMLINK: zName = "SQLITE_CANTOPEN_SYMLINK"; break;
168126 case SQLITE_PROTOCOL: zName = "SQLITE_PROTOCOL"; break;
168127 case SQLITE_EMPTY: zName = "SQLITE_EMPTY"; break;
168128 case SQLITE_SCHEMA: zName = "SQLITE_SCHEMA"; break;
168129 case SQLITE_TOOBIG: zName = "SQLITE_TOOBIG"; break;
168130 case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT"; break;
168131 case SQLITE_CONSTRAINT_UNIQUE: zName = "SQLITE_CONSTRAINT_UNIQUE"; break;
168132 case SQLITE_CONSTRAINT_TRIGGER: zName = "SQLITE_CONSTRAINT_TRIGGER";break;
168134 zName = "SQLITE_CONSTRAINT_FOREIGNKEY"; break;
168135 case SQLITE_CONSTRAINT_CHECK: zName = "SQLITE_CONSTRAINT_CHECK"; break;
168137 zName = "SQLITE_CONSTRAINT_PRIMARYKEY"; break;
168138 case SQLITE_CONSTRAINT_NOTNULL: zName = "SQLITE_CONSTRAINT_NOTNULL";break;
168140 zName = "SQLITE_CONSTRAINT_COMMITHOOK"; break;
168141 case SQLITE_CONSTRAINT_VTAB: zName = "SQLITE_CONSTRAINT_VTAB"; break;
168143 zName = "SQLITE_CONSTRAINT_FUNCTION"; break;
168144 case SQLITE_CONSTRAINT_ROWID: zName = "SQLITE_CONSTRAINT_ROWID"; break;
168145 case SQLITE_MISMATCH: zName = "SQLITE_MISMATCH"; break;
168146 case SQLITE_MISUSE: zName = "SQLITE_MISUSE"; break;
168147 case SQLITE_NOLFS: zName = "SQLITE_NOLFS"; break;
168148 case SQLITE_AUTH: zName = "SQLITE_AUTH"; break;
168149 case SQLITE_FORMAT: zName = "SQLITE_FORMAT"; break;
168150 case SQLITE_RANGE: zName = "SQLITE_RANGE"; break;
168151 case SQLITE_NOTADB: zName = "SQLITE_NOTADB"; break;
168152 case SQLITE_ROW: zName = "SQLITE_ROW"; break;
168153 case SQLITE_NOTICE: zName = "SQLITE_NOTICE"; break;
168154 case SQLITE_NOTICE_RECOVER_WAL: zName = "SQLITE_NOTICE_RECOVER_WAL";break;
168156 zName = "SQLITE_NOTICE_RECOVER_ROLLBACK"; break;
168157 case SQLITE_WARNING: zName = "SQLITE_WARNING"; break;
168158 case SQLITE_WARNING_AUTOINDEX: zName = "SQLITE_WARNING_AUTOINDEX"; break;
168159 case SQLITE_DONE: zName = "SQLITE_DONE"; break;
168162 if( zName==0 ){
168165 zName = zBuf;
168167 return zName;
168671 const char *zName = (const char*)sqlite3_user_data(context);
168675 "unable to use function %s in the requested context", zName);
168694 const char *zName,
168701 if( !sqlite3SafetyCheckOk(db) || zName==0 || nArg<-2 ){
168706 rc = sqlite3FindFunction(db, zName, nArg, SQLITE_UTF8, 0)!=0;
168709 zCopy = sqlite3_mprintf(zName);
168711 return sqlite3_create_function_v2(db, zName, nArg, SQLITE_UTF8,
169272 const char *zName,
169301 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0);
169317 CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName);
169331 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 1);
170133 const char *zName,
170138 return sqlite3_create_collation_v2(db, zName, enc, pCtx, xCompare, 0);
170146 const char *zName,
170155 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
170159 rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel);
170171 const void *zName,
170180 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
170184 zName8 = sqlite3Utf16to8(db, zName, -1, SQLITE_UTF16NATIVE);
170981 static const char *databaseName(const char *zName){
170982 while( zName[-1]!=0 || zName[-2]!=0 || zName[-3]!=0 || zName[-4]!=0 ){
170983 zName--;
170985 return zName;
172513 const char *zName; /* virtual table name */
173243 zDb, p->zName,
173244 zDb, p->zName,
173245 zDb, p->zName,
173246 zDb, p->zName,
173247 (p->zContentTbl ? "--" : ""), zDb,p->zName
173287 zCols, p->zName, zLanguageid
173308 p->zDb, p->zName
173345 p->zDb, p->zName, zContentCols
173353 p->zDb, p->zName
173365 p->zDb, p->zName
173370 p->zDb, p->zName
173552 (p->zContentTbl ? p->zContentTbl : p->zName),
174085 p->zName = zCsr;
176207 char *zTbl = sqlite3_mprintf("%s_stat", p->zName);
176470 const char *zName, /* Name of SQL function */
176475 const char *zName;
176490 if( strcmp(zName, aOverload[i].zName)==0 ){
176505 const char *zName /* New name of table */
176529 p->zDb, p->zName, zName
176536 p->zDb, p->zName, zName
176542 p->zDb, p->zName, zName
176547 p->zDb, p->zName, zName
176551 p->zDb, p->zName, zName
176606 static int fts3ShadowName(const char *zName){
176612 if( sqlite3_stricmp(zName, azName[i])==0 ) return 1;
178851 p->pFts3Tab->zName = &p->pFts3Tab->zDb[nDb+1];
178856 memcpy((char *)p->pFts3Tab->zName, zFts3, nFts3);
178857 sqlite3Fts3Dequote((char *)p->pFts3Tab->zName);
181721 const unsigned char *zName;
181728 zName = sqlite3_value_text(argv[0]);
181735 if( zName==0 || n!=sizeof(pPtr) ){
181740 pOld = sqlite3Fts3HashInsert(pHash, (void *)zName, nName, pPtr);
181749 if( zName ){
181750 pPtr = sqlite3Fts3HashFind(pHash, zName, nName);
181753 char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
181923 const char *zName;
181945 zName = (const char *)sqlite3_value_text(argv[0]);
181950 p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
181953 char *zErr2 = sqlite3_mprintf("unknown tokenizer: %s", zName);
182005 char *zName,
182017 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
182028 char *zName,
182041 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
182130 const char *zName
182140 zTest = sqlite3_mprintf("%s_test", zName);
182141 zTest2 = sqlite3_mprintf("%s_internal_test", zName);
182148 rc = sqlite3_create_function(db, zName, 1, any, p, fts3TokenizerFunc, 0, 0);
182151 rc = sqlite3_create_function(db, zName, 2, any, p, fts3TokenizerFunc, 0, 0);
182489 const char *zName,
182494 int nName = (int)strlen(zName);
182496 p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
182498 sqlite3Fts3ErrMsg(pzErr, "unknown tokenizer: %s", zName);
183273 zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName, p->zWriteExprlist);
183278 zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName);
184082 p->zSegmentsTbl = sqlite3_mprintf("%s_segments", p->zName);
193854 const char *zName;
193882 const char *zName;
193895 const char *zName;
193907 rc = sqlite3_create_function(db, aFunc[i].zName, aFunc[i].nArg, enc,
193913 rc = sqlite3_create_window_function(db, aAgg[i].zName, aAgg[i].nArg,
193921 rc = sqlite3_create_module(db, aMod[i].zName, aMod[i].pModule, 0);
194108 char *zName; /* Name of r-tree table */
194674 char *zTab = sqlite3_mprintf("%s_node", pRtree->zName);
194996 pRtree->zDb, pRtree->zName,
194997 pRtree->zDb, pRtree->zName,
194998 pRtree->zDb, pRtree->zName
197131 zSql = sqlite3_mprintf("SELECT * FROM %Q.%Q", pRtree->zDb, pRtree->zName);
197143 "UNIQUE constraint failed: %s.%s", pRtree->zName, zCol
197149 "rtree constraint failed: %s.(%s<=%s)", pRtree->zName, zCol1, zCol2
197339 , pRtree->zDb, pRtree->zName, zNewName
197340 , pRtree->zDb, pRtree->zName, zNewName
197341 , pRtree->zDb, pRtree->zName, zNewName
197394 zSql = sqlite3_mprintf(zFmt, pRtree->zDb, pRtree->zName);
197414 static int rtreeShadowName(const char *zName){
197420 if( sqlite3_stricmp(zName, azName[i])==0 ) return 1;
197638 pRtree->zDb, pRtree->zName
197647 pRtree->zName);
197717 pRtree->zName = &pRtree->zDb[nDb+1];
197720 memcpy(pRtree->zName, argv[2], nName);
199602 pRtree->zName = &pRtree->zDb[nDb+1];
199607 memcpy(pRtree->zName, argv[2], nName);
200072 const char *zName,
200076 if( sqlite3_stricmp(zName, "geopoly_overlap")==0 ){
200081 if( sqlite3_stricmp(zName, "geopoly_within")==0 ){
200123 const char *zName;
200141 const char *zName;
200153 rc = sqlite3_create_function(db, aFunc[i].zName, aFunc[i].nArg,
200158 rc = sqlite3_create_function(db, aAgg[i].zName, 1,
200410 const char *zName, /* Name of ICU function that failed */
200414 sqlite3_snprintf(128, zBuf, "ICU error: %s(): %s", zName, u_errorName(e));
200820 const char *zName; /* SQL Collation sequence name (eg. "japanese") */
200827 zName = (const char *)sqlite3_value_text(apArg[1]);
200829 if( !zLocale || !zName ){
200840 rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator,
200855 const char *zName; /* Function name */
200882 db, p->zName, p->nArg, p->enc,
201853 SQLITE_API int sqlite3rbu_create_vfs(const char *zName, const char *zParent);
201863 SQLITE_API void sqlite3rbu_destroy_vfs(const char *zName);
203140 const char *zName = (const char*)sqlite3_column_name(pStmt, i);
203141 if( sqlite3_strnicmp("rbu_", zName, 4) ){
203142 char *zCopy = rbuStrndup(zName, &p->rc);
203146 else if( 0==sqlite3_stricmp("rbu_rowid", zName) ){
203173 const char *zName = (const char*)sqlite3_column_text(pStmt, 1);
203174 if( zName==0 ) break; /* An OOM - finalize() below returns S_NOMEM */
203176 if( 0==strcmp(zName, pIter->azTblCol[i]) ) break;
203181 pIter->zDataTbl, zName
204435 const char *zName,
204441 p->rc = sqlite3_open_v2(zName, &db, flags, bUseVfs ? p->zVfsName : 0);
205132 static void assertColumnName(sqlite3_stmt *pStmt, int iCol, const char *zName){
205134 assert( 0==sqlite3_stricmp(zName, zCol) );
205662 p->zVfsName = pVfs->zName;
206630 char *zOut = sqlite3_mprintf("rbu(%s)/%z", pRbuVfs->base.zName, zIn);
206782 const char *zName,
206811 const char *zOpen = zName;
206818 if( zName ){
206825 pFd->zWal = sqlite3_filename_wal(zName);
206828 rbu_file *pDb = rbuFindMaindb(pRbuVfs, zName, 0);
206849 && sqlite3_uri_boolean(zName, "rbu_memory", 0)
207022 SQLITE_API void sqlite3rbu_destroy_vfs(const char *zName){
207023 sqlite3_vfs *pVfs = sqlite3_vfs_find(zName);
207036 SQLITE_API int sqlite3rbu_create_vfs(const char *zName, const char *zParent){
207073 nName = strlen(zName);
207090 pNew->base.zName = (const char*)(zSpace = (char*)&pNew[1]);
207091 memcpy(zSpace, zName, nName);
207261 char *zName; /* Value of 'name' column */
207759 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
207811 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
207874 const char *zName = 0; /* Only provide analysis of this table */
207893 zName = (const char*)sqlite3_value_text(argv[iArg++]);
207909 if( zName ){
207910 sqlite3_str_appendf(pSql, "WHERE name=%Q", zName);
207938 sqlite3_result_text(ctx, pCsr->zName, -1, SQLITE_TRANSIENT);
208575 char *zName; /* Local name of table */
209536 const unsigned char *zName = sqlite3_column_text(pStmt, 1);
209537 if( zName==0 ) break;
209538 memcpy(pAlloc, zName, nName+1);
209583 pTab->zName, &pTab->nCol, 0, &pTab->azCol, &abPK
209593 if( 0==sqlite3_stricmp("sqlite_stat1", pTab->zName) ){
209599 1 + sessionVarintLen(pTab->nCol) + pTab->nCol + strlen(pTab->zName)+1
209904 const char *zName,
209908 int nName = sqlite3Strlen30(zName);
209913 if( 0==sqlite3_strnicmp(pRet->zName, zName, nName+1) ) break;
209920 || pSession->xTableFilter(pSession->pFilterCtx, zName)
209922 rc = sqlite3session_attach(pSession, zName);
209929 assert( 0==sqlite3_strnicmp(pRet->zName, zName, nName+1) );
209947 char const *zName, /* Table name */
209966 pSession->rc = sessionFindTable(pSession, zName, &pTab);
210128 char *zStmt = sessionSelectFindNew(pTab->nCol, zDb1, zDb2, pTab->zName,zExpr);
210159 pSession->zDb, zFrom, pTab->zName, pTab->azCol, pTab->abPK
210166 pSession->zDb, pTab->zName, zFrom, pTab->zName, zExpr, zExpr2
210253 zDb, zFrom, pTo->zName, pTo->azCol, pTo->abPK
210399 const char *zName /* Table name */
210404 if( !zName ){
210412 nName = sqlite3Strlen30(zName);
210414 if( 0==sqlite3_strnicmp(pTab->zName, zName, nName+1) ) break;
210431 pTab->zName = (char *)&pTab[1];
210432 memcpy(pTab->zName, zName, nName+1);
210980 sessionAppendBlob(pBuf, (u8 *)pTab->zName, (int)strlen(pTab->zName)+1, pRc);
211026 const char *zName = pTab->zName;
211036 rc = sessionTableInfo(0, db, pSession->zDb, zName, &nCol, 0,&azCol,&abPK);
211047 db, pSession->zDb, zName, nCol, azCol, abPK, &pSel);
213608 if( !pTab || sqlite3_stricmp(zNew, pTab->zName) ){
213615 if( 0==sqlite3_strnicmp(pTab->zName, zNew, nNew+1) ) break;
213629 pTab->zName = (char*)&pTab->abPK[nCol];
213630 memcpy(pTab->zName, zNew, nNew+1);
214045 if( 0==sqlite3_stricmp(pTab->zName, zTab) ) break;
214814 const char *zName,
214823 const char *zName,
214831 const char *zName,
215031 char *zName; /* Name of FTS index */
215497 static int sqlite3Fts5StorageRename(Fts5Storage*, const char *zName);
218524 const char *zName;
218538 for(i=0; aEnum[i].zName; i++){
218539 if( sqlite3_strnicmp(aEnum[i].zName, zEnum, nEnum)==0 ){
218866 pRet->zName = sqlite3Fts5Strndup(&rc, azArg[2], -1);
218872 if( rc==SQLITE_OK && sqlite3_stricmp(pRet->zName, FTS5_RANK_NAME)==0 ){
218873 *pzErr = sqlite3_mprintf("reserved fts5 table name: %s", pRet->zName);
218943 &rc, "%Q.'%q_%s'", pRet->zDb, pRet->zName, zTail
218974 sqlite3_free(pConfig->zName);
219005 zSql, pConfig->zName, FTS5_RANK_NAME
219253 zSql = sqlite3Fts5Mprintf(&rc, zSelect, pConfig->zDb, pConfig->zName);
223673 pConfig->zDb, pConfig->zName
223697 pConfig->zDb, pConfig->zName
223719 pConfig->zDb, pConfig->zName
225334 pConfig->zDb, pConfig->zName
227106 pConfig->zDb, pConfig->zName
228335 p->zDataTbl = sqlite3Fts5Mprintf(&rc, "%s_data", pConfig->zName);
229014 pConfig->zDb, pConfig->zName, pSeg->iSegid
229848 char *zName; /* Name of tokenizer */
230749 pConfig->zDb, pConfig->zName, zRank, pConfig->zName,
230824 static Fts5Auxiliary *fts5FindAuxiliary(Fts5FullTable *pTab, const char *zName){
230828 if( sqlite3_stricmp(zName, pAux->zFunc)==0 ) return pAux;
231106 "%s: table does not support scanning", pConfig->zName
231419 (nArg>1 ? "UPDATE" : "DELETE from"), pConfig->zName
232267 const char *zName, /* Name of SQL function */
232275 pAux = fts5FindAuxiliary(pTab, zName);
232291 const char *zName /* New name of table */
232294 return sqlite3Fts5StorageRename(pTab->pStorage, zName);
232342 const char *zName, /* Name of new function */
232348 int rc = sqlite3_overload_function(pGlobal->db, zName, -1);
232354 nName = strlen(zName) + 1;
232360 memcpy(pAux->zFunc, zName, nName);
232381 const char *zName, /* Name of new function */
232392 nName = strlen(zName) + 1;
232397 pNew->zName = (char*)&pNew[1];
232398 memcpy(pNew->zName, zName, nName);
232416 const char *zName
232420 if( zName==0 ){
232424 if( sqlite3_stricmp(zName, pMod->zName)==0 ) break;
232437 const char *zName, /* Name of new function */
232444 pMod = fts5LocateTokenizer((Fts5Global*)pApi, zName);
232543 static int fts5ShadowName(const char *zName){
232549 if( sqlite3_stricmp(zName, azName[i])==0 ) return 1;
232792 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName, zBind);
232799 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName);
232857 pConfig->zDb, pConfig->zName,
232858 pConfig->zDb, pConfig->zName,
232859 pConfig->zDb, pConfig->zName
232864 pConfig->zDb, pConfig->zName
232870 pConfig->zDb, pConfig->zName
232880 const char *zName /* New name of FTS5 table */
232885 pConfig->zDb, pConfig->zName, zTail, zName, zTail
232890 static int sqlite3Fts5StorageRename(Fts5Storage *pStorage, const char *zName){
232894 fts5StorageRenameOne(pConfig, &rc, "data", zName);
232895 fts5StorageRenameOne(pConfig, &rc, "idx", zName);
232896 fts5StorageRenameOne(pConfig, &rc, "config", zName);
232898 fts5StorageRenameOne(pConfig, &rc, "docsize", zName);
232901 fts5StorageRenameOne(pConfig, &rc, "content", zName);
232921 pConfig->zDb, pConfig->zName, zPost, zDefn,
232930 pConfig->zName, zPost, zErr
233247 pConfig->zDb, pConfig->zName,
233248 pConfig->zDb, pConfig->zName
233253 pConfig->zDb, pConfig->zName
233449 pConfig->zDb, pConfig->zName, zSuffix
235229 const char *zName;
235243 aBuiltin[i].zName,