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 */
25336 const char *zName; /* Name of the sytem call */
25449 ** system call named zName.
25453 const char *zName, /* Name of system call to override */
25460 if( zName==0 ){
25461 /* If no zName is given, restore all system calls to their default
25471 /* If zName is specified, operate on only the one system call
25475 if( strcmp(zName, aSyscall[i].zName)==0 ){
25490 ** Return the value of a system call. Return NULL if zName is not a
25496 const char *zName
25502 if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
25508 ** Return the name of the first system call after zName. If zName==NULL
25509 ** then return the name of the first system call. Return NULL if zName
25510 ** is the last system call or if zName is not the name of a valid
25513 static const char *unixNextSystemCall(sqlite3_vfs *p, const char *zName){
25517 if( zName ){
25519 if( strcmp(zName, aSyscall[i].zName)==0 ) break;
25523 if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
28602 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
29648 if( memcmp(pVfs->zName,"unix-excl",10)==0 ){
30069 const char *zName = zPath;
30085 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
30086 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
30087 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
30088 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
30101 pUnused = findReusableFd(zName, flags);
30115 assert( (flags & SQLITE_OPEN_URI) || zName[strlen(zName)+1]==0 );
30117 }else if( !zName ){
30118 /* If zName is NULL, the upper layer is requesting a temp file. */
30124 zName = zTmpname;
30128 assert( zName[strlen(zName)+1]==0 );
30145 rc = findCreateFileMode(zName, flags, &openMode, &uid, &gid);
30151 fd = robust_open(zName, openFlags, openMode);
30152 OSTRACE(("OPENX %-3d %s 0%o\n", fd, zName, openFlags));
30160 fd = robust_open(zName, openFlags, openMode);
30163 rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName);
30190 zPath = zName;
30192 osUnlink(zName);
30939 dummyVfs.zName = "dummy";
31828 VFSNAME, /* zName */ \
32324 const char *zName; /* Name of the sytem call */
32735 ** system call named zName.
32739 const char *zName, /* Name of system call to override */
32746 if( zName==0 ){
32747 /* If no zName is given, restore all system calls to their default
32757 /* If zName is specified, operate on only the one system call
32761 if( strcmp(zName, aSyscall[i].zName)==0 ){
32776 ** Return the value of a system call. Return NULL if zName is not a
32782 const char *zName
32788 if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
32794 ** Return the name of the first system call after zName. If zName==NULL
32795 ** then return the name of the first system call. Return NULL if zName
32796 ** is the last system call or if zName is not the name of a valid
32799 static const char *winNextSystemCall(sqlite3_vfs *p, const char *zName){
32803 if( zName ){
32805 if( strcmp(zName, aSyscall[i].zName)==0 ) break;
32809 if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
33381 LPWSTR zName;
33384 zName = utf8ToUnicode(zFilename);
33385 if( zName==0 ){
33395 zTok = osCharLowerW(zName);
33401 pFile->hMutex = osCreateMutexW(NULL, FALSE, zName);
33405 sqlite3_free(zName);
33416 osCharUpperW(zName);
33419 zName);
33427 sqlite3_free(zName);
34570 int nName; /* Size of zName in bytes */
35113 const char *zName, /* Name of the file (UTF-8) */
35129 const char *zUtf8Name = zName; /* Filename in UTF-8 encoding */
35172 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
35173 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
35174 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
35175 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
35283 h, zName, dwDesiredAccess,
35291 return winOpen(pVfs, zName, id,
35312 pFile->zPath = zName;
35313 if( sqlite3_uri_boolean(zName, "psow", SQLITE_POWERSAFE_OVERWRITE) ){
35319 && !winceCreateLock(zName, pFile)
35771 "win32", /* zName */
46091 static char zName[15];
46092 sqlite3_snprintf(sizeof(zName), zName, "READ-LOCK[%d]",
46094 return zName;
60379 int n = sqlite3Strlen30(pColl->zName);
60388 memcpy(&zTemp[i], pColl->zName,n+1);
60402 sqlite3_snprintf(nTemp, zTemp, "collseq(%.20s)", pColl->zName);
60407 sqlite3_snprintf(nTemp, zTemp, "%s(%d)", pDef->zName, pDef->nArg);
61215 ** zName must be a pointer to a nul terminated string.
61221 ** to by zName will be freed by sqlite3DbFree() when the vdbe is destroyed.
61225 int idx, /* Index of column zName applies to */
61227 const char *zName, /* Pointer to buffer containing name */
61228 void (*xDel)(void*) /* Memory management strategy for zName */
61235 assert( !zName || xDel!=SQLITE_DYNAMIC );
61240 rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, xDel);
61241 assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 );
63071 rc = db->xWalCallback(db->pWalArg, db, db->aDb[i].zName, nEntry);
63301 const char *zName = context->pFunc->zName;
63305 "unable to use function %s in the requested context", zName);
63944 SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){
63949 if( zName ){
63952 if( z && memcmp(z,zName,nName)==0 && z[nName]==0 ){
63959 SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
63960 return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName));
65122 char *zName; /* Name of savepoint */
67490 char *zName; /* Name of savepoint */
67500 u.ar.zName = pOp->p4.z;
67519 u.ar.nName = sqlite3Strlen30(u.ar.zName);
67535 u.ar.pNew->zName = (char *)&u.ar.pNew[1];
67536 memcpy(u.ar.pNew->zName, u.ar.zName, u.ar.nName+1);
67560 u.ar.pSavepoint && sqlite3StrICmp(u.ar.pSavepoint->zName, u.ar.zName);
67566 sqlite3SetString(&p->zErrMsg, db, "no such savepoint: %s", u.ar.zName);
68943 u.bh.zDb = db->aDb[u.bh.pC->iDb].zName;
69011 const char *zDb = db->aDb[u.bi.pC->iDb].zName;
69778 db->aDb[u.by.iDb].zName, u.by.zMaster, pOp->p4.z);
70886 ** in register P1 is passed as the zName argument to the xRename method.
71373 if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
71454 sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT);
72724 const char *zName, /* Name of the journal file */
72737 return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0);
72742 p->zJournal = zName;
73278 if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ) return 1;
73351 assert( pTab!=0 && pTab->zName!=0 );
73359 char *zTabName = pTab->zName;
73363 if( zDb!=0 && sqlite3StrICmp(db->aDb[iDb].zName, zDb)!=0 ){
73375 if( sqlite3StrICmp(pCol->zName, zCol)==0 ){
73419 if( sqlite3StrICmp(pCol->zName, zCol)==0 ){
73473 char *zAs = pEList->a[j].zName;
73713 auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0, pDef->zName, 0);
73717 pDef->zName);
73806 char *zAs = pEList->a[i].zName;
74181 if( pItem->zName ) pParse->zAuthContext = pItem->zName;
75261 pItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
75293 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
75332 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
75417 ** Set the ExprList.a[].zName element of the most recently added item
75435 assert( pItem->zName==0 );
75436 pItem->zName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n);
75437 if( dequote && pItem->zName ) sqlite3Dequote(pItem->zName);
75493 sqlite3DbFree(db, pItem->zName);
75867 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
75911 VdbeComment((v, "%s", pIdx->zName));
77133 (pExpr->iColumn<0 ? "rowid" : pExpr->pTab->aCol[pExpr->iColumn].zName),
78717 zWhere = whereOrName(pParse->db, zWhere, p->pFrom->zName);
78743 zWhere = whereOrName(db, zWhere, pTrig->zName);
78758 ** Argument zName is the name of the table in the database schema at
78760 ** pTab->zName if this function is being called to code part of an
78763 static void reloadTableSchema(Parse *pParse, Table *pTab, const char *zName){
78782 sqlite3VdbeAddOp4(v, OP_DropTrigger, iTrigDb, 0, 0, pTrig->zName, 0);
78787 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
78790 zWhere = sqlite3MPrintf(pParse->db, "tbl_name=%Q", zName);
78805 ** Parameter zName is the name of a table that is about to be altered
78810 ** Or, if zName is not a system table, zero is returned.
78812 static int isSystemTable(Parse *pParse, const char *zName){
78813 if( sqlite3Strlen30(zName)>6 && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){
78814 sqlite3ErrorMsg(pParse, "table %s may not be altered", zName);
78832 char *zName = 0; /* NULL-terminated version of pName */
78848 pTab = sqlite3LocateTable(pParse, 0, pSrc->a[0].zName, pSrc->a[0].zDatabase);
78851 zDb = db->aDb[iDb].zName;
78855 zName = sqlite3NameFromToken(db, pName);
78856 if( !zName ) goto exit_rename_table;
78858 /* Check that a table or index named 'zName' does not already exist
78861 if( sqlite3FindTable(db, zName, zDb) || sqlite3FindIndex(db, zName, zDb) ){
78863 "there is already another table or index with this name: %s", zName);
78870 if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
78873 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ goto
78879 sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
78886 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
78923 sqlite3VdbeAddOp4(v, OP_String8, 0, i, 0, zName, 0);
78929 /* figure out how many UTF-8 characters are in zName */
78930 zTabName = pTab->zName;
78942 "WHERE %s;", zDb, SCHEMA_TABLE(iDb), zTabName, zName, zWhere);
78966 zDb, SCHEMA_TABLE(iDb), zName, zName, zName,
78968 zName,
78970 zName, nTabName, zTabName
78980 zDb, zName, pTab->zName);
78994 "WHERE %s;", zName, zName, zWhere);
79005 reloadTableSchema(pParse, p->pFrom, pFrom->zName);
79012 reloadTableSchema(pParse, pTab, zName);
79016 sqlite3DbFree(db, zName);
79072 zDb = db->aDb[iDb].zName;
79073 zTab = &pNew->zName[16]; /* Skip the "sqlite_altertab_" prefix on the name */
79081 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
79160 reloadTableSchema(pParse, pTab, pTab->zName);
79191 pTab = sqlite3LocateTable(pParse, 0, pSrc->a[0].zName, pSrc->a[0].zDatabase);
79206 if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
79229 pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
79230 if( !pNew->aCol || !pNew->zName ){
79237 pCol->zName = sqlite3DbStrDup(db, pCol->zName);
79402 const char *zName;
79427 const char *zTab = aTable[i].zName;
79429 if( (pStat = sqlite3FindTable(db, zTab, pDb->zName))==0 ){
79435 "CREATE TABLE %Q.%s(%s)", pDb->zName, zTab, aTable[i].zCols
79447 "DELETE FROM %Q.%s WHERE %s=%Q", pDb->zName, zTab, zWhereType, zWhere
79540 "stat3_init", /* zName */
79633 "stat3_push", /* zName */
79675 "stat3_get", /* zName */
79736 if( memcmp(pTab->zName, "sqlite_", 7)==0 ){
79745 if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,
79746 db->aDb[iDb].zName ) ){
79752 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
79755 sqlite3VdbeAddOp4(v, OP_String8, 0, regTabname, 0, pTab->zName, 0);
79763 VdbeNoopComment((v, "Begin analysis of %s", pIdx->zName));
79776 VdbeComment((v, "%s", pIdx->zName));
79779 sqlite3VdbeAddOp4(v, OP_String8, 0, regIdxname, 0, pIdx->zName, 0);
79945 VdbeComment((v, "%s", pTab->zName));
80013 openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");
80015 openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
80076 zDb = db->aDb[iDb].zName;
80351 sInfo.zDatabase = db->aDb[iDb].zName;
80457 const char *zName;
80469 zName = (const char *)sqlite3_value_text(argv[1]);
80471 if( zName==0 ) zName = "";
80490 char *z = db->aDb[i].zName;
80491 assert( z && zName );
80492 if( sqlite3StrICmp(z, zName)==0 ){
80493 zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName);
80518 rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
80549 aNew->zName = sqlite3DbStrDup(db, zName);
80550 if( rc==SQLITE_OK && aNew->zName==0 ){
80641 const char *zName = (const char *)sqlite3_value_text(argv[0]);
80649 if( zName==0 ) zName = "";
80653 if( sqlite3StrICmp(pDb->zName, zName)==0 ) break;
80657 sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
80661 sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
80670 sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
80772 "sqlite_detach", /* zName */
80794 "sqlite_attach", /* zName */
80822 pFix->zDb = db->aDb[iDb].zName;
81053 char *zDb = db->aDb[iDb].zName; /* Name of attached database */
81117 zCol = pTab->aCol[iCol].zName;
81120 zCol = pTab->aCol[pTab->iPKey].zName;
81125 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
81241 const char *zName; /* Name of the table */
81259 const char *zName /* Name of the table to be locked */
81283 p->zName = zName;
81305 p->zName, P4_STATIC);
81463 SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){
81467 assert( zName!=0 );
81468 nName = sqlite3Strlen30(zName);
81473 if( zDatabase!=0 && sqlite3StrICmp(zDatabase, db->aDb[j].zName) ) continue;
81475 p = sqlite3HashFind(&db->aDb[j].pSchema->tblHash, zName, nName);
81494 const char *zName, /* Name of the table we are looking for */
81505 p = sqlite3FindTable(pParse->db, zName, zDbase);
81509 sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
81511 sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
81530 SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){
81533 int nName = sqlite3Strlen30(zName);
81540 if( zDb && sqlite3StrICmp(zDb, db->aDb[j].zName) ) continue;
81542 p = sqlite3HashFind(&pSchema->idxHash, zName, nName);
81648 sqlite3DbFree(db, pDb->zName);
81649 pDb->zName = 0;
81683 sqlite3DbFree(db, pCol->zName);
81716 char *zName = pIndex->zName;
81718 &pIndex->pSchema->idxHash, zName, sqlite3Strlen30(zName), 0
81732 sqlite3DbFree(db, pTable->zName);
81778 char *zName;
81780 zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n);
81781 sqlite3Dequote(zName);
81783 zName = 0;
81785 return zName;
81803 ** Parameter zName points to a nul-terminated buffer containing the name
81808 SQLITE_PRIVATE int sqlite3FindDbName(sqlite3 *db, const char *zName){
81810 if( zName ){
81812 int n = sqlite3Strlen30(zName);
81814 if( (!OMIT_TEMPDB || i!=1 ) && n==sqlite3Strlen30(pDb->zName) &&
81815 0==sqlite3StrICmp(pDb->zName, zName) ){
81831 char *zName; /* Name we are searching for */
81832 zName = sqlite3NameFromToken(db, pName);
81833 i = sqlite3FindDbName(db, zName);
81834 sqlite3DbFree(db, zName);
81885 ** This routine is used to check if the UTF-8 string zName is a legal
81891 SQLITE_PRIVATE int sqlite3CheckObjectName(Parse *pParse, const char *zName){
81894 && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){
81895 sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s", zName);
81927 char *zName = 0; /* The name of the new table */
81961 zName = sqlite3NameFromToken(db, pName);
81962 if( zName==0 ) return;
81963 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
81971 char *zDb = db->aDb[iDb].zName;
81988 if( !isVirtual && sqlite3AuthCheck(pParse, code, zName, 0, zDb) ){
82002 char *zDb = db->aDb[iDb].zName;
82006 pTable = sqlite3FindTable(db, zName, zDb);
82016 if( sqlite3FindIndex(db, zName, zDb)!=0 ){
82017 sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
82029 pTable->zName = zName;
82042 if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){
82115 sqlite3DbFree(db, zName);
82149 sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
82156 if( STRICMP(z, p->aCol[i].zName) ){
82173 pCol->zName = z;
82297 pCol->zName);
82344 "table \"%s\" has more than one primary key", pTab->zName);
82354 if( sqlite3StrICmp(pList->a[i].zName, pTab->aCol[iCol].zName)==0 ){
82448 ** encoding identified by the string zName, length nName.
82466 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){
82472 pColl = sqlite3FindCollSeq(db, enc, zName, initbusy);
82474 pColl = sqlite3GetCollSeq(db, enc, pColl, zName);
82476 sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);
82574 n += identLength(pCol->zName) + 5;
82576 n += identLength(p->zName);
82594 identPut(zStmt, &k, p->zName);
82610 identPut(zStmt, &k, pCol->zName);
82681 sSrc.a[0].zName = p->zName;
82790 db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
82792 p->zName,
82793 p->zName,
82811 pDb->zName
82819 sqlite3MPrintf(db, "tbl_name='%q'", p->zName));
82829 pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName,
82830 sqlite3Strlen30(p->zName),p);
82841 const char *zName = (const char *)pParse->sNameToken.z;
82847 nName = (int)((const char *)pCons->z - zName);
82848 p->addColOffset = 13 + sqlite3Utf8CharLen(zName, nName);
82975 sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
83114 pParse->db->aDb[iDb].zName, SCHEMA_TABLE(iDb), iTable, r1, r1);
83186 const char *zName /* Name of index or table */
83189 const char *zDbName = pParse->db->aDb[iDb].zName;
83196 zDbName, zTab, zType, zName
83242 pDb->zName, pTab->zName
83256 pDb->zName, SCHEMA_TABLE(iDb), pTab->zName);
83265 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
83267 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
83289 pName->a[0].zName, pName->a[0].zDatabase);
83309 const char *zDb = db->aDb[iDb].zName;
83323 zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
83332 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
83335 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
83340 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
83341 && sqlite3StrNICmp(pTab->zName, "sqlite_stat", 11)!=0 ){
83342 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
83351 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
83355 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
83366 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
83416 p->aCol[iCol].zName, pTo);
83431 nByte += sqlite3Strlen30(pToCol->a[i].zName) + 1;
83453 if( sqlite3StrICmp(p->aCol[j].zName, pFromCol->a[i].zName)==0 ){
83461 pFromCol->a[i].zName);
83468 int n = sqlite3Strlen30(pToCol->a[i].zName);
83470 memcpy(z, pToCol->a[i].zName, n);
83551 if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
83552 db->aDb[iDb].zName ) ){
83558 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
83673 char *zName = 0; /* Name of the index */
83674 int nName; /* Number of characters in zName */
83731 pTab = sqlite3LocateTable(pParse, 0, pTblName->a[0].zName,
83746 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
83747 && memcmp(&pTab->zName[7],"altertab_",9)!=0 ){
83748 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
83778 zName = sqlite3NameFromToken(db, pName);
83779 if( zName==0 ) goto exit_create_index;
83781 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
83785 if( sqlite3FindTable(db, zName, 0)!=0 ){
83786 sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
83790 if( sqlite3FindIndex(db, zName, pDb->zName)!=0 ){
83792 sqlite3ErrorMsg(pParse, "index %s already exists", zName);
83803 zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
83804 if( zName==0 ){
83813 const char *zDb = pDb->zName;
83819 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
83830 nullId.z = pTab->aCol[pTab->nCol-1].zName;
83848 nExtra += (1 + sqlite3Strlen30(pColl->zName));
83856 nName = sqlite3Strlen30(zName);
83864 nName + 1 + /* Index.zName */
83878 pIndex->zName = (char *)(&pIndex->aSortOrder[nCol]);
83879 zName[nName+1]);
83880 memcpy(pIndex->zName, zName, nName+1);
83907 const char *zColName = pListItem->zName;
83913 if( sqlite3StrICmp(zColName, pTabCol->zName)==0 ) break;
83917 pTab->zName, zColName);
83929 zColl = pListItem->pExpr->pColl->zName;
83939 zColl = db->pDfltColl->zName;
84018 pIndex->zName, sqlite3Strlen30(pIndex->zName),
84080 db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
84081 pIndex->zName,
84082 pTab->zName,
84095 sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName));
84131 sqlite3DbFree(db, zName);
84188 pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
84208 const char *zDb = db->aDb[iDb].zName;
84214 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
84226 db->aDb[iDb].zName, SCHEMA_TABLE(iDb), pIndex->zName
84228 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
84231 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
84301 pList->a[i].zName = sqlite3NameFromToken(db, pToken);
84312 sqlite3DbFree(db, pList->a[i].zName);
84322 SQLITE_PRIVATE int sqlite3IdListIndex(IdList *pList, const char *zName){
84326 if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
84410 ** The SrcList.a[].zName field is filled with the table name which might
84459 pItem->zName = sqlite3NameFromToken(db, pTable);
84491 sqlite3DbFree(db, pItem->zName);
84668 char *zName = sqlite3NameFromToken(pParse->db, pName);
84669 if( zName ){
84675 if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
84676 sqlite3DbFree(pParse->db, zName);
84679 sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
84774 if( pDb->pBt && (!zDb || 0==sqlite3StrICmp(zDb, pDb->zName)) ){
84957 zDb = db->aDb[iDb].zName;
85033 ** in the encoding enc of name zName, length nName.
85035 static void callCollNeeded(sqlite3 *db, int enc, const char *zName){
85038 char *zExternal = sqlite3DbStrDup(db, zName);
85047 sqlite3ValueSetStr(pTmp, -1, zName, SQLITE_UTF8, SQLITE_STATIC);
85066 char *z = pColl->zName;
85086 ** collation sequence with name zName, length nName.
85089 ** db for collation type name zName, length nName, or NULL, if no collation
85098 const char *zName /* Collating sequence name */
85104 p = sqlite3FindCollSeq(db, enc, zName, 0);
85110 callCollNeeded(db, enc, zName);
85111 p = sqlite3FindCollSeq(db, enc, zName, 0);
85133 const char *zName = pColl->zName;
85135 CollSeq *p = sqlite3GetCollSeq(db, ENC(db), pColl, zName);
85137 sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);
85150 ** specified by zName and nName is not found and parameter 'create' is
85163 const char *zName, /* Name of the collating sequence */
85167 int nName = sqlite3Strlen30(zName);
85168 pColl = sqlite3HashFind(&db->aCollSeq, zName, nName);
85174 pColl[0].zName = (char*)&pColl[3];
85176 pColl[1].zName = (char*)&pColl[3];
85178 pColl[2].zName = (char*)&pColl[3];
85180 memcpy(pColl[0].zName, zName, nName);
85181 pColl[0].zName[nName] = 0;
85182 pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, nName, pColl);
85200 ** Parameter zName points to a UTF-8 encoded string nName bytes long.
85201 ** Return the CollSeq* pointer for the collation sequence named zName
85217 const char *zName,
85221 if( zName ){
85222 pColl = findCollSeqEntry(db, zName, create);
85285 if( sqlite3StrNICmp(p->zName, zFunc, nFunc)==0 && p->zName[nFunc]==0 ){
85300 int nName = sqlite3Strlen30(pDef->zName);
85301 u8 c1 = (u8)pDef->zName[0];
85303 pOther = functionSearch(pHash, h, pDef->zName, nName);
85339 const char *zName, /* Name of the function. Not null-terminated */
85352 h = (sqlite3UpperToLower[(u8)zName[0]] + nName) % ArraySize(db->aFunc.a);
85356 p = functionSearch(&db->aFunc, h, zName, nName);
85381 p = functionSearch(pHash, h, zName, nName);
85398 pBest->zName = (char *)&pBest[1];
85401 memcpy(pBest->zName, zName, nName);
85402 pBest->zName[nName] = 0;
85506 pTab = sqlite3LocateTable(pParse, 0, pItem->zName, pItem->zDatabase);
85540 sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
85546 sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
85578 pFrom->a[0].zAlias = sqlite3DbStrDup(db, pView->zName);
85759 zDb = db->aDb[iDb].zName;
85760 rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb);
85778 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
85826 pTab->zName, P4_STATIC);
86021 sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_TRANSIENT);
87574 static void setLikeOptFlag(sqlite3 *db, const char *zName, u8 flagVal){
87576 pDef = sqlite3FindFunction(db, zName, sqlite3Strlen30(zName),
87957 if( !sqlite3StrICmp(pParent->aCol[pParent->iPKey].zName, zKey) ) return 0;
88003 zIdxCol = pParent->aCol[iCol].zName;
88268 zCol = pFKey->pFrom->aCol[iCol].zName;
88335 int nName = sqlite3Strlen30(pTab->zName);
88336 return (FKey *)sqlite3HashFind(&pTab->pSchema->fkeyHash, pTab->zName, nName);
88455 zDb = db->aDb[iDb].zName;
88516 char *zCol = pTo->aCol[pIdx ? pIdx->aiColumn[i] : pTo->iPKey].zName;
88517 rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
88526 sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
88570 pItem->zName = pFKey->pFrom->zName;
88586 pItem->zName = 0;
88669 if( (zKey ? !sqlite3StrICmp(pCol->zName, zKey) : pCol->isPrimKey) ){
88750 tToCol.z = pIdx ? pTab->aCol[pIdx->aiColumn[i]].zName : "oid";
88751 tFromCol.z = pFKey->pFrom->aCol[iFromCol].zName;
88811 zFrom = pFKey->pFrom->zName;
88993 sqlite3TableLock(p, iDb, pTab->tnum, (opcode==OP_OpenWrite)?1:0, pTab->zName);
88996 VdbeComment((v, "%s", pTab->zName));
89206 sqlite3VdbeAddOp4(v, OP_String8, 0, memId-1, 0, p->pTab->zName, 0);
89451 zTab = pTabList->a[0].zName;
89460 zDb = pDb->zName;
89461 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb) ){
89680 if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){
89689 if( sqlite3IsRowid(pColumn->a[i].zName) ){
89693 pTabList, 0, pColumn->a[i].zName);
90158 pTab->zName, pTab->aCol[i].zName);
90338 char *zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
90435 sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_TRANSIENT);
90468 VdbeComment((v, "%s", pIdx->zName));
90645 pSrc = sqlite3LocateTable(pParse, 0, pItem->zName, pItem->zDatabase);
90767 sqlite3VdbeChangeP4(v, -1, pDest->zName, 0);
90779 VdbeComment((v, "%s", pSrcIdx->zName));
90783 VdbeComment((v, "%s", pDestIdx->zName));
91016 int (*bind_parameter_index)(sqlite3_stmt*,const char*zName);
92232 const char *zName; /* Name of the pragma */
92271 if( sqlite3StrICmp(zLeft, p->zName)==0 ){
92278 returnSingleInt(pParse, p->zName, (db->flags & p->mask)!=0 );
92313 const char *zName;
92315 case OE_SetNull: zName = "SET NULL"; break;
92316 case OE_SetDflt: zName = "SET DEFAULT"; break;
92317 case OE_Cascade: zName = "CASCADE"; break;
92318 case OE_Restrict: zName = "RESTRICT"; break;
92319 default: zName = "NO ACTION";
92322 return zName;
92410 zDb = pId2->n>0 ? pDb->zName : 0;
92987 sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pCol->zName, 0);
93020 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pTab->aCol[cnum].zName, 0);
93043 sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pIdx->zName, 0);
93063 assert( db->aDb[i].zName!=0 );
93065 sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, db->aDb[i].zName, 0);
93082 sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pColl->zName, 0);
93119 pTab->aCol[pFK->aCol[j].iFrom].zName, 0);
93239 sqlite3MPrintf(db, "*** in database %s ***\n", db->aDb[i].zName),
93282 sqlite3VdbeChangeP4(v, addr+4, pIdx->zName, P4_TRANSIENT);
93312 sqlite3VdbeChangeP4(v, addr+7, pIdx->zName, P4_TRANSIENT);
93348 char *zName;
93370 sqlite3VdbeChangeP4(v, -1, encnames[ENC(pParse->db)].zName, P4_STATIC);
93382 for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
93383 if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){
93388 if( !pEnc->zName ){
93562 if( db->aDb[i].zName==0 ) continue;
93563 sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, db->aDb[i].zName, P4_STATIC);
93567 }else if( sqlite3_file_control(db, i ? db->aDb[i].zName : 0,
93748 pIndex = sqlite3FindIndex(db, argv[0], db->aDb[iDb].zName);
93840 pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName);
93960 db->aDb[iDb].zName, zMasterName);
94216 const char *zDb = db->aDb[i].zName;
94693 if( sqlite3StrICmp(pTab->aCol[i].zName, zCol)==0 ) return i;
94853 char *zName; /* Name of column in the right table */
94857 zName = pRightTab->aCol[j].zName;
94858 if( tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol) ){
94892 char *zName; /* Name of the term in the USING clause */
94897 zName = pList->a[j].zName;
94898 iRightCol = columnIndex(pRightTab, zName);
94900 || !tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol)
94903 "not present in both tables", zName);
95589 zOriginCol = pTab->aCol[iCol].zName;
95591 zOriginTab = pTab->zName;
95594 zOriginDb = pNC->pParse->db->aDb[iDb].zName;
95697 if( pEList->a[i].zName ){
95698 char *zName = pEList->a[i].zName;
95699 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_TRANSIENT);
95714 zCol = pTab->aCol[iCol].zName;
95720 char *zName = 0;
95721 zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol);
95722 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_DYNAMIC);
95759 char *zName; /* Column name */
95760 int nName; /* Size of name in zName[] */
95771 if( (zName = pEList->a[i].zName)!=0 ){
95773 zName = sqlite3DbStrDup(db, zName);
95786 zName = sqlite3MPrintf(db, "%s",
95787 iCol>=0 ? pTab->aCol[iCol].zName : "rowid");
95790 zName = sqlite3MPrintf(db, "%s", pColExpr->u.zToken);
95793 zName = sqlite3MPrintf(db, "%s", pEList->a[i].zSpan);
95797 sqlite3DbFree(db, zName);
95804 nName = sqlite3Strlen30(zName);
95806 if( sqlite3StrICmp(aCol[j].zName, zName)==0 ){
95808 zName[nName] = 0;
95809 zNewName = sqlite3MPrintf(db, "%s:%d", zName, ++cnt);
95810 sqlite3DbFree(db, zName);
95811 zName = zNewName;
95813 if( zName==0 ) break;
95816 pCol->zName = zName;
95820 sqlite3DbFree(db, aCol[j].zName);
95869 pCol->zColl = sqlite3DbStrDup(db, pColl->zName);
95898 pTab->zName = 0;
97346 pParse->zAuthContext = pSubitem->zName;
97417 sqlite3DbFree(db, pSubitem->zName);
97420 pSubitem->zName = 0;
97521 if( pList->a[i].zName==0 ){
97524 pList->a[i].zName = sqlite3DbStrDup(db, zSpan);
97663 pIdx && sqlite3StrICmp(pIdx->zName, zIndex);
97735 if( pFrom->zName==0 ){
97745 pTab->zName = sqlite3MPrintf(db, "sqlite_subquery_%p_", (void*)pTab);
97756 sqlite3LocateTable(pParse,0,pFrom->zName,pFrom->zDatabase);
97819 pNew->a[pNew->nExpr-1].zName = a[k].zName;
97821 a[k].zName = 0;
97841 zTabName = pTab->zName;
97850 char *zName = pTab->aCol[j].zName;
97866 && tableAndColumnIndex(pTabList, i, zName, 0, 0)
97872 if( sqlite3IdListIndex(pFrom->pUsing, zName)>=0 ){
97878 pRight = sqlite3Expr(db, TK_ID, zName);
97879 zColname = zName;
97886 zColname = sqlite3MPrintf(db, "%s.%s", zTabName, zName);
98187 pTab->zName,
98189 pIdx ? pIdx->zName : "",
98369 VdbeNoopComment((v, "materialize %s", pItem->pTab->zName));
98382 VdbeComment((v, "end %s", pItem->pTab->zName));
98878 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
99047 sqlite3ExplainPrintf(pVdbe, " (tabname=%s)", pItem->pTab->zName);
99049 }else if( pItem->zName ){
99050 sqlite3ExplainPrintf(pVdbe, "%s", pItem->zName);
99375 && 0==sqlite3StrICmp(pTrig->table, pTab->zName)
99408 char *zName = 0; /* Name of the trigger */
99492 zName = sqlite3NameFromToken(db, pName);
99493 if( !zName || SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
99498 zNamezName)) ){
99509 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
99533 const char *zDb = db->aDb[iTabDb].zName;
99534 const char *zDbTrig = isTemp ? db->aDb[1].zName : zDb;
99536 if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
99557 pTrigger->zName = zName;
99558 zName = 0;
99559 pTrigger->table = sqlite3DbStrDup(db, pTableName->a[0].zName);
99570 sqlite3DbFree(db, zName);
99591 char *zName; /* Name of trigger */
99599 zName = pTrig->zName;
99606 nameToken.z = pTrig->zName;
99627 db->aDb[iDb].zName, SCHEMA_TABLE(iDb), zName,
99632 sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName));
99639 pTrig = sqlite3HashInsert(pHash, zName, sqlite3Strlen30(zName), pTrig);
99788 sqlite3DbFree(db, pTrigger->zName);
99807 const char *zName;
99818 zName = pName->a[0].zName;
99819 nName = sqlite3Strlen30(zName);
99823 if( zDb && sqlite3StrICmp(db->aDb[j].zName, zDb) ) continue;
99825 pTrigger = sqlite3HashFind(&(db->aDb[j].pSchema->trigHash), zName, nName);
99870 const char *zDb = db->aDb[iDb].zName;
99873 if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) ||
99900 sqlite3VdbeChangeP4(v, base+1, pTrigger->zName, P4_TRANSIENT);
99904 sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
99914 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){
99920 pTrigger = sqlite3HashInsert(pHash, zName, sqlite3Strlen30(zName), 0);
99946 if( sqlite3IdListIndex(pIdList, pEList->a[e].zName)>=0 ) return 1;
100008 pSrc->a[pSrc->nSrc-1].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zName);
100144 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
100171 pSubParse->zAuthContext = pTrigger->zName;
100178 pTrigger->zName, onErrorText(orconf),
100183 pTab->zName
100187 sqlite3MPrintf(db, "-- TRIGGER %s", pTrigger->zName), P4_DYNAMIC
100213 VdbeComment((v, "End: %s.%s", pTrigger->zName, onErrorText(orconf)));
100250 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
100291 int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers));
100296 (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf)));
100507 VdbeComment((v, "%s.%s", pTab->zName, pCol->zName));
100640 if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zName)==0 ){
100650 if( sqlite3IsRowid(pChanges->a[i].zName) ){
100654 sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zName);
100662 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
100663 pTab->aCol[j].zName, db->aDb[iDb].zName);
100733 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
101074 pExpr = sqlite3Expr(db, TK_ID, pTab->aCol[i].zName);
101269 assert( strcmp(pDb->zName,"vacuum_db")==0 );
101499 const char *zName, /* Name assigned to this module */
101508 nName = sqlite3Strlen30(zName);
101513 memcpy(zCopy, zName, nName+1);
101514 pMod->zName = zCopy;
101541 const char *zName, /* Name assigned to this module */
101545 return createModule(db, zName, pModule, pAux, 0);
101553 const char *zName, /* Name assigned to this module */
101558 return createModule(db, zName, pModule, pAux, xDestroy);
101763 addModuleArgument(db, pTable, sqlite3DbStrDup(db, db->aDb[iDb].zName));
101764 addModuleArgument(db, pTable, sqlite3DbStrDup(db, pTable->zName));
101774 sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName,
101775 pTable->azModuleArg[0], pParse->db->aDb[iDb].zName);
101838 db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
101839 pTab->zName,
101840 pTab->zName,
101849 zWhere = sqlite3MPrintf(db, "name='%q' AND type='table'", pTab->zName);
101852 pTab->zName, sqlite3Strlen30(pTab->zName) + 1);
101863 const char *zName = pTab->zName;
101864 int nName = sqlite3Strlen30(zName);
101866 pOld = sqlite3HashInsert(&pSchema->tblHash, zName, nName, pTab);
101919 char *zModuleName = sqlite3MPrintf(db, "%s", pTab->zName);
101958 *pzErr = sqlite3MPrintf(db, zFormat, pTab->zName);
102090 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
102192 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
102426 zLowerName = sqlite3DbStrDup(db, pDef->zName);
102441 + sqlite3Strlen30(pDef->zName) + 1);
102446 pNew->zName = (char *)&pNew[1];
102447 memcpy(pNew->zName, pDef->zName, sqlite3Strlen30(pDef->zName)+1);
103160 if( pColl && sqlite3StrICmp(pColl->zName, pIdx->azColl[j]) ) continue;
103984 if( ALWAYS(pColl) && 0==sqlite3StrICmp(pColl->zName, zColl) ){
104016 if( pIdx->zName==0 || pDistinct==0 || pDistinct->nExpr>=BMS ) return 0;
104159 assert( pIdx->zName || (pIdx->nColumn==1 && pIdx->aiColumn[0]==-1) );
104187 if( pIdx->zName && i<pIdx->nColumn ){
104197 zColl = pColl->zName;
104199 if( pExpr->iColumn!=iColumn || sqlite3StrICmp(pColl->zName, zColl) ){
104610 pIdx->zName = "auto-index";
104624 pIdx->azColl[n] = ALWAYS(pColl) ? pColl->zName : "BINARY";
104654 VdbeComment((v, "for %s", pTable->zName));
104693 WHERETRACE(("Recomputing index info for %s...\n", pSrc->pTab->zName));
104798 WHERETRACE(("xBestIndex for %s\n", pTab->zName));
104818 "table %s: xBestIndex returned an invalid plan", pTab->zName);
105830 pSrc->pTab->zName, (pIdx ? pIdx->zName : "ipk"),
105876 pCost->plan.u.pIdx ? pCost->plan.u.pIdx->zName : "ipk")
106228 explainAppendTerm(&txt, i, aCol[aiColumn[i]].zName, "=");
106233 char *z = (j==pIndex->nColumn ) ? "rowid" : aCol[aiColumn[j]].zName;
106237 char *z = (j==pIndex->nColumn ) ? "rowid" : aCol[aiColumn[j]].zName;
106278 zMsg = sqlite3MAppendf(db, zMsg, "%s TABLE %s", zMsg, pItem->zName);
106290 ((flags & WHERE_TEMP_INDEX)?"": pLevel->plan.u.pIdx->zName),
107491 sqlite3ErrorMsg(pParse, "cannot use index: %s", pIdx->zName);
107564 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
107579 VdbeComment((v, "%s", pIx->zName));
107612 if( z==0 ) z = pTabItem->pTab->zName;
107630 n = sqlite3Strlen30(pLevel->plan.u.pIdx->zName);
107632 memcpy(&sqlite3_query_plan[nQPlan], pLevel->plan.u.pIdx->zName, n);
113695 const char *zName,
113698 int nName = sqlite3Strlen30(zName);
113701 if( sqlite3FindFunction(db, zName, nName, nArg, SQLITE_UTF8, 0)==0 ){
113702 rc = sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8,
114105 ** Create a new collating function for database "db". The name is zName
114110 const char *zName,
114118 int nName = sqlite3Strlen30(zName);
114140 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0);
114156 CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName, nName);
114170 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 1);
114676 db->aDb[0].zName = "main";
114678 db->aDb[1].zName = "temp";
114835 const char *zName,
114843 rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, 0);
114854 const char *zName,
114863 rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel);
114875 const void *zName,
114884 zName8 = sqlite3Utf16to8(db, zName, -1, SQLITE_UTF16NATIVE);
115051 if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){
115465 zName)==0)
116585 const char *zName; /* virtual table name */
117150 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_content'", zDb, p->zName);
117152 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_segments'", zDb,p->zName);
117153 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_segdir'", zDb, p->zName);
117154 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_docsize'", zDb, p->zName);
117155 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_stat'", zDb, p->zName);
117194 zCols, p->zName, zLanguageid
117240 p->zDb, p->zName, zContentCols
117248 p->zDb, p->zName
117260 p->zDb, p->zName
117265 p->zDb, p->zName
117271 p->zDb, p->zName
117449 (p->zContentTbl ? p->zContentTbl : p->zName),
117896 nName + /* zName */
117928 /* Fill in the zName and zDb fields of the vtab structure. */
117930 p->zName = zCsr;
119964 const char *zName, /* Name of SQL function */
119969 const char *zName;
119984 if( strcmp(zName, aOverload[i].zName)==0 ){
119999 const char *zName /* New name of table */
120017 p->zDb, p->zName, zName
120024 p->zDb, p->zName, zName
120030 p->zDb, p->zName, zName
120035 p->zDb, p->zName, zName
120039 p->zDb, p->zName, zName
121906 p->pFts3Tab->zName = &p->pFts3Tab->zDb[nDb+1];
121911 memcpy((char *)p->pFts3Tab->zName, zFts3, nFts3);
121912 sqlite3Fts3Dequote((char *)p->pFts3Tab->zName);
123126 const char *zName,
123139 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
124391 const unsigned char *zName;
124398 zName = sqlite3_value_text(argv[0]);
124409 pOld = sqlite3Fts3HashInsert(pHash, (void *)zName, nName, pPtr);
124415 pPtr = sqlite3Fts3HashFind(pHash, zName, nName);
124417 char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
124579 const char *zName;
124597 zName = (const char *)sqlite3_value_text(argv[0]);
124606 p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
124609 char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
124657 char *zName,
124669 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
124679 char *zName,
124692 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
124771 ** The third argument to this function, zName, is used as the name
124777 const char *zName
124787 zTest = sqlite3_mprintf("%s_test", zName);
124788 zTest2 = sqlite3_mprintf("%s_internal_test", zName);
124795 rc = sqlite3_create_function(db, zName, 1, any, p, scalarFunc, 0, 0);
124798 rc = sqlite3_create_function(db, zName, 2, any, p, scalarFunc, 0, 0);
125360 zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName, p->zWriteExprlist);
125364 zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName);
126151 p->zSegmentsTbl = sqlite3_mprintf("%s_segments", p->zName);
130264 char *zName; /* Name of r-tree table */
130895 pRtree->zDb, pRtree->zName,
130896 pRtree->zDb, pRtree->zName,
130897 pRtree->zDb, pRtree->zName
132958 , pRtree->zDb, pRtree->zName, zNewName
132959 , pRtree->zDb, pRtree->zName, zNewName
132960 , pRtree->zDb, pRtree->zName, zNewName
133124 pRtree->zDb, pRtree->zName
133182 pRtree->zName = &pRtree->zDb[nDb+1];
133187 memcpy(pRtree->zName, argv[2], nName);
133606 const char *zName, /* Name of ICU function that failed */
133610 sqlite3_snprintf(128, zBuf, "ICU error: %s(): %s", zName, u_errorName(e));
133819 const char *zName; /* SQL Collation sequence name (eg. "japanese") */
133825 zName = (const char *)sqlite3_value_text(apArg[1]);
133827 if( !zLocale || !zName ){
133838 rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator,
133852 const char *zName; /* Function name */
133882 db, p->zName, p->nArg, p->enc, p->pContext, p->xFunc, 0, 0
