Lines Matching refs:zName
2410 const char *zName; /* Name of this virtual file system */ member
2412 int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,
2414 int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);
2415 int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut);
2416 int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);
2434 int (*xSetSystemCall)(sqlite3_vfs*, const char *zName, sqlite3_syscall_ptr);
2435 sqlite3_syscall_ptr (*xGetSystemCall)(sqlite3_vfs*, const char *zName);
2436 const char *(*xNextSystemCall)(sqlite3_vfs*, const char *zName);
5514 SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
6929 const char *zName,
6936 const char *zName,
6944 const void *zName,
7771 int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName,
7986 const char *zName, /* Name of the module */
7992 const char *zName, /* Name of the module */
10501 char const *zName, /* Table name */
13173 const char *zName,
13182 const char *zName,
13190 const char *zName,
17074 const char *zName; /* SQL name of the function. */ member
17211 #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \ argument
17213 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
17214 #define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \ argument
17216 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
17217 #define SFUNCTION(zName, nArg, iArg, bNC, xFunc) \ argument
17219 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
17220 #define INLINE_FUNC(zName, nArg, iArg, mFlags) \ argument
17222 SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }
17223 #define TEST_FUNC(zName, nArg, iArg, mFlags) \ argument
17226 SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }
17227 #define DFUNCTION(zName, nArg, iArg, bNC, xFunc) \ argument
17229 0, 0, xFunc, 0, 0, 0, #zName, {0} }
17230 #define PURE_DATE(zName, nArg, iArg, bNC, xFunc) \ argument
17232 (void*)&sqlite3Config, 0, xFunc, 0, 0, 0, #zName, {0} }
17233 #define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \ argument
17235 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
17236 #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \ argument
17238 pArg, 0, xFunc, 0, 0, 0, #zName, }
17239 #define LIKEFUNC(zName, nArg, arg, flags) \ argument
17241 (void *)arg, 0, likeFunc, 0, 0, 0, #zName, {0} }
17242 #define WAGGREGATE(zName, nArg, arg, nc, xStep, xFinal, xValue, xInverse, f) \ argument
17244 SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,xValue,xInverse,#zName, {0}}
17245 #define INTERNAL_FUNCTION(zName, nArg, xFunc) \ argument
17247 0, 0, xFunc, 0, 0, 0, #zName, {0} }
17257 char *zName; /* Savepoint name (nul-terminated) */ member
17279 const char *zName; /* Name passed to create_module() */ member
17304 char *zName; /* Name of this column, \000, then the type */ member
17338 char *zName; /* Name of the collating sequence, UTF-8 encoded */ member
17460 char *zName; /* Name of the table or view */ member
17750 char *zName; /* Name of this index */ member
18195 char *zName; /* Name of the identifier */ member
18226 char *zName; /* Name of the table */ member
18833 char *zName; /* The name of the trigger */ member
19108 char *zName; /* Name of this CTE */ member
19150 char *zName; /* Name of window (may be NULL) */ member
19475 SQLITE_PRIVATE Module *sqlite3PragmaVtabRegister(sqlite3*,const char *zName);
19775 SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName);
19860 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char*zName);
20072 SQLITE_PRIVATE int sqlite3ShadowTableName(sqlite3 *db, const char *zName);
21008 char *zName; /* Name of table or index */ member
22277 char *zName; /* Name of the transformation */ member
22481 && sqlite3_strnicmp(aXformType[i].zName, z, n)==0 in parseModifier()
23270 if( strcmp(zVfs, pVfs->zName)==0 ) break; in sqlite3_vfs_find()
28956 sqlite3_str_appendall(pAccum, pItem->zName);
29503 sqlite3_str_appendf(&x, "%s", pCte->zName);
29535 sqlite3_str_appendf(&x, " %s.%s", pItem->zDatabase, pItem->zName);
29536 }else if( pItem->zName ){
29537 sqlite3_str_appendf(&x, " %s", pItem->zName);
29541 pItem->pTab->zName, pItem->pTab->nCol, pItem->pTab, pItem->colUsed);
29728 if( pWin->zName ){
29729 sqlite3TreeViewLine(pView, "OVER %s (%p)", pWin->zName, pWin);
29788 pWin->pFunc->zName, pWin->pFunc->nArg);
30141 char *zName = pList->a[i].zEName;
30143 if( pList->a[i].eEName!=ENAME_NAME ) zName = 0;
30144 if( j || zName ){
30148 if( zName ){
30149 fprintf(stdout, "AS %s ", zName);
30158 if( j || zName ){
31223 return pCol->zName + strlen(pCol->zName) + 1;
32721 const char *zName, /* Name of symbol to add */
32746 memcpy(z, zName, nName);
32772 SQLITE_PRIVATE int sqlite3VListNameToNum(VList *pIn, const char *zName, int nName){
32779 if( strncmp(z,zName,nName)==0 && z[nName]==0 ) return pIn[i];
33835 const char *zName; /* Name of the system call */
34024 const char *zName, /* Name of system call to override */
34031 if( zName==0 ){
34046 if( strcmp(zName, aSyscall[i].zName)==0 ){
34067 const char *zName
34073 if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
34084 static const char *unixNextSystemCall(sqlite3_vfs *p, const char *zName){
34088 if( zName ){
34090 if( strcmp(zName, aSyscall[i].zName)==0 ) break;
34094 if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
37433 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
39006 if( strcmp(pVfs->zName,"unix-excl")==0 ){
39445 const char *zName = zPath;
39461 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
39462 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
39463 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
39464 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
39486 pUnused = findReusableFd(zName, flags);
39500 assert( (flags & SQLITE_OPEN_URI) || zName[strlen(zName)+1]==0 );
39502 }else if( !zName ){
39509 zName = zTmpname;
39513 assert( zName[strlen(zName)+1]==0 );
39530 rc = findCreateFileMode(zName, flags, &openMode, &uid, &gid);
39536 fd = robust_open(zName, openFlags, openMode);
39537 OSTRACE(("OPENX %-3d %s 0%o\n", fd, zName, openFlags));
39540 if( isNewJrnl && errno==EACCES && osAccess(zName, F_OK) ){
39551 fd = robust_open(zName, openFlags, openMode);
39555 int rc2 = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName);
39589 zPath = zName;
39591 zPath = sqlite3_mprintf("%s", zName);
39597 osUnlink(zName);
40409 dummyVfs.zName = "dummy";
42091 const char *zName; /* Name of the system call */
42753 const char *zName, /* Name of system call to override */
42760 if( zName==0 ){
42775 if( strcmp(zName, aSyscall[i].zName)==0 ){
42796 const char *zName
42802 if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
42813 static const char *winNextSystemCall(sqlite3_vfs *p, const char *zName){
42817 if( zName ){
42819 if( strcmp(zName, aSyscall[i].zName)==0 ) break;
42823 if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
43831 LPWSTR zName;
43836 zName = winUtf8ToUnicode(zFilename);
43837 if( zName==0 ){
43847 zTok = osCharLowerW(zName);
43853 pFile->hMutex = osCreateMutexW(NULL, FALSE, zName);
43856 sqlite3_free(zName);
43868 osCharUpperW(zName);
43871 zName);
43880 sqlite3_free(zName);
45144 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
46573 const char *zName, /* Name of the file (UTF-8) */
46590 const char *zUtf8Name = zName; /* Filename in UTF-8 encoding */
46634 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
46635 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
46636 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
46637 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
46754 rc2 = winAccess(pVfs, zName, SQLITE_ACCESS_READ, &isRO);
46771 rc2 = winAccess(pVfs, zName, SQLITE_ACCESS_READ, &isRO);
46791 rc2 = winAccess(pVfs, zName, SQLITE_ACCESS_READ, &isRO);
46807 return winOpen(pVfs, zName, id,
46836 && (rc = winceCreateLock(zName, pFile))!=SQLITE_OK
46841 OSTRACE(("OPEN-CE-LOCK name=%s, rc=%s\n", zName, sqlite3ErrName(rc)));
46861 && sqlite3_uri_boolean(zName, "psow", SQLITE_POWERSAFE_OVERWRITE)
46866 pFile->zPath = zName;
47805 static int memdbAccess(sqlite3_vfs*, const char *zName, int flags, int *);
47806 static int memdbFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
48067 const char *zName,
48074 return ORIGVFS(pVfs)->xOpen(ORIGVFS(pVfs), zName, pFile, flags, pOutFlags);
56623 SQLITE_API sqlite3_file *sqlite3_database_file_object(const char *zName){
56625 while( zName[-1]!=0 || zName[-2]!=0 || zName[-3]!=0 || zName[-4]!=0 ){
56626 zName--;
56628 pPager = *(Pager**)(zName - 4 - sizeof(Pager*));
60148 static char zName[15];
60149 sqlite3_snprintf(sizeof(zName), zName, "READ-LOCK[%d]",
60151 return zName;
78556 const char *zName /* Name of table or index being scanned */
78567 pNew->zName = sqlite3DbStrDup(p->db, zName);
79180 const char *zColl = pColl ? pColl->zName : "";
79200 sqlite3_str_appendf(&x, "%.18s-%s", pColl->zName,
79206 sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg);
79211 sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg);
79269 zP4 = pOp->p4.pTab->zName;
80145 const char *zName, /* Pointer to buffer containing name */
80153 assert( !zName || xDel!=SQLITE_DYNAMIC );
80158 rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, xDel);
80159 assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 );
80995 sqlite3DbFree(db, p->aScan[i].zName);
82662 pCtx->pFunc->zName, zContext);
82728 const char *zTbl = pTab->zName;
84381 SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){
84382 if( p==0 || zName==0 ) return 0;
84383 return sqlite3VListNameToNum(p->pVList, zName, nName);
84385 SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
84386 return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName));
84796 *(const char**)pOut = pScan->zName;
88348 char *zName; /* Name of savepoint */
88357 zName = pOp->p4.z;
88376 nName = sqlite3Strlen30(zName);
88392 pNew->zName = (char *)&pNew[1];
88393 memcpy(pNew->zName, zName, nName+1);
88419 pSavepoint && sqlite3StrICmp(pSavepoint->zName, zName);
88425 sqlite3VdbeError(p, "no such savepoint: %s", zName);
90067 zDb, pTab->zName, x.nKey);
90198 db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, pTab->zName,
93336 if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
93441 sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT);
96463 const char *zName; /* tables_used.name */
96556 pCur->zName = 0;
96581 if( pCur->zName ){
96582 pCur->zName = 0;
96636 pCur->zName = pTab->zName;
96641 if( pCur->zName==0 ){
96645 pCur->zName = pIdx->zName;
96708 sqlite3_result_text(ctx, pCur->zName, -1, SQLITE_STATIC);
97193 const char *zName, /* Name of the journal file */
97206 return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0);
97219 p->zJournal = zName;
97652 if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ) return 1;
97829 assert( pTab!=0 && pTab->zName!=0 );
97849 const char *zTabName = pItem->zAlias ? pItem->zAlias : pTab->zName;
97863 if( pCol->hName==hCol && sqlite3StrICmp(pCol->zName, zCol)==0 ){
97928 if( pCol->hName==hCol && sqlite3StrICmp(pCol->zName, zCol)==0 ){
98395 pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120;
98400 int auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0,pDef->zName,0);
98404 pDef->zName);
99116 if( pItem->zName ) pParse->zAuthContext = pItem->zName;
99466 sSrc.a[0].zName = pTab->zName;
99724 return sqlite3StrICmp(pColl1->zName, pColl2->zName)==0;
100494 sqlite3ErrorMsg(pParse, "unsafe use of %s()", pDef->zName);
100874 pRet->a[i].zName = sqlite3DbStrDup(db, p->a[i].zName);
101005 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
101049 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
101200 pList->a[pList->nExpr-1].zEName = pColumns->a[i].zName;
101201 pColumns->a[i].zName = 0;
102051 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
102062 "USING ROWID SEARCH ON TABLE %s FOR IN-OPERATOR",pTab->zName));
102126 if( pReq!=0 && sqlite3StrICmp(pReq->zName, pIdx->azColl[j])!=0 ){
102143 "USING INDEX %s FOR IN-OPERATOR",pIdx->zName));
102146 VdbeComment((v, "%s", pIdx->zName));
103037 sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", pCol->zName);
103310 VdbeComment((v,"%s.rowid",pTab->zName));
103312 VdbeComment((v,"%s.%s",pTab->zName,pTab->aCol[pCol->iColumn].zName));
103372 pCol->zName);
103848 (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zName)
105519 if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7)
105526 sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName);
105587 char *zName = 0; /* NULL-terminated version of pName */
105607 zName = sqlite3NameFromToken(db, pName);
105608 if( !zName ) goto exit_rename_table;
105613 if( sqlite3FindTable(db, zName, zDb)
105614 || sqlite3FindIndex(db, zName, zDb)
105615 || sqlite3IsShadowTableOf(db, pTab, zName)
105618 "there is already another table or index with this name: %s", zName);
105628 if( SQLITE_OK!=sqlite3CheckObjectName(pParse,zName,"table",zName) ){
105634 sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
105641 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
105669 zTabName = pTab->zName;
105679 , zDb, MASTER_NAME, zDb, zTabName, zName, (iDb==1), zTabName
105696 zName, zName, zName,
105707 zDb, zName, pTab->zName);
105723 , zDb, zTabName, zName, zTabName, zDb, zName);
105734 sqlite3VdbeLoadString(v, i, zName);
105744 sqlite3DbFree(db, zName);
105793 zTab = &pNew->zName[16]; /* Skip the "sqlite_altertab_" prefix on the name */
105801 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
105968 pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
105969 if( !pNew->aCol || !pNew->zName ){
105976 pCol->zName = sqlite3DbStrDup(db, pCol->zName);
105977 pCol->hName = sqlite3StrIHash(pCol->zName);
106013 pParse, "cannot rename columns of %s \"%s\"", zType, pTab->zName
106058 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
106068 if( 0==sqlite3StrICmp(pTab->aCol[iCol].zName, zOld) ) break;
106091 zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1,
106092 pTab->zName
106100 zDb, pTab->zName, iCol, zNew, bQuote
106274 sqlite3RenameTokenRemap(pParse, 0, (void*)pIdList->a[ii].zName);
106298 sqlite3RenameTokenRemap(pParse, 0, (void*)pSrc->a[i].zName);
106476 char *zName = pEList->a[i].zEName;
106478 && ALWAYS(zName!=0)
106479 && 0==sqlite3_stricmp(zName, zOld)
106481 renameTokenFind(pParse, pCtx, (void*)zName);
106501 char *zName = pIdList->a[i].zName;
106502 if( 0==sqlite3_stricmp(zName, zOld) ){
106503 renameTokenFind(pParse, pCtx, (void*)zName);
106689 sSrc.a[0].zName = pStep->zTarget;
106830 zOld = pTab->aCol[iCol].zName;
106861 int bFKOnly = sqlite3_stricmp(zTable, sParse.pNewTable->zName);
106867 &sParse, &sCtx, (void*)sParse.pNewTable->aCol[iCol].zName
106978 renameTokenFind(pWalker->pParse, p, pItem->zName);
107080 if( sqlite3_stricmp(zOld, pTab->zName)==0 ){
107085 renameTokenFind(&sParse, &sCtx, pTab->zName);
107091 renameTokenFind(&sParse, &sCtx, sParse.pNewIndex->zName);
107404 const char *zName;
107436 const char *zTab = aTable[i].zName;
107478 VdbeComment((v, aTable[i].zName));
108228 if( sqlite3_strlike("sqlite\\_%", pTab->zName, '\\')==0 ){
108237 if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,
108247 pStat1->zName = (char*)&pStat1[1];
108248 memcpy(pStat1->zName, "sqlite_stat1", 13);
108259 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
108264 sqlite3VdbeLoadString(v, regTabname, pTab->zName);
108277 zIdxName = pTab->zName;
108281 zIdxName = pIdx->zName;
108287 VdbeComment((v, "Analysis for %s.%s", pTab->zName, zIdxName));
108331 VdbeComment((v, "%s", pIdx->zName));
108400 VdbeComment((v, "%s.column(%d)", pIdx->zName, i));
108421 VdbeComment((v, "%s.column(%d)", pIdx->zName, i));
108447 VdbeComment((v, "%s.column(%d)", pIdx->zName, i));
108529 VdbeComment((v, "%s", pTab->zName));
108598 openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");
108600 openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
108903 const char *zName,
108906 Index *pIdx = sqlite3FindIndex(db, zName, zDb);
108908 Table *pTab = sqlite3FindTable(db, zName, zDb);
109203 SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName){
109205 sqlite3StrICmp(db->aDb[iDb].zDbSName, zName)==0
109206 || (iDb==0 && sqlite3StrICmp("main", zName)==0)
109233 const char *zName;
109245 zName = (const char *)sqlite3_value_text(argv[1]);
109247 if( zName==0 ) zName = "";
109282 assert( zName );
109283 if( sqlite3DbIsNamed(db, i, zName) ){
109284 zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName);
109309 rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
109320 pNew->zDbSName = sqlite3DbStrDup(db, zName);
109371 rc = sqlite3UserAuthCheckLogin(db, zName, &newAuth);
109423 const char *zName = (const char *)sqlite3_value_text(argv[0]);
109432 if( zName==0 ) zName = "";
109436 if( sqlite3DbIsNamed(db, i, zName) ) break;
109440 sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
109444 sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
109448 sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
109951 zCol = pTab->aCol[iCol].zName;
109954 zCol = pTab->aCol[pTab->iPKey].zName;
109959 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
110102 const char *zName /* Name of the table to be locked */
110128 p->zLockName = zName;
110350 SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){
110359 if( db->auth.authLevel<UAUTH_Admin && sqlite3UserAuthTable(zName)!=0 ){
110376 p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName);
110377 if( p==0 && i==1 && sqlite3StrICmp(zName, MASTER_NAME)==0 ){
110383 p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash, zName);
110386 p = sqlite3HashFind(&db->aDb[0].pSchema->tblHash, zName);
110391 p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName);
110411 const char *zName, /* Name of the table we are looking for */
110425 p = sqlite3FindTable(db, zName, zDbase);
110432 Module *pMod = (Module*)sqlite3HashFind(&db->aModule, zName);
110433 if( pMod==0 && sqlite3_strnicmp(zName, "pragma_", 7)==0 ){
110434 pMod = sqlite3PragmaVtabRegister(db, zName);
110450 sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
110452 sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
110481 return sqlite3LocateTable(pParse, flags, p->zName, zDb);
110496 SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){
110507 p = sqlite3HashFind(&pSchema->idxHash, zName);
110658 assert( pCol->zName==0 || pCol->hName==sqlite3StrIHash(pCol->zName) );
110659 sqlite3DbFree(db, pCol->zName);
110705 char *zName = pIndex->zName;
110707 &pIndex->pSchema->idxHash, zName, 0
110721 sqlite3DbFree(db, pTable->zName);
110774 char *zName;
110776 zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n);
110777 sqlite3Dequote(zName);
110779 zName = 0;
110781 return zName;
110803 SQLITE_PRIVATE int sqlite3FindDbName(sqlite3 *db, const char *zName){
110805 if( zName ){
110808 if( 0==sqlite3_stricmp(pDb->zDbSName, zName) ) break;
110811 if( i==0 && 0==sqlite3_stricmp("main", zName) ) break;
110825 char *zName; /* Name we are searching for */
110826 zName = sqlite3NameFromToken(db, pName);
110827 i = sqlite3FindDbName(db, zName);
110828 sqlite3DbFree(db, zName);
110905 const char *zName, /* Name of the object to check */
110916 || sqlite3_stricmp(zName, db->init.azInit[1])
110925 if( (pParse->nested==0 && 0==sqlite3StrNICmp(zName, "sqlite_", 7))
110926 || (sqlite3ReadOnlyShadowTables(db) && sqlite3ShadowTableName(db, zName))
110929 zName);
111064 char *zName = 0; /* The name of the new table */
111073 zName = sqlite3DbStrDup(db, SCHEMA_TABLE(iDb));
111086 zName = sqlite3NameFromToken(db, pName);
111088 sqlite3RenameTokenMap(pParse, (void*)zName, pName);
111092 if( zName==0 ) return;
111093 if( sqlite3CheckObjectName(pParse, zName, isView?"view":"table", zName) ){
111112 zName, 0, zDb) ){
111130 pTable = sqlite3FindTable(db, zName, zDb);
111140 if( sqlite3FindIndex(db, zName, zDb)!=0 ){
111141 sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
111153 pTable->zName = zName;
111170 if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){
111244 sqlite3DbFree(db, zName);
111253 if( sqlite3_strnicmp(pCol->zName, "__hidden__", 10)==0 ){
111279 sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
111289 if( sqlite3_stricmp(z, p->aCol[i].zName)==0 ){
111306 pCol->zName = z;
111478 pCol->zName);
111577 "table \"%s\" has more than one primary key", pTab->zName);
111595 if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zName)==0 ){
111736 pCol->zName);
111838 n += identLength(pCol->zName) + 5;
111840 n += identLength(p->zName);
111858 identPut(zStmt, &k, p->zName);
111874 identPut(zStmt, &k, pCol->zName);
112089 sqlite3TokenInit(&ipkToken, pTab->aCol[pTab->iPKey].zName);
112205 SQLITE_PRIVATE int sqlite3IsShadowTableOf(sqlite3 *db, Table *pTab, const char *zName){
112210 nName = sqlite3Strlen30(pTab->zName);
112211 if( sqlite3_strnicmp(zName, pTab->zName, nName)!=0 ) return 0;
112212 if( zName[nName]!='_' ) return 0;
112217 return pMod->pModule->xShadowName(zName+nName+1);
112229 SQLITE_PRIVATE int sqlite3ShadowTableName(sqlite3 *db, const char *zName){
112232 zTail = strrchr(zName, '_');
112235 pTab = sqlite3FindTable(db, zName, 0);
112239 return sqlite3IsShadowTableOf(db, pTab, zName);
112309 if( pSelect==0 && sqlite3ShadowTableName(db, p->zName) ){
112344 sqlite3ErrorMsg(pParse, "PRIMARY KEY missing on table %s", p->zName);
112517 p->zName,
112518 p->zName,
112544 sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName));
112553 pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p);
112564 const char *zName = (const char *)pParse->sNameToken.z;
112570 nName = (int)((const char *)pCons->z - zName);
112571 p->addColOffset = 13 + sqlite3Utf8CharLen(zName, nName);
112709 sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
112944 const char *zName /* Name of index or table */
112954 zDbName, zTab, zType, zName
113000 pDb->zDbSName, pTab->zName
113014 pDb->zDbSName, MASTER_NAME, pTab->zName);
113023 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
113026 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
113051 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
113052 if( sqlite3StrNICmp(pTab->zName+7, "stat", 4)==0 ) return 0;
113053 if( sqlite3StrNICmp(pTab->zName+7, "parameters", 10)==0 ) return 0;
113114 zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
113123 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
113126 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
113132 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
113141 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
113145 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
113157 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
113208 p->aCol[iCol].zName, pTo);
113248 if( sqlite3StrICmp(p->aCol[j].zName, pFromCol->a[i].zEName)==0 ){
113350 if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
113357 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
113516 char *zName = 0; /* Name of the index */
113583 pTab->zName);
113598 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
113602 && sqlite3UserAuthTable(pTab->zName)==0
113605 && sqlite3StrICmp(&pTab->zName[7],"master")!=0
113608 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
113638 zName = sqlite3NameFromToken(db, pName);
113639 if( zName==0 ) goto exit_create_index;
113641 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName,"index",pTab->zName) ){
113646 if( sqlite3FindTable(db, zName, 0)!=0 ){
113647 sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
113651 if( sqlite3FindIndex(db, zName, pDb->zDbSName)!=0 ){
113653 sqlite3ErrorMsg(pParse, "index %s already exists", zName);
113665 zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
113666 if( zName==0 ){
113675 if( IN_SPECIAL_PARSE ) zName[7]++;
113688 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
113702 sqlite3TokenInit(&prevCol, pCol->zName);
113727 nName = sqlite3Strlen30(zName);
113737 pIndex->zName = zExtra;
113739 memcpy(pIndex->zName, zName, nName+1);
113961 pIndex->zName, pIndex);
114023 pIndex->zName,
114024 pTab->zName,
114037 sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName));
114076 sqlite3DbFree(db, zName);
114143 pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
114169 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
114181 db->aDb[iDb].zDbSName, MASTER_NAME, pIndex->zName
114183 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
114186 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
114258 pList->a[i].zName = sqlite3NameFromToken(db, pToken);
114259 if( IN_RENAME_OBJECT && pList->a[i].zName ){
114260 sqlite3RenameTokenMap(pParse, (void*)pList->a[i].zName, pToken);
114272 sqlite3DbFree(db, pList->a[i].zName);
114282 SQLITE_PRIVATE int sqlite3IdListIndex(IdList *pList, const char *zName){
114286 if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
114445 pItem->zName = sqlite3NameFromToken(db, pDatabase);
114448 pItem->zName = sqlite3NameFromToken(db, pTable);
114481 sqlite3DbFree(db, pItem->zName);
114534 assert( pItem->zName==0 || pDatabase!=0 );
114535 if( IN_RENAME_OBJECT && pItem->zName ){
114537 sqlite3RenameTokenMap(pParse, pItem->zName, pToken);
114675 char *zName = sqlite3NameFromToken(pParse->db, pName);
114676 if( zName ){
114682 if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
114683 sqlite3DbFree(pParse->db, zName);
114686 sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
114850 sqlite3_str_appendf(&errMsg, "index '%q'", pIdx->zName);
114855 zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
114857 sqlite3_str_appendall(&errMsg, pTab->zName);
114881 zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
114882 pTab->aCol[pTab->iPKey].zName);
114885 zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
115083 char *zName;
115087 zName = sqlite3NameFromToken(pParse->db, pName);
115088 if( zName && pWith ){
115091 if( sqlite3StrICmp(zName, pWith->a[i].zName)==0 ){
115092 sqlite3ErrorMsg(pParse, "duplicate WITH table name: %s", zName);
115103 assert( (pNew!=0 && zName!=0) || db->mallocFailed );
115108 sqlite3DbFree(db, zName);
115113 pNew->a[pNew->nCte].zName = zName;
115131 sqlite3DbFree(db, pCte->zName);
115162 static void callCollNeeded(sqlite3 *db, int enc, const char *zName){
115165 char *zExternal = sqlite3DbStrDup(db, zName);
115174 sqlite3ValueSetStr(pTmp, -1, zName, SQLITE_UTF8, SQLITE_STATIC);
115193 char *z = pColl->zName;
115220 const char *zName = pColl->zName;
115222 CollSeq *p = sqlite3GetCollSeq(pParse, ENC(db), pColl, zName);
115248 const char *zName, /* Name of the collating sequence */
115252 pColl = sqlite3HashFind(&db->aCollSeq, zName);
115255 int nName = sqlite3Strlen30(zName) + 1;
115259 pColl[0].zName = (char*)&pColl[3];
115261 pColl[1].zName = (char*)&pColl[3];
115263 pColl[2].zName = (char*)&pColl[3];
115265 memcpy(pColl[0].zName, zName, nName);
115266 pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, pColl);
115301 const char *zName, /* Name of the collating sequence. Might be NULL */
115307 if( zName ){
115308 pColl = findCollSeqEntry(db, zName, create);
115347 const char *zName /* Collating sequence name */
115354 p = sqlite3FindCollSeq(db, enc, zName, 0);
115360 callCollNeeded(db, enc, zName);
115361 p = sqlite3FindCollSeq(db, enc, zName, 0);
115368 sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);
115394 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){
115400 pColl = sqlite3FindCollSeq(db, enc, zName, initbusy);
115402 pColl = sqlite3GetCollSeq(pParse, enc, pColl, zName);
115479 if( sqlite3StrICmp(p->zName, zFunc)==0 ){
115496 const char *zName = aDef[i].zName;
115497 int nName = sqlite3Strlen30(zName);
115498 int h = SQLITE_FUNC_HASH(zName[0], nName);
115499 assert( zName[0]>='a' && zName[0]<='z' );
115500 pOther = sqlite3FunctionSearch(h, zName);
115536 const char *zName, /* Name of the function. zero-terminated */
115549 nName = sqlite3Strlen30(zName);
115553 p = (FuncDef*)sqlite3HashFind(&db->aFunc, zName);
115577 h = SQLITE_FUNC_HASH(sqlite3UpperToLower[(u8)zName[0]], nName);
115578 p = sqlite3FunctionSearch(h, zName);
115597 pBest->zName = (const char*)&pBest[1];
115600 memcpy((char*)&pBest[1], zName, nName+1);
115601 for(z=(u8*)pBest->zName; *z; z++) *z = sqlite3UpperToLower[*z];
115602 pOther = (FuncDef*)sqlite3HashInsert(&db->aFunc, pBest->zName, pBest);
115761 sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
115766 sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
115797 pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName);
115869 const char *zName = pTab->aCol[pPk->aiColumn[0]].zName;
115870 pLhs = sqlite3Expr(db, TK_ID, zName);
115871 pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ID, zName));
115875 Expr *p = sqlite3Expr(db, TK_ID, pTab->aCol[pPk->aiColumn[i]].zName);
116008 rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0,
116027 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
116094 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
116097 pTab->zName, P4_STATIC);
116463 if( pParse->nested==0 || 0==sqlite3_stricmp(pTab->zName, "sqlite_stat1") ){
116534 VdbeModuleComment((v, "GenRowIdxDel for %s", pIdx->zName));
118687 int n = sqlite3Strlen30(p->zName);
118688 int h = p->zName[0] + n;
118689 printf(" %s(%d)", p->zName, h);
118916 if( !sqlite3StrICmp(pParent->aCol[pParent->iPKey].zName, zKey) ) return 0;
118962 zIdxCol = pParent->aCol[iCol].zName;
118980 pFKey->pFrom->zName, pFKey->zTo);
119187 if( zColl==0 ) zColl = db->pDfltColl->zName;
119295 zCol = pFKey->pFrom->aCol[iCol].zName;
119330 pRight = sqlite3Expr(db, TK_ID, pTab->aCol[iCol].zName);
119378 return (FKey *)sqlite3HashFind(&pTab->pSchema->fkeyHash, pTab->zName);
119521 if( 0==sqlite3StrICmp(pCol->zName, zKey) ) return 1;
119604 && sqlite3_stricmp(pTab->zName, pFKey->zTo)!=0
119661 char *zCol = pTo->aCol[pIdx ? pIdx->aiColumn[i] : pTo->iPKey].zName;
119662 rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
119671 sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
119727 pItem->zName = pFKey->pFrom->zName;
119758 pItem->zName = 0;
119839 if( 0==sqlite3_stricmp(pTab->zName, p->zTo) ) return 2;
119931 pTab->aCol[pIdx ? pIdx->aiColumn[i] : pTab->iPKey].zName);
119932 sqlite3TokenInit(&tFromCol, pFKey->pFrom->aCol[iFromCol].zName);
119993 zFrom = pFKey->pFrom->zName;
120187 (opcode==OP_OpenWrite)?1:0, pTab->zName);
120190 VdbeComment((v, "%s", pTab->zName));
120197 VdbeComment((v, "%s", pTab->zName));
120459 sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", pRedo->zName);
120573 sqlite3VdbeLoadString(v, memId-1, p->pTab->zName);
120841 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0,
120943 if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){
120953 pTab->aCol[j].zName);
120961 if( sqlite3IsRowid(pColumn->a[i].zName) && !withoutRowid ){
120966 pTabList, 0, pColumn->a[i].zName);
121128 pTab->zName);
121767 char *zMsg = sqlite3MPrintf(db, "%s.%s", pTab->zName,
121768 pCol->zName);
121836 char *zName = pCheck->a[i].zEName;
121837 if( zName==0 ) zName = pTab->zName;
121840 onError, zName, P4_TRANSIENT,
122096 VdbeNoopComment((v, "prep index %s", pIdx->zName));
122120 VdbeComment((v, "%s column %d", pIdx->zName, i));
122129 VdbeComment((v, "%s", pTab->aCol[iField].zName));
122133 VdbeComment((v, "for %s", pIdx->zName));
122222 VdbeComment((v, "%s.%s", pTab->zName,
122223 pTab->aCol[pPk->aiColumn[i]].zName));
122565 sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
122579 VdbeComment((v, "%s", pIdx->zName));
122960 sqlite3TableLock(pParse, iDbDest, pDest->tnum, 1, pDest->zName);
122961 sqlite3TableLock(pParse, iDbSrc, pSrc->tnum, 0, pSrc->zName);
122971 VdbeComment((v, "%s", pSrcIdx->zName));
122975 VdbeComment((v, "%s", pDestIdx->zName));
123232 int (*bind_parameter_index)(sqlite3_stmt*,const char*zName);
124849 const char *const zName; /* Name of pragma */
125516 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, pPragma->zName, SQLITE_STATIC);
125581 const char *zName;
125583 case OE_SetNull: zName = "SET NULL"; break;
125584 case OE_SetDflt: zName = "SET DEFAULT"; break;
125585 case OE_Cascade: zName = "CASCADE"; break;
125586 case OE_Restrict: zName = "RESTRICT"; break;
125587 default: zName = "NO ACTION";
125590 return zName;
125622 static const PragmaName *pragmaLocate(const char *zName){
125628 rc = sqlite3_stricmp(zName, aPragmaName[mid].zName);
125679 p->zName, isBuiltin,
126517 pCol->zName,
126537 pTab->zName,
126544 pIdx->zName,
126587 cnum<0 ? 0 : pTab->aCol[cnum].zName);
126613 pIdx->zName,
126642 sqlite3VdbeMultiLoad(v, 1, "is", i++, pColl->zName);
126672 sqlite3VdbeMultiLoad(v, 1, "s", pMod->zName);
126681 sqlite3VdbeMultiLoad(v, 1, "s", aPragmaName[i].zName);
126708 pTab->aCol[pFK->aCol[j].iFrom].zName,
126758 sqlite3TableLock(pParse, iTabDb, pTab->tnum, 0, pTab->zName);
126761 sqlite3VdbeLoadString(v, regResult, pTab->zName);
126766 sqlite3TableLock(pParse, iTabDb, pParent->tnum, 0, pParent->zName);
126993 zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName,
126994 pTab->aCol[j].zName);
127016 pTab->zName);
127040 jmp5 = sqlite3VdbeLoadString(v, 4, pIdx->zName);
127080 sqlite3VdbeLoadString(v, 4, pIdx->zName);
127140 char *zName;
127159 returnSingleText(v, encnames[ENC(pParse->db)].zName);
127167 for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
127168 if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){
127175 if( !pEnc->zName ){
127428 db->aDb[iDb].zDbSName, pTab->zName);
127639 sqlite3_str_appendf(&acc, "(\"%s\"", pPragma->zName);
127807 sqlite3_str_appendall(&acc, pTab->pName->zName);
127890 SQLITE_PRIVATE Module *sqlite3PragmaVtabRegister(sqlite3 *db, const char *zName){
127892 assert( sqlite3_strnicmp(zName, "pragma_", 7)==0 );
127893 pName = pragmaLocate(zName+7);
127896 assert( sqlite3HashFind(&db->aModule, zName)==0 );
127897 return sqlite3VtabCreateModule(db, zName, &pragmaVtabModule, (void*)pName, 0);
129133 if( sqlite3StrICmp(pTab->aCol[i].zName, zCol)==0 ) return i;
129324 char *zName; /* Name of column in the right table */
129329 zName = pRightTab->aCol[j].zName;
129330 if( tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol, 1) ){
129364 char *zName; /* Name of the term in the USING clause */
129369 zName = pList->a[j].zName;
129370 iRightCol = columnIndex(pRightTab, zName);
129372 || !tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol, 0)
129375 "not present in both tables", zName);
130575 zOrigCol = pTab->aCol[iCol].zName;
130578 zOrigTab = pTab->zName;
130735 char *zName = pEList->a[i].zEName;
130736 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_TRANSIENT);
130747 zCol = pTab->aCol[iCol].zName;
130750 char *zName = 0;
130751 zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol);
130752 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_DYNAMIC);
130798 char *zName; /* Column name */
130819 if( (zName = pEList->a[i].zEName)!=0 && pEList->a[i].eEName==ENAME_NAME ){
130833 zName = iCol>=0 ? pTab->aCol[iCol].zName : "rowid";
130836 zName = pColExpr->u.zToken;
130839 zName = pEList->a[i].zEName;
130842 if( zName && !sqlite3IsTrueOrFalse(zName) ){
130843 zName = sqlite3DbStrDup(db, zName);
130845 zName = sqlite3MPrintf(db,"column%d",i+1);
130852 while( zName && sqlite3HashFind(&ht, zName)!=0 ){
130853 nName = sqlite3Strlen30(zName);
130855 for(j=nName-1; j>0 && sqlite3Isdigit(zName[j]); j--){}
130856 if( zName[j]==':' ) nName = j;
130858 zName = sqlite3MPrintf(db, "%.*z:%u", nName, zName, ++cnt);
130861 pCol->zName = zName;
130862 pCol->hName = sqlite3StrIHash(zName);
130864 if( zName && sqlite3HashInsert(&ht, zName, pCol)==pCol ){
130871 sqlite3DbFree(db, aCol[j].zName);
130922 n = sqlite3Strlen30(pCol->zName);
130923 pCol->zName = sqlite3DbReallocOrFree(db, pCol->zName, n+m+2);
130924 if( pCol->zName ){
130925 memcpy(&pCol->zName[n+1], zType, m+1);
130932 pCol->zColl = sqlite3DbStrDup(db, pColl->zName);
130959 pTab->zName = 0;
131112 sqlite3ExprAddCollateString(pParse, pTerm, pColl->zName);
132358 (pColl ? pColl->zName : "BINARY")
132768 pParse->zAuthContext = pSubitem->zName;
132842 sqlite3DbFree(db, pSubitem->zName);
132845 pSubitem->zName = 0;
133421 pIdx && sqlite3StrICmp(pIdx->zName, zIndexedBy);
133513 sqlite3ErrorMsg(pParse, "'%s' is not a function", pFrom->zName);
133535 const char *zName;
133536 if( pItem->zDatabase==0 && (zName = pItem->zName)!=0 ){
133541 if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){
133614 sqlite3ErrorMsg(pParse, pCte->zCteErr, pCte->zName);
133623 pTab->zName = sqlite3DbStrDup(db, pCte->zName);
133640 && pItem->zName!=0
133641 && 0==sqlite3StrICmp(pItem->zName, pCte->zName)
133654 pParse, "multiple references to recursive table: %s", pCte->zName
133680 pCte->zName, pEList->nExpr, pCte->pCols->nExpr
133744 pTab->zName = sqlite3DbStrDup(pParse->db, pFrom->zAlias);
133746 pTab->zName = sqlite3MPrintf(pParse->db, "subquery_%u", pSel->selId);
133826 if( pFrom->zName==0 ){
133842 pTab->zName);
133858 pTab->zName);
133867 pTab->zName);
133958 zTabName = pTab->zName;
133970 char *zName = pTab->aCol[j].zName;
133975 assert( zName );
133995 && tableAndColumnIndex(pTabList, i, zName, 0, 0, 1)
134001 if( sqlite3IdListIndex(pFrom->pUsing, zName)>=0 ){
134007 pRight = sqlite3Expr(db, TK_ID, zName);
134008 zColname = zName;
134019 zColname = sqlite3MPrintf(db, "%s.%s", zTabName, zName);
134368 pTab->zName,
134370 bCover ? pIdx->zName : ""
134452 if( pItem->zName==0 ) continue;
134456 if( sqlite3_stricmp(pItem->zName, pThis->zName)!=0 ) continue;
134690 pTab->nCol, pTab->zName, pSub->pEList->nExpr);
134818 if( pItem->colUsed==0 && pItem->zName!=0 ){
134819 sqlite3AuthCheck(pParse, SQLITE_READ, pItem->zName, "", pItem->zDatabase);
134870 pParse->zAuthContext = pItem->zName;
134892 VdbeComment((v, "%s", pItem->pTab->zName));
134923 VdbeComment((v, "materialize \"%s\"", pItem->pTab->zName));
134925 VdbeNoopComment((v, "materialize \"%s\"", pItem->pTab->zName));
134940 VdbeComment((v, "end %s", pItem->pTab->zName));
135502 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
135906 && 0==sqlite3StrICmp(pTrig->table, pTab->zName)
135939 char *zName = 0; /* Name of the trigger */
136022 zName = sqlite3NameFromToken(db, pName);
136023 if( zName==0 ){
136027 if( sqlite3CheckObjectName(pParse, zName, "trigger", pTab->zName) ){
136032 if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),zName) ){
136044 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
136070 if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
136091 pTrigger->zName = zName;
136092 zName = 0;
136093 pTrigger->table = sqlite3DbStrDup(db, pTableName->a[0].zName);
136099 sqlite3RenameTokenRemap(pParse, pTrigger->table, pTableName->a[0].zName);
136111 sqlite3DbFree(db, zName);
136132 char *zName; /* Name of trigger */
136140 zName = pTrig->zName;
136147 sqlite3TokenInit(&nameToken, pTrig->zName);
136178 db->aDb[iDb].zDbSName, MASTER_NAME, zName,
136183 sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName));
136191 pTrig = sqlite3HashInsert(pHash, zName, pTrig);
136393 sqlite3DbFree(db, pTrigger->zName);
136412 const char *zName;
136422 zName = pName->a[0].zName;
136428 pTrigger = sqlite3HashFind(&(db->aDb[j].pSchema->trigHash), zName);
136474 if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) ||
136486 db->aDb[iDb].zDbSName, MASTER_NAME, pTrigger->zName
136489 sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
136496 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){
136502 pTrigger = sqlite3HashInsert(pHash, zName, 0);
136592 pSrc->a[pSrc->nSrc-1].zName = sqlite3DbStrDup(db, pStep->zTarget);
136744 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
136771 pSubParse->zAuthContext = pTrigger->zName;
136779 pTrigger->zName, onErrorText(orconf),
136784 pTab->zName
136787 if( pTrigger->zName ){
136789 sqlite3MPrintf(db, "-- TRIGGER %s", pTrigger->zName), P4_DYNAMIC
136816 VdbeComment((v, "End: %s.%s", pTrigger->zName, onErrorText(orconf)));
136853 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
136894 int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers));
136899 (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf)));
137111 VdbeComment((v, "%s.%s", pTab->zName, pCol->zName));
137353 if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zEName)==0 ){
137366 pTab->aCol[j].zName);
137388 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
137389 j<0 ? "ROWID" : pTab->aCol[j].zName,
137501 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
138351 VdbeComment((v, "%s.%s", pIdx->zName,
138352 pTab->aCol[pPk->aiColumn[i]].zName));
138830 const char *zName, /* Name assigned to this module */
138839 zCopy = (char*)zName;
138842 int nName = sqlite3Strlen30(zName);
138849 memcpy(zCopy, zName, nName+1);
138850 pMod->zName = zCopy;
138878 const char *zName, /* Name assigned to this module */
138886 (void)sqlite3VtabCreateModule(db, zName, pModule, pAux, xDestroy);
138899 const char *zName, /* Name assigned to this module */
138904 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
138906 return createModule(db, zName, pModule, pAux, 0);
138914 const char *zName, /* Name assigned to this module */
138920 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
138922 return createModule(db, zName, pModule, pAux, xDestroy);
138939 for(ii=0; azNames[ii]!=0 && strcmp(azNames[ii],pMod->zName)!=0; ii++){}
138942 createModule(db, pMod->zName, 0, 0, 0);
139148 sqlite3ErrorMsg(pParse, "too many columns on %s", pTable->zName);
139186 addModuleArgument(pParse, pTable, sqlite3DbStrDup(db, pTable->zName));
139203 sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName,
139271 pTab->zName,
139272 pTab->zName,
139280 zWhere = sqlite3MPrintf(db, "name=%Q AND sql=%Q", pTab->zName, zStmt);
139285 sqlite3VdbeLoadString(v, iReg, pTab->zName);
139297 const char *zName = pTab->zName;
139299 pOld = sqlite3HashInsert(&pSchema->tblHash, zName, pTab);
139360 "vtable constructor called recursively: %s", pTab->zName
139366 zModuleName = sqlite3DbStrDup(db, pTab->zName);
139414 *pzErr = sqlite3MPrintf(db, zFormat, pTab->zName);
139926 for(i=0; pDef->zName[i]; i++){
139927 unsigned char x = (unsigned char)pDef->zName[i];
139932 rc = pMod->xFindFunction(pVtab, nArg, pDef->zName, &xSFunc, &pArg);
139940 + sqlite3Strlen30(pDef->zName) + 1);
139945 pNew->zName = (const char*)&pNew[1];
139946 memcpy((char*)&pNew[1], pDef->zName, sqlite3Strlen30(pDef->zName)+1);
140002 pTab->zName = sqlite3DbStrDup(db, pMod->zName);
140003 if( pTab->zName==0 ){
140012 addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
140014 addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
140766 return pIdx->pTable->aCol[i].zName;
140889 sqlite3_str_appendf(&str, " TABLE %s", pItem->zName);
140917 sqlite3_str_appendf(&str, zFmt, pIdx->zName);
140977 zObj = pLoop->u.btree.pIndex->zName;
140979 zObj = pSrclist->a[pLvl->iFrom].zName;
141438 VdbeComment((v, "begin skip-scan on %s", pIdx->zName));
142040 VdbeModuleComment((v, "Begin WHERE-loop%d: %s",iLevel,pTabItem->pTab->zName));
142094 VdbeComment((v, "next row of %s", pTabItem->pTab->zName));
144804 pTab->zName, j);
145115 if( sqlite3StrICmp(pColl->zName, pScan->zCollName) ){
145289 if( 0==sqlite3StrICmp(pColl->zName, zColl) ){
145579 "automatic index on %s(%s)", pTable->zName,
145580 pTable->aCol[iCol].zName);
145620 pIdx->zName = "auto-index";
145636 pIdx->azColl[n] = pColl ? pColl->zName : sqlite3StrBINARY;
145668 VdbeComment((v, "for %s", pTable->zName));
145678 VdbeComment((v, "next row of %s", pTabItem->pTab->zName));
146504 p->zName, nEq-1, (int)a[1]));
146631 pItem->zAlias ? pItem->zAlias : pTab->zName);
146633 const char *zName;
146634 if( p->u.btree.pIndex && (zName = p->u.btree.pIndex->zName)!=0 ){
146635 if( strncmp(zName, "sqlite_autoindex_", 17)==0 ){
146636 int i = sqlite3Strlen30(zName) - 1;
146637 while( zName[i]!='_' ) i--;
146638 zName += i;
146640 sqlite3DebugPrintf(".%-16s %2d", zName, p->u.btree.nEq);
147207 if( sqlite3StrICmp(pColl->zName, pIdx->azColl[i+nEq]) ) break;
147263 pProbe->pTable->zName,pProbe->zName,
147385 saved_nEq, pProbe->zName, M+logK+10, nIn+rLogSize));
147390 saved_nEq, pProbe->zName, M+logK+10, nIn+rLogSize));
147607 pProbe->pTable->zName, pProbe->zName, saved_nEq, rc));
148050 sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
148090 sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
148142 zRet = (pC ? pC->zName : sqlite3StrBINARY);
148210 WHERETRACE(0x800, ("BEGIN %s.addVirtual()\n", pSrc->pTab->zName));
148286 WHERETRACE(0x800, ("END %s.addVirtual(), rc=%d\n", pSrc->pTab->zName, rc));
148609 if( pColl2==0 || sqlite3StrICmp(pColl1->zName, pColl2->zName) ){
148729 if( sqlite3StrICmp(pColl->zName, pIndex->azColl[j])!=0 ) continue;
148838 static char zName[65];
148840 for(i=0; i<nLoop; i++){ zName[i] = pPath->aLoop[i]->cId; }
148841 if( pLast ) zName[i++] = pLast->cId;
148842 zName[i] = 0;
148843 return zName;
149961 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
150006 VdbeComment((v, "%s", pIx->zName));
150195 VdbeComment((v, "next skip-scan on %s", pLoop->u.btree.pIndex->zName));
150227 pWInfo->pTabList->a[pLevel->iFrom].pTab->zName));
150994 static Window *windowFind(Parse *pParse, Window *pList, const char *zName){
150997 if( sqlite3StrICmp(p->zName, zName)==0 ) break;
151000 sqlite3ErrorMsg(pParse, "no such window: %s", zName);
151028 if( pWin->zName && pWin->eFrmType==0 ){
151029 Window *p = windowFind(pParse, pList, pWin->zName);
151074 if( pFunc->zName==aUp[i].zFunc ){
151470 sqlite3DbFree(db, p->zName);
151757 if( pKeyInfo && pWin->pFunc->zName[1]=='i' ){
151765 else if( p->zName==nth_valueName || p->zName==first_valueName ){
151773 else if( p->zName==leadName || p->zName==lagName ){
151988 if( i!=1 || pFunc->zName!=nth_valueName ){
152015 assert( pFunc->zName==nth_valueName
152016 || pFunc->zName==first_valueName
152236 if( pFunc->zName==nth_valueName
152237 || pFunc->zName==first_valueName
152244 if( pFunc->zName==nth_valueName ){
152259 else if( pFunc->zName==leadName || pFunc->zName==lagName ){
152273 int val = (pFunc->zName==leadName ? 1 : -1);
152276 int op = (pFunc->zName==leadName ? OP_Add : OP_Subtract);
152311 if( pFunc->zName==nth_valueName || pFunc->zName==first_valueName ){
152337 if( (pFunc->zName==nth_valueName)
152338 || (pFunc->zName==first_valueName)
152339 || (pFunc->zName==leadName)
152340 || (pFunc->zName==lagName)
152675 pNew->zName = sqlite3DbStrDup(db, p->zName);
157170 pNew->zName = pOld->zName;
157179 pOld->zName = pOld->zDatabase = 0;
157198 … && yylhsminor.yy47 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy47->a[0].zName, &yymsp[0].minor.y…
157205 … && yylhsminor.yy47 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy47->a[0].zName, &yymsp[0].minor.y…
157688 sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0);
157944 …yymsp[-1].minor.yy303->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor…
158062 …yymsp[-1].minor.yy303->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.y…
159052 SQLITE_API int sqlite3_keyword_check(const char *zName, int nName){
159053 return TK_ID!=sqlite3KeywordCode((const u8*)zName, nName);
161197 assert( p==0 || p->xCmp!=binCollFunc || strcmp(p->zName,"BINARY")==0 );
161602 const char *zName = 0;
161604 for(i=0; i<2 && zName==0; i++, rc &= 0xff){
161606 case SQLITE_OK: zName = "SQLITE_OK"; break;
161607 case SQLITE_ERROR: zName = "SQLITE_ERROR"; break;
161608 case SQLITE_ERROR_SNAPSHOT: zName = "SQLITE_ERROR_SNAPSHOT"; break;
161609 case SQLITE_INTERNAL: zName = "SQLITE_INTERNAL"; break;
161610 case SQLITE_PERM: zName = "SQLITE_PERM"; break;
161611 case SQLITE_ABORT: zName = "SQLITE_ABORT"; break;
161612 case SQLITE_ABORT_ROLLBACK: zName = "SQLITE_ABORT_ROLLBACK"; break;
161613 case SQLITE_BUSY: zName = "SQLITE_BUSY"; break;
161614 case SQLITE_BUSY_RECOVERY: zName = "SQLITE_BUSY_RECOVERY"; break;
161615 case SQLITE_BUSY_SNAPSHOT: zName = "SQLITE_BUSY_SNAPSHOT"; break;
161616 case SQLITE_LOCKED: zName = "SQLITE_LOCKED"; break;
161617 case SQLITE_LOCKED_SHAREDCACHE: zName = "SQLITE_LOCKED_SHAREDCACHE";break;
161618 case SQLITE_NOMEM: zName = "SQLITE_NOMEM"; break;
161619 case SQLITE_READONLY: zName = "SQLITE_READONLY"; break;
161620 case SQLITE_READONLY_RECOVERY: zName = "SQLITE_READONLY_RECOVERY"; break;
161621 case SQLITE_READONLY_CANTINIT: zName = "SQLITE_READONLY_CANTINIT"; break;
161622 case SQLITE_READONLY_ROLLBACK: zName = "SQLITE_READONLY_ROLLBACK"; break;
161623 case SQLITE_READONLY_DBMOVED: zName = "SQLITE_READONLY_DBMOVED"; break;
161624 case SQLITE_READONLY_DIRECTORY: zName = "SQLITE_READONLY_DIRECTORY";break;
161625 case SQLITE_INTERRUPT: zName = "SQLITE_INTERRUPT"; break;
161626 case SQLITE_IOERR: zName = "SQLITE_IOERR"; break;
161627 case SQLITE_IOERR_READ: zName = "SQLITE_IOERR_READ"; break;
161628 case SQLITE_IOERR_SHORT_READ: zName = "SQLITE_IOERR_SHORT_READ"; break;
161629 case SQLITE_IOERR_WRITE: zName = "SQLITE_IOERR_WRITE"; break;
161630 case SQLITE_IOERR_FSYNC: zName = "SQLITE_IOERR_FSYNC"; break;
161631 case SQLITE_IOERR_DIR_FSYNC: zName = "SQLITE_IOERR_DIR_FSYNC"; break;
161632 case SQLITE_IOERR_TRUNCATE: zName = "SQLITE_IOERR_TRUNCATE"; break;
161633 case SQLITE_IOERR_FSTAT: zName = "SQLITE_IOERR_FSTAT"; break;
161634 case SQLITE_IOERR_UNLOCK: zName = "SQLITE_IOERR_UNLOCK"; break;
161635 case SQLITE_IOERR_RDLOCK: zName = "SQLITE_IOERR_RDLOCK"; break;
161636 case SQLITE_IOERR_DELETE: zName = "SQLITE_IOERR_DELETE"; break;
161637 case SQLITE_IOERR_NOMEM: zName = "SQLITE_IOERR_NOMEM"; break;
161638 case SQLITE_IOERR_ACCESS: zName = "SQLITE_IOERR_ACCESS"; break;
161640 zName = "SQLITE_IOERR_CHECKRESERVEDLOCK"; break;
161641 case SQLITE_IOERR_LOCK: zName = "SQLITE_IOERR_LOCK"; break;
161642 case SQLITE_IOERR_CLOSE: zName = "SQLITE_IOERR_CLOSE"; break;
161643 case SQLITE_IOERR_DIR_CLOSE: zName = "SQLITE_IOERR_DIR_CLOSE"; break;
161644 case SQLITE_IOERR_SHMOPEN: zName = "SQLITE_IOERR_SHMOPEN"; break;
161645 case SQLITE_IOERR_SHMSIZE: zName = "SQLITE_IOERR_SHMSIZE"; break;
161646 case SQLITE_IOERR_SHMLOCK: zName = "SQLITE_IOERR_SHMLOCK"; break;
161647 case SQLITE_IOERR_SHMMAP: zName = "SQLITE_IOERR_SHMMAP"; break;
161648 case SQLITE_IOERR_SEEK: zName = "SQLITE_IOERR_SEEK"; break;
161649 case SQLITE_IOERR_DELETE_NOENT: zName = "SQLITE_IOERR_DELETE_NOENT";break;
161650 case SQLITE_IOERR_MMAP: zName = "SQLITE_IOERR_MMAP"; break;
161651 case SQLITE_IOERR_GETTEMPPATH: zName = "SQLITE_IOERR_GETTEMPPATH"; break;
161652 case SQLITE_IOERR_CONVPATH: zName = "SQLITE_IOERR_CONVPATH"; break;
161653 case SQLITE_CORRUPT: zName = "SQLITE_CORRUPT"; break;
161654 case SQLITE_CORRUPT_VTAB: zName = "SQLITE_CORRUPT_VTAB"; break;
161655 case SQLITE_NOTFOUND: zName = "SQLITE_NOTFOUND"; break;
161656 case SQLITE_FULL: zName = "SQLITE_FULL"; break;
161657 case SQLITE_CANTOPEN: zName = "SQLITE_CANTOPEN"; break;
161658 case SQLITE_CANTOPEN_NOTEMPDIR: zName = "SQLITE_CANTOPEN_NOTEMPDIR";break;
161659 case SQLITE_CANTOPEN_ISDIR: zName = "SQLITE_CANTOPEN_ISDIR"; break;
161660 case SQLITE_CANTOPEN_FULLPATH: zName = "SQLITE_CANTOPEN_FULLPATH"; break;
161661 case SQLITE_CANTOPEN_CONVPATH: zName = "SQLITE_CANTOPEN_CONVPATH"; break;
161662 case SQLITE_CANTOPEN_SYMLINK: zName = "SQLITE_CANTOPEN_SYMLINK"; break;
161663 case SQLITE_PROTOCOL: zName = "SQLITE_PROTOCOL"; break;
161664 case SQLITE_EMPTY: zName = "SQLITE_EMPTY"; break;
161665 case SQLITE_SCHEMA: zName = "SQLITE_SCHEMA"; break;
161666 case SQLITE_TOOBIG: zName = "SQLITE_TOOBIG"; break;
161667 case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT"; break;
161668 case SQLITE_CONSTRAINT_UNIQUE: zName = "SQLITE_CONSTRAINT_UNIQUE"; break;
161669 case SQLITE_CONSTRAINT_TRIGGER: zName = "SQLITE_CONSTRAINT_TRIGGER";break;
161671 zName = "SQLITE_CONSTRAINT_FOREIGNKEY"; break;
161672 case SQLITE_CONSTRAINT_CHECK: zName = "SQLITE_CONSTRAINT_CHECK"; break;
161674 zName = "SQLITE_CONSTRAINT_PRIMARYKEY"; break;
161675 case SQLITE_CONSTRAINT_NOTNULL: zName = "SQLITE_CONSTRAINT_NOTNULL";break;
161677 zName = "SQLITE_CONSTRAINT_COMMITHOOK"; break;
161678 case SQLITE_CONSTRAINT_VTAB: zName = "SQLITE_CONSTRAINT_VTAB"; break;
161680 zName = "SQLITE_CONSTRAINT_FUNCTION"; break;
161681 case SQLITE_CONSTRAINT_ROWID: zName = "SQLITE_CONSTRAINT_ROWID"; break;
161682 case SQLITE_MISMATCH: zName = "SQLITE_MISMATCH"; break;
161683 case SQLITE_MISUSE: zName = "SQLITE_MISUSE"; break;
161684 case SQLITE_NOLFS: zName = "SQLITE_NOLFS"; break;
161685 case SQLITE_AUTH: zName = "SQLITE_AUTH"; break;
161686 case SQLITE_FORMAT: zName = "SQLITE_FORMAT"; break;
161687 case SQLITE_RANGE: zName = "SQLITE_RANGE"; break;
161688 case SQLITE_NOTADB: zName = "SQLITE_NOTADB"; break;
161689 case SQLITE_ROW: zName = "SQLITE_ROW"; break;
161690 case SQLITE_NOTICE: zName = "SQLITE_NOTICE"; break;
161691 case SQLITE_NOTICE_RECOVER_WAL: zName = "SQLITE_NOTICE_RECOVER_WAL";break;
161693 zName = "SQLITE_NOTICE_RECOVER_ROLLBACK"; break;
161694 case SQLITE_WARNING: zName = "SQLITE_WARNING"; break;
161695 case SQLITE_WARNING_AUTOINDEX: zName = "SQLITE_WARNING_AUTOINDEX"; break;
161696 case SQLITE_DONE: zName = "SQLITE_DONE"; break;
161699 if( zName==0 ){
161702 zName = zBuf;
161704 return zName;
162194 const char *zName = (const char*)sqlite3_user_data(context);
162198 "unable to use function %s in the requested context", zName);
162217 const char *zName,
162224 if( !sqlite3SafetyCheckOk(db) || zName==0 || nArg<-2 ){
162229 rc = sqlite3FindFunction(db, zName, nArg, SQLITE_UTF8, 0)!=0;
162232 zCopy = sqlite3_mprintf(zName);
162234 return sqlite3_create_function_v2(db, zName, nArg, SQLITE_UTF8,
162763 const char *zName,
162792 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0);
162808 CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName);
162822 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 1);
163614 const char *zName,
163619 return sqlite3_create_collation_v2(db, zName, enc, pCtx, xCompare, 0);
163627 const char *zName,
163636 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
163640 rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel);
163652 const void *zName,
163661 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
163665 zName8 = sqlite3Utf16to8(db, zName, -1, SQLITE_UTF16NATIVE);
163857 if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){
164382 static const char *databaseName(const char *zName){
164383 while( zName[-1]!=0 || zName[-2]!=0 || zName[-3]!=0 || zName[-4]!=0 ){
164384 zName--;
164386 return zName;
165909 const char *zName; /* virtual table name */
166643 zDb, p->zName,
166644 zDb, p->zName,
166645 zDb, p->zName,
166646 zDb, p->zName,
166647 (p->zContentTbl ? "--" : ""), zDb,p->zName
166687 zCols, p->zName, zLanguageid
166708 p->zDb, p->zName
166745 p->zDb, p->zName, zContentCols
166753 p->zDb, p->zName
166765 p->zDb, p->zName
166770 p->zDb, p->zName
166952 (p->zContentTbl ? p->zContentTbl : p->zName),
167485 p->zName = zCsr;
169604 char *zTbl = sqlite3_mprintf("%s_stat", p->zName);
169857 const char *zName, /* Name of SQL function */
169862 const char *zName;
169877 if( strcmp(zName, aOverload[i].zName)==0 ){
169892 const char *zName /* New name of table */
169916 p->zDb, p->zName, zName
169923 p->zDb, p->zName, zName
169929 p->zDb, p->zName, zName
169934 p->zDb, p->zName, zName
169938 p->zDb, p->zName, zName
169993 static int fts3ShadowName(const char *zName){
169999 if( sqlite3_stricmp(zName, azName[i])==0 ) return 1;
172230 p->pFts3Tab->zName = &p->pFts3Tab->zDb[nDb+1];
172235 memcpy((char *)p->pFts3Tab->zName, zFts3, nFts3);
172236 sqlite3Fts3Dequote((char *)p->pFts3Tab->zName);
175090 const unsigned char *zName;
175097 zName = sqlite3_value_text(argv[0]);
175104 if( zName==0 || n!=sizeof(pPtr) ){
175109 pOld = sqlite3Fts3HashInsert(pHash, (void *)zName, nName, pPtr);
175118 if( zName ){
175119 pPtr = sqlite3Fts3HashFind(pHash, zName, nName);
175122 char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
175292 const char *zName;
175314 zName = (const char *)sqlite3_value_text(argv[0]);
175319 p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
175322 char *zErr2 = sqlite3_mprintf("unknown tokenizer: %s", zName);
175374 char *zName,
175386 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
175397 char *zName,
175410 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
175499 const char *zName
175509 zTest = sqlite3_mprintf("%s_test", zName);
175510 zTest2 = sqlite3_mprintf("%s_internal_test", zName);
175517 rc = sqlite3_create_function(db, zName, 1, any, p, fts3TokenizerFunc, 0, 0);
175520 rc = sqlite3_create_function(db, zName, 2, any, p, fts3TokenizerFunc, 0, 0);
175858 const char *zName,
175863 int nName = (int)strlen(zName);
175865 p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
175867 sqlite3Fts3ErrMsg(pzErr, "unknown tokenizer: %s", zName);
176639 zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName, p->zWriteExprlist);
176644 zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName);
177448 p->zSegmentsTbl = sqlite3_mprintf("%s_segments", p->zName);
187096 const char *zName;
187124 const char *zName;
187137 const char *zName;
187149 rc = sqlite3_create_function(db, aFunc[i].zName, aFunc[i].nArg, enc,
187155 rc = sqlite3_create_window_function(db, aAgg[i].zName, aAgg[i].nArg,
187163 rc = sqlite3_create_module(db, aMod[i].zName, aMod[i].pModule, 0);
187330 char *zName; /* Name of r-tree table */
187893 char *zTab = sqlite3_mprintf("%s_node", pRtree->zName);
188215 pRtree->zDb, pRtree->zName,
188216 pRtree->zDb, pRtree->zName,
188217 pRtree->zDb, pRtree->zName
190322 zSql = sqlite3_mprintf("SELECT * FROM %Q.%Q", pRtree->zDb, pRtree->zName);
190334 "UNIQUE constraint failed: %s.%s", pRtree->zName, zCol
190340 "rtree constraint failed: %s.(%s<=%s)", pRtree->zName, zCol1, zCol2
190530 , pRtree->zDb, pRtree->zName, zNewName
190531 , pRtree->zDb, pRtree->zName, zNewName
190532 , pRtree->zDb, pRtree->zName, zNewName
190585 zSql = sqlite3_mprintf(zFmt, pRtree->zDb, pRtree->zName);
190615 static int rtreeShadowName(const char *zName){
190621 if( sqlite3_stricmp(zName, azName[i])==0 ) return 1;
190836 pRtree->zDb, pRtree->zName
190845 pRtree->zName);
190915 pRtree->zName = &pRtree->zDb[nDb+1];
190918 memcpy(pRtree->zName, argv[2], nName);
192785 pRtree->zName = &pRtree->zDb[nDb+1];
192790 memcpy(pRtree->zName, argv[2], nName);
193253 const char *zName,
193257 if( sqlite3_stricmp(zName, "geopoly_overlap")==0 ){
193262 if( sqlite3_stricmp(zName, "geopoly_within")==0 ){
193304 const char *zName;
193322 const char *zName;
193334 rc = sqlite3_create_function(db, aFunc[i].zName, aFunc[i].nArg,
193339 rc = sqlite3_create_function(db, aAgg[i].zName, 1,
193588 const char *zName, /* Name of ICU function that failed */
193592 sqlite3_snprintf(128, zBuf, "ICU error: %s(): %s", zName, u_errorName(e));
193998 const char *zName; /* SQL Collation sequence name (eg. "japanese") */
194005 zName = (const char *)sqlite3_value_text(apArg[1]);
194007 if( !zLocale || !zName ){
194018 rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator,
194033 const char *zName; /* Function name */
194060 db, p->zName, p->nArg, p->enc,
195031 SQLITE_API int sqlite3rbu_create_vfs(const char *zName, const char *zParent);
195041 SQLITE_API void sqlite3rbu_destroy_vfs(const char *zName);
196309 const char *zName = (const char*)sqlite3_column_name(pStmt, i);
196310 if( sqlite3_strnicmp("rbu_", zName, 4) ){
196311 char *zCopy = rbuStrndup(zName, &p->rc);
196315 else if( 0==sqlite3_stricmp("rbu_rowid", zName) ){
196342 const char *zName = (const char*)sqlite3_column_text(pStmt, 1);
196343 if( zName==0 ) break; /* An OOM - finalize() below returns S_NOMEM */
196345 if( 0==strcmp(zName, pIter->azTblCol[i]) ) break;
196350 pIter->zDataTbl, zName
197602 const char *zName,
197608 p->rc = sqlite3_open_v2(zName, &db, flags, bUseVfs ? p->zVfsName : 0);
198263 static void assertColumnName(sqlite3_stmt *pStmt, int iCol, const char *zName){
198265 assert( 0==sqlite3_stricmp(zName, zCol) );
198793 p->zVfsName = pVfs->zName;
199754 char *zOut = sqlite3_mprintf("rbu(%s)/%z", pRbuVfs->base.zName, zIn);
199904 const char *zName,
199933 const char *zOpen = zName;
199940 if( zName ){
199947 pFd->zWal = sqlite3_filename_wal(zName);
199950 rbu_file *pDb = rbuFindMaindb(pRbuVfs, zName, 0);
199957 const char *zBase = zName;
199985 && sqlite3_uri_boolean(zName, "rbu_memory", 0)
200158 SQLITE_API void sqlite3rbu_destroy_vfs(const char *zName){
200159 sqlite3_vfs *pVfs = sqlite3_vfs_find(zName);
200172 SQLITE_API int sqlite3rbu_create_vfs(const char *zName, const char *zParent){
200209 nName = strlen(zName);
200226 pNew->base.zName = (const char*)(zSpace = (char*)&pNew[1]);
200227 memcpy(zSpace, zName, nName);
200389 char *zName; /* Value of 'name' column */
200848 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
200901 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
200964 const char *zName = 0; /* Only provide analysis of this table */
200983 zName = (const char*)sqlite3_value_text(argv[iArg++]);
200999 if( zName ){
201000 sqlite3_str_appendf(pSql, "WHERE name=%Q", zName);
201027 sqlite3_result_text(ctx, pCsr->zName, -1, SQLITE_TRANSIENT);
201660 char *zName; /* Local name of table */
202577 const unsigned char *zName = sqlite3_column_text(pStmt, 1);
202578 if( zName==0 ) break;
202579 memcpy(pAlloc, zName, nName+1);
202624 pTab->zName, &pTab->nCol, 0, &pTab->azCol, &abPK
202634 if( 0==sqlite3_stricmp("sqlite_stat1", pTab->zName) ){
202837 const char *zName,
202841 int nName = sqlite3Strlen30(zName);
202846 if( 0==sqlite3_strnicmp(pRet->zName, zName, nName+1) ) break;
202853 || pSession->xTableFilter(pSession->pFilterCtx, zName)
202855 rc = sqlite3session_attach(pSession, zName);
202858 assert( 0==sqlite3_strnicmp(pRet->zName, zName, nName+1) );
202876 char const *zName, /* Table name */
202895 pSession->rc = sessionFindTable(pSession, zName, &pTab);
203057 char *zStmt = sessionSelectFindNew(pTab->nCol, zDb1, zDb2, pTab->zName,zExpr);
203088 pSession->zDb, zFrom, pTab->zName, pTab->azCol, pTab->abPK
203095 pSession->zDb, pTab->zName, zFrom, pTab->zName, zExpr, zExpr2
203182 zDb, zFrom, pTo->zName, pTo->azCol, pTo->abPK
203326 const char *zName /* Table name */
203331 if( !zName ){
203339 nName = sqlite3Strlen30(zName);
203341 if( 0==sqlite3_strnicmp(pTab->zName, zName, nName+1) ) break;
203357 pTab->zName = (char *)&pTab[1];
203358 memcpy(pTab->zName, zName, nName+1);
203889 sessionAppendBlob(pBuf, (u8 *)pTab->zName, (int)strlen(pTab->zName)+1, pRc);
203933 const char *zName = pTab->zName;
203943 rc = sessionTableInfo(db, pSession->zDb, zName, &nCol, 0, &azCol, &abPK);
203954 db, pSession->zDb, zName, nCol, azCol, abPK, &pSel);
206363 if( !pTab || sqlite3_stricmp(zNew, pTab->zName) ){
206370 if( 0==sqlite3_strnicmp(pTab->zName, zNew, nNew+1) ) break;
206384 pTab->zName = (char*)&pTab->abPK[nCol];
206385 memcpy(pTab->zName, zNew, nNew+1);
206800 if( 0==sqlite3_stricmp(pTab->zName, zTab) ) break;
207569 const char *zName,
207578 const char *zName,
207586 const char *zName,
207774 char *zName; /* Name of FTS index */
208235 static int sqlite3Fts5StorageRename(Fts5Storage*, const char *zName);
211236 const char *zName;
211250 for(i=0; aEnum[i].zName; i++){
211251 if( sqlite3_strnicmp(aEnum[i].zName, zEnum, nEnum)==0 ){
211580 pRet->zName = sqlite3Fts5Strndup(&rc, azArg[2], -1);
211586 if( rc==SQLITE_OK && sqlite3_stricmp(pRet->zName, FTS5_RANK_NAME)==0 ){
211587 *pzErr = sqlite3_mprintf("reserved fts5 table name: %s", pRet->zName);
211652 &rc, "%Q.'%q_%s'", pRet->zDb, pRet->zName, zTail
211683 sqlite3_free(pConfig->zName);
211714 zSql, pConfig->zName, FTS5_RANK_NAME
211962 zSql = sqlite3Fts5Mprintf(&rc, zSelect, pConfig->zDb, pConfig->zName);
216201 pConfig->zDb, pConfig->zName
216225 pConfig->zDb, pConfig->zName
216247 pConfig->zDb, pConfig->zName
217806 pConfig->zDb, pConfig->zName
219563 pConfig->zDb, pConfig->zName
220712 p->zDataTbl = sqlite3Fts5Mprintf(&rc, "%s_data", pConfig->zName);
221384 pConfig->zDb, pConfig->zName, pSeg->iSegid
222188 char *zName; /* Name of tokenizer */
223066 pConfig->zDb, pConfig->zName, zRank, pConfig->zName,
223141 static Fts5Auxiliary *fts5FindAuxiliary(Fts5FullTable *pTab, const char *zName){
223145 if( sqlite3_stricmp(zName, pAux->zFunc)==0 ) return pAux;
223409 "%s: table does not support scanning", pConfig->zName
223720 (nArg>1 ? "UPDATE" : "DELETE from"), pConfig->zName
224563 const char *zName, /* Name of SQL function */
224571 pAux = fts5FindAuxiliary(pTab, zName);
224587 const char *zName /* New name of table */
224590 return sqlite3Fts5StorageRename(pTab->pStorage, zName);
224638 const char *zName, /* Name of new function */
224644 int rc = sqlite3_overload_function(pGlobal->db, zName, -1);
224650 nName = strlen(zName) + 1;
224656 memcpy(pAux->zFunc, zName, nName);
224677 const char *zName, /* Name of new function */
224688 nName = strlen(zName) + 1;
224693 pNew->zName = (char*)&pNew[1];
224694 memcpy(pNew->zName, zName, nName);
224712 const char *zName
224716 if( zName==0 ){
224720 if( sqlite3_stricmp(zName, pMod->zName)==0 ) break;
224733 const char *zName, /* Name of new function */
224740 pMod = fts5LocateTokenizer((Fts5Global*)pApi, zName);
224834 static int fts5ShadowName(const char *zName){
224840 if( sqlite3_stricmp(zName, azName[i])==0 ) return 1;
225083 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName, zBind);
225090 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName);
225148 pConfig->zDb, pConfig->zName,
225149 pConfig->zDb, pConfig->zName,
225150 pConfig->zDb, pConfig->zName
225155 pConfig->zDb, pConfig->zName
225161 pConfig->zDb, pConfig->zName
225171 const char *zName /* New name of FTS5 table */
225176 pConfig->zDb, pConfig->zName, zTail, zName, zTail
225181 static int sqlite3Fts5StorageRename(Fts5Storage *pStorage, const char *zName){
225185 fts5StorageRenameOne(pConfig, &rc, "data", zName);
225186 fts5StorageRenameOne(pConfig, &rc, "idx", zName);
225187 fts5StorageRenameOne(pConfig, &rc, "config", zName);
225189 fts5StorageRenameOne(pConfig, &rc, "docsize", zName);
225192 fts5StorageRenameOne(pConfig, &rc, "content", zName);
225212 pConfig->zDb, pConfig->zName, zPost, zDefn,
225221 pConfig->zName, zPost, zErr
225527 pConfig->zDb, pConfig->zName,
225528 pConfig->zDb, pConfig->zName
225533 pConfig->zDb, pConfig->zName
225729 pConfig->zDb, pConfig->zName, zSuffix
227373 const char *zName;
227386 aBuiltin[i].zName,