Lines Matching full:zname
1448 ** The zName field holds the name of the VFS module. The name must
1580 const char *zName; /* Name of this virtual file system */
1582 int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,
1584 int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);
1585 int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut);
1586 int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);
1604 int (*xSetSystemCall)(sqlite3_vfs*, const char *zName, sqlite3_syscall_ptr);
1605 sqlite3_syscall_ptr (*xGetSystemCall)(sqlite3_vfs*, const char *zName);
1606 const char *(*xNextSystemCall)(sqlite3_vfs*, const char *zName);
3808 SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
4848 const char *zName,
4855 const char *zName,
4863 const void *zName,
5522 int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName,
5654 const char *zName, /* Name of the module */
5660 const char *zName, /* Name of the module */
9598 char *zName; /* Name of this database */
9898 char *zName; /* SQL name of the function. */
9937 ** FUNCTION(zName, nArg, iArg, bNC, xFunc)
9938 ** Used to create a scalar function definition of a function zName
9944 ** AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal)
9950 ** LIKEFUNC(zName, nArg, pArg, flags)
9951 ** Used to create a scalar function definition of a function zName
9958 #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \
9960 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0}
9961 #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \
9963 pArg, 0, xFunc, 0, 0, #zName, 0, 0}
9964 #define LIKEFUNC(zName, nArg, arg, flags) \
9965 {nArg, SQLITE_UTF8, flags, (void *)arg, 0, likeFunc, 0, 0, #zName, 0, 0}
9966 #define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal) \
9968 SQLITE_INT_TO_PTR(arg), 0, 0, xStep,xFinal,#zName,0,0}
9977 char *zName; /* Savepoint name (nul-terminated) */
9998 const char *zName; /* Name passed to create_module() */
10008 char *zName; /* Name of this column */
10043 char *zName; /* Name of the collating sequence, UTF-8 encoded */
10148 ** Table.zName is the name of the table. The case of the original
10175 char *zName; /* Name of the table or view */
10372 char *zName; /* Name of this index */
10656 ** also be used as the argument to a function, in which case the a.zName
10664 char *zName; /* Token associated with this expression */
10669 u16 iAlias; /* Index into Parse.aAlias[] for zName */
10701 char *zName; /* Name of the identifier */
10702 int idx; /* Index in some Table.aCol[] of a column named zName */
10745 char *zName; /* Name of the table */
10746 char *zAlias; /* The "B" part of a "A AS B" phrase. zName is the "A" */
10747 Table *pTab; /* An SQL table corresponding to zName */
11216 char *zName; /* The name of the trigger */
11874 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char*zName);
14961 if( strcmp(zVfs, pVfs->zName)==0 ) break;
20014 sqlite3StrAccumAppend(pAccum, pItem->zName, -1);
24342 const char *zName, /* Name of the file (UTF-8) */
24353 const char *zUtf8Name = zName;
24388 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
24389 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
24390 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
24391 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
24457 OSTRACE(( "OPEN Invalid handle rc=%d: zName=%s, ulAction=%#lx, ulFlags=%#lx, ulMode=%#lx\n",
24461 return os2Open( pVfs, zName, id,
24775 "os2", /* zName */
25343 const char *zName; /* Name of the sytem call */
25467 ** system call named zName.
25471 const char *zName, /* Name of system call to override */
25478 if( zName==0 ){
25479 /* If no zName is given, restore all system calls to their default
25489 /* If zName is specified, operate on only the one system call
25493 if( strcmp(zName, aSyscall[i].zName)==0 ){
25508 ** Return the value of a system call. Return NULL if zName is not a
25514 const char *zName
25520 if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
25526 ** Return the name of the first system call after zName. If zName==NULL
25527 ** then return the name of the first system call. Return NULL if zName
25528 ** is the last system call or if zName is not the name of a valid
25531 static const char *unixNextSystemCall(sqlite3_vfs *p, const char *zName){
25535 if( zName ){
25537 if( strcmp(zName, aSyscall[i].zName)==0 ) break;
25541 if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
28622 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
29676 if( memcmp(pVfs->zName,"unix-excl",10)==0 ){
30097 const char *zName = zPath;
30113 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
30114 zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
30115 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
30116 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
30129 pUnused = findReusableFd(zName, flags);
30143 assert( (flags & SQLITE_OPEN_URI) || zName[strlen(zName)+1]==0 );
30145 }else if( !zName ){
30146 /* If zName is NULL, the upper layer is requesting a temp file. */
30152 zName = zTmpname;
30156 assert( zName[strlen(zName)+1]==0 );
30173 rc = findCreateFileMode(zName, flags, &openMode, &uid, &gid);
30179 fd = robust_open(zName, openFlags, openMode);
30180 OSTRACE(("OPENX %-3d %s 0%o\n", fd, zName, openFlags));
30188 fd = robust_open(zName, openFlags, openMode);
30191 rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName);
30218 zPath = zName;
30220 osUnlink(zName);
30967 dummyVfs.zName = "dummy";
31856 VFSNAME, /* zName */ \
32352 const char *zName; /* Name of the sytem call */
32763 ** system call named zName.
32767 const char *zName, /* Name of system call to override */
32774 if( zName==0 ){
32775 /* If no zName is given, restore all system calls to their default
32785 /* If zName is specified, operate on only the one system call
32789 if( strcmp(zName, aSyscall[i].zName)==0 ){
32804 ** Return the value of a system call. Return NULL if zName is not a
32810 const char *zName
32816 if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
32822 ** Return the name of the first system call after zName. If zName==NULL
32823 ** then return the name of the first system call. Return NULL if zName
32824 ** is the last system call or if zName is not the name of a valid
32827 static const char *winNextSystemCall(sqlite3_vfs *p, const char *zName){
32831 if( zName ){
32833 if( strcmp(zName, aSyscall[i].zName)==0 ) break;
32837 if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
33409 LPWSTR zName;
33412 zName = utf8ToUnicode(zFilename);
33413 if( zName==0 ){
33423 zTok = osCharLowerW(zName);
33429 pFile->hMutex = osCreateMutexW(NULL, FALSE, zName);
33433 sqlite3_free(zName);
33444 osCharUpperW(zName);
33447 zName);
33455 sqlite3_free(zName);
34598 int nName; /* Size of zName in bytes */
35141 const char *zName, /* Name of the file (UTF-8) */
35157 const char *zUtf8Name = zName; /* Filename in UTF-8 encoding */
35200 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
35201 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
35202 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
35203 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
35311 h, zName, dwDesiredAccess,
35319 return winOpen(pVfs, zName, id,
35340 pFile->zPath = zName;
35341 if( sqlite3_uri_boolean(zName, "psow", SQLITE_POWERSAFE_OVERWRITE) ){
35347 && !winceCreateLock(zName, pFile)
35799 "win32", /* zName */
46119 static char zName[15];
46120 sqlite3_snprintf(sizeof(zName), zName, "READ-LOCK[%d]",
46122 return zName;
60407 int n = sqlite3Strlen30(pColl->zName);
60416 memcpy(&zTemp[i], pColl->zName,n+1);
60430 sqlite3_snprintf(nTemp, zTemp, "collseq(%.20s)", pColl->zName);
60435 sqlite3_snprintf(nTemp, zTemp, "%s(%d)", pDef->zName, pDef->nArg);
61243 ** zName must be a pointer to a nul terminated string.
61249 ** to by zName will be freed by sqlite3DbFree() when the vdbe is destroyed.
61253 int idx, /* Index of column zName applies to */
61255 const char *zName, /* Pointer to buffer containing name */
61256 void (*xDel)(void*) /* Memory management strategy for zName */
61263 assert( !zName || xDel!=SQLITE_DYNAMIC );
61268 rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, xDel);
61269 assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 );
63099 rc = db->xWalCallback(db->pWalArg, db, db->aDb[i].zName, nEntry);
63329 const char *zName = context->pFunc->zName;
63333 "unable to use function %s in the requested context", zName);
63972 SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){
63977 if( zName ){
63980 if( z && memcmp(z,zName,nName)==0 && z[nName]==0 ){
63987 SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
63988 return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName));
65150 char *zName; /* Name of savepoint */
67518 char *zName; /* Name of savepoint */
67528 u.ar.zName = pOp->p4.z;
67547 u.ar.nName = sqlite3Strlen30(u.ar.zName);
67563 u.ar.pNew->zName = (char *)&u.ar.pNew[1];
67564 memcpy(u.ar.pNew->zName, u.ar.zName, u.ar.nName+1);
67588 u.ar.pSavepoint && sqlite3StrICmp(u.ar.pSavepoint->zName, u.ar.zName);
67594 sqlite3SetString(&p->zErrMsg, db, "no such savepoint: %s", u.ar.zName);
68971 u.bh.zDb = db->aDb[u.bh.pC->iDb].zName;
69039 const char *zDb = db->aDb[u.bi.pC->iDb].zName;
69806 db->aDb[u.by.iDb].zName, u.by.zMaster, pOp->p4.z);
70914 ** in register P1 is passed as the zName argument to the xRename method.
71401 if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
71482 sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT);
72760 const char *zName, /* Name of the journal file */
72773 return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0);
72778 p->zJournal = zName;
73314 if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ) return 1;
73387 assert( pTab!=0 && pTab->zName!=0 );
73395 char *zTabName = pTab->zName;
73399 if( zDb!=0 && sqlite3StrICmp(db->aDb[iDb].zName, zDb)!=0 ){
73411 if( sqlite3StrICmp(pCol->zName, zCol)==0 ){
73455 if( sqlite3StrICmp(pCol->zName, zCol)==0 ){
73509 char *zAs = pEList->a[j].zName;
73749 auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0, pDef->zName, 0);
73753 pDef->zName);
73842 char *zAs = pEList->a[i].zName;
74217 if( pItem->zName ) pParse->zAuthContext = pItem->zName;
75297 pItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
75329 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
75368 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
75453 ** Set the ExprList.a[].zName element of the most recently added item
75471 assert( pItem->zName==0 );
75472 pItem->zName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n);
75473 if( dequote && pItem->zName ) sqlite3Dequote(pItem->zName);
75529 sqlite3DbFree(db, pItem->zName);
75903 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
75947 VdbeComment((v, "%s", pIdx->zName));
77169 (pExpr->iColumn<0 ? "rowid" : pExpr->pTab->aCol[pExpr->iColumn].zName),
78753 zWhere = whereOrName(pParse->db, zWhere, p->pFrom->zName);
78779 zWhere = whereOrName(db, zWhere, pTrig->zName);
78794 ** Argument zName is the name of the table in the database schema at
78796 ** pTab->zName if this function is being called to code part of an
78799 static void reloadTableSchema(Parse *pParse, Table *pTab, const char *zName){
78818 sqlite3VdbeAddOp4(v, OP_DropTrigger, iTrigDb, 0, 0, pTrig->zName, 0);
78823 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
78826 zWhere = sqlite3MPrintf(pParse->db, "tbl_name=%Q", zName);
78841 ** Parameter zName is the name of a table that is about to be altered
78846 ** Or, if zName is not a system table, zero is returned.
78848 static int isSystemTable(Parse *pParse, const char *zName){
78849 if( sqlite3Strlen30(zName)>6 && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){
78850 sqlite3ErrorMsg(pParse, "table %s may not be altered", zName);
78868 char *zName = 0; /* NULL-terminated version of pName */
78884 pTab = sqlite3LocateTable(pParse, 0, pSrc->a[0].zName, pSrc->a[0].zDatabase);
78887 zDb = db->aDb[iDb].zName;
78891 zName = sqlite3NameFromToken(db, pName);
78892 if( !zName ) goto exit_rename_table;
78894 /* Check that a table or index named 'zName' does not already exist
78897 if( sqlite3FindTable(db, zName, zDb) || sqlite3FindIndex(db, zName, zDb) ){
78899 "there is already another table or index with this name: %s", zName);
78906 if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
78909 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ goto
78915 sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
78922 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
78959 sqlite3VdbeAddOp4(v, OP_String8, 0, i, 0, zName, 0);
78965 /* figure out how many UTF-8 characters are in zName */
78966 zTabName = pTab->zName;
78978 "WHERE %s;", zDb, SCHEMA_TABLE(iDb), zTabName, zName, zWhere);
79002 zDb, SCHEMA_TABLE(iDb), zName, zName, zName,
79004 zName,
79006 zName, nTabName, zTabName
79016 zDb, zName, pTab->zName);
79030 "WHERE %s;", zName, zName, zWhere);
79041 reloadTableSchema(pParse, p->pFrom, pFrom->zName);
79048 reloadTableSchema(pParse, pTab, zName);
79052 sqlite3DbFree(db, zName);
79108 zDb = db->aDb[iDb].zName;
79109 zTab = &pNew->zName[16]; /* Skip the "sqlite_altertab_" prefix on the name */
79117 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
79196 reloadTableSchema(pParse, pTab, pTab->zName);
79227 pTab = sqlite3LocateTable(pParse, 0, pSrc->a[0].zName, pSrc->a[0].zDatabase);
79242 if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
79265 pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
79266 if( !pNew->aCol || !pNew->zName ){
79273 pCol->zName = sqlite3DbStrDup(db, pCol->zName);
79438 const char *zName;
79463 const char *zTab = aTable[i].zName;
79465 if( (pStat = sqlite3FindTable(db, zTab, pDb->zName))==0 ){
79471 "CREATE TABLE %Q.%s(%s)", pDb->zName, zTab, aTable[i].zCols
79483 "DELETE FROM %Q.%s WHERE %s=%Q", pDb->zName, zTab, zWhereType, zWhere
79576 "stat3_init", /* zName */
79669 "stat3_push", /* zName */
79711 "stat3_get", /* zName */
79772 if( memcmp(pTab->zName, "sqlite_", 7)==0 ){
79781 if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,
79782 db->aDb[iDb].zName ) ){
79788 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
79791 sqlite3VdbeAddOp4(v, OP_String8, 0, regTabname, 0, pTab->zName, 0);
79799 VdbeNoopComment((v, "Begin analysis of %s", pIdx->zName));
79812 VdbeComment((v, "%s", pIdx->zName));
79815 sqlite3VdbeAddOp4(v, OP_String8, 0, regIdxname, 0, pIdx->zName, 0);
79981 VdbeComment((v, "%s", pTab->zName));
80049 openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");
80051 openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
80112 zDb = db->aDb[iDb].zName;
80387 sInfo.zDatabase = db->aDb[iDb].zName;
80493 const char *zName;
80505 zName = (const char *)sqlite3_value_text(argv[1]);
80507 if( zName==0 ) zName = "";
80526 char *z = db->aDb[i].zName;
80527 assert( z && zName );
80528 if( sqlite3StrICmp(z, zName)==0 ){
80529 zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName);
80554 rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
80585 aNew->zName = sqlite3DbStrDup(db, zName);
80586 if( rc==SQLITE_OK && aNew->zName==0 ){
80677 const char *zName = (const char *)sqlite3_value_text(argv[0]);
80685 if( zName==0 ) zName = "";
80689 if( sqlite3StrICmp(pDb->zName, zName)==0 ) break;
80693 sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
80697 sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
80706 sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
80808 "sqlite_detach", /* zName */
80830 "sqlite_attach", /* zName */
80858 pFix->zDb = db->aDb[iDb].zName;
81089 char *zDb = db->aDb[iDb].zName; /* Name of attached database */
81153 zCol = pTab->aCol[iCol].zName;
81156 zCol = pTab->aCol[pTab->iPKey].zName;
81161 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
81277 const char *zName; /* Name of the table */
81295 const char *zName /* Name of the table to be locked */
81319 p->zName = zName;
81341 p->zName, P4_STATIC);
81499 SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){
81503 assert( zName!=0 );
81504 nName = sqlite3Strlen30(zName);
81509 if( zDatabase!=0 && sqlite3StrICmp(zDatabase, db->aDb[j].zName) ) continue;
81511 p = sqlite3HashFind(&db->aDb[j].pSchema->tblHash, zName, nName);
81530 const char *zName, /* Name of the table we are looking for */
81541 p = sqlite3FindTable(pParse->db, zName, zDbase);
81545 sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
81547 sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
81566 SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){
81569 int nName = sqlite3Strlen30(zName);
81576 if( zDb && sqlite3StrICmp(zDb, db->aDb[j].zName) ) continue;
81578 p = sqlite3HashFind(&pSchema->idxHash, zName, nName);
81684 sqlite3DbFree(db, pDb->zName);
81685 pDb->zName = 0;
81719 sqlite3DbFree(db, pCol->zName);
81752 char *zName = pIndex->zName;
81754 &pIndex->pSchema->idxHash, zName, sqlite3Strlen30(zName), 0
81768 sqlite3DbFree(db, pTable->zName);
81814 char *zName;
81816 zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n);
81817 sqlite3Dequote(zName);
81819 zName = 0;
81821 return zName;
81839 ** Parameter zName points to a nul-terminated buffer containing the name
81844 SQLITE_PRIVATE int sqlite3FindDbName(sqlite3 *db, const char *zName){
81846 if( zName ){
81848 int n = sqlite3Strlen30(zName);
81850 if( (!OMIT_TEMPDB || i!=1 ) && n==sqlite3Strlen30(pDb->zName) &&
81851 0==sqlite3StrICmp(pDb->zName, zName) ){
81867 char *zName; /* Name we are searching for */
81868 zName = sqlite3NameFromToken(db, pName);
81869 i = sqlite3FindDbName(db, zName);
81870 sqlite3DbFree(db, zName);
81921 ** This routine is used to check if the UTF-8 string zName is a legal
81927 SQLITE_PRIVATE int sqlite3CheckObjectName(Parse *pParse, const char *zName){
81930 zName, "sqlite_", 7) ){
81931 sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s", zName);
81963 char *zName = 0; /* The name of the new table */
81997 zName = sqlite3NameFromToken(db, pName);
81998 if( zName==0 ) return;
81999 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
82007 char *zDb = db->aDb[iDb].zName;
82024 if( !isVirtual && sqlite3AuthCheck(pParse, code, zName, 0, zDb) ){
82038 char *zDb = db->aDb[iDb].zName;
82042 pTable = sqlite3FindTable(db, zName, zDb);
82052 if( sqlite3FindIndex(db, zName, zDb)!=0 ){
82053 sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
82065 pTable->zName = zName;
82078 if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){
82151 sqlite3DbFree(db, zName);
82185 sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
82192 if( STRICMP(z, p->aCol[i].zName) ){
82209 pCol->zName = z;
82333 pCol->zName);
82380 "table \"%s\" has more than one primary key", pTab->zName);
82390 if( sqlite3StrICmp(pList->a[i].zName, pTab->aCol[iCol].zName)==0 ){
82484 ** encoding identified by the string zName, length nName.
82502 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){
82508 pColl = sqlite3FindCollSeq(db, enc, zName, initbusy);
82510 pColl = sqlite3GetCollSeq(db, enc, pColl, zName);
82512 sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);
82610 n += identLength(pCol->zName) + 5;
82612 n += identLength(p->zName);
82630 identPut(zStmt, &k, p->zName);
82646 identPut(zStmt, &k, pCol->zName);
82717 sSrc.a[0].zName = p->zName;
82826 db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
82828 p->zName,
82829 p->zName,
82847 pDb->zName
82855 sqlite3MPrintf(db, "tbl_name='%q'", p->zName));
82865 pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName,
82866 sqlite3Strlen30(p->zName),p);
82877 const char *zName = (const char *)pParse->sNameToken.z;
82883 nName = (int)((const char *)pCons->z - zName);
82884 p->addColOffset = 13 + sqlite3Utf8CharLen(zName, nName);
83011 sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
83150 pParse->db->aDb[iDb].zName, SCHEMA_TABLE(iDb), iTable, r1, r1);
83222 const char *zName /* Name of index or table */
83225 const char *zDbName = pParse->db->aDb[iDb].zName;
83232 zDbName, zTab, zType, zName
83278 pDb->zName, pTab->zName
83292 pDb->zName, SCHEMA_TABLE(iDb), pTab->zName);
83301 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
83303 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
83325 pName->a[0].zName, pName->a[0].zDatabase);
83345 const char *zDb = db->aDb[iDb].zName;
83359 zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
83368 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
83371 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
83376 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
83377 && sqlite3StrNICmp(pTab->zName, "sqlite_stat", 11)!=0 ){
83378 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
83387 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
83391 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
83402 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
83452 p->aCol[iCol].zName, pTo);
83467 nByte += sqlite3Strlen30(pToCol->a[i].zName) + 1;
83489 if( sqlite3StrICmp(p->aCol[j].zName, pFromCol->a[i].zName)==0 ){
83497 pFromCol->a[i].zName);
83504 int n = sqlite3Strlen30(pToCol->a[i].zName);
83506 memcpy(z, pToCol->a[i].zName, n);
83587 if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
83588 db->aDb[iDb].zName ) ){
83594 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
83709 char *zName = 0; /* Name of the index */
83710 int nName; /* Number of characters in zName */
83767 pTab = sqlite3LocateTable(pParse, 0, pTblName->a[0].zName,
83782 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
83783 && memcmp(&pTab->zName[7],"altertab_",9)!=0 ){
83784 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
83814 zName = sqlite3NameFromToken(db, pName);
83815 if( zName==0 ) goto exit_create_index;
83817 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
83821 if( sqlite3FindTable(db, zName, 0)!=0 ){
83822 sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
83826 if( sqlite3FindIndex(db, zName, pDb->zName)!=0 ){
83828 sqlite3ErrorMsg(pParse, "index %s already exists", zName);
83839 zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
83840 if( zName==0 ){
83849 const char *zDb = pDb->zName;
83855 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
83866 nullId.z = pTab->aCol[pTab->nCol-1].zName;
83884 nExtra += (1 + sqlite3Strlen30(pColl->zName));
83892 nName = sqlite3Strlen30(zName);
83900 nName + 1 + /* Index.zName */
83914 pIndex->zName = (char *)(&pIndex->aSortOrder[nCol]);
83915 zExtra = (char *)(&pIndex->zName[nName+1]);
83916 memcpy(pIndex->zName, zName, nName+1);
83943 const char *zColName = pListItem->zName;
83949 if( sqlite3StrICmp(zColName, pTabCol->zName)==0 ) break;
83953 pTab->zName, zColName);
83965 zColl = pListItem->pExpr->pColl->zName;
83975 zColl = db->pDfltColl->zName;
84054 pIndex->zName, sqlite3Strlen30(pIndex->zName),
84116 db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
84117 pIndex->zName,
84118 pTab->zName,
84131 sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName));
84167 sqlite3DbFree(db, zName);
84224 pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
84244 const char *zDb = db->aDb[iDb].zName;
84250 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
84262 db->aDb[iDb].zName, SCHEMA_TABLE(iDb), pIndex->zName
84264 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
84267 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
84337 pList->a[i].zName = sqlite3NameFromToken(db, pToken);
84348 sqlite3DbFree(db, pList->a[i].zName);
84358 SQLITE_PRIVATE int sqlite3IdListIndex(IdList *pList, const char *zName){
84362 if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
84446 ** The SrcList.a[].zName field is filled with the table name which might
84495 pItem->zName = sqlite3NameFromToken(db, pTable);
84527 sqlite3DbFree(db, pItem->zName);
84704 char *zName = sqlite3NameFromToken(pParse->db, pName);
84705 if( zName ){
84711 if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
84712 sqlite3DbFree(pParse->db, zName);
84715 sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
84810 if( pDb->pBt && (!zDb || 0==sqlite3StrICmp(zDb, pDb->zName)) ){
84993 zDb = db->aDb[iDb].zName;
85069 ** in the encoding enc of name zName, length nName.
85071 static void callCollNeeded(sqlite3 *db, int enc, const char *zName){
85074 char *zExternal = sqlite3DbStrDup(db, zName);
85083 sqlite3ValueSetStr(pTmp, -1, zName, SQLITE_UTF8, SQLITE_STATIC);
85102 char *z = pColl->zName;
85122 ** collation sequence with name zName, length nName.
85125 ** db for collation type name zName, length nName, or NULL, if no collation
85134 const char *zName /* Collating sequence name */
85140 p = sqlite3FindCollSeq(db, enc, zName, 0);
85146 callCollNeeded(db, enc, zName);
85147 p = sqlite3FindCollSeq(db, enc, zName, 0);
85169 const char *zName = pColl->zName;
85171 CollSeq *p = sqlite3GetCollSeq(db, ENC(db), pColl, zName);
85173 sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);
85186 ** specified by zName and nName is not found and parameter 'create' is
85199 const char *zName, /* Name of the collating sequence */
85203 int nName = sqlite3Strlen30(zName);
85204 pColl = sqlite3HashFind(&db->aCollSeq, zName, nName);
85210 pColl[0].zName = (char*)&pColl[3];
85212 pColl[1].zName = (char*)&pColl[3];
85214 pColl[2].zName = (char*)&pColl[3];
85216 memcpy(pColl[0].zName, zName, nName);
85217 pColl[0].zName[nName] = 0;
85218 pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, nName, pColl);
85236 ** Parameter zName points to a UTF-8 encoded string nName bytes long.
85237 ** Return the CollSeq* pointer for the collation sequence named zName
85253 const char *zName,
85257 if( zName ){
85258 pColl = findCollSeqEntry(db, zName, create);
85321 if( sqlite3StrNICmp(p->zName, zFunc, nFunc)==0 && p->zName[nFunc]==0 ){
85336 int nName = sqlite3Strlen30(pDef->zName);
85337 u8 c1 = (u8)pDef->zName[0];
85339 pOther = functionSearch(pHash, h, pDef->zName, nName);
85375 const char *zName, /* Name of the function. Not null-terminated */
85388 h = (sqlite3UpperToLower[(u8)zName[0]] + nName) % ArraySize(db->aFunc.a);
85392 p = functionSearch(&db->aFunc, h, zName, nName);
85417 p = functionSearch(pHash, h, zName, nName);
85434 pBest->zName = (char *)&pBest[1];
85437 memcpy(pBest->zName, zName, nName);
85438 pBest->zName[nName] = 0;
85542 pTab = sqlite3LocateTable(pParse, 0, pItem->zName, pItem->zDatabase);
85576 sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
85582 sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
85614 pFrom->a[0].zAlias = sqlite3DbStrDup(db, pView->zName);
85795 zDb = db->aDb[iDb].zName;
85796 rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb);
85814 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
85862 pTab->zName, P4_STATIC);
86057 sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_TRANSIENT);
87610 static void setLikeOptFlag(sqlite3 *db, const char *zName, u8 flagVal){
87612 pDef = sqlite3FindFunction(db, zName, sqlite3Strlen30(zName),
87993 if( !sqlite3StrICmp(pParent->aCol[pParent->iPKey].zName, zKey) ) return 0;
88039 zIdxCol = pParent->aCol[iCol].zName;
88304 zCol = pFKey->pFrom->aCol[iCol].zName;
88371 int nName = sqlite3Strlen30(pTab->zName);
88372 return (FKey *)sqlite3HashFind(&pTab->pSchema->fkeyHash, pTab->zName, nName);
88491 zDb = db->aDb[iDb].zName;
88552 char *zCol = pTo->aCol[pIdx ? pIdx->aiColumn[i] : pTo->iPKey].zName;
88553 rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
88562 sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
88606 pItem->zName = pFKey->pFrom->zName;
88622 pItem->zName = 0;
88705 if( (zKey ? !sqlite3StrICmp(pCol->zName, zKey) : pCol->isPrimKey) ){
88786 tToCol.z = pIdx ? pTab->aCol[pIdx->aiColumn[i]].zName : "oid";
88787 tFromCol.z = pFKey->pFrom->aCol[iFromCol].zName;
88847 zFrom = pFKey->pFrom->zName;
89029 sqlite3TableLock(p, iDb, pTab->tnum, (opcode==OP_OpenWrite)?1:0, pTab->zName);
89032 VdbeComment((v, "%s", pTab->zName));
89242 sqlite3VdbeAddOp4(v, OP_String8, 0, memId-1, 0, p->pTab->zName, 0);
89487 zTab = pTabList->a[0].zName;
89496 zDb = pDb->zName;
89497 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb) ){
89716 if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){
89725 if( sqlite3IsRowid(pColumn->a[i].zName) ){
89729 pTabList, 0, pColumn->a[i].zName);
90194 pTab->zName, pTab->aCol[i].zName);
90374 char *zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
90471 sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_TRANSIENT);
90504 VdbeComment((v, "%s", pIdx->zName));
90681 pSrc = sqlite3LocateTable(pParse, 0, pItem->zName, pItem->zDatabase);
90803 sqlite3VdbeChangeP4(v, -1, pDest->zName, 0);
90815 VdbeComment((v, "%s", pSrcIdx->zName));
90819 VdbeComment((v, "%s", pDestIdx->zName));
91052 int (*bind_parameter_index)(sqlite3_stmt*,const char*zName);
92268 const char *zName; /* Name of the pragma */
92307 if( sqlite3StrICmp(zLeft, p->zName)==0 ){
92314 returnSingleInt(pParse, p->zName, (db->flags & p->mask)!=0 );
92349 const char *zName;
92351 case OE_SetNull: zName = "SET NULL"; break;
92352 case OE_SetDflt: zName = "SET DEFAULT"; break;
92353 case OE_Cascade: zName = "CASCADE"; break;
92354 case OE_Restrict: zName = "RESTRICT"; break;
92355 default: zName = "NO ACTION";
92358 return zName;
92446 zDb = pId2->n>0 ? pDb->zName : 0;
93023 sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pCol->zName, 0);
93056 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pTab->aCol[cnum].zName, 0);
93079 sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pIdx->zName, 0);
93099 assert( db->aDb[i].zName!=0 );
93101 sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, db->aDb[i].zName, 0);
93118 sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pColl->zName, 0);
93155 pTab->aCol[pFK->aCol[j].iFrom].zName, 0);
93275 sqlite3MPrintf(db, "*** in database %s ***\n", db->aDb[i].zName),
93318 sqlite3VdbeChangeP4(v, addr+4, pIdx->zName, P4_TRANSIENT);
93348 sqlite3VdbeChangeP4(v, addr+7, pIdx->zName, P4_TRANSIENT);
93384 char *zName;
93406 sqlite3VdbeChangeP4(v, -1, encnames[ENC(pParse->db)].zName, P4_STATIC);
93418 for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
93419 if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){
93424 if( !pEnc->zName ){
93598 if( db->aDb[i].zName==0 ) continue;
93599 sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, db->aDb[i].zName, P4_STATIC);
93603 }else if( sqlite3_file_control(db, i ? db->aDb[i].zName : 0,
93784 pIndex = sqlite3FindIndex(db, argv[0], db->aDb[iDb].zName);
93876 pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName);
93996 db->aDb[iDb].zName, zMasterName);
94252 const char *zDb = db->aDb[i].zName;
94729 if( sqlite3StrICmp(pTab->aCol[i].zName, zCol)==0 ) return i;
94889 char *zName; /* Name of column in the right table */
94893 zName = pRightTab->aCol[j].zName;
94894 if( tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol) ){
94928 char *zName; /* Name of the term in the USING clause */
94933 zName = pList->a[j].zName;
94934 iRightCol = columnIndex(pRightTab, zName);
94936 || !tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol)
94939 "not present in both tables", zName);
95625 zOriginCol = pTab->aCol[iCol].zName;
95627 zOriginTab = pTab->zName;
95630 zOriginDb = pNC->pParse->db->aDb[iDb].zName;
95733 if( pEList->a[i].zName ){
95734 char *zName = pEList->a[i].zName;
95735 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_TRANSIENT);
95750 zCol = pTab->aCol[iCol].zName;
95756 char *zName = 0;
95757 zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol);
95758 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_DYNAMIC);
95795 char *zName; /* Column name */
95796 int nName; /* Size of name in zName[] */
95807 if( (zName = pEList->a[i].zName)!=0 ){
95809 zName = sqlite3DbStrDup(db, zName);
95822 zName = sqlite3MPrintf(db, "%s",
95823 iCol>=0 ? pTab->aCol[iCol].zName : "rowid");
95826 zName = sqlite3MPrintf(db, "%s", pColExpr->u.zToken);
95829 zName = sqlite3MPrintf(db, "%s", pEList->a[i].zSpan);
95833 sqlite3DbFree(db, zName);
95840 nName = sqlite3Strlen30(zName);
95842 if( sqlite3StrICmp(aCol[j].zName, zName)==0 ){
95844 zName[nName] = 0;
95845 zNewName = sqlite3MPrintf(db, "%s:%d", zName, ++cnt);
95846 sqlite3DbFree(db, zName);
95847 zName = zNewName;
95849 if( zName==0 ) break;
95852 pCol->zName = zName;
95856 sqlite3DbFree(db, aCol[j].zName);
95905 pCol->zColl = sqlite3DbStrDup(db, pColl->zName);
95934 pTab->zName = 0;
97382 pParse->zAuthContext = pSubitem->zName;
97453 sqlite3DbFree(db, pSubitem->zName);
97456 pSubitem->zName = 0;
97557 if( pList->a[i].zName==0 ){
97560 pList->a[i].zName = sqlite3DbStrDup(db, zSpan);
97699 pIdx && sqlite3StrICmp(pIdx->zName, zIndex);
97771 if( pFrom->zName==0 ){
97781 pTab->zName = sqlite3MPrintf(db, "sqlite_subquery_%p_", (void*)pTab);
97792 sqlite3LocateTable(pParse,0,pFrom->zName,pFrom->zDatabase);
97855 pNew->a[pNew->nExpr-1].zName = a[k].zName;
97857 a[k].zName = 0;
97877 zTabName = pTab->zName;
97886 char *zName = pTab->aCol[j].zName;
97902 && tableAndColumnIndex(pTabList, i, zName, 0, 0)
97908 if( sqlite3IdListIndex(pFrom->pUsing, zName)>=0 ){
97914 pRight = sqlite3Expr(db, TK_ID, zName);
97915 zColname = zName;
97922 zColname = sqlite3MPrintf(db, "%s.%s", zTabName, zName);
98223 pTab->zName,
98225 pIdx ? pIdx->zName : "",
98405 VdbeNoopComment((v, "materialize %s", pItem->pTab->zName));
98418 VdbeComment((v, "end %s", pItem->pTab->zName));
98914 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
99083 sqlite3ExplainPrintf(pVdbe, " (tabname=%s)", pItem->pTab->zName);
99085 }else if( pItem->zName ){
99086 sqlite3ExplainPrintf(pVdbe, "%s", pItem->zName);
99411 && 0==sqlite3StrICmp(pTrig->table, pTab->zName)
99444 char *zName = 0; /* Name of the trigger */
99528 zName = sqlite3NameFromToken(db, pName);
99529 if( !zName || SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
99534 zName, sqlite3Strlen30(zName)) ){
99545 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
99569 const char *zDb = db->aDb[iTabDb].zName;
99570 const char *zDbTrig = isTemp ? db->aDb[1].zName : zDb;
99572 if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
99593 pTrigger->zName = zName;
99594 zName = 0;
99595 pTrigger->table = sqlite3DbStrDup(db, pTableName->a[0].zName);
99606 sqlite3DbFree(db, zName);
99627 char *zName; /* Name of trigger */
99635 zName = pTrig->zName;
99642 nameToken.z = pTrig->zName;
99663 db->aDb[iDb].zName, SCHEMA_TABLE(iDb), zName,
99668 sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName));
99675 pTrig = sqlite3HashInsert(pHash, zName, sqlite3Strlen30(zName), pTrig);
99824 sqlite3DbFree(db, pTrigger->zName);
99843 const char *zName;
99854 zName = pName->a[0].zName;
99855 nName = sqlite3Strlen30(zName);
99859 if( zDb && sqlite3StrICmp(db->aDb[j].zName, zDb) ) continue;
99861 pTrigger = sqlite3HashFind(&(db->aDb[j].pSchema->trigHash), zName, nName);
99906 const char *zDb = db->aDb[iDb].zName;
99909 if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) ||
99936 sqlite3VdbeChangeP4(v, base+1, pTrigger->zName, P4_TRANSIENT);
99940 sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
99950 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){
99956 pTrigger = sqlite3HashInsert(pHash, zName, sqlite3Strlen30(zName), 0);
99982 if( sqlite3IdListIndex(pIdList, pEList->a[e].zName)>=0 ) return 1;
100044 pSrc->a[pSrc->nSrc-1].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zName);
100180 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
100207 pSubParse->zAuthContext = pTrigger->zName;
100214 pTrigger->zName, onErrorText(orconf),
100219 pTab->zName
100223 sqlite3MPrintf(db, "-- TRIGGER %s", pTrigger->zName), P4_DYNAMIC
100249 VdbeComment((v, "End: %s.%s", pTrigger->zName, onErrorText(orconf)));
100286 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
100327 int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers));
100332 (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf)));
100543 VdbeComment((v, "%s.%s", pTab->zName, pCol->zName));
100676 if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zName)==0 ){
100686 if( sqlite3IsRowid(pChanges->a[i].zName) ){
100690 sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zName);
100698 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
100699 pTab->aCol[j].zName, db->aDb[iDb].zName);
100769 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
101110 pExpr = sqlite3Expr(db, TK_ID, pTab->aCol[i].zName);
101305 assert( strcmp(pDb->zName,"vacuum_db")==0 );
101535 const char *zName, /* Name assigned to this module */
101544 nName = sqlite3Strlen30(zName);
101549 memcpy(zCopy, zName, nName+1);
101550 pMod->zName = zCopy;
101577 const char *zName, /* Name assigned to this module */
101581 return createModule(db, zName, pModule, pAux, 0);
101589 const char *zName, /* Name assigned to this module */
101594 return createModule(db, zName, pModule, pAux, xDestroy);
101799 addModuleArgument(db, pTable, sqlite3DbStrDup(db, db->aDb[iDb].zName));
101800 addModuleArgument(db, pTable, sqlite3DbStrDup(db, pTable->zName));
101810 sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName,
101811 pTable->azModuleArg[0], pParse->db->aDb[iDb].zName);
101874 db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
101875 pTab->zName,
101876 pTab->zName,
101885 zWhere = sqlite3MPrintf(db, "name='%q' AND type='table'", pTab->zName);
101888 pTab->zName, sqlite3Strlen30(pTab->zName) + 1);
101899 const char *zName = pTab->zName;
101900 int nName = sqlite3Strlen30(zName);
101902 pOld = sqlite3HashInsert(&pSchema->tblHash, zName, nName, pTab);
101955 char *zModuleName = sqlite3MPrintf(db, "%s", pTab->zName);
101994 *pzErr = sqlite3MPrintf(db, zFormat, pTab->zName);
102126 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
102228 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
102462 zLowerName = sqlite3DbStrDup(db, pDef->zName);
102477 + sqlite3Strlen30(pDef->zName) + 1);
102482 pNew->zName = (char *)&pNew[1];
102483 memcpy(pNew->zName, pDef->zName, sqlite3Strlen30(pDef->zName)+1);
103196 if( pColl && sqlite3StrICmp(pColl->zName, pIdx->azColl[j]) ) continue;
104020 if( ALWAYS(pColl) && 0==sqlite3StrICmp(pColl->zName, zColl) ){
104052 if( pIdx->zName==0 || pDistinct==0 || pDistinct->nExpr>=BMS ) return 0;
104195 assert( pIdx->zName || (pIdx->nColumn==1 && pIdx->aiColumn[0]==-1) );
104223 if( pIdx->zName && i<pIdx->nColumn ){
104233 zColl = pColl->zName;
104235 if( pExpr->iColumn!=iColumn || sqlite3StrICmp(pColl->zName, zColl) ){
104646 pIdx->zName = "auto-index";
104660 pIdx->azColl[n] = ALWAYS(pColl) ? pColl->zName : "BINARY";
104690 VdbeComment((v, "for %s", pTable->zName));
104729 WHERETRACE(("Recomputing index info for %s...\n", pSrc->pTab->zName));
104834 WHERETRACE(("xBestIndex for %s\n", pTab->zName));
104854 "table %s: xBestIndex returned an invalid plan", pTab->zName);
105866 pSrc->pTab->zName, (pIdx ? pIdx->zName : "ipk"),
105912 pCost->plan.u.pIdx ? pCost->plan.u.pIdx->zName : "ipk")
106264 explainAppendTerm(&txt, i, aCol[aiColumn[i]].zName, "=");
106269 char *z = (j==pIndex->nColumn ) ? "rowid" : aCol[aiColumn[j]].zName;
106273 zName;
106314 zMsg = sqlite3MAppendf(db, zMsg, "%s TABLE %s", zMsg, pItem->zName);
106326 ((flags & WHERE_TEMP_INDEX)?"": pLevel->plan.u.pIdx->zName),
107527 sqlite3ErrorMsg(pParse, "cannot use index: %s", pIdx->zName);
107600 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
107615 VdbeComment((v, "%s", pIx->zName));
107648 if( z==0 ) z = pTabItem->pTab->zName;
107666 n = sqlite3Strlen30(pLevel->plan.u.pIdx->zName);
107668 memcpy(&sqlite3_query_plan[nQPlan], pLevel->plan.u.pIdx->zName, n);
113731 const char *zName,
113734 int nName = sqlite3Strlen30(zName);
113737 if( sqlite3FindFunction(db, zName, nName, nArg, SQLITE_UTF8, 0)==0 ){
113738 rc = sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8,
114141 ** Create a new collating function for database "db". The name is zName
114146 const char *zName,
114154 int nName = sqlite3Strlen30(zName);
114176 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0);
114192 CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName, nName);
114206 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 1);
114712 db->aDb[0].zName = "main";
114714 db->aDb[1].zName = "temp";
114871 const char *zName,
114879 rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, 0);
114890 const char *zName,
114899 rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel);
114911 const void *zName,
114920 zName8 = sqlite3Utf16to8(db, zName, -1, SQLITE_UTF16NATIVE);
115087 if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){
115501 && (zDbName==0 || sqlite3StrICmp(zDbName, db->aDb[i].zName)==0)
116621 const char *zName; /* virtual table name */
117186 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_content'", zDb, p->zName);
117188 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_segments'", zDb,p->zName);
117189 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_segdir'", zDb, p->zName);
117190 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_docsize'", zDb, p->zName);
117191 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_stat'", zDb, p->zName);
117230 zCols, p->zName, zLanguageid
117276 p->zDb, p->zName, zContentCols
117284 p->zDb, p->zName
117296 p->zDb, p->zName
117301 p->zDb, p->zName
117307 p->zDb, p->zName
117485 (p->zContentTbl ? p->zContentTbl : p->zName),
117932 nName + /* zName */
117964 /* Fill in the zName and zDb fields of the vtab structure. */
117966 p->zName = zCsr;
120000 const char *zName, /* Name of SQL function */
120005 const char *zName;
120020 if( strcmp(zName, aOverload[i].zName)==0 ){
120035 const char *zName /* New name of table */
120053 p->zDb, p->zName, zName
120060 p->zDb, p->zName, zName
120066 p->zDb, p->zName, zName
120071 p->zDb, p->zName, zName
120075 p->zDb, p->zName, zName
121954 p->pFts3Tab->zName = &p->pFts3Tab->zDb[nDb+1];
121959 memcpy((char *)p->pFts3Tab->zName, zFts3, nFts3);
121960 sqlite3Fts3Dequote((char *)p->pFts3Tab->zName);
123174 const char *zName,
123187 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
124439 const unsigned char *zName;
124446 zName = sqlite3_value_text(argv[0]);
124457 pOld = sqlite3Fts3HashInsert(pHash, (void *)zName, nName, pPtr);
124463 pPtr = sqlite3Fts3HashFind(pHash, zName, nName);
124465 char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
124627 const char *zName;
124645 zName = (const char *)sqlite3_value_text(argv[0]);
124654 p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
124657 char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
124705 char *zName,
124717 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
124727 char *zName,
124740 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
124819 ** The third argument to this function, zName, is used as the name
124825 const char *zName
124835 zTest = sqlite3_mprintf("%s_test", zName);
124836 zTest2 = sqlite3_mprintf("%s_internal_test", zName);
124843 rc = sqlite3_create_function(db, zName, 1, any, p, scalarFunc, 0, 0);
124846 rc = sqlite3_create_function(db, zName, 2, any, p, scalarFunc, 0, 0);
125408 zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName, p->zWriteExprlist);
125412 zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName);
126199 p->zSegmentsTbl = sqlite3_mprintf("%s_segments", p->zName);
130312 char *zName; /* Name of r-tree table */
130943 pRtree->zDb, pRtree->zName,
130944 pRtree->zDb, pRtree->zName,
130945 pRtree->zDb, pRtree->zName
133006 , pRtree->zDb, pRtree->zName, zNewName
133007 , pRtree->zDb, pRtree->zName, zNewName
133008 , pRtree->zDb, pRtree->zName, zNewName
133172 pRtree->zDb, pRtree->zName
133230 pRtree->zName = &pRtree->zDb[nDb+1];
133235 memcpy(pRtree->zName, argv[2], nName);
133654 const char *zName, /* Name of ICU function that failed */
133658 sqlite3_snprintf(128, zBuf, "ICU error: %s(): %s", zName, u_errorName(e));
133867 const char *zName; /* SQL Collation sequence name (eg. "japanese") */
133873 zName = (const char *)sqlite3_value_text(apArg[1]);
133875 if( !zLocale || !zName ){
133886 rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator,
133900 const char *zName; /* Function name */
133930 db, p->zName, p->nArg, p->enc, p->pContext, p->xFunc, 0, 0
