Lines Matching defs:zName
1223 ** The zName
1327 const char *zName; /* Name of this virtual file system */
1329 int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,
1331 int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);
1332 int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut);
1333 int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);
3194 SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
4130 const char *zName,
4137 const char *zName,
4145 const void *zName,
4697 int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName,
4812 const char *zName, /* Name of the module */
4818 const char *zName, /* Name of the module */
8181 char *zName; /* Name of this database */
8487 char *zName; /* SQL name of the function. */
8506 ** FUNCTION(zName, nArg, iArg, bNC, xFunc)
8507 ** Used to create a scalar function definition of a function zName
8513 ** AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal)
8519 ** LIKEFUNC(zName, nArg, pArg, flags)
8520 ** Used to create a scalar function definition of a function zName
8527 #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \
8529 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0}
8530 #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \
8532 pArg, 0, xFunc, 0, 0, #zName, 0}
8533 #define LIKEFUNC(zName, nArg, arg, flags) \
8534 {nArg, SQLITE_UTF8, flags, (void *)arg, 0, likeFunc, 0, 0, #zName, 0}
8535 #define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal) \
8537 SQLITE_INT_TO_PTR(arg), 0, 0, xStep,xFinal,#zName,0}
8546 char *zName; /* Savepoint name (nul-terminated) */
8567 const char *zName; /* Name passed to create_module() */
8577 char *zName; /* Name of this column */
8612 char *zName; /* Name of the collating sequence, UTF-8 encoded */
8724 ** Table.zName is the name of the table. The case of the original
8752 char *zName; /* Name of the table or view */
8953 char *zName; /* Name of this index */
9228 ** also be used as the argument to a function, in which case the a.zName
9237 char *zName; /* Token associated with this expression */
9242 u16 iAlias; /* Index into Parse.aAlias[] for zName */
9274 char *zName; /* Name of the identifier */
9275 int idx; /* Index in some Table.aCol[] of a column named zName */
9316 char *zName; /* Name of the table */
9317 char *zAlias; /* The "B" part of a "A AS B" phrase. zName is the "A" */
9318 Table *pTab; /* An SQL table corresponding to zName */
9756 char *zName; /* The name of the trigger */
10369 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char*zName);
12284 if( strcmp(zVfs, pVfs->zName)==0 ) break;
17029 sqlite3StrAccumAppend(pAccum, pItem->zName, -1);
20915 const char *zName, /* Name of the file */
20933 if( !zName ){
20938 zName = zTmpname;
20975 os2FullPathname( pVfs, zName, CCHMAXPATH, pathUtf8 );
20988 zNameCp = convertUtf8PathToCp( zName );
20999 OSTRACE7( "OPEN Invalid handle rc=%d: zName=%s, ulAction=%#lx, ulAttr=%#lx, ulFlags=%#lx, ulMode=%#lx\n",
21000 rc, zName, ulAction, ulFileAttribute, ulOpenFlags, ulOpenMode );
21006 return os2Open( pVfs, zName, id,
21265 "os2", /* zName */
25393 const char *zName = zPath;
25409 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
25410 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
25411 zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
25424 pUnused = findReusableFd(zName, flags);
25434 }else if( !zName ){
25435 /* If zName is NULL, the upper layer is requesting a temp file. */
25441 zName = zTmpname;
25456 fd = open(zName, openFlags, openMode);
25457 OSTRACE4("OPENX %-3d %s 0%o\n", fd, zName, openFlags);
25464 fd = open(zName, openFlags, openMode);
25483 zPath = zName;
25485 unlink(zName);
27030 VFSNAME, /* zName */ \
27669 WCHAR *zName = utf8ToUnicode(zFilename);
27677 zTok = CharLowerW(zName);
27683 pFile->hMutex = CreateMutexW(NULL, FALSE, zName);
27686 free(zName);
27697 CharUpperW(zName);
27700 zName);
27708 free(zName);
28628 const char *zName, /* Name of the file (UTF-8) */
28643 const char *zUtf8Name = zName; /* Filename in UTF-8 encoding */
28733 return winOpen(pVfs, zName, id,
28754 && !winceCreateLock(zName, pFile)
29217 "win32", /* zName */
48288 int n = sqlite3Strlen30(pColl->zName);
48297 memcpy(&zTemp[i], pColl->zName,n+1);
48311 sqlite3_snprintf(nTemp, zTemp, "collseq(%.20s)", pColl->zName);
48316 sqlite3_snprintf(nTemp, zTemp, "%s(%d)", pDef->zName, pDef->nArg);
49011 ** zName must be a pointer to a nul terminated string.
49017 ** to by zName will be freed by sqlite3DbFree() when the vdbe is destroyed.
49021 int idx, /* Index of column zName applies to */
49023 const char *zName, /* Pointer to buffer containing name */
49024 void (*xDel)(void*) /* Memory management strategy for zName */
49031 assert( !zName || xDel!=SQLITE_DYNAMIC );
49036 rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, xDel);
49037 assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 );
51028 const char *zName = context->pFunc->zName;
51032 "unable to use function %s in the requested context", zName);
51689 SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){
51695 if( zName ){
51698 if( z && memcmp(z,zName,nName)==0 && z[nName]==0 ){
51705 SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
51706 return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName));
52708 char *zName; /* Name of savepoint */
54961 char *zName; /* Name of savepoint */
54971 u.aq.zName = pOp->p4.z;
54990 u.aq.nName = sqlite3Strlen30(u.aq.zName);
54995 u.aq.pNew->zName = (char *)&u.aq.pNew[1];
54996 memcpy(u.aq.pNew->zName, u.aq.zName, u.aq.nName+1);
55020 u.aq.pSavepoint && sqlite3StrICmp(u.aq.pSavepoint->zName, u.aq.zName);
55026 sqlite3SetString(&p->zErrMsg, db, "no such savepoint: %s", u.aq.zName);
56327 u.bf.zDb = db->aDb[u.bf.pC->iDb].zName;
56395 const char *zDb = db->aDb[u.bg.pC->iDb].zName;
57088 db->aDb[u.bu.iDb].zName, u.bu.zMaster, pOp->p4.z);
58048 ** in register P1 is passed as the zName argument to the xRename method.
58421 if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
58495 sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT);
58874 const char *zName, /* Name of the journal file */
58887 return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0);
58892 p->zJournal = zName;
59477 assert( pTab!=0 && pTab->zName!=0 );
59485 char *zTabName = pTab->zName;
59489 if( zDb!=0 && sqlite3StrICmp(db->aDb[iDb].zName, zDb)!=0 ){
59501 if( sqlite3StrICmp(pCol->zName, zCol)==0 ){
59522 if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ){
59558 if( sqlite3StrICmp(pCol->zName, zCol)==0 ){
59612 char *zAs = pEList->a[j].zName;
59849 auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0, pDef->zName, 0);
59853 pDef->zName);
59942 char *zAs = pEList->a[i].zName;
60307 if( pItem->zName ) pParse->zAuthContext = pItem->zName;
61371 pItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
61403 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
61437 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
61521 ** Set the ExprList.a[].zName element of the most recently added item
61539 assert( pItem->zName==0 );
61540 pItem->zName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n);
61541 if( dequote && pItem->zName ) sqlite3Dequote(pItem->zName);
61598 sqlite3DbFree(db, pItem->zName);
61961 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
62009 VdbeComment((v, "%s", pIdx->zName));
63255 (pExpr->iColumn<0 ? "rowid" : pExpr->pTab->aCol[pExpr->iColumn].zName),
64531 zWhere = whereOrName(pParse->db, zWhere, p->pFrom->zName);
64557 zWhere = whereOrName(db, zWhere, pTrig->zName);
64567 ** Argument zName is the name of the table in the database schema at
64569 ** pTab->zName if this function is being called to code part of an
64572 static void reloadTableSchema(Parse *pParse, Table *pTab, const char *zName){
64591 sqlite3VdbeAddOp4(v, OP_DropTrigger, iTrigDb, 0, 0, pTrig->zName, 0);
64596 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
64599 zWhere = sqlite3MPrintf(pParse->db, "tbl_name=%Q", zName);
64625 char *zName = 0; /* NULL-terminated version of pName */
64639 pTab = sqlite3LocateTable(pParse, 0, pSrc->a[0].zName, pSrc->a[0].zDatabase);
64642 zDb = db->aDb[iDb].zName;
64645 zName = sqlite3NameFromToken(db, pName);
64646 if( !zName ) goto exit_rename_table;
64648 /* Check that a table or index named 'zName' does not already exist
64651 if( sqlite3FindTable(db, zName, zDb) || sqlite3FindIndex(db, zName, zDb) ){
64653 "there is already another table or index with this name: %s", zName);
64660 if( sqlite3Strlen30(pTab->zName)>6
64661 && 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7)
64663 sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName);
64666 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
64672 sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
64679 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
64716 sqlite3VdbeAddOp4(v, OP_String8, 0, i, 0, zName, 0);
64722 /* figure out how many UTF-8 characters are in zName */
64723 zTabName = pTab->zName;
64735 "WHERE %s;", zTabName, zName, zWhere);
64759 zDb, SCHEMA_TABLE(iDb), zName, zName, zName,
64761 zName,
64763 zName, nTabName, zTabName
64773 zDb, zName, pTab->zName);
64787 "WHERE %s;", zName, zName, zWhere);
64798 reloadTableSchema(pParse, p->pFrom, pFrom->zName);
64805 reloadTableSchema(pParse, pTab, zName);
64809 sqlite3DbFree(db, zName);
64864 zDb = db->aDb[iDb].zName;
64865 zTab = &pNew->zName[16]; /* Skip the "sqlite_altertab_" prefix on the name */
64873 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
64949 reloadTableSchema(pParse, pTab, pTab->zName);
64980 pTab = sqlite3LocateTable(pParse, 0, pSrc->a[0].zName, pSrc->a[0].zDatabase);
65016 pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
65017 if( !pNew->aCol || !pNew->zName ){
65024 pCol->zName = sqlite3DbStrDup(db, pCol->zName);
65086 const char *zName;
65108 const char *zTab = aTable[i].zName;
65110 if( (pStat = sqlite3FindTable(db, zTab, pDb->zName))==0 ){
65116 "CREATE TABLE %Q.%s(%s)", pDb->zName, zTab, aTable[i].zCols
65128 "DELETE FROM %Q.%s WHERE tbl=%Q", pDb->zName, zTab, zWhere
65189 if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,
65190 db->aDb[iDb].zName ) ){
65196 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
65211 VdbeComment((v, "%s", pIdx->zName));
65215 sqlite3VdbeAddOp4(v, OP_String8, 0, regTabname, 0, pTab->zName, 0);
65217 sqlite3VdbeAddOp4(v, OP_String8, 0, regIdxname, 0, pIdx->zName, 0);
65417 openStatTable(pParse, iDb, iStatCur, pTab->zName);
65475 zDb = db->aDb[iDb].zName;
65597 sInfo.zDatabase = db->aDb[iDb].zName;
65764 const char *zName;
65772 zName = (const char *)sqlite3_value_text(argv[1]);
65774 if( zName==0 ) zName = "";
65793 char *z = db->aDb[i].zName;
65794 assert( z && zName );
65795 if( sqlite3StrICmp(z, zName)==0 ){
65796 zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName);
65842 aNew->zName = sqlite3DbStrDup(db, zName);
65843 if( rc==SQLITE_OK && aNew->zName==0 ){
65932 const char *zName = (const char *)sqlite3_value_text(argv[0]);
65940 if( zName==0 ) zName = "";
65944 if( sqlite3StrICmp(pDb->zName, zName)==0 ) break;
65948 sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
65952 sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
65961 sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
66061 "sqlite_detach", /* zName */
66082 "sqlite_attach", /* zName */
66109 pFix->zDb = db->aDb[iDb].zName;
66340 char *zDb = db->aDb[iDb].zName; /* Name of attached database */
66404 zCol = pTab->aCol[iCol].zName;
66407 zCol = pTab->aCol[pTab->iPKey].zName;
66412 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
66528 const char *zName; /* Name of the table */
66546 const char *zName /* Name of the table to be locked */
66570 p->zName = zName;
66592 p->zName, P4_STATIC);
66749 SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){
66753 assert( zName!=0 );
66754 nName = sqlite3Strlen30(zName);
66757 if( zDatabase!=0 && sqlite3StrICmp(zDatabase, db->aDb[j].zName) ) continue;
66758 p = sqlite3HashFind(&db->aDb[j].pSchema->tblHash, zName, nName);
66777 const char *zName, /* Name of the table we are looking for */
66788 p = sqlite3FindTable(pParse->db, zName, zDbase);
66792 sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
66794 sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
66813 SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){
66816 int nName = sqlite3Strlen30(zName);
66821 if( zDb && sqlite3StrICmp(zDb, db->aDb[j].zName) ) continue;
66822 p = sqlite3HashFind(&pSchema->idxHash, zName, nName);
66850 const char *zName = p->zName;
66852 pOld = sqlite3HashInsert(&p->pSchema->idxHash, zName,
66853 sqlite3Strlen30(zName), 0);
66929 sqlite3DbFree(db, pDb->zName);
66930 pDb->zName = 0;
66965 sqlite3DbFree(db, pCol->zName);
67015 sqlite3DbFree(db, pTable->zName);
67058 char *zName;
67060 zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n);
67061 sqlite3Dequote(zName);
67063 zName = 0;
67065 return zName;
67083 ** Parameter zName points to a nul-terminated buffer containing the name
67088 SQLITE_PRIVATE int sqlite3FindDbName(sqlite3 *db, const char *zName){
67090 if( zName ){
67092 int n = sqlite3Strlen30(zName);
67094 if( (!OMIT_TEMPDB || i!=1 ) && n==sqlite3Strlen30(pDb->zName) &&
67095 0==sqlite3StrICmp(pDb->zName, zName) ){
67111 char *zName; /* Name we are searching for */
67112 zName = sqlite3NameFromToken(db, pName);
67113 i = sqlite3FindDbName(db, zName);
67114 sqlite3DbFree(db, zName);
67165 ** This routine is used to check if the UTF-8 string zName is a legal
67171 SQLITE_PRIVATE int sqlite3CheckObjectName(Parse *pParse, const char *zName){
67174 && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){
67175 sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s", zName);
67207 char *zName = 0; /* The name of the new table */
67240 zName = sqlite3NameFromToken(db, pName);
67241 if( zName==0 ) return;
67242 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
67250 char *zDb = db->aDb[iDb].zName;
67267 if( !isVirtual && sqlite3AuthCheck(pParse, code, zName, 0, zDb) ){
67284 pTable = sqlite3FindTable(db, zName, db->aDb[iDb].zName);
67291 if( sqlite3FindIndex(db, zName, 0)!=0 && (iDb==0 || !db->init.busy) ){
67292 sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
67304 pTable->zName = zName;
67317 if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){
67389 sqlite3DbFree(db, zName);
67423 sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
67430 if( STRICMP(z, p->aCol[i].zName) ){
67447 pCol->zName = z;
67571 pCol->zName);
67618 "table \"%s\" has more than one primary key", pTab->zName);
67628 if( sqlite3StrICmp(pList->a[i].zName, pTab->aCol[iCol].zName)==0 ){
67722 ** encoding identified by the string zName, length nName.
67740 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){
67746 pColl = sqlite3FindCollSeq(db, enc, zName, initbusy);
67748 pColl = sqlite3GetCollSeq(db, enc, pColl, zName);
67750 sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);
67847 n += identLength(pCol->zName) + 5;
67849 n += identLength(p->zName);
67867 identPut(zStmt, &k, p->zName);
67883 identPut(zStmt, &k, pCol->zName);
67954 sSrc.a[0].zName = p->zName;
68063 db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
68065 p->zName,
68066 p->zName,
68083 pDb->zName
68091 sqlite3MPrintf(db, "tbl_name='%q'",p->zName), P4_DYNAMIC);
68100 pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName,
68101 sqlite3Strlen30(p->zName),p);
68113 const char *zName = (const char *)pParse->sNameToken.z;
68119 nName = (int)((const char *)pCons->z - zName);
68120 p->addColOffset = 13 + sqlite3Utf8CharLen(zName, nName);
68249 sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
68381 pParse->db->aDb[iDb].zName, SCHEMA_TABLE(iDb), iTable, r1, r1);
68462 zName, pName->a[0].zDatabase);
68481 const char *zDb = db->aDb[iDb].zName;
68495 zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
68504 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
68507 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
68512 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
68513 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
68522 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
68526 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
68568 pDb->zName, pTab->zName
68582 pDb->zName, SCHEMA_TABLE(iDb), pTab->zName);
68585 if( sqlite3FindTable(db, "sqlite_stat1", db->aDb[iDb].zName) ){
68587 "DELETE FROM %Q.sqlite_stat1 WHERE tbl=%Q", pDb->zName, pTab->zName
68599 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
68601 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
68651 p->aCol[iCol].zName, pTo);
68666 nByte += sqlite3Strlen30(pToCol->a[i].zName) + 1;
68688 if( sqlite3StrICmp(p->aCol[j].zName, pFromCol->a[i].zName)==0 ){
68696 pFromCol->a[i].zName);
68703 int n = sqlite3Strlen30(pToCol->a[i].zName);
68705 memcpy(z, pToCol->a[i].zName, n);
68781 if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
68782 db->aDb[iDb].zName ) ){
68788 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
68866 char *zName = 0; /* Name of the index */
68867 int nName; /* Number of characters in zName */
68923 pTab = sqlite3LocateTable(pParse, 0, pTblName->a[0].zName,
68937 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
68938 && memcmp(&pTab->zName[7],"altertab_",9)!=0 ){
68939 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
68969 zName = sqlite3NameFromToken(db, pName);
68970 if( zName==0 ) goto exit_create_index;
68971 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
68975 if( sqlite3FindTable(db, zName, 0)!=0 ){
68976 sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
68980 if( sqlite3FindIndex(db, zName, pDb->zName)!=0 ){
68982 sqlite3ErrorMsg(pParse, "index %s already exists", zName);
68990 zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
68991 if( zName==0 ){
69000 const char *zDb = pDb->zName;
69006 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
69017 nullId.z = pTab->aCol[pTab->nCol-1].zName;
69035 nExtra += (1 + sqlite3Strlen30(pColl->zName));
69043 nName = sqlite3Strlen30(zName);
69051 nName + 1 + /* Index.zName */
69061 pIndex->zName = (char *)(&pIndex->aSortOrder[nCol]);
69062 zExtra = (char *)(&pIndex->zName[nName+1]);
69063 memcpy(pIndex->zName, zName, nName+1);
69089 const char *zColName = pListItem->zName;
69095 if( sqlite3StrICmp(zColName, pTabCol->zName)==0 ) break;
69099 pTab->zName, zColName);
69110 zColl = pListItem->pExpr->pColl->zName;
69120 zColl = db->pDfltColl->zName;
69198 pIndex->zName, sqlite3Strlen30(pIndex->zName),
69260 db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
69261 pIndex->zName,
69262 pTab->zName,
69275 sqlite3MPrintf(db, "name='%q'", pIndex->zName), P4_DYNAMIC);
69311 sqlite3DbFree(db, zName);
69368 pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
69386 const char *zDb = db->aDb[iDb].zName;
69392 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
69404 db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
69405 pIndex->zName
69407 if( sqlite3FindTable(db, "sqlite_stat1", db->aDb[iDb].zName) ){
69410 db->aDb[iDb].zName, pIndex->zName
69415 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
69492 pList->a[i].zName = sqlite3NameFromToken(db, pToken);
69503 sqlite3DbFree(db, pList->a[i].zName);
69513 SQLITE_PRIVATE int sqlite3IdListIndex(IdList *pList, const char *zName){
69517 if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
69601 ** The SrcList.a[].zName field is filled with the table name which might
69650 pItem->zName = sqlite3NameFromToken(db, pTable);
69682 sqlite3DbFree(db, pItem->zName);
69864 char *zName = sqlite3NameFromToken(pParse->db, pName);
69865 if( zName ){
69871 if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
69872 sqlite3DbFree(pParse->db, zName);
69875 sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
70133 zDb = db->aDb[iDb].zName;
70209 ** in the encoding enc of name zName, length nName.
70211 static void callCollNeeded(sqlite3 *db, int enc, const char *zName){
70214 char *zExternal = sqlite3DbStrDup(db, zName);
70223 sqlite3ValueSetStr(pTmp, -1, zName, SQLITE_UTF8, SQLITE_STATIC);
70242 char *z = pColl->zName;
70262 ** collation sequence with name zName, length nName.
70265 ** db for collation type name zName, length nName, or NULL, if no collation
70274 const char *zName /* Collating sequence name */
70280 p = sqlite3FindCollSeq(db, enc, zName, 0);
70286 callCollNeeded(db, enc, zName);
70287 p = sqlite3FindCollSeq(db, enc, zName, 0);
70309 const char *zName = pColl->zName;
70311 CollSeq *p = sqlite3GetCollSeq(db, ENC(db), pColl, zName);
70313 sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);
70326 ** specified by zName and nName is not found and parameter 'create' is
70339 const char *zName, /* Name of the collating sequence */
70343 int nName = sqlite3Strlen30(zName);
70344 pColl = sqlite3HashFind(&db->aCollSeq, zName, nName);
70350 pColl[0].zName = (char*)&pColl[3];
70352 pColl[1].zName = (char*)&pColl[3];
70354 pColl[2].zName = (char*)&pColl[3];
70356 memcpy(pColl[0].zName, zName, nName);
70357 pColl[0].zName[nName] = 0;
70358 pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, nName, pColl);
70376 ** Parameter zName points to a UTF-8 encoded string nName bytes long.
70377 ** Return the CollSeq* pointer for the collation sequence named zName
70393 const char *zName,
70397 zName ){
70398 pColl = findCollSeqEntry(db, zName, create);
70461 if( sqlite3StrNICmp(p->zName, zFunc, nFunc)==0 && p->zName[nFunc]==0 ){
70476 int nName = sqlite3Strlen30(pDef->zName);
70477 u8 c1 = (u8)pDef->zName[0];
70479 pOther = functionSearch(pHash, h, pDef->zName, nName);
70515 const char *zName, /* Name of the function. Not null-terminated */
70528 h = (sqlite3UpperToLower[(u8)zName[0]] + nName) % ArraySize(db->aFunc.a);
70532 p = functionSearch(&db->aFunc, h, zName, nName);
70552 p = functionSearch(pHash, h, zName, nName);
70569 pBest->zName = (char *)&pBest[1];
70572 memcpy(pBest->zName, zName, nName);
70573 pBest->zName[nName] = 0;
70666 pTab = sqlite3LocateTable(pParse, 0, pItem->zName, pItem->zDatabase);
70700 sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
70706 sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
70738 pFrom->a[0].zAlias = sqlite3DbStrDup(db, pView->zName);
70920 zDb = db->aDb[iDb].zName;
70921 rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb);
70939 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
70987 pTab->zName, P4_STATIC);
71181 sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_STATIC);
72644 static void setLikeOptFlag(sqlite3 *db, const char *zName, u8 flagVal){
72646 pDef = sqlite3FindFunction(db, zName, sqlite3Strlen30(zName),
73019 if( !sqlite3StrICmp(pParent->aCol[pParent->iPKey].zName, zKey) ) return 0;
73065 zIdxCol = pParent->aCol[iCol].zName;
73317 zCol = pFKey->pFrom->aCol[iCol].zName;
73384 int nName = sqlite3Strlen30(pTab->zName);
73385 return (FKey *)sqlite3HashFind(&pTab->pSchema->fkeyHash, pTab->zName, nName);
73506 zDb = db->aDb[iDb].zName;
73550 char *zCol = pTo->aCol[pIdx ? pIdx->aiColumn[i] : pTo->iPKey].zName;
73551 rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
73560 sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
73604 pItem->zName = pFKey->pFrom->zName;
73620 pItem->zName = 0;
73703 if( (zKey ? !sqlite3StrICmp(pCol->zName, zKey) : pCol->isPrimKey) ){
73784 tToCol.z = pIdx ? pTab->aCol[pIdx->aiColumn[i]].zName : "oid";
73785 tFromCol.z = pFKey->pFrom->aCol[iFromCol].zName;
73845 zFrom = pFKey->pFrom->zName;
74027 sqlite3TableLock(p, iDb, pTab->tnum, (opcode==OP_OpenWrite)?1:0, pTab->zName);
74030 VdbeComment((v, "%s", pTab->zName));
74238 sqlite3VdbeAddOp4(v, OP_String8, 0, memId-1, 0, p->pTab->zName, 0);
74483 zTab = pTabList->a[0].zName;
74492 zDb = pDb->zName;
74493 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb) ){
74712 if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){
74721 if( sqlite3IsRowid(pColumn->a[i].zName) ){
74725 pTabList, 0, pColumn->a[i].zName);
75190 pTab->zName, pTab->aCol[i].zName);
75355 char *zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
75452 sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_STATIC);
75485 VdbeComment((v, "%s", pIdx->zName));
75670 pSrc = sqlite3LocateTable(pParse, 0, pItem->zName, pItem->zDatabase);
75774 sqlite3VdbeChangeP4(v, -1, pDest->zName, 0);
75786 VdbeComment((v, "%s", pSrcIdx->zName));
75790 VdbeComment((v, "%s", pDestIdx->zName));
76022 int (*bind_parameter_index)(sqlite3_stmt*,const char*zName);
77116 const char *zName; /* Name of the pragma */
77152 if( sqlite3StrICmp(zLeft, p->zName)==0 ){
77159 returnSingleInt(pParse, p->zName, (db->flags & p->mask)!=0 );
77194 const char *zName;
77196 case OE_SetNull: zName = "SET NULL"; break;
77197 case OE_SetDflt: zName = "SET DEFAULT"; break;
77198 case OE_Cascade: zName = "CASCADE"; break;
77199 case OE_Restrict: zName = "RESTRICT"; break;
77200 default: zName = "NO ACTION";
77203 return zName;
77263 zDb = pId2->n>0 ? pDb->zName : 0;
77807 sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pCol->zName, 0);
77840 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pTab->aCol[cnum].zName, 0);
77863 sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pIdx->zName, 0);
77883 assert( db->aDb[i].zName!=0 );
77885 sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, db->aDb[i].zName, 0);
77902 sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pColl->zName, 0);
77939 pTab->aCol[pFK->aCol[j].iFrom].zName, 0);
78058 sqlite3MPrintf(db, "*** in database %s ***\n", db->aDb[i].zName),
78101 sqlite3VdbeChangeP4(v, addr+4, pIdx->zName, P4_STATIC);
78131 sqlite3VdbeChangeP4(v, addr+7, pIdx->zName, P4_STATIC);
78167 char *zName;
78189 sqlite3VdbeChangeP4(v, -1, encnames[ENC(pParse->db)].zName, P4_STATIC);
78201 for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
78202 if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){
78207 if( !pEnc->zName ){
78306 if( db->aDb[i].zName==0 ) continue;
78307 sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, db->aDb[i].zName, P4_STATIC);
78311 }else if( sqlite3_file_control(db, i ? db->aDb[i].zName : 0,
78490 pIndex = sqlite3FindIndex(db, argv[0], db->aDb[iDb].zName);
78582 pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName);
78699 db->aDb[iDb].zName, zMasterName);
78953 const char *zDb = db->aDb[i].zName;
79427 if( sqlite3StrICmp(pTab->aCol[i].zName, zCol)==0 ) return i;
79587 char *zName; /* Name of column in the right table */
79591 zName = pRightTab->aCol[j].zName;
79592 if( tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol) ){
79626 char *zName; /* Name of the term in the USING clause */
79631 zName = pList->a[j].zName;
79632 iRightCol = columnIndex(pRightTab, zName);
79634 || !tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol)
79637 "not present in both tables", zName);
80222 zOriginCol = pTab->aCol[iCol].zName;
80224 zOriginTab = pTab->zName;
80227 zOriginDb = pNC->pParse->db->aDb[iDb].zName;
80330 if( pEList->a[i].zName ){
80331 char *zName = pEList->a[i].zName;
80332 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_TRANSIENT);
80347 zCol = pTab->aCol[iCol].zName;
80353 char *zName = 0;
80354 zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol);
80355 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_DYNAMIC);
80408 char *zName; /* Column name */
80409 int nName; /* Size of name in zName[] */
80420 if( (zName = pEList->a[i].zName)!=0 ){
80422 zName = sqlite3DbStrDup(db, zName);
80432 zName = sqlite3MPrintf(db, "%s",
80433 iCol>=0 ? pTab->aCol[iCol].zName : "rowid");
80436 zName = sqlite3MPrintf(db, "%s", pColExpr->u.zToken);
80439 zName = sqlite3MPrintf(db, "%s", pEList->a[i].zSpan);
80443 sqlite3DbFree(db, zName);
80450 nName = sqlite3Strlen30(zName);
80452 if( sqlite3StrICmp(aCol[j].zName, zName)==0 ){
80454 zName[nName] = 0;
80455 zNewName = sqlite3MPrintf(db, "%s:%d", zName, ++cnt);
80456 sqlite3DbFree(db, zName);
80457 zName = zNewName;
80459 if( zName==0 ) break;
80462 pCol->zName = zName;
80466 sqlite3DbFree(db, aCol[j].zName);
80515 pCol->zColl = sqlite3DbStrDup(db, pColl->zName);
80545 pTab->zName = 0;
81941 pParse->zAuthContext = pSubitem->zName;
82012 sqlite3DbFree(db, pSubitem->zName);
82015 pSubitem->zName = 0;
82116 if( pList->a[i].zName==0 ){
82119 pList->a[i].zName = sqlite3DbStrDup(db, zSpan);
82258 pIdx && sqlite3StrICmp(pIdx->zName, zIndex);
82329 if( pFrom->zName==0 ){
82340 pTab->zName = sqlite3MPrintf(db, "sqlite_subquery_%p_", (void*)pTab);
82350 sqlite3LocateTable(pParse,0,pFrom->zName,pFrom->zDatabase);
82413 pNew->a[pNew->nExpr-1].zName = a[k].zName;
82415 a[k].zName = 0;
82435 zTabName = pTab->zName;
82444 char *zName = pTab->aCol[j].zName;
82460 && tableAndColumnIndex(pTabList, i, zName, 0, 0)
82466 if( sqlite3IdListIndex(pFrom->pUsing, zName)>=0 ){
82472 pRight = sqlite3Expr(db, TK_ID, zName);
82473 zColname = zName;
82480 zColname = sqlite3MPrintf(db, "%s.%s", zTabName, zName);
83299 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
83487 }else if( pItem->zName ){
83488 sqlite3DebugPrintf("%s", pItem->zName);
83491 sqlite3DebugPrintf("(table: %s)", pItem->pTab->zName);
83784 && 0==sqlite3StrICmp(pTrig->table, pTab->zName)
83817 char *zName = 0; /* Name of the trigger */
83887 zName = sqlite3NameFromToken(db, pName);
83888 if( !zName || SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
83892 zName, sqlite3Strlen30(zName)) ){
83900 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
83924 const char *zDb = db->aDb[iTabDb].zName;
83925 const char *zDbTrig = isTemp ? db->aDb[1].zName : zDb;
83927 if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
83948 pTrigger->zName = zName;
83949 zName = 0;
83950 pTrigger->table = sqlite3DbStrDup(db, pTableName->a[0].zName);
83961 sqlite3DbFree(db, zName);
83982 char *zName; /* Name of trigger */
83991 zName = pTrig->zName;
83998 nameToken.z = pTrig->zName;
84019 db->aDb[iDb].zName, SCHEMA_TABLE(iDb), zName,
84024 db, "type='trigger' AND name='%q'", zName), P4_DYNAMIC
84031 pTrig = sqlite3HashInsert(pHash, zName, sqlite3Strlen30(zName), pTrig);
84180 sqlite3DbFree(db, pTrigger->zName);
84199 const char *zName;
84210 zName = pName->a[0].zName;
84211 nName = sqlite3Strlen30(zName);
84214 if( zDb && sqlite3StrICmp(db->aDb[j].zName, zDb) ) continue;
84215 pTrigger = sqlite3HashFind(&(db->aDb[j].pSchema->trigHash), zName, nName);
84257 const char *zDb = db->aDb[iDb].zName;
84260 if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) ||
84287 sqlite3VdbeChangeP4(v, base+1, pTrigger->zName, 0);
84291 sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
84301 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){
84304 pTrigger = sqlite3HashInsert(pHash, zName, sqlite3Strlen30(zName), 0);
84330 if( sqlite3IdListIndex(pIdList, pEList->a[e].zName)>=0 ) return 1;
84388 pSrc->a[pSrc->nSrc-1].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zName);
84524 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
84550 pSubParse->zAuthContext = pTrigger->zName;
84556 pTrigger->zName, onErrorText(orconf),
84561 pTab->zName
84565 sqlite3MPrintf(db, "-- TRIGGER %s", pTrigger->zName), P4_DYNAMIC
84591 VdbeComment((v, "End: %s.%s", pTrigger->zName, onErrorText(orconf)));
84627 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
84672 (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf)));
84679 sqlite3VdbeChangeP5(v, (u8)(p->zName && !(pParse->db->flags&SQLITE_RecTriggers)));
84882 VdbeComment((v, "%s.%s", pTab->zName, pCol->zName));
85016 if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zName)==0 ){
85026 if( sqlite3IsRowid(pChanges->a[i].zName) ){
85030 sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zName);
85037 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
85038 pTab->aCol[j].zName, db->aDb[iDb].zName);
85108 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
85445 pExpr = sqlite3Expr(db, TK_ID, pTab->aCol[i].zName);
85632 assert( strcmp(db->aDb[db->nDb-1].zName,"vacuum_db")==0 );
85836 const char *zName, /* Name assigned to this module */
85845 nName = sqlite3Strlen30(zName);
85850 memcpy(zCopy, zName, nName+1);
85851 pMod->zName = zCopy;
85878 const char *zName, /* Name assigned to this module */
85882 return createModule(db, zName, pModule, pAux, 0);
85890 const char *zName, /* Name assigned to this module */
85895 return createModule(db, zName, pModule, pAux, xDestroy);
86100 addModuleArgument(db, pTable, sqlite3DbStrDup(db, db->aDb[iDb].zName));
86101 addModuleArgument(db, pTable, sqlite3DbStrDup(db, pTable->zName));
86111 sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName,
86112 pTable->azModuleArg[0], pParse->db->aDb[iDb].zName);
86175 db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
86176 pTab->zName,
86177 pTab->zName,
86186 zWhere = sqlite3MPrintf(db, "name='%q'", pTab->zName);
86189 pTab->zName, sqlite3Strlen30(pTab->zName) + 1);
86200 const char *zName = pTab->zName;
86201 int nName = sqlite3Strlen30(zName);
86202 pOld = sqlite3HashInsert(&pSchema->tblHash, zName, nName, pTab);
86255 char *zModuleName = sqlite3MPrintf(db, "%s", pTab->zName);
86292 *pzErr = sqlite3MPrintf(db, zFormat, pTab->zName);
86418 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
86517 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName
86699 zLowerName = sqlite3DbStrDup(db, pDef->zName);
86714 + sqlite3Strlen30(pDef->zName) + 1);
86719 pNew->zName = (char *)&pNew[1];
86720 memcpy(pNew->zName, pDef->zName, sqlite3Strlen30(pDef->zName)+1);
87342 if( pColl && sqlite3StrICmp(pColl->zName, pIdx->azColl[j]) ) continue;
88141 assert( pIdx->zName || (pIdx->nColumn==1 && pIdx->aiColumn[0]==-1) );
88169 if( pIdx->zName && i<pIdx->nColumn ){
88179 zColl = pColl->zName;
88181 if( pExpr->iColumn!=iColumn || sqlite3StrICmp(pColl->zName, zColl) ){
88412 WHERETRACE(("Recomputing index info for %s...\n", pSrc->pTab->zName));
88515 WHERETRACE(("xBestIndex for %s\n", pTab->zName));
88535 "table %s: xBestIndex returned an invalid plan", pTab->zName);
89229 pSrc->pTab->zName, (pIdx ? pIdx->zName : "ipk"),
89271 (pCost->plan.u.pIdx ? pCost->plan.u.pIdx->zName : "ipk")
90562 sqlite3ErrorMsg(pParse, "cannot use index: %s", pIdx->zName);
90607 zMsg = sqlite3MPrintf(db, "TABLE %s", pItem->zName);
90613 zMsg, pLevel->plan.u.pIdx->zName);
90656 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
90667 VdbeComment((v, "%s", pIx->zName));
90696 if( z==0 ) z = pTabItem->pTab->zName;
90714 n = sqlite3Strlen30(pLevel->plan.u.pIdx->zName);
90716 memcpy(&sqlite3_query_plan[nQPlan], pLevel->plan.u.pIdx->zName, n);
96528 const char *zName,
96531 int nName = sqlite3Strlen30(zName);
96534 if( sqlite3FindFunction(db, zName, nName, nArg, SQLITE_UTF8, 0)==0 ){
96535 sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8,
96825 ** Create a new collating function for database "db". The name is zName
96830 const char *zName,
96839 int nName = sqlite3Strlen30(zName);
96861 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0);
96877 CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName, nName);
96891 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 1);
97126 db->aDb[0].zName = "main";
97128 db->aDb[1].zName = "temp";
97299 const char *zName,
97307 rc = createCollation(db, zName, (u8)enc, SQLITE_COLL_USER, pCtx, xCompare, 0);
97318 const char *zName,
97327 rc = createCollation(db, zName, (u8)enc, SQLITE_COLL_USER, pCtx, xCompare, xDel);
97339 const void *zName,
97348 zName8 = sqlite3Utf16to8(db, zName, -1);
97512 if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){
97610 if( strcmp(db->aDb[iDb].zName, zDbName)==0 ) break;
98811 const char *zName; /* virtual table name */
99179 p->zDb, p->zName, p->zDb, p->zName, p->zDb, p->zName
99219 "CREATE TABLE x(%s %Q HIDDEN, docid HIDDEN)", zCols, p->zName
99264 p->zDb, p->zName, zContentCols, p->zDb, p->zName, p->zDb, p->zName
99344 nName + /* zName */
99365 /* Fill in the zName and zDb fields of the vtab structure. */
99366 p->zName = zCsr;
100609 zSql = sqlite3_mprintf(azSql[idxNum==FTS3_FULLSCAN_SEARCH], p->zDb, p->zName);
101009 const char *zName, /* Name of SQL function */
101014 const char *zName;
101030 if( strcmp(zName, aOverload[i].zName)==0 ){
101045 const char *zName /* New name of table */
101055 , p->zDb, p->zName, zName
101056 , p->zDb, p->zName, zName
101057 , p->zDb, p->zName, zName
101959 const char *zName,
101972 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
103211 const unsigned char *zName;
103218 zName = sqlite3_value_text(argv[0]);
103229 pOld = sqlite3Fts3HashInsert(pHash, (void *)zName, nName, pPtr);
103235 pPtr = sqlite3Fts3HashFind(pHash, zName, nName);
103237 char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
103409 const char *zName;
103427 zName = (const char *)sqlite3_value_text(argv[0]);
103436 p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
103439 char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
103488 char *zName,
103500 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
103510 char *zName,
103523 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
103602 ** The third argument to this function, zName, is used as the name
103608 const char *zName
103618 zTest = sqlite3_mprintf("%s_test", zName);
103619 zTest2 = sqlite3_mprintf("%s_internal_test", zName);
103626 || SQLITE_OK!=(rc = sqlite3_create_function(db, zName, 1, any, p, scalarFunc, 0, 0))
103627 || SQLITE_OK!=(rc = sqlite3_create_function(db, zName, 2, any, p, scalarFunc, 0, 0))
104090 zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName, zVarlist);
104092 zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName);
104782 "ORDER BY blockid", p->zDb, p->zName
107641 char *zName; /* Name of r-tree table */
108221 pRtree->zDb, pRtree->zName,
108222 pRtree->zDb, pRtree->zName,
108223 pRtree->zDb, pRtree->zName
110056 , pRtree->zDb, pRtree->zName, zNewName
110057 , pRtree->zDb, pRtree->zName, zNewName
110058 , pRtree->zDb, pRtree->zName, zNewName
110243 pRtree->zName = &pRtree->zDb[nDb+1];
110248 memcpy(pRtree->zName, argv[2], nName);
110610 const char *zName, /* Name of ICU function that failed */
110614 sqlite3_snprintf(128, zBuf, "ICU error: %s(): %s", zName, u_errorName(e));
110821 const char *zName; /* SQL Collation sequence name (eg. "japanese") */
110827 zName = (const char *)sqlite3_value_text(apArg[1]);
110829 if( !zLocale || !zName ){
110840 rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator,
110854 const char *zName; /* Function name */
110884 db, p->zName, p->nArg, p->enc, p->pContext, p->xFunc, 0, 0
