Lines Matching defs:char
123 typedef unsigned char u8;
216 extern FILE *popen(const char*,const char*);
232 #define IsSpace(X) isspace((unsigned char)X)
233 #define IsDigit(X) isdigit((unsigned char)X)
234 #define ToLower(X) (char)tolower((unsigned char)X)
243 extern char *sqlite3_win32_unicode_to_utf8(LPCWSTR);
244 extern char *sqlite3_win32_mbcs_to_utf8_v2(const char *, int);
245 extern char *sqlite3_win32_utf8_to_mbcs_v2(const char *, int);
246 extern LPWSTR sqlite3_win32_utf8_to_unicode(const char *zText);
273 static int cli_strcmp(const char *a, const char *b){
278 static int cli_strncmp(const char *a, const char *b, size_t n){
482 static char *Argv0;
488 static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/
489 static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */
497 void utf8_printf(FILE *out, const char *zFormat, ...){
501 char *z1 = sqlite3_vmprintf(zFormat, ap);
502 char *z2 = sqlite3_win32_utf8_to_mbcs_v2(z1, 0);
550 static void SQLITE_CDECL iotracePrintf(const char *zFormat, ...){
552 char *z;
568 static void utf8_width_print(FILE *pOut, int w, const char *zUtf){
595 static int isNumber(const char *z, int *realnum){
623 static int strlen30(const char *z){
624 const char *z2 = z;
633 static int strlenChar(const char *z){
646 static FILE * openChrSource(const char *zFile){
684 static char *local_getline(char *zLine, FILE *in){
714 char *zTrans = sqlite3_win32_mbcs_to_utf8_v2(zLine, 0);
744 static char *one_input_line(FILE *in, char *zPrior, int isContinuation){
745 char *zPrompt;
746 char *zResult;
769 static int hexDigitValue(char c){
779 static sqlite3_int64 integerValue(const char *zArg){
781 static const struct { char *zSuffix; int iMult; } aMult[] = {
827 char *z;
851 static void appendText(ShellText *p, const char *zAppend, char quote){
871 char *zCsr = p->z+p->n;
895 static char quoteChar(const char *zName){
897 if( !isalpha((unsigned char)zName[0]) && zName[0]!='_' ) return '"';
899 if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ) return '"';
908 static char *shellFakeSchema(
910 const char *zSchema, /* Schema of the database holding the vtab */
911 const char *zName /* The name of the virtual table */
914 char *zSql;
916 char cQuote;
917 char *zDiv = "(";
935 const char *zCol = (const char*)sqlite3_column_text(pStmt, 1);
963 const char *zName;
964 char *zFake;
966 zName = (const char*)sqlite3_value_text(apVal[0]);
999 static const char *aPrefix[] = {
1008 const char *zIn = (const char*)sqlite3_value_text(apVal[0]);
1009 const char *zSchema = (const char*)sqlite3_value_text(apVal[1]);
1010 const char *zName = (const char*)sqlite3_value_text(apVal[2]);
1017 char *z = 0;
1018 char *zFake = 0;
1020 char cQuote = quoteChar(zSchema);
1174 char d_name[NAME_MAX + 1]; /* Name within the directory. */
1205 extern const char *windirent_getenv(const char *name);
1212 extern LPDIR opendir(const char *dirname);
1243 const char *windirent_getenv(
1244 const char *name
1246 static char value[32768]; /* Maximum length, per MSDN */
1247 DWORD dwSize = sizeof(value) / sizeof(char); /* Size in chars */
1271 const char *dirname
1599 unsigned char x[1600]; /* ... or 1600 bytes */
1945 if( 1==*(unsigned char*)&one ){
1962 const unsigned char *aData,
1968 if( (p->nLoaded % 8)==0 && ((aData - (const unsigned char*)0)&7)==0 ){
2000 static unsigned char *SHA3Final(SHA3Context *p){
2003 const unsigned char c1 = 0x86;
2006 const unsigned char c2 = 0x06;
2007 const unsigned char c3 = 0x80;
2063 const char *zFormat,
2068 char zBuf[50];
2073 SHA3Update(p, (unsigned char*)zBuf, n);
2114 const char *zSql = (const char*)sqlite3_value_text(argv[0]);
2120 const char *z;
2139 char *zMsg = sqlite3_mprintf("error SQL statement [%s]: %s",
2147 char *zMsg = sqlite3_mprintf("non-query: [%s]", sqlite3_sql(pStmt));
2158 SHA3Update(&cx,(unsigned char*)z,n);
2163 SHA3Update(&cx,(const unsigned char*)"R",1);
2167 SHA3Update(&cx, (const unsigned char*)"N",1);
2173 unsigned char x[9];
2187 unsigned char x[9];
2200 const unsigned char *z2 = sqlite3_column_text(pStmt, i);
2207 const unsigned char *z2 = sqlite3_column_blob(pStmt, i);
2226 char **pzErrMsg,
2299 const unsigned char *zA = (const unsigned char*)pKey1;
2300 const unsigned char *zB = (const unsigned char*)pKey2;
2340 char **pzErrMsg,
2383 char sign; /* 0 for positive, 1 for negative */
2384 char oom; /* True if an OOM is encountered */
2385 char isNull; /* True if holds a NULL rather than a number */
2386 char isInit; /* True upon initialization */
2389 signed char *a; /* Array of digits. Most significant first. */
2417 const unsigned char *zAlt
2421 const unsigned char *zIn;
2454 char c = zIn[i];
2533 char *z;
2734 signed char *aA, *aB;
2767 const unsigned char *zA = (const unsigned char*)pKey1;
2768 const unsigned char *zB = (const unsigned char*)pKey2;
2896 signed char *acc = 0;
2914 signed char f = pA->a[i];
2948 char **pzErrMsg,
2953 const char *zFuncName;
3099 char zResult[100];
3104 const unsigned char *x = sqlite3_value_blob(argv[0]);
3214 const unsigned char *x = sqlite3_value_blob(argv[0]);
3235 unsigned char a[sizeof(r)];
3252 char **pzErrMsg,
3256 char *zFName;
3393 int argcUnused, const char *const*argvUnused,
3395 char **pzErrUnused
3542 int idxNum, const char *idxStrUnused,
3728 char **pzErrMsg,
3846 static const char *ReOpName[] = {
3887 const unsigned char *z; /* All text */
3898 const char *zErr; /* Error message to return */
3899 char *aOp; /* Operators for the virtual machine */
3902 unsigned char zInit[12]; /* Initial text to match */
3970 static int re_match(ReCompiled *pRe, const unsigned char *zIn, int nIn){
3983 in.mx = nIn>=0 ? nIn : (int)strlen((char const*)zIn);
3987 unsigned char x = pRe->zInit[0];
3990 strncmp((const char*)zIn+in.i, (const char*)pRe->zInit, pRe->nInit)!=0)
4121 char *aOp;
4144 p->aOp[iBefore] = (char)op;
4187 static const char zEsc[] = "afnrtv\\()*.+?[$^{|}]";
4188 static const char zTrans[] = "\a\f\n\r\t\v";
4190 char c;
4194 const unsigned char *zIn = p->sIn.z + p->sIn.i;
4205 const unsigned char *zIn = p->sIn.z + p->sIn.i;
4224 static const char *re_subcompile_string(ReCompiled*);
4227 static unsigned char rePeek(ReCompiled *p){
4235 static const char *re_subcompile_re(ReCompiled *p){
4236 const char *zErr;
4257 static const char *re_subcompile_string(ReCompiled *p){
4261 const char *zErr;
4418 static const char *re_compile(ReCompiled **ppRe, const char *zIn, int noCase){
4420 const char *zErr;
4439 pRe->sIn.z = (unsigned char*)zIn;
4467 pRe->zInit[j++] = (unsigned char)x;
4469 pRe->zInit[j++] = (unsigned char)(0xc0 | (x>>6));
4472 pRe->zInit[j++] = (unsigned char)(0xe0 | (x>>12));
4500 const char *zPattern; /* The regular expression */
4501 const unsigned char *zStr;/* String being searched */
4502 const char *zErr; /* Compile error message */
4508 zPattern = (const char*)sqlite3_value_text(argv[0]);
4522 zStr = (const unsigned char*)sqlite3_value_text(argv[1]);
4544 const char *zPattern;
4545 const char *zErr;
4550 char *z;
4552 zPattern = (const char*)sqlite3_value_text(argv[0]);
4575 ReOpName[(unsigned char)pRe->aOp[i]], pRe->aArg[i]);
4601 char **pzErrMsg,
4767 static void readFileContents(sqlite3_context *ctx, const char *zName){
4814 const char *zName;
4816 zName = (const char*)sqlite3_value_text(argv[0]);
4825 static void ctxErrorMsg(sqlite3_context *ctx, const char *zFmt, ...){
4826 char *zMsg = 0;
4868 LPWSTR utf8_to_utf16(const char *z){
4884 const char *zPath,
4890 extern LPWSTR sqlite3_win32_utf8_to_unicode(const char*);
4912 const char *zPath,
4930 const char *zPath,
4954 const char *zFile
4956 char *zCopy = sqlite3_mprintf("%s", zFile);
4995 const char *zFile, /* File to write */
5003 const char *zTo = (const char*)sqlite3_value_text(pData);
5025 const char *z;
5029 z = (const char*)sqlite3_value_blob(pData);
5056 extern LPWSTR sqlite3_win32_utf8_to_unicode(const char*);
5113 const char *zFile;
5125 zFile = (const char*)sqlite3_value_text(argv[0]);
5165 char z[16];
5178 char *a = &z[1 + i*3];
5197 char *zDir; /* Name of directory (nul-terminated) */
5207 const char *zBase;
5211 char *zPath; /* Path to current entry */
5226 int argc, const char *const*argv,
5228 char **pzErr
5306 static void fsdirSetErrmsg(fsdir_cursor *pCur, const char *zFmt, ...){
5407 char aStatic[64];
5408 char *aBuf = aStatic;
5469 int idxNum, const char *idxStr,
5472 const char *zDir = 0;
5483 zDir = (const char*)sqlite3_value_text(argv[0]);
5489 pCur->zBase = (const char*)sqlite3_value_text(argv[1]);
5629 char **pzErrMsg,
5724 char *zPrefix; /* The prefix for the word we want to complete */
5725 char *zLine; /* The whole that we want to complete */
5726 const char *zCurrentRow; /* Current output row */
5765 int argc, const char *const*argv,
5767 char **pzErr
5884 char *zSql = 0;
5885 const char *zSep = "";
5888 const char *zDb = (const char*)sqlite3_column_text(pS2, 1);
5908 char *zSql = 0;
5909 const char *zSep = "";
5912 const char *zDb = (const char*)sqlite3_column_text(pS2, 1);
5938 pCur->zCurrentRow = (const char*)sqlite3_column_text(pCur->pStmt, iCol);
6017 int idxNum, const char *idxStr,
6153 char **pzErrMsg,
6326 static int apndOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *);
6327 static int apndDelete(sqlite3_vfs*, const char *zName, int syncDir);
6328 static int apndAccess(sqlite3_vfs*, const char *zName, int flags, int *);
6329 static int apndFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
6330 static void *apndDlOpen(sqlite3_vfs*, const char *zFilename);
6331 static void apndDlError(sqlite3_vfs*, int nByte, char *zErrMsg);
6332 static void (*apndDlSym(sqlite3_vfs *pVfs, void *p, const char*zSym))(void);
6334 static int apndRandomness(sqlite3_vfs*, int nByte, char *zOut);
6337 static int apndGetLastError(sqlite3_vfs*, int, char *);
6339 static int apndSetSystemCall(sqlite3_vfs*, const char*,sqlite3_syscall_ptr);
6340 static sqlite3_syscall_ptr apndGetSystemCall(sqlite3_vfs*, const char *z);
6341 static const char *apndNextSystemCall(sqlite3_vfs*, const char *zName);
6423 unsigned char a[APND_MARK_SIZE];
6429 a[APND_MARK_PREFIX_SZ+i] = (unsigned char)(iPgOne & 0xff);
6525 *(char**)pArg = sqlite3_mprintf("apnd(%lld)/%z", paf->iPgOne,*(char**)pArg);
6611 unsigned char a[APND_MARK_SIZE];
6627 static const char apvfsSqliteHdr[] = "SQLite format 3";
6634 char zHdr[16];
6658 char zHdr[16];
6675 const char *zName,
6740 static int apndDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
6749 const char *zPath,
6757 const char *zPath,
6759 char *zOut
6763 static void *apndDlOpen(sqlite3_vfs *pVfs, const char *zPath){
6766 static void apndDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
6769 static void (*apndDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){
6775 static int apndRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
6784 static int apndGetLastError(sqlite3_vfs *pVfs, int a, char *b){
6792 const char *zName,
6799 const char *zName
6803 static const char *apndNextSystemCall(sqlite3_vfs *pVfs, const char *zName){
6817 char **pzErrMsg,
6897 /* typedef unsigned char u8; */
6937 static const char ZIPFILE_SCHEMA[] =
7064 char *zFile; /* Filename (sqlite3_malloc()) */
7130 char *zFile; /* Zip file this table accesses (may be NULL) */
7149 static void zipfileCtxErrorMsg(sqlite3_context *ctx, const char *zFmt, ...){
7150 char *zMsg = 0;
7163 static void zipfileDequote(char *zIn){
7164 char q = zIn[0];
7170 char c = zIn[iIn++];
7189 int argc, const char *const*argv,
7191 char **pzErr
7195 const char *zFile = 0;
7227 pNew->zFile = (char*)&pNew->aBuffer[ZIPFILE_BUFFER_SIZE];
7339 static void zipfileTableErr(ZipfileTab *pTab, const char *zFmt, ...){
7346 static void zipfileCursorErr(ZipfileCsr *pCsr, const char *zFmt, ...){
7369 char **pzErrmsg /* OUT: Error message (from sqlite3_malloc) */
7652 char **pzErr = &pTab->base.zErrMsg;
7836 char **pzErr /* OUT: Error message */
8091 int idxNum, const char *idxStr,
8096 const char *zFile = 0; /* Zip file to scan */
8122 zFile = (const char*)sqlite3_value_text(argv[0]);
8181 static ZipfileEntry *zipfileNewEntry(const char *zPath){
8252 char **pzErr /* OUT: Error message */
8254 const char *z = (const char*)sqlite3_value_text(pVal);
8261 const char zTemplate[11] = "-rwxrwxrwx";
8290 ** Both (const char*) arguments point to nul-terminated strings. Argument
8293 static int zipfileComparePath(const char *zA, const char *zB, int nB){
8397 const char *zPath = 0; /* Path for new entry */
8403 char *zFree = 0; /* Also free this */
8417 const char *zDelete = (const char*)sqlite3_value_text(apVal[0]);
8420 const char *zUpdate = (const char*)sqlite3_value_text(apVal[1]);
8484 zPath = (const char*)sqlite3_value_text(apVal[2]);
8497 zPath = (const char*)zFree;
8698 char *zRes = sqlite3_mprintf("{"
8740 const char *zName, /* Name of SQL function */
8802 char *zErr = 0;
8812 char *zName = 0; /* Path (name) of new entry */
8814 char *zFree = 0; /* Free this before returning */
8840 zName = (char*)sqlite3_value_text(pName);
9049 char **pzErrMsg,
9167 char **pzErrMsg,
9214 sqlite3expert *sqlite3_expert_new(sqlite3 *db, char **pzErr);
9271 const char *zSql, /* SQL statement(s) to add */
9272 char **pzErr /* OUT: Error message (if any) */
9294 int sqlite3_expert_analyze(sqlite3expert *p, char **pzErr);
9337 const char *sqlite3_expert_report(sqlite3expert*, int iStmt, int eReport);
9422 char *zColl; /* Collation sequence */
9449 char *zName;
9450 char *zColl;
9455 char *zName; /* Table name */
9477 char *zSql; /* SQL statement */
9478 char *zIdx; /* Indexes */
9479 char *zEQP; /* Plan */
9497 char *zKey; /* nul-terminated key */
9498 char *zVal; /* nul-terminated value string */
9499 char *zVal2; /* nul-terminated value string 2 */
9521 char **pzErrmsg;
9524 char *zCandidates; /* For EXPERT_REPORT_CANDIDATES */
9573 static int idxHashString(const char *z, int n){
9577 ret += (ret<<3) + (unsigned char)(z[i]);
9590 const char *zKey,
9591 const char *zVal
9605 pEntry->zKey = (char*)&pEntry[1];
9624 static IdxHashEntry *idxHashFind(IdxHash *pHash, const char *zKey, int nKey){
9644 static const char *idxHashSearch(IdxHash *pHash, const char *zKey, int nKey){
9654 static IdxConstraint *idxNewConstraint(int *pRc, const char *zColl){
9661 pNew->zColl = (char*)&pNew[1];
9673 char **pzErrmsg /* Write error here */
9684 char **pzErrmsg, /* OUT: sqlite3_malloc()ed error message */
9685 const char *zSql /* SQL statement to compile */
9701 char **pzErrmsg, /* OUT: sqlite3_malloc()ed error message */
9702 const char *zFmt, /* printf() format of SQL statement */
9707 char *zSql;
9737 static char *expertDequote(const char *zIn){
9739 char *zRet = sqlite3_malloc(n);
9772 int argc, const char *const*argv,
9774 char **pzErr
9784 char *zCreateTable = expertDequote(argv[3]);
9839 const char *zColl = sqlite3_vtab_collation(pIdxInfo, i);
9970 int idxNum, const char *idxStr,
10051 const char *zTab, /* Table name */
10053 char **pzErrmsg /* OUT: Error message (if not) */
10061 char *pCsr = 0;
10070 const char *zCol = (const char*)sqlite3_column_text(p1, 1);
10071 const char *zColSeq = 0;
10095 pCsr = (char*)&pNew->aCol[nCol];
10100 const char *zCol = (const char*)sqlite3_column_text(p1, 1);
10101 const char *zColSeq = 0;
10146 static char *idxAppendText(int *pRc, char *zIn, const char *zFmt, ...){
10148 char *zAppend = 0;
10149 char *zRet = 0;
10157 zRet = (char*)sqlite3_malloc(nIn + nAppend + 1);
10178 static int idxIdentifierRequiresQuotes(const char *zId){
10200 static char *idxAppendColDefn(
10202 char *zIn, /* Column defn accumulated so far */
10206 char *zRet = zIn;
10245 const char *zTbl = pScan->pTab->zName;
10259 const char *zIdx = (const char*)sqlite3_column_text(pIdxList, 1);
10269 const char *zColl = (const char*)sqlite3_column_text(pInfo, 4);
10311 char* azResults[], char* azColumns[]){
10329 char *zCols = 0;
10330 char *zIdx = 0;
10333 const char *zFmt;
10344 const char *zTable = pScan->pTab->zName;
10346 char *zName = 0; /* Index name */
10350 char *zFind;
10545 char **pzErr /* OUT: Error message (sqlite3_malloc) */
10565 const char *zDetail = (const char*)sqlite3_column_text(pExplain, 3);
10573 const char *zIdx = 0;
10582 const char *zSql;
10616 const char *z3,
10617 const char *z4,
10618 const char *zDb,
10619 const char *zTrigger
10654 char **pzErr
10656 static const char *zInt = UNIQUE_TABLE_NAME;
10657 static const char *zDrop = "DROP TABLE " UNIQUE_TABLE_NAME;
10659 const char *zTab = pTab->zName;
10660 const char *zSql =
10666 char *zWrite = 0;
10671 const char *zCreate = (const char*)sqlite3_column_text(pSelect, 0);
10679 char *z = sqlite3_mprintf("ALTER TABLE temp.%Q RENAME TO %Q", zTab, zInt);
10734 static int idxProcessTriggers(sqlite3expert *p, char **pzErr){
10752 static int idxCreateVtabSchema(sqlite3expert *p, char **pzErrmsg){
10771 const char *zType = (const char*)sqlite3_column_text(pSchema, 0);
10772 const char *zName = (const char*)sqlite3_column_text(pSchema, 1);
10773 const char *zSql = (const char*)sqlite3_column_text(pSchema, 2);
10783 char *zInner = 0;
10784 char *zOuter = 0;
10854 char *z; /* SQLITE_TEXT/BLOB value */
10916 char *zNew = (char*)sqlite3_realloc(pSlot->z, nByte*2);
10937 static int idxLargestIndex(sqlite3 *db, int *pnMax, char **pzErr){
10939 const char *zMax =
10961 const char *zTab,
10962 const char *zIdx,
10963 char **pzErr
10965 char *zCols = 0;
10966 char *zOrder = 0;
10967 char *zQuery = 0;
10979 const char *zComma = zCols==0 ? "" : ", ";
10980 const char *zName = (const char*)sqlite3_column_text(pIndexXInfo, 0);
10981 const char *zColl = (const char*)sqlite3_column_text(pIndexXInfo, 1);
11014 char *zStat = 0;
11057 static int idxBuildSampleTable(sqlite3expert *p, const char *zTab){
11059 char *zSql;
11081 static int idxPopulateStat1(sqlite3expert *p, char **pzErr){
11092 const char *zAllIndex =
11097 const char *zIndexXInfo =
11099 const char *zWrite = "INSERT INTO sqlite_stat1 VALUES(?, ?, ?)";
11139 const char *zTab = (const char*)sqlite3_column_text(pAllIndex, 1);
11140 const char *zIdx = (const char*)sqlite3_column_text(pAllIndex, 2);
11181 sqlite3expert *sqlite3_expert_new(sqlite3 *db, char **pzErrmsg){
11214 const char *zSql = (const char*)sqlite3_column_text(pSql, 0);
11268 const char *zSql, /* SQL statement to add */
11269 char **pzErr /* OUT: Error message (if any) */
11274 const char *zStmt = zSql;
11284 const char *z = sqlite3_sql(pStmt);
11288 pNew->zSql = (char*)&pNew[1];
11311 int sqlite3_expert_analyze(sqlite3expert *p, char **pzErr){
11365 const char *sqlite3_expert_report(sqlite3expert *p, int iStmt, int eReport){
11366 const char *zRet = 0;
11493 /* typedef unsigned char u8; */
11575 int argc, const char *const*argv,
11577 char **pzErr
11722 static u32 get_uint16(unsigned char *a){
11725 static u32 get_uint32(unsigned char *a){
11864 sqlite3_uint64 v = (signed char)pData[0];
11898 sqlite3_result_text(pCtx, (char*)pData, n, SQLITE_TRANSIENT);
12117 static int dbdataIsFunction(const char *zSchema){
12131 static int dbdataDbsize(DbdataCursor *pCsr, const char *zSchema){
12133 char *zSql = 0;
12179 int idxNum, const char *idxStr,
12185 const char *zSchema = "main";
12190 zSchema = (const char*)sqlite3_value_text(argv[0]);
12206 char *zSql = sqlite3_mprintf("SELECT %.*s(?2)", nFunc, zSchema);
12350 char **pzErrMsg,
12474 const char *zDb,
12475 const char *zUri
12479 const char *zDb,
12480 int (*xSql)(void*, const char*),
12587 const char *sqlite3_recover_errmsg(sqlite3_recover*);
12642 int sqlite3_dbdata_init(sqlite3*, char**, const sqlite3_api_routines*);
12645 /* typedef unsigned char u8; */
12689 char *zTab; /* Name of table */
12722 char *zCol;
12807 char *zDb; /* Name of input db ("main" etc.) */
12808 char *zUri; /* URI for output database */
12810 int (*xSql)(void*,const char*); /* Pointer to SQL callback function */
12813 char *zStateDb; /* State database to use (or NULL) */
12814 char *zLostAndFound; /* Name of lost-and-found table (or NULL) */
12827 char *zErrMsg; /* For sqlite3_recover_errmsg() */
12927 static int recoverStrlen(const char *zStr){
12971 const char *zFmt, ...
12973 char *z = 0;
13059 const char *zSql
13084 const char *zFmt, ...
13089 char *z;
13143 static int recoverExec(sqlite3_recover *p, sqlite3 *db, const char *zSql){
13184 static char *recoverMPrintf(sqlite3_recover *p, const char *zFmt, ...){
13186 char *z;
13235 const unsigned char *pBlob;
13241 pBlob = (const unsigned char*)sqlite3_value_blob(argv[0]);
13245 const unsigned char *a = &pBlob[iInt*4];
13344 static const char *recoverUnusedString(
13345 const char *z, /* Result must not appear anywhere in z */
13346 const char *zA, const char *zB, /* Try these first */
13347 char *zBuf /* Space to store a generated string */
13365 ** replace(replace(<input>, '\n', char(10), '\r', char(13));
13375 const char *zText = (const char*)sqlite3_value_text(argv[0]);
13379 char zBuf1[20];
13380 char zBuf2[20];
13381 const char *zNL = 0;
13382 const char *zCR = 0;
13401 char *zOut = (char*)sqlite3_malloc64(nAlloc);
13430 memcpy(&zOut[iOut], "', char(10))", 12); iOut += 12;
13435 memcpy(&zOut[iOut], "', char(13))", 12); iOut += 12;
13488 static void recoverSqlCallback(sqlite3_recover *p, const char *zSql){
13508 const char *aPragma[] = {
13529 const char *zPrag = aPragma[ii];
13533 const char *zArg = (const char*)sqlite3_column_text(p1, 0);
13534 char *z2 = recoverMPrintf(p, "PRAGMA %s = %Q", zPrag, zArg);
13577 const char *zName;
13622 char *zSql = recoverMPrintf(p, "ATTACH %Q AS recovery;", p->zStateDb);
13648 const char *zName, /* Name of table created in output db */
13673 char *csr = 0;
13675 pNew->zTab = csr = (char*)&pNew->aCol[nCol];
13684 const char *z = (const char*)sqlite3_column_text(pStmt, 1);
13685 const char *zType = (const char*)sqlite3_column_text(pStmt, 2);
13784 const char *zName = (const char*)sqlite3_column_text(pSelect, 3);
13785 const char *zSql = (const char*)sqlite3_column_text(pSelect, 4);
13786 char *zFree = 0;
13790 zSql = (const char*)(zFree = recoverMPrintf(p,
13800 const char *zTbl = (const char*)sqlite3_column_text(pTblname, 0);
13844 const char *zSql = (const char*)sqlite3_column_text(pSelect, 1);
13899 const char *zSep = "";
13900 const char *zSqlSep = "";
13901 char *zSql = 0;
13902 char *zFinal = 0;
13903 char *zBind = 0;
13982 static char *recoverLostAndFoundCreate(
13986 char *zTbl = 0;
14018 const char *zSep = 0;
14019 char *zField = 0;
14020 char *zSql = 0;
14050 const char *zTab,
14055 char *zBind = 0;
14066 const char *zSep = "";
14154 recoverSqlCallback(p, (const char*)sqlite3_column_text(pInsert, 0));
14235 char *zTab = 0; /* Name of lost_and_found table */
14407 const char *z = (const char*)sqlite3_column_text(pInsert, 0);
15295 const char *zDb,
15296 const char *zUri, /* Output URI for _recover_init() */
15297 int (*xSql)(void*, const char*),/* SQL callback for _recover_init_sql() */
15315 pRet->zDb = (char*)&pRet[1];
15333 const char *zDb,
15334 const char *zUri
15345 const char *zDb,
15346 int (*xSql)(void*, const char*),
15355 const char *sqlite3_recover_errmsg(sqlite3_recover *p){
15384 p->zStateDb = recoverMPrintf(p, "%s", (char*)pArg);
15388 const char *zArg = (const char*)pArg;
15484 char *zName; /* Symbolic name for this session */
15486 char **azFilter; /* Array of xFilter rejection GLOB patterns */
15503 char zText[1]; /* Text to display for this row */
15511 char zPrefix[100]; /* Graph prefix */
15566 char *zDestTable; /* Name of destination table when MODE_Insert */
15567 char *zTempFile; /* Temporary file that might need deleting */
15568 char zTestcase[30]; /* Name of current test case */
15569 char colSeparator[20]; /* Column separator character for several modes */
15570 char rowSeparator[20]; /* Row separator character for MODE_Ascii */
15571 char colSepPrior[20]; /* Saved column separator */
15572 char rowSepPrior[20]; /* Saved row separator */
15576 char nullValue[20]; /* The text to print when a NULL comes back from
15578 char outfile[FILENAME_MAX]; /* Filename for *out */
15583 const char *zDbFilename; /* Filename used to open the connection */
15584 char *zFreeOnClose; /* Free this memory allocation on close */
15594 char *zNonce; /* Nonce for temporary safe-mode excapes */
15599 const char * zInput; /* Input string from wasm/JS proxy */
15600 const char * zPos; /* Cursor pos into zInput */
15601 const char * zDefaultDbName; /* Default name for db file */
15685 static const char *modeDescr[] = {
15729 static void shellLog(void *pArg, int iErrCode, const char *zMsg){
15759 const char *zErrMsg,
15764 char *zMsg;
15796 const char *zEditor;
15797 char *zTempFile = 0;
15799 char *zCmd = 0;
15806 unsigned char *p = 0;
15809 zEditor = (const char*)sqlite3_value_text(argv[1]);
15845 const char *z = (const char*)sqlite3_value_text(argv[0]);
15904 sqlite3_result_text64(context, (const char*)p, sz,
15938 unsigned char *aBlob = (unsigned char*)pBlob;
15940 char *zStr = sqlite3_malloc(nBlob*2 + 1);
15944 static const char aHex[] = {
15964 static const char *unused_string(
15965 const char *z, /* Result must not appear anywhere in z */
15966 const char *zA, const char *zB, /* Try these first */
15967 char *zBuf /* Space to store a generated string */
15983 static void output_quoted_string(FILE *out, const char *z){
15985 char c;
16022 static void output_quoted_escaped_string(FILE *out, const char *z){
16024 char c;
16030 const char *zNL = 0;
16031 const char *zCR = 0;
16034 char zBuf1[20], zBuf2[20];
16071 raw_printf(out, ",'%s',char(13))", zCR);
16074 raw_printf(out, ",'%s',char(10))", zNL);
16083 static void output_c_string(FILE *out, const char *z){
16114 static void output_json_string(FILE *out, const char *z, i64 n){
16149 static void output_html_string(FILE *out, const char *z){
16184 static const char needCsvQuote[] = {
16209 static void output_csv(ShellState *p, const char *z, int bSep){
16216 if( needCsvQuote[((unsigned char*)z)[i]] ){
16222 char *zQuoted = sqlite3_mprintf("\"%w\"", z);
16267 const char *zA1,
16268 const char *zA2,
16269 const char *zA3,
16270 const char *zA4
16273 static const char *azProhibitedFunctions[] = {
16315 const char *zA1,
16316 const char *zA2,
16317 const char *zA3,
16318 const char *zA4
16321 static const char *azAction[] = { 0,
16335 const char *az[4];
16365 static void printSchemaLine(FILE *out, const char *z, const char *zTail){
16366 char *zToFree = 0;
16370 const char *zOrig = z;
16371 static const char *azTerm[] = { "", "*/", "\n" };
16374 char *zNew = sqlite3_mprintf("%s%s;", zOrig, azTerm[i]);
16392 static void printSchemaLineN(FILE *out, char *z, int n, const char *zTail){
16393 char c = z[n];
16403 static int wsToEol(const char *z){
16417 static void eqp_append(ShellState *p, int iEqpId, int p2, const char *zText){
16467 char *z;
16528 const char zDash[] = "--------------------------------------------------";
16543 const char *zSep
16565 char **azArg, /* Text of each result column */
16566 char **azCol, /* Column names */
16632 char *z;
16635 char cEnd = 0;
16636 char c;
16706 char *z = azArg[i];
16778 char *z = sqlite3_mprintf("\"%w\"", azCol[i]);
16802 char z[50];
16848 char z[50];
16895 char z[50];
16940 static int callback(void *pArg, int nArg, char **azArg, char **azCol){
16949 static int captureOutputCallback(void *pArg, int nArg, char **azArg, char **az){
16966 char *zErrMsg = 0;
17016 static void set_table_name(ShellState *p, const char *zName){
17018 char cQuote;
17019 char *z;
17050 static char *shell_error_context(const char *zSql, sqlite3 *db){
17053 char *zCode;
17054 char *zMsg;
17096 const char *zSelect /* SELECT statement to extract content */
17102 const char *z;
17105 char *zContext = shell_error_context(zSelect, p->db);
17115 z = (const char*)sqlite3_column_text(pSelect, 0);
17141 static char *save_err_msg(
17143 const char *zPhase, /* When the error occcurs */
17145 const char *zSql /* SQL string, or NULL */
17147 char *zErr;
17148 char *zContext;
17170 char z[200];
17176 const char *zPattern;
17177 const char *zDesc;
17205 char *zLabel, /* Label for this one line */
17206 char *zFormat, /* Format for the result */
17213 char zLine[200];
17243 char z[100];
17393 const char *zExplain;
17426 static int str_in_array(const char *zStr, const char **azArray){
17456 const char *zSql; /* The text of the SQL statement */
17457 const char *z; /* Used to check if this is an EXPLAIN */
17462 const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext",
17464 const char *azYield[] = { "Yield", "SeekLT", "SeekGT", "RowSetRead",
17466 const char *azGoto[] = { "Goto", 0 };
17485 const char *zOp = (const char*)sqlite3_column_text(pSql, 1);
17500 static const char *explainCols[] = {
17610 char zNum[30];
17611 const char *zVar = sqlite3_bind_parameter_name(pStmt, i);
17656 const char zDash[] =
17674 const char *zSep1,
17675 const char *zSep2,
17676 const char *zSep3
17702 static char *translateForDisplayAndDup(
17703 const unsigned char *z, /* Input text to be transformed */
17704 const unsigned char **pzTail, /* OUT: Tail of the input for next line */
17712 unsigned char *zOut; /* Output text */
17785 return (char*)zOut;
17792 static char *quoted_column(sqlite3_stmt *pStmt, int i){
17807 const unsigned char *a = sqlite3_column_blob(pStmt,i);
17836 char **azData = 0;
17838 char *abRowDiv = 0;
17839 const unsigned char *uz;
17840 const char *z;
17841 char **azQuoted = 0;
17845 const char *colSep = 0;
17846 const char *rowSep = 0;
17847 const unsigned char **azNextLine = 0;
17851 const char *zEmpty = "";
17852 const char *zShowNull = p->nullValue;
17859 azData = sqlite3_malloc64( nAlloc*sizeof(char*) );
17861 azNextLine = sqlite3_malloc64( nColumn*sizeof(char*) );
17863 memset((void*)azNextLine, 0, nColumn*sizeof(char*) );
17865 azQuoted = sqlite3_malloc64( nColumn*sizeof(char*) );
17867 memset(azQuoted, 0, nColumn*sizeof(char*) );
17885 const unsigned char *zNotUsed;
17891 uz = (const unsigned char*)sqlite3_column_name(pStmt,i);
17899 azData = sqlite3_realloc64(azData, nAlloc*sizeof(char*));
17918 uz = (const unsigned char*)azQuoted[i];
17920 uz = (const unsigned char*)sqlite3_column_text(pStmt,i);
17935 if( z==0 ) z = (char*)zEmpty;
18079 void *pData = sqlite3_malloc64(3*nCol*sizeof(const char*) + 1);
18083 char **azCols = (char **)pData; /* Names of result columns */
18084 char **azVals = &azCols[nCol]; /* Results */
18087 assert(sizeof(int) <= sizeof(char *));
18090 azCols[i] = (char *)sqlite3_column_name(pStmt, i);
18103 azVals[i] = (char*)sqlite3_column_text(pStmt, i);
18125 char zBuf[200];
18147 const char *zSql,
18148 char **pzErr
18168 char **pzErr
18184 const char *zCand = sqlite3_expert_report(p,0,EXPERT_REPORT_CANDIDATES);
18189 const char *zSql = sqlite3_expert_report(p, i, EXPERT_REPORT_SQL);
18190 const char *zIdx = sqlite3_expert_report(p, i, EXPERT_REPORT_INDEXES);
18191 const char *zEQP = sqlite3_expert_report(p, i, EXPERT_REPORT_PLAN);
18212 char **azArg, /* Array of arguments passed to dot command */
18216 char *zErr = 0;
18224 char *z = azArg[i];
18277 const char *zSql, /* SQL to be evaluated */
18278 char **pzErrMsg /* Error msg written here */
18283 const char *zLeftover; /* Tail of unprocessed SQL */
18298 static const char *zStmtSql;
18324 char *zEQP;
18336 const char *zEQPLine = (const char*)sqlite3_column_text(pExplain,3);
18429 static void freeColumnList(char **azCol){
18451 static char **tableColumnList(ShellState *p, const char *zTab){
18452 char **azCol = 0;
18454 char *zSql;
18478 && sqlite3_stricmp((const char*)sqlite3_column_text(pStmt,2),
18522 static char *azRowid[] = { "rowid", "_rowid_", "oid" };
18548 char zStmt[100];
18565 static int dump_callback(void *pArg, int nArg, char **azArg, char **azNotUsed){
18567 const char *zTable;
18568 const char *zType;
18569 const char *zSql;
18593 char *zIns;
18613 char **azCol;
18615 char *savedDestTable;
18688 const char *zQuery
18691 char *zErr = 0;
18694 char *zQ2;
18726 static const char *(azHelp[]) = {
19021 static int showHelp(FILE *out, const char *zPattern){
19025 char *zPat;
19102 static char *readFile(const char *zName, int *pnByte){
19106 char *pBuf;
19162 static int session_filter(void *pCtx, const char *zTab){
19181 int deduceDatabaseType(const char *zName, int dfltZip){
19185 char zBuf[100];
19222 static unsigned char *readHexDb(ShellState *p, int *pnData){
19223 unsigned char *a = 0;
19231 const char *zDbFilename = p->pAuxDb->zDbFilename;
19233 char zLine[1000];
19316 const unsigned char *pBlob;
19322 pBlob = (const unsigned char*)sqlite3_value_blob(argv[0]);
19326 const unsigned char *a = &pBlob[iInt*4];
19344 const char *zName = (const char*)sqlite3_value_text(argv[0]);
19347 char *z = sqlite3_mprintf("\"%w\"", zName);
19374 ** replace(replace(<input>, '\n', char(10), '\r', char(13));
19384 const char *zText = (const char*)sqlite3_value_text(argv[0]);
19389 char zBuf1[20];
19390 char zBuf2[20];
19391 const char *zNL = 0;
19392 const char *zCR = 0;
19411 char *zOut = (char*)sqlite3_malloc64(nAlloc);
19440 memcpy(&zOut[iOut], "', char(10))", 12); iOut += 12;
19445 memcpy(&zOut[iOut], "', char(13))", 12); iOut += 12;
19476 const char *zDbFilename = p->pAuxDb->zDbFilename;
19565 char *zSql = sqlite3_mprintf(
19576 unsigned char *aData;
19578 aData = (unsigned char*)readFile(zDbFilename, &nData);
19617 static char *readline_completion_generator(const char *text, int state){
19619 char *zRet;
19621 char *zSql;
19630 const char *z = (const char*)sqlite3_column_text(pStmt,0);
19639 static char **readline_completion(const char *zText, int iStart, int iEnd){
19648 static void linenoise_completion(const char *zLine, linenoiseCompletions *lc){
19652 char *zSql;
19653 char zBuf[1000];
19669 const char *zCompletion = (const char*)sqlite3_column_text(pStmt, 0);
19696 static void resolve_backslashes(char *z){
19698 char c;
19744 static int booleanValue(const char *zArg){
19766 static void setOrClearFlag(ShellState *p, unsigned mFlag, const char *zArg){
19786 static FILE *output_file_open(const char *zFile, int bTextMode){
19815 const char *zSql;
19822 if( mType!=SQLITE_TRACE_ROW && ((const char*)pX)[0]=='-' ){
19823 zSql = (const char*)pX;
19877 const char *zFile; /* Name of the input file */
19880 char *z; /* Accumulated text for a field */
19909 p->z[p->n++] = (char)c;
19925 static char *SQLITE_CDECL csv_read_one_field(ImportCtx *p){
20015 static char *SQLITE_CDECL ascii_read_one_field(ImportCtx *p){
20045 const char *zTable
20049 char *zQuery = 0;
20050 char *zInsert = 0;
20103 (const char*)sqlite3_column_text(pQuery,i),
20157 const char *zWhere,
20158 void (*xForEach)(ShellState*,sqlite3*,const char*)
20161 char *zQuery = 0;
20163 const unsigned char *zName;
20164 const unsigned char *zSql;
20165 char *zErrMsg = 0;
20182 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
20189 xForEach(p, newDb, (const char*)zName);
20211 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
20218 xForEach(p, newDb, (const char*)zName);
20233 static void tryToClone(ShellState *p, const char *zNewDb){
20271 const char *zXdgOpenCmd =
20279 char *zCmd;
20302 static int db_int(sqlite3 *db, const char *zSql){
20317 static unsigned int get2byteInt(unsigned char *a){
20320 static unsigned int get4byteInt(unsigned char *a){
20329 static int shell_dbinfo_command(ShellState *p, int nArg, char **azArg){
20330 static const struct { const char *zName; int ofst; } aField[] = {
20344 static const struct { const char *zName; const char *zSql; } aQuery[] = {
20358 char *zSchemaTab;
20359 char *zDb = nArg>=2 ? azArg[1] : "main";
20361 unsigned char aHdr[100];
20410 char *zSql = sqlite3_mprintf(aQuery[i].zSql, zSchemaTab);
20426 const char *zErr = sqlite3_errmsg(db);
20454 static int testcase_glob(const char *zGlob, const char *z){
20533 static int optionMatch(const char *zStr, const char *zOpt){
20543 int shellDeleteFile(const char *zFilename){
20570 static void newTempFile(ShellState *p, const char *zSuffix){
20580 char *zTemp;
20621 const char *zParent;
20622 const char *zParentCol;
20623 const char *zParentSeq;
20624 const char *zChild;
20625 const char *zChildCol;
20626 const char *zChildSeq = 0; /* Initialize to avoid false-positive warning */
20630 zParent = (const char*)sqlite3_value_text(apVal[0]);
20631 zParentCol = (const char*)sqlite3_value_text(apVal[1]);
20632 zChild = (const char*)sqlite3_value_text(apVal[2]);
20633 zChildCol = (const char*)sqlite3_value_text(apVal[3]);
20646 char *z = sqlite3_mprintf(" COLLATE %s", zParentSeq);
20658 char **azArg, /* Array of arguments passed to dot command */
20666 const char *zIndent = ""; /* How much to indent CREATE INDEX by */
20705 const char *zSql =
20732 const char *zGlobIPK = "SEARCH * USING INTEGER PRIMARY KEY (rowid=?)";
20766 char *zPrev = 0;
20770 const char *zEQP = (const char*)sqlite3_column_text(pSql, 0);
20771 const char *zGlob = (const char*)sqlite3_column_text(pSql, 1);
20772 const char *zFrom = (const char*)sqlite3_column_text(pSql, 2);
20773 const char *zTarget = (const char*)sqlite3_column_text(pSql, 3);
20774 const char *zCI = (const char*)sqlite3_column_text(pSql, 4);
20775 const char *zParent = (const char*)sqlite3_column_text(pSql, 5);
20782 const char *zPlan = (const char*)sqlite3_column_text(pExplain, 3);
20834 char **azArg, /* Array of arguments passed to dot command */
20853 const char *zSql,
20879 const char *zFmt,
20885 char *z;
20958 char *zSrcTable; /* "sqlar", "zipfile($file)" or "zip" */
20959 const char *zFile; /* --file argument, or NULL */
20960 const char *zDir; /* --directory argument, or NULL */
20961 char **azArg; /* Array of command arguments */
20978 static int arErrorMsg(ArCommand *pAr, const char *zFmt, ...){
20980 char *z;
21015 static int arProcessSwitch(ArCommand *pAr, int eSwitch, const char *zArg){
21060 char **azArg, /* Array of arguments passed to dot command */
21065 const char *zLong;
21066 char cShort;
21091 char *z = azArg[1];
21097 const char *zArg = 0;
21135 const char *zArg = 0;
21165 const char *zArg = 0; /* Argument for option, if any */
21169 const char *zLong = pOpt->zLong;
21216 const char *zSel = (pAr->bGlob)
21223 char *z = pAr->azArg[i];
21254 char **pzWhere /* OUT: New WHERE clause */
21256 char *zWhere = 0;
21257 const char *zSameOp = (pAr->bGlob)? "GLOB" : "=";
21263 const char *zSep = "";
21265 const char *z = pAr->azArg[i];
21285 const char *zSql = "SELECT %s FROM %s WHERE %s";
21286 const char *azCols[] = {
21291 char *zWhere = 0;
21327 char *zSql = 0;
21328 char *zWhere = 0;
21342 char *zErr = 0;
21367 const char *zSql1 =
21374 const char *azExtraArg[] = {
21381 char *zDir = 0;
21382 char *zWhere = 0;
21438 static int arExecSql(ArCommand *pAr, const char *zSql){
21444 char *zErr = 0;
21478 const char *zCreate =
21486 const char *zDrop = "DROP TABLE IF EXISTS sqlar";
21487 const char *zInsertFmt[2] = {
21512 const char *zTab = 0; /* SQL table into which to insert */
21513 char *zSql;
21514 char zTemp[50];
21515 char *zExists = 0;
21558 char *zSql2 = sqlite3_mprintf(zInsertFmt[pAr->bZip], zTab,
21585 char **azArg, /* Array of arguments passed to dot command */
21699 static int recoverSqlCb(void *pCtx, const char *zSql){
21710 static int recoverDatabaseCmd(ShellState *pState, int nArg, char **azArg){
21712 const char *zRecoveryDb = ""; /* Name of "recovery" database. Debug only */
21713 const char *zLAF = "lost_and_found";
21720 char *z = azArg[i];
21761 const char *zErr = sqlite3_recover_errmsg(p);
21797 static char zCOL_DB[] = SHELL_STRINGIFY(SHELL_COLFIX_DB);
21799 static const char *zCOL_DB = ":memory:";
21813 static char *zAutoColumn(const char *zColNew, sqlite3 **pDb, char **pzRenamed){
21815 static const char * const zTabMake = "\
21825 static const char * const zTabFill = "\
21829 static const char * const zHasDupes = "\
21834 static const char * const zDedoctor = "\
21843 static const char * const zSetReps = "\
21851 static const char * const zColDigits = "\
21856 static const char * const zColDigits = "\
21862 static const char * const zRenameRank =
21899 static const char * const zCollectVar = "\
21910 static const char * const zRenamesDone =
21944 char *zColsSpec = 0;
21994 static int do_meta_command(char *zLine, ShellState *p){
21999 char *azArg[52];
22070 const char *zDestFile = 0;
22071 const char *zDb = 0;
22076 const char *zVfs = 0;
22079 const char *z = azArg[j];
22203 char *zRes = 0;
22241 const char *zFile = p->aAuxDb[i].zDbFilename;
22283 char **azName = 0;
22294 const char *zSchema = (const char *)sqlite3_column_text(pStmt,1);
22295 const char *zFile = (const char*)sqlite3_column_text(pStmt,2);
22297 azName = sqlite3_realloc(azName, (nName+1)*2*sizeof(char*));
22308 const char *z = azName[i*2+1];
22323 const char *zName;
22372 char *zLike = 0;
22373 char *zSql;
22382 const char *z = azArg[i]+1;
22416 char *zExpr = sqlite3_mprintf(
22570 const char *zCtrlName; /* Name of a test-control option */
22572 const char *zUsage; /* Usage notes */
22591 const char *zCmd = 0;
22592 const char *zSchema = 0;
22681 char *z = 0;
22709 char zBuf[100];
22785 char *zTable = 0; /* Insert data into this table */
22786 char *zSchema = 0; /* within this schema (may default to "main") */
22787 char *zFile = 0; /* Name of file to extra content from */
22794 char *zSql; /* An SQL statement */
22795 char *zFullTabName; /* Table name with schema if applicable */
22797 char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */
22801 char *zCreate = 0; /* CREATE TABLE statement text */
22812 char *z = azArg[i];
22913 char zSep[2];
22947 char *zRenames = 0;
22948 char *zColDefs;
23024 char *z = xRead(&sCtx);
23080 char *zSql;
23081 char *zCollist = 0;
23126 char zLabel[20];
23127 const char *zCol = (const char*)sqlite3_column_text(pStmt,2);
23181 SQLITE_API extern void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...);
23204 const char *zLimitName; /* Name of a limit */
23268 const char *zFile, *zProc;
23269 char *zErrMsg = 0;
23295 const char *zFile = azArg[1];
23303 const char *zMode = 0;
23304 const char *zTabname = 0;
23308 const char *z = azArg[i];
23453 const char *zFN = 0; /* Pointer to constant filename */
23454 char *zNewFilename = 0; /* Name of the database file to open */
23461 const char *z = azArg[iName];
23551 char *zFile = 0;
23556 unsigned char zBOM[4]; /* Byte-order mark to using if --bom is present */
23567 char *z = azArg[i];
23720 char *zSql;
23722 const char *zKey = azArg[2];
23723 const char *zValue = azArg[3];
23757 char *zSql = sqlite3_mprintf(
23785 const char *z = azArg[i];
23877 const char *zSrcFile;
23878 const char *zDb;
23944 char *zErrMsg = 0;
23945 const char *zDiv = "(";
23946 const char *zName = 0;
23982 char *new_argv[2], *new_colv[2];
24012 const char *zDb = (const char*)sqlite3_column_text(pStmt, 0);
24013 char zScNum[30];
24042 char *zQarg = sqlite3_mprintf("%Q", zName);
24095 char **azCmd = &azArg[1];
24213 char *x = pSession->azFilter[ii-1] = sqlite3_mprintf("%s", azCmd[ii]);
24261 char *zName;
24308 char zBuf[200];
24329 const char *z = azArg[i];
24376 const char *zOp = (const char*)sqlite3_column_text(pStmt, 1);
24377 const char *zSql = (const char*)sqlite3_column_text(pStmt, 2);
24378 const char *zAns = (const char*)sqlite3_column_text(pStmt, 3);
24391 char *zErrMsg = 0;
24440 const char *zLike = 0; /* Which table to checksum. 0 means everything */
24447 char *zSql; /* SQL to be run */
24448 char *zSep; /* Separator */
24453 const char *z = azArg[i];
24502 const char *zTab = (const char*)sqlite3_column_text(pStmt,0);
24560 char *zCmd;
24580 static const char *azBool[] = { "off", "on", "trigger", "full"};
24581 const char *zOut;
24654 char **azResult;
24676 const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1);
24716 char **azNew;
24745 char *zSp = j<nPrintRow ? "" : " ";
24776 const char *zCtrlName; /* Name of a test-control option */
24779 const char *zUsage; /* Usage notes */
24809 const char *zCmd = 0;
25031 const char *z = azArg[jj];
25079 char *zOpt;
25091 sqlite3_drop_modules(p->db, nArg>2 ? (const char**)(azArg+2) : 0);
25183 const char *zDbName = nArg==2 ? azArg[1] : "main";
25215 const char *zDbName = nArg==2 ? azArg[1] : "main";
25216 char *zVfsName = 0;
25279 static QuickScanState quickscan(char *zLine, QuickScanState qss){
25280 char cin;
25281 char cWait = (char)qss; /* intentional narrowing loss */
25354 static int line_is_command_terminator(char *zLine){
25379 static int line_is_complete(char *zSql, int nSql){
25392 static int runOneSqlLine(ShellState *p, char *zSql, FILE *in, int startline){
25394 char *zErrMsg = 0;
25403 char zPrefix[100];
25404 const char *zErrorTail;
25405 const char *zErrorType;
25430 char zLineBuf[2000];
25439 static void echo_group_input(ShellState *p, const char *zDo){
25449 static char *one_input_line(FILE *in, char *zPrior, int isContinuation){
25451 const char *zBegin = shellState.wasm.zPos;
25452 const char *z = zBegin;
25453 char *zLine = 0;
25486 char *zLine = 0; /* A single input line */
25487 char *zSql = 0; /* Accumulated SQL text */
25595 static char *find_home_dir(int clearFlag){
25596 static char *home_dir = NULL;
25633 char *zDrive, *zPath;
25652 char *z = malloc( n );
25668 const char *sqliterc_override /* Name of config file. NULL to use default */
25670 char *home_dir = NULL;
25671 const char *sqliterc = sqliterc_override;
25672 char *zBuf = 0;
25706 static const char zOptions[] =
25815 static void printBold(const char *zText){
25830 static void printBold(const char *zText){
25839 static char *cmdline_option_value(int argc, char **argv, int i){
25862 int SQLITE_CDECL main(int argc, char **argv){
25865 char **argv;
25870 char *zErrMsg = 0;
25876 const char *zInitFile = 0;
25882 char **azCmd = 0;
25883 const char *zVfs = 0; /* Value of -vfs command-line option */
25885 char **argvToFree = 0;
25943 char *z = sqlite3_win32_unicode_to_utf8(wargv[i]);
25974 extern void SQLITE_SHELL_DBNAME_PROC(const char**);
25987 char *z;
26019 const char *zSize;
26060 const char *zTraceName,
26061 const char *zOldVfsName,
26062 int (*xOut)(const char*,void*),
26066 vfstrace_register("trace",0,(int(*)(const char*,void*))fputs,stderr,1);
26070 extern int sqlite3_multiple_initialize(const char*,int);
26179 char *z = argv[i];
26381 char *zHome;
26382 char *zHistory;
26480 sqlite3_vfs * fiddle_db_vfs(const char *zDbName){
26509 const char * fiddle_db_filename(const char * zDbName){
26537 int fiddle_export_db( int (*xCallback)(unsigned const char *zOut, int n) ){
26541 unsigned char buf[1024 * 8];
26575 void fiddle_exec(const char * zSql){