Annotation of src/usr.bin/sqlite3/shell.c, Revision 1.1.1.11
1.1 espie 1: /*
2: ** 2001 September 15
3: **
4: ** The author disclaims copyright to this source code. In place of
5: ** a legal notice, here is a blessing:
6: **
7: ** May you do good and not evil.
8: ** May you find forgiveness for yourself and forgive others.
9: ** May you share freely, never taking more than you give.
10: **
11: *************************************************************************
12: ** This file contains code to implement the "sqlite" command line
13: ** utility for accessing SQLite databases.
14: */
15: #if (defined(_WIN32) || defined(WIN32)) && !defined(_CRT_SECURE_NO_WARNINGS)
16: /* This needs to come before any includes for MSVC compiler */
17: #define _CRT_SECURE_NO_WARNINGS
18: #endif
19:
20: /*
1.1.1.11! jturner 21: ** If requested, include the SQLite compiler options file for MSVC.
! 22: */
! 23: #if defined(INCLUDE_MSVC_H)
! 24: #include "msvc.h"
! 25: #endif
! 26:
! 27: /*
1.1 espie 28: ** Enable large-file support for fopen() and friends on unix.
29: */
30: #ifndef SQLITE_DISABLE_LFS
31: # define _LARGE_FILE 1
32: # ifndef _FILE_OFFSET_BITS
33: # define _FILE_OFFSET_BITS 64
34: # endif
35: # define _LARGEFILE_SOURCE 1
36: #endif
37:
38: #include <stdlib.h>
39: #include <string.h>
40: #include <stdio.h>
41: #include <assert.h>
42: #include "sqlite3.h"
1.1.1.10 jturner 43: #if SQLITE_USER_AUTHENTICATION
44: # include "sqlite3userauth.h"
45: #endif
1.1 espie 46: #include <ctype.h>
47: #include <stdarg.h>
48:
1.1.1.4 espie 49: #if !defined(_WIN32) && !defined(WIN32)
1.1 espie 50: # include <signal.h>
51: # if !defined(__RTP__) && !defined(_WRS_KERNEL)
52: # include <pwd.h>
53: # endif
54: # include <unistd.h>
55: # include <sys/types.h>
56: #endif
57:
1.1.1.11! jturner 58: #if HAVE_READLINE
1.1 espie 59: # include <readline/readline.h>
60: # include <readline/history.h>
61: #endif
1.1.1.11! jturner 62:
! 63: #if HAVE_EDITLINE
1.1.1.8 jturner 64: # include <editline/readline.h>
65: #endif
1.1.1.11! jturner 66:
! 67: #if HAVE_EDITLINE || HAVE_READLINE
! 68:
! 69: # define shell_add_history(X) add_history(X)
! 70: # define shell_read_history(X) read_history(X)
! 71: # define shell_write_history(X) write_history(X)
! 72: # define shell_stifle_history(X) stifle_history(X)
! 73: # define shell_readline(X) readline(X)
! 74:
! 75: #elif HAVE_LINENOISE
! 76:
! 77: # include "linenoise.h"
! 78: # define shell_add_history(X) linenoiseHistoryAdd(X)
! 79: # define shell_read_history(X) linenoiseHistoryLoad(X)
! 80: # define shell_write_history(X) linenoiseHistorySave(X)
! 81: # define shell_stifle_history(X) linenoiseHistorySetMaxLen(X)
! 82: # define shell_readline(X) linenoise(X)
! 83:
! 84: #else
! 85:
! 86: # define shell_read_history(X)
! 87: # define shell_write_history(X)
! 88: # define shell_stifle_history(X)
! 89:
! 90: # define SHELL_USE_LOCAL_GETLINE 1
1.1 espie 91: #endif
92:
1.1.1.11! jturner 93:
1.1 espie 94: #if defined(_WIN32) || defined(WIN32)
95: # include <io.h>
1.1.1.9 jturner 96: # include <fcntl.h>
1.1 espie 97: #define isatty(h) _isatty(h)
1.1.1.8 jturner 98: #ifndef access
99: # define access(f,m) _access((f),(m))
100: #endif
1.1.1.4 espie 101: #undef popen
1.1.1.7 jturner 102: #define popen _popen
1.1.1.4 espie 103: #undef pclose
1.1.1.7 jturner 104: #define pclose _pclose
1.1 espie 105: #else
106: /* Make sure isatty() has a prototype.
107: */
108: extern int isatty(int);
109:
1.1.1.7 jturner 110: /* popen and pclose are not C89 functions and so are sometimes omitted from
111: ** the <stdio.h> header */
1.1.1.8 jturner 112: extern FILE *popen(const char*,const char*);
113: extern int pclose(FILE*);
114: #endif
1.1.1.7 jturner 115:
1.1 espie 116: #if defined(_WIN32_WCE)
117: /* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty()
118: * thus we always assume that we have a console. That can be
119: * overridden with the -batch command line option.
120: */
121: #define isatty(x) 1
122: #endif
123:
124: /* ctype macros that work with signed characters */
125: #define IsSpace(X) isspace((unsigned char)X)
126: #define IsDigit(X) isdigit((unsigned char)X)
127: #define ToLower(X) (char)tolower((unsigned char)X)
128:
1.1.1.8 jturner 129:
130: /* True if the timer is enabled */
131: static int enableTimer = 0;
132:
133: /* Return the current wall-clock time */
134: static sqlite3_int64 timeOfDay(void){
135: static sqlite3_vfs *clockVfs = 0;
136: sqlite3_int64 t;
137: if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0);
138: if( clockVfs->iVersion>=1 && clockVfs->xCurrentTimeInt64!=0 ){
139: clockVfs->xCurrentTimeInt64(clockVfs, &t);
140: }else{
141: double r;
142: clockVfs->xCurrentTime(clockVfs, &r);
143: t = (sqlite3_int64)(r*86400000.0);
144: }
145: return t;
146: }
147:
1.1.1.6 landry 148: #if !defined(_WIN32) && !defined(WIN32) && !defined(_WRS_KERNEL) \
149: && !defined(__minux)
1.1 espie 150: #include <sys/time.h>
151: #include <sys/resource.h>
152:
153: /* Saved resource information for the beginning of an operation */
1.1.1.8 jturner 154: static struct rusage sBegin; /* CPU time at start */
155: static sqlite3_int64 iBegin; /* Wall-clock time at start */
1.1 espie 156:
157: /*
158: ** Begin timing an operation
159: */
160: static void beginTimer(void){
161: if( enableTimer ){
162: getrusage(RUSAGE_SELF, &sBegin);
1.1.1.8 jturner 163: iBegin = timeOfDay();
1.1 espie 164: }
165: }
166:
167: /* Return the difference of two time_structs in seconds */
168: static double timeDiff(struct timeval *pStart, struct timeval *pEnd){
169: return (pEnd->tv_usec - pStart->tv_usec)*0.000001 +
170: (double)(pEnd->tv_sec - pStart->tv_sec);
171: }
172:
173: /*
174: ** Print the timing results.
175: */
176: static void endTimer(void){
177: if( enableTimer ){
178: struct rusage sEnd;
1.1.1.8 jturner 179: sqlite3_int64 iEnd = timeOfDay();
1.1 espie 180: getrusage(RUSAGE_SELF, &sEnd);
1.1.1.8 jturner 181: printf("Run Time: real %.3f user %f sys %f\n",
182: (iEnd - iBegin)*0.001,
1.1 espie 183: timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
184: timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
185: }
186: }
187:
188: #define BEGIN_TIMER beginTimer()
189: #define END_TIMER endTimer()
190: #define HAS_TIMER 1
191:
192: #elif (defined(_WIN32) || defined(WIN32))
193:
194: #include <windows.h>
195:
196: /* Saved resource information for the beginning of an operation */
197: static HANDLE hProcess;
198: static FILETIME ftKernelBegin;
199: static FILETIME ftUserBegin;
1.1.1.8 jturner 200: static sqlite3_int64 ftWallBegin;
1.1.1.11! jturner 201: typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME,
! 202: LPFILETIME, LPFILETIME);
1.1 espie 203: static GETPROCTIMES getProcessTimesAddr = NULL;
204:
205: /*
206: ** Check to see if we have timer support. Return 1 if necessary
207: ** support found (or found previously).
208: */
209: static int hasTimer(void){
210: if( getProcessTimesAddr ){
211: return 1;
212: } else {
1.1.1.11! jturner 213: /* GetProcessTimes() isn't supported in WIN95 and some other Windows
! 214: ** versions. See if the version we are running on has it, and if it
! 215: ** does, save off a pointer to it and the current process handle.
1.1 espie 216: */
217: hProcess = GetCurrentProcess();
218: if( hProcess ){
219: HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll"));
220: if( NULL != hinstLib ){
1.1.1.11! jturner 221: getProcessTimesAddr =
! 222: (GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes");
1.1 espie 223: if( NULL != getProcessTimesAddr ){
224: return 1;
225: }
226: FreeLibrary(hinstLib);
227: }
228: }
229: }
230: return 0;
231: }
232:
233: /*
234: ** Begin timing an operation
235: */
236: static void beginTimer(void){
237: if( enableTimer && getProcessTimesAddr ){
238: FILETIME ftCreation, ftExit;
1.1.1.11! jturner 239: getProcessTimesAddr(hProcess,&ftCreation,&ftExit,
! 240: &ftKernelBegin,&ftUserBegin);
1.1.1.8 jturner 241: ftWallBegin = timeOfDay();
1.1 espie 242: }
243: }
244:
245: /* Return the difference of two FILETIME structs in seconds */
246: static double timeDiff(FILETIME *pStart, FILETIME *pEnd){
247: sqlite_int64 i64Start = *((sqlite_int64 *) pStart);
248: sqlite_int64 i64End = *((sqlite_int64 *) pEnd);
249: return (double) ((i64End - i64Start) / 10000000.0);
250: }
251:
252: /*
253: ** Print the timing results.
254: */
255: static void endTimer(void){
256: if( enableTimer && getProcessTimesAddr){
257: FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd;
1.1.1.8 jturner 258: sqlite3_int64 ftWallEnd = timeOfDay();
1.1.1.11! jturner 259: getProcessTimesAddr(hProcess,&ftCreation,&ftExit,&ftKernelEnd,&ftUserEnd);
1.1.1.8 jturner 260: printf("Run Time: real %.3f user %f sys %f\n",
261: (ftWallEnd - ftWallBegin)*0.001,
1.1 espie 262: timeDiff(&ftUserBegin, &ftUserEnd),
263: timeDiff(&ftKernelBegin, &ftKernelEnd));
264: }
265: }
266:
267: #define BEGIN_TIMER beginTimer()
268: #define END_TIMER endTimer()
269: #define HAS_TIMER hasTimer()
270:
271: #else
272: #define BEGIN_TIMER
273: #define END_TIMER
274: #define HAS_TIMER 0
275: #endif
276:
277: /*
278: ** Used to prevent warnings about unused parameters
279: */
280: #define UNUSED_PARAMETER(x) (void)(x)
281:
282: /*
283: ** If the following flag is set, then command execution stops
284: ** at an error if we are not interactive.
285: */
286: static int bail_on_error = 0;
287:
288: /*
289: ** Threat stdin as an interactive input if the following variable
290: ** is true. Otherwise, assume stdin is connected to a file or pipe.
291: */
292: static int stdin_is_interactive = 1;
293:
294: /*
295: ** The following is the open SQLite database. We make a pointer
296: ** to this database a static variable so that it can be accessed
297: ** by the SIGINT handler to interrupt database processing.
298: */
299: static sqlite3 *db = 0;
300:
301: /*
302: ** True if an interrupt (Control-C) has been received.
303: */
304: static volatile int seenInterrupt = 0;
305:
306: /*
307: ** This is the name of our program. It is set in main(), used
308: ** in a number of other places, mostly for error messages.
309: */
310: static char *Argv0;
311:
312: /*
313: ** Prompt strings. Initialized in main. Settable with
314: ** .prompt main continue
315: */
316: static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/
317: static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */
318:
319: /*
320: ** Write I/O traces to the following stream.
321: */
322: #ifdef SQLITE_ENABLE_IOTRACE
323: static FILE *iotrace = 0;
324: #endif
325:
326: /*
327: ** This routine works like printf in that its first argument is a
328: ** format string and subsequent arguments are values to be substituted
329: ** in place of % fields. The result of formatting this string
330: ** is written to iotrace.
331: */
332: #ifdef SQLITE_ENABLE_IOTRACE
333: static void iotracePrintf(const char *zFormat, ...){
334: va_list ap;
335: char *z;
336: if( iotrace==0 ) return;
337: va_start(ap, zFormat);
338: z = sqlite3_vmprintf(zFormat, ap);
339: va_end(ap);
340: fprintf(iotrace, "%s", z);
341: sqlite3_free(z);
342: }
343: #endif
344:
345:
346: /*
347: ** Determines if a string is a number of not.
348: */
349: static int isNumber(const char *z, int *realnum){
350: if( *z=='-' || *z=='+' ) z++;
351: if( !IsDigit(*z) ){
352: return 0;
353: }
354: z++;
355: if( realnum ) *realnum = 0;
356: while( IsDigit(*z) ){ z++; }
357: if( *z=='.' ){
358: z++;
359: if( !IsDigit(*z) ) return 0;
360: while( IsDigit(*z) ){ z++; }
361: if( realnum ) *realnum = 1;
362: }
363: if( *z=='e' || *z=='E' ){
364: z++;
365: if( *z=='+' || *z=='-' ) z++;
366: if( !IsDigit(*z) ) return 0;
367: while( IsDigit(*z) ){ z++; }
368: if( realnum ) *realnum = 1;
369: }
370: return *z==0;
371: }
372:
373: /*
374: ** A global char* and an SQL function to access its current value
375: ** from within an SQL statement. This program used to use the
376: ** sqlite_exec_printf() API to substitue a string into an SQL statement.
377: ** The correct way to do this with sqlite3 is to use the bind API, but
378: ** since the shell is built around the callback paradigm it would be a lot
379: ** of work. Instead just use this hack, which is quite harmless.
380: */
381: static const char *zShellStatic = 0;
382: static void shellstaticFunc(
383: sqlite3_context *context,
384: int argc,
385: sqlite3_value **argv
386: ){
387: assert( 0==argc );
388: assert( zShellStatic );
389: UNUSED_PARAMETER(argc);
390: UNUSED_PARAMETER(argv);
391: sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC);
392: }
393:
394:
395: /*
396: ** This routine reads a line of text from FILE in, stores
397: ** the text in memory obtained from malloc() and returns a pointer
398: ** to the text. NULL is returned at end of file, or if malloc()
399: ** fails.
400: **
1.1.1.7 jturner 401: ** If zLine is not NULL then it is a malloced buffer returned from
402: ** a previous call to this routine that may be reused.
1.1 espie 403: */
1.1.1.7 jturner 404: static char *local_getline(char *zLine, FILE *in){
405: int nLine = zLine==0 ? 0 : 100;
406: int n = 0;
1.1 espie 407:
408: while( 1 ){
409: if( n+100>nLine ){
410: nLine = nLine*2 + 100;
411: zLine = realloc(zLine, nLine);
412: if( zLine==0 ) return 0;
413: }
414: if( fgets(&zLine[n], nLine - n, in)==0 ){
415: if( n==0 ){
416: free(zLine);
417: return 0;
418: }
419: zLine[n] = 0;
420: break;
421: }
1.1.1.7 jturner 422: while( zLine[n] ) n++;
423: if( n>0 && zLine[n-1]=='\n' ){
1.1 espie 424: n--;
425: if( n>0 && zLine[n-1]=='\r' ) n--;
426: zLine[n] = 0;
427: break;
428: }
429: }
430: return zLine;
431: }
432:
433: /*
434: ** Retrieve a single line of input text.
435: **
1.1.1.7 jturner 436: ** If in==0 then read from standard input and prompt before each line.
437: ** If isContinuation is true, then a continuation prompt is appropriate.
438: ** If isContinuation is zero, then the main prompt should be used.
439: **
440: ** If zPrior is not NULL then it is a buffer from a prior call to this
441: ** routine that can be reused.
442: **
443: ** The result is stored in space obtained from malloc() and must either
444: ** be freed by the caller or else passed back into this routine via the
445: ** zPrior argument for reuse.
1.1 espie 446: */
1.1.1.7 jturner 447: static char *one_input_line(FILE *in, char *zPrior, int isContinuation){
1.1 espie 448: char *zPrompt;
449: char *zResult;
450: if( in!=0 ){
1.1.1.7 jturner 451: zResult = local_getline(zPrior, in);
1.1 espie 452: }else{
1.1.1.7 jturner 453: zPrompt = isContinuation ? continuePrompt : mainPrompt;
1.1.1.11! jturner 454: #if SHELL_USE_LOCAL_GETLINE
1.1.1.7 jturner 455: printf("%s", zPrompt);
456: fflush(stdout);
457: zResult = local_getline(zPrior, stdin);
1.1.1.11! jturner 458: #else
! 459: free(zPrior);
! 460: zResult = shell_readline(zPrompt);
! 461: if( zResult && *zResult ) shell_add_history(zResult);
1.1 espie 462: #endif
1.1.1.7 jturner 463: }
1.1 espie 464: return zResult;
465: }
466:
1.1.1.10 jturner 467: /*
468: ** Shell output mode information from before ".explain on",
469: ** saved so that it can be restored by ".explain off"
470: */
471: typedef struct SavedModeInfo SavedModeInfo;
472: struct SavedModeInfo {
473: int valid; /* Is there legit data in here? */
474: int mode; /* Mode prior to ".explain on" */
475: int showHeader; /* The ".header" setting prior to ".explain on" */
476: int colWidth[100]; /* Column widths prior to ".explain on" */
1.1 espie 477: };
478:
479: /*
1.1.1.10 jturner 480: ** State information about the database connection is contained in an
481: ** instance of the following structure.
1.1 espie 482: */
1.1.1.10 jturner 483: typedef struct ShellState ShellState;
484: struct ShellState {
1.1 espie 485: sqlite3 *db; /* The database */
486: int echoOn; /* True to echo input commands */
1.1.1.9 jturner 487: int autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
1.1 espie 488: int statsOn; /* True to display memory stats before each finalize */
1.1.1.11! jturner 489: int scanstatsOn; /* True to display scan stats before each finalize */
1.1.1.9 jturner 490: int outCount; /* Revert to stdout when reaching zero */
1.1 espie 491: int cnt; /* Number of records displayed so far */
492: FILE *out; /* Write results here */
1.1.1.2 espie 493: FILE *traceOut; /* Output for sqlite3_trace() */
1.1 espie 494: int nErr; /* Number of errors seen */
495: int mode; /* An output mode setting */
496: int writableSchema; /* True if PRAGMA writable_schema=ON */
497: int showHeader; /* True to show column names in List or Column mode */
1.1.1.10 jturner 498: unsigned shellFlgs; /* Various flags */
1.1 espie 499: char *zDestTable; /* Name of destination table when MODE_Insert */
1.1.1.11! jturner 500: char colSeparator[20]; /* Column separator character for several modes */
! 501: char rowSeparator[20]; /* Row separator character for MODE_Ascii */
1.1 espie 502: int colWidth[100]; /* Requested width of each column when in column mode*/
503: int actualWidth[100]; /* Actual width of each column */
1.1.1.11! jturner 504: char nullValue[20]; /* The text to print when a NULL comes back from
1.1 espie 505: ** the database */
1.1.1.10 jturner 506: SavedModeInfo normalMode;/* Holds the mode just before .explain ON */
1.1 espie 507: char outfile[FILENAME_MAX]; /* Filename for *out */
508: const char *zDbFilename; /* name of the database file */
1.1.1.8 jturner 509: char *zFreeOnClose; /* Filename to free when closing */
1.1 espie 510: const char *zVfs; /* Name of VFS to use */
511: sqlite3_stmt *pStmt; /* Current statement if any. */
512: FILE *pLog; /* Write log output here */
1.1.1.8 jturner 513: int *aiIndent; /* Array of indents used in MODE_Explain */
514: int nIndent; /* Size of array aiIndent[] */
515: int iIndent; /* Index of current op in aiIndent[] */
1.1 espie 516: };
517:
518: /*
1.1.1.10 jturner 519: ** These are the allowed shellFlgs values
520: */
521: #define SHFLG_Scratch 0x00001 /* The --scratch option is used */
522: #define SHFLG_Pagecache 0x00002 /* The --pagecache option is used */
523: #define SHFLG_Lookaside 0x00004 /* Lookaside memory is used */
524:
525: /*
1.1 espie 526: ** These are the allowed modes.
527: */
528: #define MODE_Line 0 /* One column per line. Blank line between records */
529: #define MODE_Column 1 /* One record per line in neat columns */
530: #define MODE_List 2 /* One record per line with a separator */
531: #define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */
532: #define MODE_Html 4 /* Generate an XHTML table */
533: #define MODE_Insert 5 /* Generate SQL "insert" statements */
534: #define MODE_Tcl 6 /* Generate ANSI-C or TCL quoted elements */
535: #define MODE_Csv 7 /* Quote strings, numbers are plain */
536: #define MODE_Explain 8 /* Like MODE_Column, but do not truncate data */
1.1.1.11! jturner 537: #define MODE_Ascii 9 /* Use ASCII unit and record separators (0x1F/0x1E) */
1.1 espie 538:
539: static const char *modeDescr[] = {
540: "line",
541: "column",
542: "list",
543: "semi",
544: "html",
545: "insert",
546: "tcl",
547: "csv",
548: "explain",
1.1.1.11! jturner 549: "ascii",
1.1 espie 550: };
551:
552: /*
1.1.1.11! jturner 553: ** These are the column/row/line separators used by the various
! 554: ** import/export modes.
! 555: */
! 556: #define SEP_Column "|"
! 557: #define SEP_Row "\n"
! 558: #define SEP_Tab "\t"
! 559: #define SEP_Space " "
! 560: #define SEP_Comma ","
! 561: #define SEP_CrLf "\r\n"
! 562: #define SEP_Unit "\x1F"
! 563: #define SEP_Record "\x1E"
! 564:
! 565: /*
1.1 espie 566: ** Number of elements in an array
567: */
568: #define ArraySize(X) (int)(sizeof(X)/sizeof(X[0]))
569:
570: /*
571: ** Compute a string length that is limited to what can be stored in
572: ** lower 30 bits of a 32-bit signed integer.
573: */
574: static int strlen30(const char *z){
575: const char *z2 = z;
576: while( *z2 ){ z2++; }
577: return 0x3fffffff & (int)(z2 - z);
578: }
579:
580: /*
581: ** A callback for the sqlite3_log() interface.
582: */
583: static void shellLog(void *pArg, int iErrCode, const char *zMsg){
1.1.1.10 jturner 584: ShellState *p = (ShellState*)pArg;
1.1 espie 585: if( p->pLog==0 ) return;
586: fprintf(p->pLog, "(%d) %s\n", iErrCode, zMsg);
587: fflush(p->pLog);
588: }
589:
590: /*
591: ** Output the given string as a hex-encoded blob (eg. X'1234' )
592: */
593: static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){
594: int i;
595: char *zBlob = (char *)pBlob;
596: fprintf(out,"X'");
1.1.1.2 espie 597: for(i=0; i<nBlob; i++){ fprintf(out,"%02x",zBlob[i]&0xff); }
1.1 espie 598: fprintf(out,"'");
599: }
600:
601: /*
602: ** Output the given string as a quoted string using SQL quoting conventions.
603: */
604: static void output_quoted_string(FILE *out, const char *z){
605: int i;
606: int nSingle = 0;
607: for(i=0; z[i]; i++){
608: if( z[i]=='\'' ) nSingle++;
609: }
610: if( nSingle==0 ){
611: fprintf(out,"'%s'",z);
612: }else{
613: fprintf(out,"'");
614: while( *z ){
615: for(i=0; z[i] && z[i]!='\''; i++){}
616: if( i==0 ){
617: fprintf(out,"''");
618: z++;
619: }else if( z[i]=='\'' ){
620: fprintf(out,"%.*s''",i,z);
621: z += i+1;
622: }else{
623: fprintf(out,"%s",z);
624: break;
625: }
626: }
627: fprintf(out,"'");
628: }
629: }
630:
631: /*
632: ** Output the given string as a quoted according to C or TCL quoting rules.
633: */
634: static void output_c_string(FILE *out, const char *z){
635: unsigned int c;
636: fputc('"', out);
637: while( (c = *(z++))!=0 ){
638: if( c=='\\' ){
639: fputc(c, out);
640: fputc(c, out);
1.1.1.5 espie 641: }else if( c=='"' ){
642: fputc('\\', out);
643: fputc('"', out);
1.1 espie 644: }else if( c=='\t' ){
645: fputc('\\', out);
646: fputc('t', out);
647: }else if( c=='\n' ){
648: fputc('\\', out);
649: fputc('n', out);
650: }else if( c=='\r' ){
651: fputc('\\', out);
652: fputc('r', out);
1.1.1.8 jturner 653: }else if( !isprint(c&0xff) ){
1.1 espie 654: fprintf(out, "\\%03o", c&0xff);
655: }else{
656: fputc(c, out);
657: }
658: }
659: fputc('"', out);
660: }
661:
662: /*
663: ** Output the given string with characters that are special to
664: ** HTML escaped.
665: */
666: static void output_html_string(FILE *out, const char *z){
667: int i;
1.1.1.8 jturner 668: if( z==0 ) z = "";
1.1 espie 669: while( *z ){
670: for(i=0; z[i]
671: && z[i]!='<'
672: && z[i]!='&'
673: && z[i]!='>'
674: && z[i]!='\"'
675: && z[i]!='\'';
676: i++){}
677: if( i>0 ){
678: fprintf(out,"%.*s",i,z);
679: }
680: if( z[i]=='<' ){
681: fprintf(out,"<");
682: }else if( z[i]=='&' ){
683: fprintf(out,"&");
684: }else if( z[i]=='>' ){
685: fprintf(out,">");
686: }else if( z[i]=='\"' ){
687: fprintf(out,""");
688: }else if( z[i]=='\'' ){
689: fprintf(out,"'");
690: }else{
691: break;
692: }
693: z += i + 1;
694: }
695: }
696:
697: /*
698: ** If a field contains any character identified by a 1 in the following
699: ** array, then the string must be quoted for CSV.
700: */
701: static const char needCsvQuote[] = {
702: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
703: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
704: 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
705: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
706: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
707: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
708: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
709: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
710: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
711: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
712: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
713: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
714: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
715: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
716: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
717: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
718: };
719:
720: /*
1.1.1.11! jturner 721: ** Output a single term of CSV. Actually, p->colSeparator is used for
! 722: ** the separator, which may or may not be a comma. p->nullValue is
1.1.1.9 jturner 723: ** the null value. Strings are quoted if necessary. The separator
724: ** is only issued if bSep is true.
1.1 espie 725: */
1.1.1.10 jturner 726: static void output_csv(ShellState *p, const char *z, int bSep){
1.1 espie 727: FILE *out = p->out;
728: if( z==0 ){
1.1.1.11! jturner 729: fprintf(out,"%s",p->nullValue);
1.1 espie 730: }else{
731: int i;
1.1.1.11! jturner 732: int nSep = strlen30(p->colSeparator);
1.1 espie 733: for(i=0; z[i]; i++){
734: if( needCsvQuote[((unsigned char*)z)[i]]
1.1.1.11! jturner 735: || (z[i]==p->colSeparator[0] &&
! 736: (nSep==1 || memcmp(z, p->colSeparator, nSep)==0)) ){
1.1 espie 737: i = 0;
738: break;
739: }
740: }
741: if( i==0 ){
742: putc('"', out);
743: for(i=0; z[i]; i++){
744: if( z[i]=='"' ) putc('"', out);
745: putc(z[i], out);
746: }
747: putc('"', out);
748: }else{
749: fprintf(out, "%s", z);
750: }
751: }
752: if( bSep ){
1.1.1.11! jturner 753: fprintf(p->out, "%s", p->colSeparator);
1.1 espie 754: }
755: }
756:
757: #ifdef SIGINT
758: /*
759: ** This routine runs when the user presses Ctrl-C
760: */
761: static void interrupt_handler(int NotUsed){
762: UNUSED_PARAMETER(NotUsed);
1.1.1.9 jturner 763: seenInterrupt++;
764: if( seenInterrupt>2 ) exit(1);
1.1 espie 765: if( db ) sqlite3_interrupt(db);
766: }
767: #endif
768:
769: /*
770: ** This is the callback routine that the shell
771: ** invokes for each row of a query result.
772: */
1.1.1.11! jturner 773: static int shell_callback(
! 774: void *pArg,
! 775: int nArg, /* Number of result columns */
! 776: char **azArg, /* Text of each result column */
! 777: char **azCol, /* Column names */
! 778: int *aiType /* Column types */
! 779: ){
1.1 espie 780: int i;
1.1.1.10 jturner 781: ShellState *p = (ShellState*)pArg;
1.1 espie 782:
783: switch( p->mode ){
784: case MODE_Line: {
785: int w = 5;
786: if( azArg==0 ) break;
787: for(i=0; i<nArg; i++){
788: int len = strlen30(azCol[i] ? azCol[i] : "");
789: if( len>w ) w = len;
790: }
1.1.1.11! jturner 791: if( p->cnt++>0 ) fprintf(p->out, "%s", p->rowSeparator);
1.1 espie 792: for(i=0; i<nArg; i++){
1.1.1.11! jturner 793: fprintf(p->out,"%*s = %s%s", w, azCol[i],
! 794: azArg[i] ? azArg[i] : p->nullValue, p->rowSeparator);
1.1 espie 795: }
796: break;
797: }
798: case MODE_Explain:
799: case MODE_Column: {
800: if( p->cnt++==0 ){
801: for(i=0; i<nArg; i++){
802: int w, n;
803: if( i<ArraySize(p->colWidth) ){
804: w = p->colWidth[i];
805: }else{
806: w = 0;
807: }
1.1.1.5 espie 808: if( w==0 ){
1.1 espie 809: w = strlen30(azCol[i] ? azCol[i] : "");
810: if( w<10 ) w = 10;
1.1.1.11! jturner 811: n = strlen30(azArg && azArg[i] ? azArg[i] : p->nullValue);
1.1 espie 812: if( w<n ) w = n;
813: }
814: if( i<ArraySize(p->actualWidth) ){
815: p->actualWidth[i] = w;
816: }
817: if( p->showHeader ){
1.1.1.5 espie 818: if( w<0 ){
1.1.1.11! jturner 819: fprintf(p->out,"%*.*s%s",-w,-w,azCol[i],
! 820: i==nArg-1 ? p->rowSeparator : " ");
1.1.1.5 espie 821: }else{
1.1.1.11! jturner 822: fprintf(p->out,"%-*.*s%s",w,w,azCol[i],
! 823: i==nArg-1 ? p->rowSeparator : " ");
1.1.1.5 espie 824: }
1.1 espie 825: }
826: }
827: if( p->showHeader ){
828: for(i=0; i<nArg; i++){
829: int w;
830: if( i<ArraySize(p->actualWidth) ){
831: w = p->actualWidth[i];
1.1.1.5 espie 832: if( w<0 ) w = -w;
1.1 espie 833: }else{
834: w = 10;
835: }
836: fprintf(p->out,"%-*.*s%s",w,w,"-----------------------------------"
837: "----------------------------------------------------------",
1.1.1.11! jturner 838: i==nArg-1 ? p->rowSeparator : " ");
1.1 espie 839: }
840: }
841: }
842: if( azArg==0 ) break;
843: for(i=0; i<nArg; i++){
844: int w;
845: if( i<ArraySize(p->actualWidth) ){
846: w = p->actualWidth[i];
847: }else{
848: w = 10;
849: }
1.1.1.8 jturner 850: if( p->mode==MODE_Explain && azArg[i] && strlen30(azArg[i])>w ){
1.1 espie 851: w = strlen30(azArg[i]);
852: }
1.1.1.8 jturner 853: if( i==1 && p->aiIndent && p->pStmt ){
854: if( p->iIndent<p->nIndent ){
855: fprintf(p->out, "%*.s", p->aiIndent[p->iIndent], "");
856: }
857: p->iIndent++;
858: }
1.1.1.5 espie 859: if( w<0 ){
860: fprintf(p->out,"%*.*s%s",-w,-w,
1.1.1.11! jturner 861: azArg[i] ? azArg[i] : p->nullValue,
! 862: i==nArg-1 ? p->rowSeparator : " ");
1.1.1.5 espie 863: }else{
864: fprintf(p->out,"%-*.*s%s",w,w,
1.1.1.11! jturner 865: azArg[i] ? azArg[i] : p->nullValue,
! 866: i==nArg-1 ? p->rowSeparator : " ");
1.1.1.5 espie 867: }
1.1 espie 868: }
869: break;
870: }
871: case MODE_Semi:
872: case MODE_List: {
873: if( p->cnt++==0 && p->showHeader ){
874: for(i=0; i<nArg; i++){
1.1.1.11! jturner 875: fprintf(p->out,"%s%s",azCol[i],
! 876: i==nArg-1 ? p->rowSeparator : p->colSeparator);
1.1 espie 877: }
878: }
879: if( azArg==0 ) break;
880: for(i=0; i<nArg; i++){
881: char *z = azArg[i];
1.1.1.11! jturner 882: if( z==0 ) z = p->nullValue;
1.1 espie 883: fprintf(p->out, "%s", z);
884: if( i<nArg-1 ){
1.1.1.11! jturner 885: fprintf(p->out, "%s", p->colSeparator);
1.1 espie 886: }else if( p->mode==MODE_Semi ){
1.1.1.11! jturner 887: fprintf(p->out, ";%s", p->rowSeparator);
1.1 espie 888: }else{
1.1.1.11! jturner 889: fprintf(p->out, "%s", p->rowSeparator);
1.1 espie 890: }
891: }
892: break;
893: }
894: case MODE_Html: {
895: if( p->cnt++==0 && p->showHeader ){
896: fprintf(p->out,"<TR>");
897: for(i=0; i<nArg; i++){
898: fprintf(p->out,"<TH>");
899: output_html_string(p->out, azCol[i]);
900: fprintf(p->out,"</TH>\n");
901: }
902: fprintf(p->out,"</TR>\n");
903: }
904: if( azArg==0 ) break;
905: fprintf(p->out,"<TR>");
906: for(i=0; i<nArg; i++){
907: fprintf(p->out,"<TD>");
1.1.1.11! jturner 908: output_html_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
1.1 espie 909: fprintf(p->out,"</TD>\n");
910: }
911: fprintf(p->out,"</TR>\n");
912: break;
913: }
914: case MODE_Tcl: {
915: if( p->cnt++==0 && p->showHeader ){
916: for(i=0; i<nArg; i++){
917: output_c_string(p->out,azCol[i] ? azCol[i] : "");
1.1.1.11! jturner 918: if(i<nArg-1) fprintf(p->out, "%s", p->colSeparator);
1.1 espie 919: }
1.1.1.11! jturner 920: fprintf(p->out, "%s", p->rowSeparator);
1.1 espie 921: }
922: if( azArg==0 ) break;
923: for(i=0; i<nArg; i++){
1.1.1.11! jturner 924: output_c_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
! 925: if(i<nArg-1) fprintf(p->out, "%s", p->colSeparator);
1.1 espie 926: }
1.1.1.11! jturner 927: fprintf(p->out, "%s", p->rowSeparator);
1.1 espie 928: break;
929: }
930: case MODE_Csv: {
1.1.1.9 jturner 931: #if defined(WIN32) || defined(_WIN32)
932: fflush(p->out);
933: _setmode(_fileno(p->out), _O_BINARY);
934: #endif
1.1 espie 935: if( p->cnt++==0 && p->showHeader ){
936: for(i=0; i<nArg; i++){
937: output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
938: }
1.1.1.11! jturner 939: fprintf(p->out, "%s", p->rowSeparator);
1.1 espie 940: }
1.1.1.11! jturner 941: if( nArg>0 ){
1.1.1.9 jturner 942: for(i=0; i<nArg; i++){
943: output_csv(p, azArg[i], i<nArg-1);
944: }
1.1.1.11! jturner 945: fprintf(p->out, "%s", p->rowSeparator);
1.1 espie 946: }
1.1.1.9 jturner 947: #if defined(WIN32) || defined(_WIN32)
948: fflush(p->out);
949: _setmode(_fileno(p->out), _O_TEXT);
950: #endif
1.1 espie 951: break;
952: }
953: case MODE_Insert: {
954: p->cnt++;
955: if( azArg==0 ) break;
956: fprintf(p->out,"INSERT INTO %s VALUES(",p->zDestTable);
957: for(i=0; i<nArg; i++){
958: char *zSep = i>0 ? ",": "";
959: if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
960: fprintf(p->out,"%sNULL",zSep);
961: }else if( aiType && aiType[i]==SQLITE_TEXT ){
962: if( zSep[0] ) fprintf(p->out,"%s",zSep);
963: output_quoted_string(p->out, azArg[i]);
1.1.1.9 jturner 964: }else if( aiType && (aiType[i]==SQLITE_INTEGER
965: || aiType[i]==SQLITE_FLOAT) ){
1.1 espie 966: fprintf(p->out,"%s%s",zSep, azArg[i]);
967: }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
968: const void *pBlob = sqlite3_column_blob(p->pStmt, i);
969: int nBlob = sqlite3_column_bytes(p->pStmt, i);
970: if( zSep[0] ) fprintf(p->out,"%s",zSep);
971: output_hex_blob(p->out, pBlob, nBlob);
972: }else if( isNumber(azArg[i], 0) ){
973: fprintf(p->out,"%s%s",zSep, azArg[i]);
974: }else{
975: if( zSep[0] ) fprintf(p->out,"%s",zSep);
976: output_quoted_string(p->out, azArg[i]);
977: }
978: }
979: fprintf(p->out,");\n");
980: break;
981: }
1.1.1.11! jturner 982: case MODE_Ascii: {
! 983: if( p->cnt++==0 && p->showHeader ){
! 984: for(i=0; i<nArg; i++){
! 985: if( i>0 ) fprintf(p->out, "%s", p->colSeparator);
! 986: fprintf(p->out,"%s",azCol[i] ? azCol[i] : "");
! 987: }
! 988: fprintf(p->out, "%s", p->rowSeparator);
! 989: }
! 990: if( azArg==0 ) break;
! 991: for(i=0; i<nArg; i++){
! 992: if( i>0 ) fprintf(p->out, "%s", p->colSeparator);
! 993: fprintf(p->out,"%s",azArg[i] ? azArg[i] : p->nullValue);
! 994: }
! 995: fprintf(p->out, "%s", p->rowSeparator);
! 996: break;
! 997: }
1.1 espie 998: }
999: return 0;
1000: }
1001:
1002: /*
1003: ** This is the callback routine that the SQLite library
1004: ** invokes for each row of a query result.
1005: */
1006: static int callback(void *pArg, int nArg, char **azArg, char **azCol){
1007: /* since we don't have type info, call the shell_callback with a NULL value */
1008: return shell_callback(pArg, nArg, azArg, azCol, NULL);
1009: }
1010:
1011: /*
1.1.1.10 jturner 1012: ** Set the destination table field of the ShellState structure to
1.1 espie 1013: ** the name of the table given. Escape any quote characters in the
1014: ** table name.
1015: */
1.1.1.10 jturner 1016: static void set_table_name(ShellState *p, const char *zName){
1.1 espie 1017: int i, n;
1018: int needQuote;
1019: char *z;
1020:
1021: if( p->zDestTable ){
1022: free(p->zDestTable);
1023: p->zDestTable = 0;
1024: }
1025: if( zName==0 ) return;
1026: needQuote = !isalpha((unsigned char)*zName) && *zName!='_';
1027: for(i=n=0; zName[i]; i++, n++){
1028: if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){
1029: needQuote = 1;
1030: if( zName[i]=='\'' ) n++;
1031: }
1032: }
1033: if( needQuote ) n += 2;
1034: z = p->zDestTable = malloc( n+1 );
1035: if( z==0 ){
1036: fprintf(stderr,"Error: out of memory\n");
1037: exit(1);
1038: }
1039: n = 0;
1040: if( needQuote ) z[n++] = '\'';
1041: for(i=0; zName[i]; i++){
1042: z[n++] = zName[i];
1043: if( zName[i]=='\'' ) z[n++] = '\'';
1044: }
1045: if( needQuote ) z[n++] = '\'';
1046: z[n] = 0;
1047: }
1048:
1049: /* zIn is either a pointer to a NULL-terminated string in memory obtained
1050: ** from malloc(), or a NULL pointer. The string pointed to by zAppend is
1051: ** added to zIn, and the result returned in memory obtained from malloc().
1052: ** zIn, if it was not NULL, is freed.
1053: **
1054: ** If the third argument, quote, is not '\0', then it is used as a
1055: ** quote character for zAppend.
1056: */
1057: static char *appendText(char *zIn, char const *zAppend, char quote){
1058: int len;
1059: int i;
1060: int nAppend = strlen30(zAppend);
1061: int nIn = (zIn?strlen30(zIn):0);
1062:
1063: len = nAppend+nIn+1;
1064: if( quote ){
1065: len += 2;
1066: for(i=0; i<nAppend; i++){
1067: if( zAppend[i]==quote ) len++;
1068: }
1069: }
1070:
1071: zIn = (char *)realloc(zIn, len);
1072: if( !zIn ){
1073: return 0;
1074: }
1075:
1076: if( quote ){
1077: char *zCsr = &zIn[nIn];
1078: *zCsr++ = quote;
1079: for(i=0; i<nAppend; i++){
1080: *zCsr++ = zAppend[i];
1081: if( zAppend[i]==quote ) *zCsr++ = quote;
1082: }
1083: *zCsr++ = quote;
1084: *zCsr++ = '\0';
1085: assert( (zCsr-zIn)==len );
1086: }else{
1087: memcpy(&zIn[nIn], zAppend, nAppend);
1088: zIn[len-1] = '\0';
1089: }
1090:
1091: return zIn;
1092: }
1093:
1094:
1095: /*
1096: ** Execute a query statement that will generate SQL output. Print
1097: ** the result columns, comma-separated, on a line and then add a
1098: ** semicolon terminator to the end of that line.
1099: **
1100: ** If the number of columns is 1 and that column contains text "--"
1101: ** then write the semicolon on a separate line. That way, if a
1102: ** "--" comment occurs at the end of the statement, the comment
1103: ** won't consume the semicolon terminator.
1104: */
1105: static int run_table_dump_query(
1.1.1.10 jturner 1106: ShellState *p, /* Query context */
1.1 espie 1107: const char *zSelect, /* SELECT statement to extract content */
1108: const char *zFirstRow /* Print before first row, if not NULL */
1109: ){
1110: sqlite3_stmt *pSelect;
1111: int rc;
1112: int nResult;
1113: int i;
1114: const char *z;
1.1.1.8 jturner 1115: rc = sqlite3_prepare_v2(p->db, zSelect, -1, &pSelect, 0);
1.1 espie 1116: if( rc!=SQLITE_OK || !pSelect ){
1117: fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db));
1.1.1.8 jturner 1118: if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
1.1 espie 1119: return rc;
1120: }
1121: rc = sqlite3_step(pSelect);
1122: nResult = sqlite3_column_count(pSelect);
1123: while( rc==SQLITE_ROW ){
1124: if( zFirstRow ){
1125: fprintf(p->out, "%s", zFirstRow);
1126: zFirstRow = 0;
1127: }
1128: z = (const char*)sqlite3_column_text(pSelect, 0);
1129: fprintf(p->out, "%s", z);
1130: for(i=1; i<nResult; i++){
1131: fprintf(p->out, ",%s", sqlite3_column_text(pSelect, i));
1132: }
1133: if( z==0 ) z = "";
1134: while( z[0] && (z[0]!='-' || z[1]!='-') ) z++;
1135: if( z[0] ){
1136: fprintf(p->out, "\n;\n");
1137: }else{
1138: fprintf(p->out, ";\n");
1139: }
1140: rc = sqlite3_step(pSelect);
1141: }
1142: rc = sqlite3_finalize(pSelect);
1143: if( rc!=SQLITE_OK ){
1144: fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db));
1.1.1.8 jturner 1145: if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
1.1 espie 1146: }
1147: return rc;
1148: }
1149:
1150: /*
1151: ** Allocate space and save off current error string.
1152: */
1153: static char *save_err_msg(
1154: sqlite3 *db /* Database to query */
1155: ){
1156: int nErrMsg = 1+strlen30(sqlite3_errmsg(db));
1157: char *zErrMsg = sqlite3_malloc(nErrMsg);
1158: if( zErrMsg ){
1159: memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg);
1160: }
1161: return zErrMsg;
1162: }
1163:
1164: /*
1165: ** Display memory stats.
1166: */
1167: static int display_stats(
1168: sqlite3 *db, /* Database to query */
1.1.1.10 jturner 1169: ShellState *pArg, /* Pointer to ShellState */
1.1 espie 1170: int bReset /* True to reset the stats */
1171: ){
1172: int iCur;
1173: int iHiwtr;
1174:
1175: if( pArg && pArg->out ){
1176:
1177: iHiwtr = iCur = -1;
1178: sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, bReset);
1.1.1.11! jturner 1179: fprintf(pArg->out,
! 1180: "Memory Used: %d (max %d) bytes\n",
! 1181: iCur, iHiwtr);
1.1 espie 1182: iHiwtr = iCur = -1;
1183: sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset);
1.1.1.11! jturner 1184: fprintf(pArg->out, "Number of Outstanding Allocations: %d (max %d)\n",
! 1185: iCur, iHiwtr);
1.1.1.10 jturner 1186: if( pArg->shellFlgs & SHFLG_Pagecache ){
1187: iHiwtr = iCur = -1;
1188: sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset);
1.1.1.11! jturner 1189: fprintf(pArg->out,
! 1190: "Number of Pcache Pages Used: %d (max %d) pages\n",
! 1191: iCur, iHiwtr);
1.1.1.10 jturner 1192: }
1.1 espie 1193: iHiwtr = iCur = -1;
1194: sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset);
1.1.1.11! jturner 1195: fprintf(pArg->out,
! 1196: "Number of Pcache Overflow Bytes: %d (max %d) bytes\n",
! 1197: iCur, iHiwtr);
1.1.1.10 jturner 1198: if( pArg->shellFlgs & SHFLG_Scratch ){
1199: iHiwtr = iCur = -1;
1200: sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset);
1.1.1.11! jturner 1201: fprintf(pArg->out, "Number of Scratch Allocations Used: %d (max %d)\n",
! 1202: iCur, iHiwtr);
1.1.1.10 jturner 1203: }
1.1 espie 1204: iHiwtr = iCur = -1;
1205: sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset);
1.1.1.11! jturner 1206: fprintf(pArg->out,
! 1207: "Number of Scratch Overflow Bytes: %d (max %d) bytes\n",
! 1208: iCur, iHiwtr);
1.1 espie 1209: iHiwtr = iCur = -1;
1210: sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, bReset);
1.1.1.11! jturner 1211: fprintf(pArg->out, "Largest Allocation: %d bytes\n",
! 1212: iHiwtr);
1.1 espie 1213: iHiwtr = iCur = -1;
1214: sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, bReset);
1.1.1.11! jturner 1215: fprintf(pArg->out, "Largest Pcache Allocation: %d bytes\n",
! 1216: iHiwtr);
1.1 espie 1217: iHiwtr = iCur = -1;
1218: sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHiwtr, bReset);
1.1.1.11! jturner 1219: fprintf(pArg->out, "Largest Scratch Allocation: %d bytes\n",
! 1220: iHiwtr);
1.1 espie 1221: #ifdef YYTRACKMAXSTACKDEPTH
1222: iHiwtr = iCur = -1;
1223: sqlite3_status(SQLITE_STATUS_PARSER_STACK, &iCur, &iHiwtr, bReset);
1.1.1.11! jturner 1224: fprintf(pArg->out, "Deepest Parser Stack: %d (max %d)\n",
! 1225: iCur, iHiwtr);
1.1 espie 1226: #endif
1227: }
1228:
1229: if( pArg && pArg->out && db ){
1.1.1.10 jturner 1230: if( pArg->shellFlgs & SHFLG_Lookaside ){
1231: iHiwtr = iCur = -1;
1.1.1.11! jturner 1232: sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED,
! 1233: &iCur, &iHiwtr, bReset);
! 1234: fprintf(pArg->out, "Lookaside Slots Used: %d (max %d)\n",
! 1235: iCur, iHiwtr);
! 1236: sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT,
! 1237: &iCur, &iHiwtr, bReset);
1.1.1.10 jturner 1238: fprintf(pArg->out, "Successful lookaside attempts: %d\n", iHiwtr);
1.1.1.11! jturner 1239: sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE,
! 1240: &iCur, &iHiwtr, bReset);
1.1.1.10 jturner 1241: fprintf(pArg->out, "Lookaside failures due to size: %d\n", iHiwtr);
1.1.1.11! jturner 1242: sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL,
! 1243: &iCur, &iHiwtr, bReset);
1.1.1.10 jturner 1244: fprintf(pArg->out, "Lookaside failures due to OOM: %d\n", iHiwtr);
1245: }
1.1 espie 1246: iHiwtr = iCur = -1;
1247: sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);
1.1.1.11! jturner 1248: fprintf(pArg->out, "Pager Heap Usage: %d bytes\n",iCur);
! 1249: iHiwtr = iCur = -1;
1.1 espie 1250: sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1);
1251: fprintf(pArg->out, "Page cache hits: %d\n", iCur);
1252: iHiwtr = iCur = -1;
1253: sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1);
1254: fprintf(pArg->out, "Page cache misses: %d\n", iCur);
1255: iHiwtr = iCur = -1;
1.1.1.2 espie 1256: sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1);
1257: fprintf(pArg->out, "Page cache writes: %d\n", iCur);
1258: iHiwtr = iCur = -1;
1.1 espie 1259: sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset);
1.1.1.11! jturner 1260: fprintf(pArg->out, "Schema Heap Usage: %d bytes\n",iCur);
1.1 espie 1261: iHiwtr = iCur = -1;
1262: sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset);
1.1.1.11! jturner 1263: fprintf(pArg->out, "Statement Heap/Lookaside Usage: %d bytes\n",iCur);
1.1 espie 1264: }
1265:
1266: if( pArg && pArg->out && db && pArg->pStmt ){
1.1.1.11! jturner 1267: iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP,
! 1268: bReset);
1.1 espie 1269: fprintf(pArg->out, "Fullscan Steps: %d\n", iCur);
1270: iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset);
1271: fprintf(pArg->out, "Sort Operations: %d\n", iCur);
1.1.1.11! jturner 1272: iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX,bReset);
1.1 espie 1273: fprintf(pArg->out, "Autoindex Inserts: %d\n", iCur);
1.1.1.7 jturner 1274: iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset);
1275: fprintf(pArg->out, "Virtual Machine Steps: %d\n", iCur);
1.1 espie 1276: }
1277:
1278: return 0;
1279: }
1280:
1281: /*
1.1.1.11! jturner 1282: ** Display scan stats.
! 1283: */
! 1284: static void display_scanstats(
! 1285: sqlite3 *db, /* Database to query */
! 1286: ShellState *pArg /* Pointer to ShellState */
! 1287: ){
! 1288: #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
! 1289: int i, k, n, mx;
! 1290: fprintf(pArg->out, "-------- scanstats --------\n");
! 1291: mx = 0;
! 1292: for(k=0; k<=mx; k++){
! 1293: double rEstLoop = 1.0;
! 1294: for(i=n=0; 1; i++){
! 1295: sqlite3_stmt *p = pArg->pStmt;
! 1296: sqlite3_int64 nLoop, nVisit;
! 1297: double rEst;
! 1298: int iSid;
! 1299: const char *zExplain;
! 1300: if( sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NLOOP, (void*)&nLoop) ){
! 1301: break;
! 1302: }
! 1303: sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_SELECTID, (void*)&iSid);
! 1304: if( iSid>mx ) mx = iSid;
! 1305: if( iSid!=k ) continue;
! 1306: if( n==0 ){
! 1307: rEstLoop = (double)nLoop;
! 1308: if( k>0 ) fprintf(pArg->out, "-------- subquery %d -------\n", k);
! 1309: }
! 1310: n++;
! 1311: sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NVISIT, (void*)&nVisit);
! 1312: sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EST, (void*)&rEst);
! 1313: sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EXPLAIN, (void*)&zExplain);
! 1314: fprintf(pArg->out, "Loop %2d: %s\n", n, zExplain);
! 1315: rEstLoop *= rEst;
! 1316: fprintf(pArg->out,
! 1317: " nLoop=%-8lld nRow=%-8lld estRow=%-8lld estRow/Loop=%-8g\n",
! 1318: nLoop, nVisit, (sqlite3_int64)(rEstLoop+0.5), rEst
! 1319: );
! 1320: }
! 1321: }
! 1322: fprintf(pArg->out, "---------------------------\n");
! 1323: #endif
! 1324: }
! 1325:
! 1326: /*
1.1.1.8 jturner 1327: ** Parameter azArray points to a zero-terminated array of strings. zStr
1328: ** points to a single nul-terminated string. Return non-zero if zStr
1329: ** is equal, according to strcmp(), to any of the strings in the array.
1330: ** Otherwise, return zero.
1331: */
1332: static int str_in_array(const char *zStr, const char **azArray){
1333: int i;
1334: for(i=0; azArray[i]; i++){
1335: if( 0==strcmp(zStr, azArray[i]) ) return 1;
1336: }
1337: return 0;
1338: }
1339:
1340: /*
1341: ** If compiled statement pSql appears to be an EXPLAIN statement, allocate
1.1.1.10 jturner 1342: ** and populate the ShellState.aiIndent[] array with the number of
1.1.1.8 jturner 1343: ** spaces each opcode should be indented before it is output.
1344: **
1345: ** The indenting rules are:
1346: **
1347: ** * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent
1348: ** all opcodes that occur between the p2 jump destination and the opcode
1349: ** itself by 2 spaces.
1350: **
1351: ** * For each "Goto", if the jump destination is earlier in the program
1352: ** and ends on one of:
1353: ** Yield SeekGt SeekLt RowSetRead Rewind
1354: ** or if the P1 parameter is one instead of zero,
1355: ** then indent all opcodes between the earlier instruction
1356: ** and "Goto" by 2 spaces.
1357: */
1.1.1.10 jturner 1358: static void explain_data_prepare(ShellState *p, sqlite3_stmt *pSql){
1.1.1.8 jturner 1359: const char *zSql; /* The text of the SQL statement */
1360: const char *z; /* Used to check if this is an EXPLAIN */
1361: int *abYield = 0; /* True if op is an OP_Yield */
1362: int nAlloc = 0; /* Allocated size of p->aiIndent[], abYield */
1363: int iOp; /* Index of operation in p->aiIndent[] */
1364:
1.1.1.9 jturner 1365: const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext",
1366: "NextIfOpen", "PrevIfOpen", 0 };
1.1.1.11! jturner 1367: const char *azYield[] = { "Yield", "SeekLT", "SeekGT", "RowSetRead",
! 1368: "Rewind", 0 };
1.1.1.8 jturner 1369: const char *azGoto[] = { "Goto", 0 };
1370:
1371: /* Try to figure out if this is really an EXPLAIN statement. If this
1372: ** cannot be verified, return early. */
1373: zSql = sqlite3_sql(pSql);
1374: if( zSql==0 ) return;
1375: for(z=zSql; *z==' ' || *z=='\t' || *z=='\n' || *z=='\f' || *z=='\r'; z++);
1376: if( sqlite3_strnicmp(z, "explain", 7) ) return;
1377:
1378: for(iOp=0; SQLITE_ROW==sqlite3_step(pSql); iOp++){
1379: int i;
1380: int iAddr = sqlite3_column_int(pSql, 0);
1381: const char *zOp = (const char*)sqlite3_column_text(pSql, 1);
1382:
1383: /* Set p2 to the P2 field of the current opcode. Then, assuming that
1384: ** p2 is an instruction address, set variable p2op to the index of that
1385: ** instruction in the aiIndent[] array. p2 and p2op may be different if
1386: ** the current instruction is part of a sub-program generated by an
1387: ** SQL trigger or foreign key. */
1388: int p2 = sqlite3_column_int(pSql, 3);
1389: int p2op = (p2 + (iOp-iAddr));
1390:
1391: /* Grow the p->aiIndent array as required */
1392: if( iOp>=nAlloc ){
1393: nAlloc += 100;
1394: p->aiIndent = (int*)sqlite3_realloc(p->aiIndent, nAlloc*sizeof(int));
1395: abYield = (int*)sqlite3_realloc(abYield, nAlloc*sizeof(int));
1396: }
1397: abYield[iOp] = str_in_array(zOp, azYield);
1398: p->aiIndent[iOp] = 0;
1399: p->nIndent = iOp+1;
1400:
1401: if( str_in_array(zOp, azNext) ){
1402: for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2;
1403: }
1404: if( str_in_array(zOp, azGoto) && p2op<p->nIndent
1405: && (abYield[p2op] || sqlite3_column_int(pSql, 2))
1406: ){
1407: for(i=p2op+1; i<iOp; i++) p->aiIndent[i] += 2;
1408: }
1409: }
1410:
1411: p->iIndent = 0;
1412: sqlite3_free(abYield);
1413: sqlite3_reset(pSql);
1414: }
1415:
1416: /*
1417: ** Free the array allocated by explain_data_prepare().
1418: */
1.1.1.10 jturner 1419: static void explain_data_delete(ShellState *p){
1.1.1.8 jturner 1420: sqlite3_free(p->aiIndent);
1421: p->aiIndent = 0;
1422: p->nIndent = 0;
1423: p->iIndent = 0;
1424: }
1425:
1426: /*
1.1 espie 1427: ** Execute a statement or set of statements. Print
1428: ** any result rows/columns depending on the current mode
1429: ** set via the supplied callback.
1430: **
1431: ** This is very similar to SQLite's built-in sqlite3_exec()
1432: ** function except it takes a slightly different callback
1433: ** and callback data argument.
1434: */
1435: static int shell_exec(
1.1.1.10 jturner 1436: sqlite3 *db, /* An open database */
1437: const char *zSql, /* SQL to be evaluated */
1.1 espie 1438: int (*xCallback)(void*,int,char**,char**,int*), /* Callback function */
1.1.1.10 jturner 1439: /* (not the same as sqlite3_exec) */
1440: ShellState *pArg, /* Pointer to ShellState */
1441: char **pzErrMsg /* Error msg written here */
1.1 espie 1442: ){
1443: sqlite3_stmt *pStmt = NULL; /* Statement to execute. */
1444: int rc = SQLITE_OK; /* Return Code */
1445: int rc2;
1446: const char *zLeftover; /* Tail of unprocessed SQL */
1447:
1448: if( pzErrMsg ){
1449: *pzErrMsg = NULL;
1450: }
1451:
1452: while( zSql[0] && (SQLITE_OK == rc) ){
1453: rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
1454: if( SQLITE_OK != rc ){
1455: if( pzErrMsg ){
1456: *pzErrMsg = save_err_msg(db);
1457: }
1458: }else{
1459: if( !pStmt ){
1460: /* this happens for a comment or white-space */
1461: zSql = zLeftover;
1462: while( IsSpace(zSql[0]) ) zSql++;
1463: continue;
1464: }
1465:
1466: /* save off the prepared statment handle and reset row count */
1467: if( pArg ){
1468: pArg->pStmt = pStmt;
1469: pArg->cnt = 0;
1470: }
1471:
1472: /* echo the sql statement if echo on */
1473: if( pArg && pArg->echoOn ){
1474: const char *zStmtSql = sqlite3_sql(pStmt);
1475: fprintf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
1476: }
1477:
1.1.1.8 jturner 1478: /* Show the EXPLAIN QUERY PLAN if .eqp is on */
1479: if( pArg && pArg->autoEQP ){
1480: sqlite3_stmt *pExplain;
1.1.1.11! jturner 1481: char *zEQP = sqlite3_mprintf("EXPLAIN QUERY PLAN %s",
! 1482: sqlite3_sql(pStmt));
1.1.1.8 jturner 1483: rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
1484: if( rc==SQLITE_OK ){
1485: while( sqlite3_step(pExplain)==SQLITE_ROW ){
1486: fprintf(pArg->out,"--EQP-- %d,", sqlite3_column_int(pExplain, 0));
1487: fprintf(pArg->out,"%d,", sqlite3_column_int(pExplain, 1));
1488: fprintf(pArg->out,"%d,", sqlite3_column_int(pExplain, 2));
1489: fprintf(pArg->out,"%s\n", sqlite3_column_text(pExplain, 3));
1490: }
1491: }
1492: sqlite3_finalize(pExplain);
1493: sqlite3_free(zEQP);
1494: }
1495:
1496: /* If the shell is currently in ".explain" mode, gather the extra
1497: ** data required to add indents to the output.*/
1498: if( pArg && pArg->mode==MODE_Explain ){
1499: explain_data_prepare(pArg, pStmt);
1500: }
1501:
1.1 espie 1502: /* perform the first step. this will tell us if we
1503: ** have a result set or not and how wide it is.
1504: */
1505: rc = sqlite3_step(pStmt);
1506: /* if we have a result set... */
1507: if( SQLITE_ROW == rc ){
1508: /* if we have a callback... */
1509: if( xCallback ){
1510: /* allocate space for col name ptr, value ptr, and type */
1511: int nCol = sqlite3_column_count(pStmt);
1512: void *pData = sqlite3_malloc(3*nCol*sizeof(const char*) + 1);
1513: if( !pData ){
1514: rc = SQLITE_NOMEM;
1515: }else{
1516: char **azCols = (char **)pData; /* Names of result columns */
1517: char **azVals = &azCols[nCol]; /* Results */
1518: int *aiTypes = (int *)&azVals[nCol]; /* Result types */
1.1.1.8 jturner 1519: int i, x;
1.1 espie 1520: assert(sizeof(int) <= sizeof(char *));
1521: /* save off ptrs to column names */
1522: for(i=0; i<nCol; i++){
1523: azCols[i] = (char *)sqlite3_column_name(pStmt, i);
1524: }
1525: do{
1526: /* extract the data and data types */
1527: for(i=0; i<nCol; i++){
1.1.1.8 jturner 1528: aiTypes[i] = x = sqlite3_column_type(pStmt, i);
1529: if( x==SQLITE_BLOB && pArg && pArg->mode==MODE_Insert ){
1530: azVals[i] = "";
1531: }else{
1532: azVals[i] = (char*)sqlite3_column_text(pStmt, i);
1533: }
1.1 espie 1534: if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){
1535: rc = SQLITE_NOMEM;
1536: break; /* from for */
1537: }
1538: } /* end for */
1539:
1540: /* if data and types extracted successfully... */
1541: if( SQLITE_ROW == rc ){
1542: /* call the supplied callback with the result row data */
1543: if( xCallback(pArg, nCol, azVals, azCols, aiTypes) ){
1544: rc = SQLITE_ABORT;
1545: }else{
1546: rc = sqlite3_step(pStmt);
1547: }
1548: }
1549: } while( SQLITE_ROW == rc );
1550: sqlite3_free(pData);
1551: }
1552: }else{
1553: do{
1554: rc = sqlite3_step(pStmt);
1555: } while( rc == SQLITE_ROW );
1556: }
1557: }
1558:
1.1.1.8 jturner 1559: explain_data_delete(pArg);
1560:
1.1 espie 1561: /* print usage stats if stats on */
1562: if( pArg && pArg->statsOn ){
1563: display_stats(db, pArg, 0);
1564: }
1565:
1.1.1.11! jturner 1566: /* print loop-counters if required */
! 1567: if( pArg && pArg->scanstatsOn ){
! 1568: display_scanstats(db, pArg);
! 1569: }
! 1570:
1.1 espie 1571: /* Finalize the statement just executed. If this fails, save a
1572: ** copy of the error message. Otherwise, set zSql to point to the
1573: ** next statement to execute. */
1574: rc2 = sqlite3_finalize(pStmt);
1575: if( rc!=SQLITE_NOMEM ) rc = rc2;
1576: if( rc==SQLITE_OK ){
1577: zSql = zLeftover;
1578: while( IsSpace(zSql[0]) ) zSql++;
1579: }else if( pzErrMsg ){
1580: *pzErrMsg = save_err_msg(db);
1581: }
1582:
1583: /* clear saved stmt handle */
1584: if( pArg ){
1585: pArg->pStmt = NULL;
1586: }
1587: }
1588: } /* end while */
1589:
1590: return rc;
1591: }
1592:
1593:
1594: /*
1595: ** This is a different callback routine used for dumping the database.
1596: ** Each row received by this callback consists of a table name,
1597: ** the table type ("index" or "table") and SQL to create the table.
1598: ** This routine should print text sufficient to recreate the table.
1599: */
1600: static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
1601: int rc;
1602: const char *zTable;
1603: const char *zType;
1604: const char *zSql;
1605: const char *zPrepStmt = 0;
1.1.1.10 jturner 1606: ShellState *p = (ShellState *)pArg;
1.1 espie 1607:
1608: UNUSED_PARAMETER(azCol);
1609: if( nArg!=3 ) return 1;
1610: zTable = azArg[0];
1611: zType = azArg[1];
1612: zSql = azArg[2];
1613:
1614: if( strcmp(zTable, "sqlite_sequence")==0 ){
1615: zPrepStmt = "DELETE FROM sqlite_sequence;\n";
1.1.1.8 jturner 1616: }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
1.1 espie 1617: fprintf(p->out, "ANALYZE sqlite_master;\n");
1618: }else if( strncmp(zTable, "sqlite_", 7)==0 ){
1619: return 0;
1620: }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
1621: char *zIns;
1622: if( !p->writableSchema ){
1623: fprintf(p->out, "PRAGMA writable_schema=ON;\n");
1624: p->writableSchema = 1;
1625: }
1626: zIns = sqlite3_mprintf(
1627: "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
1628: "VALUES('table','%q','%q',0,'%q');",
1629: zTable, zTable, zSql);
1630: fprintf(p->out, "%s\n", zIns);
1631: sqlite3_free(zIns);
1632: return 0;
1633: }else{
1634: fprintf(p->out, "%s;\n", zSql);
1635: }
1636:
1637: if( strcmp(zType, "table")==0 ){
1638: sqlite3_stmt *pTableInfo = 0;
1639: char *zSelect = 0;
1640: char *zTableInfo = 0;
1641: char *zTmp = 0;
1642: int nRow = 0;
1643:
1644: zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);
1645: zTableInfo = appendText(zTableInfo, zTable, '"');
1646: zTableInfo = appendText(zTableInfo, ");", 0);
1647:
1.1.1.8 jturner 1648: rc = sqlite3_prepare_v2(p->db, zTableInfo, -1, &pTableInfo, 0);
1.1 espie 1649: free(zTableInfo);
1650: if( rc!=SQLITE_OK || !pTableInfo ){
1651: return 1;
1652: }
1653:
1654: zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0);
1.1.1.2 espie 1655: /* Always quote the table name, even if it appears to be pure ascii,
1656: ** in case it is a keyword. Ex: INSERT INTO "table" ... */
1657: zTmp = appendText(zTmp, zTable, '"');
1.1 espie 1658: if( zTmp ){
1659: zSelect = appendText(zSelect, zTmp, '\'');
1.1.1.2 espie 1660: free(zTmp);
1.1 espie 1661: }
1662: zSelect = appendText(zSelect, " || ' VALUES(' || ", 0);
1663: rc = sqlite3_step(pTableInfo);
1664: while( rc==SQLITE_ROW ){
1665: const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1);
1666: zSelect = appendText(zSelect, "quote(", 0);
1667: zSelect = appendText(zSelect, zText, '"');
1668: rc = sqlite3_step(pTableInfo);
1669: if( rc==SQLITE_ROW ){
1670: zSelect = appendText(zSelect, "), ", 0);
1671: }else{
1672: zSelect = appendText(zSelect, ") ", 0);
1673: }
1674: nRow++;
1675: }
1676: rc = sqlite3_finalize(pTableInfo);
1677: if( rc!=SQLITE_OK || nRow==0 ){
1678: free(zSelect);
1679: return 1;
1680: }
1681: zSelect = appendText(zSelect, "|| ')' FROM ", 0);
1682: zSelect = appendText(zSelect, zTable, '"');
1683:
1684: rc = run_table_dump_query(p, zSelect, zPrepStmt);
1685: if( rc==SQLITE_CORRUPT ){
1686: zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);
1687: run_table_dump_query(p, zSelect, 0);
1688: }
1.1.1.2 espie 1689: free(zSelect);
1.1 espie 1690: }
1691: return 0;
1692: }
1693:
1694: /*
1695: ** Run zQuery. Use dump_callback() as the callback routine so that
1696: ** the contents of the query are output as SQL statements.
1697: **
1698: ** If we get a SQLITE_CORRUPT error, rerun the query after appending
1699: ** "ORDER BY rowid DESC" to the end.
1700: */
1701: static int run_schema_dump_query(
1.1.1.10 jturner 1702: ShellState *p,
1.1 espie 1703: const char *zQuery
1704: ){
1705: int rc;
1706: char *zErr = 0;
1707: rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr);
1708: if( rc==SQLITE_CORRUPT ){
1709: char *zQ2;
1710: int len = strlen30(zQuery);
1711: fprintf(p->out, "/****** CORRUPTION ERROR *******/\n");
1712: if( zErr ){
1713: fprintf(p->out, "/****** %s ******/\n", zErr);
1714: sqlite3_free(zErr);
1715: zErr = 0;
1716: }
1717: zQ2 = malloc( len+100 );
1718: if( zQ2==0 ) return rc;
1.1.1.2 espie 1719: sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery);
1.1 espie 1720: rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr);
1721: if( rc ){
1722: fprintf(p->out, "/****** ERROR: %s ******/\n", zErr);
1723: }else{
1724: rc = SQLITE_CORRUPT;
1725: }
1726: sqlite3_free(zErr);
1727: free(zQ2);
1728: }
1729: return rc;
1730: }
1731:
1732: /*
1733: ** Text of a help message
1734: */
1735: static char zHelp[] =
1736: ".backup ?DB? FILE Backup DB (default \"main\") to FILE\n"
1.1.1.9 jturner 1737: ".bail on|off Stop after hitting an error. Default OFF\n"
1.1.1.8 jturner 1738: ".clone NEWDB Clone data into NEWDB from the existing database\n"
1.1 espie 1739: ".databases List names and files of attached databases\n"
1740: ".dump ?TABLE? ... Dump the database in an SQL text format\n"
1741: " If TABLE specified, only dump tables matching\n"
1742: " LIKE pattern TABLE.\n"
1.1.1.9 jturner 1743: ".echo on|off Turn command echo on or off\n"
1744: ".eqp on|off Enable or disable automatic EXPLAIN QUERY PLAN\n"
1.1 espie 1745: ".exit Exit this program\n"
1.1.1.9 jturner 1746: ".explain ?on|off? Turn output mode suitable for EXPLAIN on or off.\n"
1.1 espie 1747: " With no args, it turns EXPLAIN on.\n"
1.1.1.9 jturner 1748: ".fullschema Show schema and the content of sqlite_stat tables\n"
1749: ".headers on|off Turn display of headers on or off\n"
1.1 espie 1750: ".help Show this message\n"
1751: ".import FILE TABLE Import data from FILE into TABLE\n"
1752: ".indices ?TABLE? Show names of all indices\n"
1753: " If TABLE specified, only show indices for tables\n"
1754: " matching LIKE pattern TABLE.\n"
1755: #ifdef SQLITE_ENABLE_IOTRACE
1756: ".iotrace FILE Enable I/O diagnostic logging to FILE\n"
1757: #endif
1758: #ifndef SQLITE_OMIT_LOAD_EXTENSION
1759: ".load FILE ?ENTRY? Load an extension library\n"
1760: #endif
1761: ".log FILE|off Turn logging on or off. FILE can be stderr/stdout\n"
1762: ".mode MODE ?TABLE? Set output mode where MODE is one of:\n"
1.1.1.11! jturner 1763: " ascii Columns/rows delimited by 0x1F and 0x1E\n"
1.1 espie 1764: " csv Comma-separated values\n"
1765: " column Left-aligned columns. (See .width)\n"
1766: " html HTML <table> code\n"
1767: " insert SQL insert statements for TABLE\n"
1768: " line One value per line\n"
1.1.1.11! jturner 1769: " list Values delimited by .separator strings\n"
1.1 espie 1770: " tabs Tab-separated values\n"
1771: " tcl TCL list elements\n"
1.1.1.5 espie 1772: ".nullvalue STRING Use STRING in place of NULL values\n"
1.1.1.9 jturner 1773: ".once FILENAME Output for the next SQL command only to FILENAME\n"
1.1.1.8 jturner 1774: ".open ?FILENAME? Close existing database and reopen FILENAME\n"
1.1.1.9 jturner 1775: ".output ?FILENAME? Send output to FILENAME or stdout\n"
1.1.1.5 espie 1776: ".print STRING... Print literal STRING\n"
1.1 espie 1777: ".prompt MAIN CONTINUE Replace the standard prompts\n"
1778: ".quit Exit this program\n"
1779: ".read FILENAME Execute SQL in FILENAME\n"
1780: ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n"
1.1.1.8 jturner 1781: ".save FILE Write in-memory database into FILE\n"
1.1.1.11! jturner 1782: ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off\n"
1.1 espie 1783: ".schema ?TABLE? Show the CREATE statements\n"
1784: " If TABLE specified, only show tables matching\n"
1785: " LIKE pattern TABLE.\n"
1.1.1.11! jturner 1786: ".separator COL ?ROW? Change the column separator and optionally the row\n"
! 1787: " separator for both the output mode and .import\n"
1.1.1.9 jturner 1788: ".shell CMD ARGS... Run CMD ARGS... in a system shell\n"
1.1 espie 1789: ".show Show the current values for various settings\n"
1.1.1.9 jturner 1790: ".stats on|off Turn stats on or off\n"
1791: ".system CMD ARGS... Run CMD ARGS... in a system shell\n"
1.1 espie 1792: ".tables ?TABLE? List names of tables\n"
1793: " If TABLE specified, only list tables matching\n"
1794: " LIKE pattern TABLE.\n"
1795: ".timeout MS Try opening locked tables for MS milliseconds\n"
1.1.1.9 jturner 1796: ".timer on|off Turn SQL timer on or off\n"
1.1.1.2 espie 1797: ".trace FILE|off Output each SQL statement as it is run\n"
1.1 espie 1798: ".vfsname ?AUX? Print the name of the VFS stack\n"
1799: ".width NUM1 NUM2 ... Set column widths for \"column\" mode\n"
1.1.1.9 jturner 1800: " Negative values right-justify\n"
1.1 espie 1801: ;
1802:
1803: /* Forward reference */
1.1.1.10 jturner 1804: static int process_input(ShellState *p, FILE *in);
1.1.1.9 jturner 1805: /*
1806: ** Implementation of the "readfile(X)" SQL function. The entire content
1807: ** of the file named X is read and returned as a BLOB. NULL is returned
1808: ** if the file does not exist or is unreadable.
1809: */
1810: static void readfileFunc(
1811: sqlite3_context *context,
1812: int argc,
1813: sqlite3_value **argv
1814: ){
1815: const char *zName;
1816: FILE *in;
1817: long nIn;
1818: void *pBuf;
1819:
1820: zName = (const char*)sqlite3_value_text(argv[0]);
1821: if( zName==0 ) return;
1822: in = fopen(zName, "rb");
1823: if( in==0 ) return;
1824: fseek(in, 0, SEEK_END);
1825: nIn = ftell(in);
1826: rewind(in);
1827: pBuf = sqlite3_malloc( nIn );
1828: if( pBuf && 1==fread(pBuf, nIn, 1, in) ){
1829: sqlite3_result_blob(context, pBuf, nIn, sqlite3_free);
1830: }else{
1831: sqlite3_free(pBuf);
1832: }
1833: fclose(in);
1834: }
1835:
1836: /*
1837: ** Implementation of the "writefile(X,Y)" SQL function. The argument Y
1838: ** is written into file X. The number of bytes written is returned. Or
1839: ** NULL is returned if something goes wrong, such as being unable to open
1840: ** file X for writing.
1841: */
1842: static void writefileFunc(
1843: sqlite3_context *context,
1844: int argc,
1845: sqlite3_value **argv
1846: ){
1847: FILE *out;
1848: const char *z;
1849: sqlite3_int64 rc;
1850: const char *zFile;
1851:
1852: zFile = (const char*)sqlite3_value_text(argv[0]);
1853: if( zFile==0 ) return;
1854: out = fopen(zFile, "wb");
1855: if( out==0 ) return;
1856: z = (const char*)sqlite3_value_blob(argv[1]);
1857: if( z==0 ){
1858: rc = 0;
1859: }else{
1860: rc = fwrite(z, 1, sqlite3_value_bytes(argv[1]), out);
1861: }
1862: fclose(out);
1863: sqlite3_result_int64(context, rc);
1864: }
1.1 espie 1865:
1866: /*
1867: ** Make sure the database is open. If it is not, then open it. If
1868: ** the database fails to open, print an error message and exit.
1869: */
1.1.1.10 jturner 1870: static void open_db(ShellState *p, int keepAlive){
1.1 espie 1871: if( p->db==0 ){
1.1.1.4 espie 1872: sqlite3_initialize();
1.1 espie 1873: sqlite3_open(p->zDbFilename, &p->db);
1874: db = p->db;
1875: if( db && sqlite3_errcode(db)==SQLITE_OK ){
1876: sqlite3_create_function(db, "shellstatic", 0, SQLITE_UTF8, 0,
1877: shellstaticFunc, 0, 0);
1878: }
1879: if( db==0 || SQLITE_OK!=sqlite3_errcode(db) ){
1880: fprintf(stderr,"Error: unable to open database \"%s\": %s\n",
1881: p->zDbFilename, sqlite3_errmsg(db));
1.1.1.8 jturner 1882: if( keepAlive ) return;
1.1 espie 1883: exit(1);
1884: }
1885: #ifndef SQLITE_OMIT_LOAD_EXTENSION
1886: sqlite3_enable_load_extension(p->db, 1);
1887: #endif
1.1.1.9 jturner 1888: sqlite3_create_function(db, "readfile", 1, SQLITE_UTF8, 0,
1889: readfileFunc, 0, 0);
1890: sqlite3_create_function(db, "writefile", 2, SQLITE_UTF8, 0,
1891: writefileFunc, 0, 0);
1.1 espie 1892: }
1893: }
1894:
1895: /*
1896: ** Do C-language style dequoting.
1897: **
1898: ** \t -> tab
1899: ** \n -> newline
1900: ** \r -> carriage return
1.1.1.7 jturner 1901: ** \" -> "
1.1 espie 1902: ** \NNN -> ascii character NNN in octal
1903: ** \\ -> backslash
1904: */
1905: static void resolve_backslashes(char *z){
1906: int i, j;
1907: char c;
1.1.1.9 jturner 1908: while( *z && *z!='\\' ) z++;
1.1 espie 1909: for(i=j=0; (c = z[i])!=0; i++, j++){
1910: if( c=='\\' ){
1911: c = z[++i];
1912: if( c=='n' ){
1913: c = '\n';
1914: }else if( c=='t' ){
1915: c = '\t';
1916: }else if( c=='r' ){
1917: c = '\r';
1.1.1.7 jturner 1918: }else if( c=='\\' ){
1919: c = '\\';
1.1 espie 1920: }else if( c>='0' && c<='7' ){
1921: c -= '0';
1922: if( z[i+1]>='0' && z[i+1]<='7' ){
1923: i++;
1924: c = (c<<3) + z[i] - '0';
1925: if( z[i+1]>='0' && z[i+1]<='7' ){
1926: i++;
1927: c = (c<<3) + z[i] - '0';
1928: }
1929: }
1930: }
1931: }
1932: z[j] = c;
1933: }
1.1.1.9 jturner 1934: if( j<i ) z[j] = 0;
1.1 espie 1935: }
1936:
1937: /*
1.1.1.7 jturner 1938: ** Return the value of a hexadecimal digit. Return -1 if the input
1939: ** is not a hex digit.
1.1 espie 1940: */
1.1.1.7 jturner 1941: static int hexDigitValue(char c){
1942: if( c>='0' && c<='9' ) return c - '0';
1943: if( c>='a' && c<='f' ) return c - 'a' + 10;
1944: if( c>='A' && c<='F' ) return c - 'A' + 10;
1945: return -1;
1.1.1.6 landry 1946: }
1947:
1948: /*
1949: ** Interpret zArg as an integer value, possibly with suffixes.
1950: */
1951: static sqlite3_int64 integerValue(const char *zArg){
1952: sqlite3_int64 v = 0;
1953: static const struct { char *zSuffix; int iMult; } aMult[] = {
1954: { "KiB", 1024 },
1955: { "MiB", 1024*1024 },
1956: { "GiB", 1024*1024*1024 },
1957: { "KB", 1000 },
1958: { "MB", 1000000 },
1959: { "GB", 1000000000 },
1960: { "K", 1000 },
1961: { "M", 1000000 },
1962: { "G", 1000000000 },
1963: };
1964: int i;
1965: int isNeg = 0;
1966: if( zArg[0]=='-' ){
1967: isNeg = 1;
1968: zArg++;
1969: }else if( zArg[0]=='+' ){
1970: zArg++;
1971: }
1.1.1.7 jturner 1972: if( zArg[0]=='0' && zArg[1]=='x' ){
1973: int x;
1974: zArg += 2;
1975: while( (x = hexDigitValue(zArg[0]))>=0 ){
1976: v = (v<<4) + x;
1977: zArg++;
1978: }
1979: }else{
1980: while( IsDigit(zArg[0]) ){
1981: v = v*10 + zArg[0] - '0';
1982: zArg++;
1983: }
1.1.1.6 landry 1984: }
1.1.1.7 jturner 1985: for(i=0; i<ArraySize(aMult); i++){
1.1.1.6 landry 1986: if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){
1987: v *= aMult[i].iMult;
1988: break;
1989: }
1.1 espie 1990: }
1.1.1.6 landry 1991: return isNeg? -v : v;
1.1 espie 1992: }
1993:
1994: /*
1.1.1.7 jturner 1995: ** Interpret zArg as either an integer or a boolean value. Return 1 or 0
1996: ** for TRUE and FALSE. Return the integer value if appropriate.
1997: */
1998: static int booleanValue(char *zArg){
1999: int i;
2000: if( zArg[0]=='0' && zArg[1]=='x' ){
2001: for(i=2; hexDigitValue(zArg[i])>=0; i++){}
2002: }else{
2003: for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
2004: }
2005: if( i>0 && zArg[i]==0 ) return (int)(integerValue(zArg) & 0xffffffff);
2006: if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){
2007: return 1;
2008: }
2009: if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){
2010: return 0;
2011: }
2012: fprintf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
2013: zArg);
2014: return 0;
2015: }
2016:
2017: /*
1.1.1.2 espie 2018: ** Close an output file, assuming it is not stderr or stdout
2019: */
2020: static void output_file_close(FILE *f){
2021: if( f && f!=stdout && f!=stderr ) fclose(f);
2022: }
2023:
2024: /*
2025: ** Try to open an output file. The names "stdout" and "stderr" are
2026: ** recognized and do the right thing. NULL is returned if the output
2027: ** filename is "off".
2028: */
2029: static FILE *output_file_open(const char *zFile){
2030: FILE *f;
2031: if( strcmp(zFile,"stdout")==0 ){
2032: f = stdout;
2033: }else if( strcmp(zFile, "stderr")==0 ){
2034: f = stderr;
2035: }else if( strcmp(zFile, "off")==0 ){
2036: f = 0;
2037: }else{
2038: f = fopen(zFile, "wb");
2039: if( f==0 ){
2040: fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
2041: }
2042: }
2043: return f;
2044: }
2045:
2046: /*
2047: ** A routine for handling output from sqlite3_trace().
2048: */
2049: static void sql_trace_callback(void *pArg, const char *z){
2050: FILE *f = (FILE*)pArg;
1.1.1.10 jturner 2051: if( f ){
2052: int i = (int)strlen(z);
2053: while( i>0 && z[i-1]==';' ){ i--; }
2054: fprintf(f, "%.*s;\n", i, z);
2055: }
1.1.1.2 espie 2056: }
2057:
2058: /*
2059: ** A no-op routine that runs with the ".breakpoint" doc-command. This is
2060: ** a useful spot to set a debugger breakpoint.
2061: */
2062: static void test_breakpoint(void){
2063: static int nCall = 0;
2064: nCall++;
2065: }
2066:
2067: /*
1.1.1.11! jturner 2068: ** An object used to read a CSV and other files for import.
1.1.1.7 jturner 2069: */
1.1.1.11! jturner 2070: typedef struct ImportCtx ImportCtx;
! 2071: struct ImportCtx {
1.1.1.7 jturner 2072: const char *zFile; /* Name of the input file */
2073: FILE *in; /* Read the CSV text from this input stream */
2074: char *z; /* Accumulated text for a field */
2075: int n; /* Number of bytes in z */
2076: int nAlloc; /* Space allocated for z[] */
2077: int nLine; /* Current line number */
2078: int cTerm; /* Character that terminated the most recent field */
1.1.1.11! jturner 2079: int cColSep; /* The column separator character. (Usually ",") */
! 2080: int cRowSep; /* The row separator character. (Usually "\n") */
1.1.1.7 jturner 2081: };
2082:
2083: /* Append a single byte to z[] */
1.1.1.11! jturner 2084: static void import_append_char(ImportCtx *p, int c){
1.1.1.7 jturner 2085: if( p->n+1>=p->nAlloc ){
2086: p->nAlloc += p->nAlloc + 100;
2087: p->z = sqlite3_realloc(p->z, p->nAlloc);
2088: if( p->z==0 ){
2089: fprintf(stderr, "out of memory\n");
2090: exit(1);
2091: }
2092: }
2093: p->z[p->n++] = (char)c;
2094: }
2095:
2096: /* Read a single field of CSV text. Compatible with rfc4180 and extended
2097: ** with the option of having a separator other than ",".
2098: **
2099: ** + Input comes from p->in.
2100: ** + Store results in p->z of length p->n. Space to hold p->z comes
2101: ** from sqlite3_malloc().
1.1.1.11! jturner 2102: ** + Use p->cSep as the column separator. The default is ",".
! 2103: ** + Use p->rSep as the row separator. The default is "\n".
1.1.1.7 jturner 2104: ** + Keep track of the line number in p->nLine.
2105: ** + Store the character that terminates the field in p->cTerm. Store
2106: ** EOF on end-of-file.
2107: ** + Report syntax errors on stderr
2108: */
1.1.1.11! jturner 2109: static char *csv_read_one_field(ImportCtx *p){
! 2110: int c;
! 2111: int cSep = p->cColSep;
! 2112: int rSep = p->cRowSep;
1.1.1.7 jturner 2113: p->n = 0;
2114: c = fgetc(p->in);
2115: if( c==EOF || seenInterrupt ){
2116: p->cTerm = EOF;
2117: return 0;
2118: }
2119: if( c=='"' ){
1.1.1.11! jturner 2120: int pc, ppc;
1.1.1.7 jturner 2121: int startLine = p->nLine;
2122: int cQuote = c;
1.1.1.8 jturner 2123: pc = ppc = 0;
1.1.1.7 jturner 2124: while( 1 ){
2125: c = fgetc(p->in);
1.1.1.11! jturner 2126: if( c==rSep ) p->nLine++;
1.1.1.7 jturner 2127: if( c==cQuote ){
2128: if( pc==cQuote ){
2129: pc = 0;
2130: continue;
2131: }
2132: }
2133: if( (c==cSep && pc==cQuote)
1.1.1.11! jturner 2134: || (c==rSep && pc==cQuote)
! 2135: || (c==rSep && pc=='\r' && ppc==cQuote)
1.1.1.7 jturner 2136: || (c==EOF && pc==cQuote)
2137: ){
2138: do{ p->n--; }while( p->z[p->n]!=cQuote );
2139: p->cTerm = c;
2140: break;
2141: }
2142: if( pc==cQuote && c!='\r' ){
2143: fprintf(stderr, "%s:%d: unescaped %c character\n",
2144: p->zFile, p->nLine, cQuote);
2145: }
2146: if( c==EOF ){
2147: fprintf(stderr, "%s:%d: unterminated %c-quoted field\n",
2148: p->zFile, startLine, cQuote);
1.1.1.11! jturner 2149: p->cTerm = c;
1.1.1.7 jturner 2150: break;
2151: }
1.1.1.11! jturner 2152: import_append_char(p, c);
1.1.1.8 jturner 2153: ppc = pc;
1.1.1.7 jturner 2154: pc = c;
2155: }
2156: }else{
1.1.1.11! jturner 2157: while( c!=EOF && c!=cSep && c!=rSep ){
! 2158: import_append_char(p, c);
1.1.1.7 jturner 2159: c = fgetc(p->in);
2160: }
1.1.1.11! jturner 2161: if( c==rSep ){
1.1.1.7 jturner 2162: p->nLine++;
1.1.1.8 jturner 2163: if( p->n>0 && p->z[p->n-1]=='\r' ) p->n--;
1.1.1.7 jturner 2164: }
2165: p->cTerm = c;
2166: }
2167: if( p->z ) p->z[p->n] = 0;
2168: return p->z;
2169: }
2170:
1.1.1.11! jturner 2171: /* Read a single field of ASCII delimited text.
! 2172: **
! 2173: ** + Input comes from p->in.
! 2174: ** + Store results in p->z of length p->n. Space to hold p->z comes
! 2175: ** from sqlite3_malloc().
! 2176: ** + Use p->cSep as the column separator. The default is "\x1F".
! 2177: ** + Use p->rSep as the row separator. The default is "\x1E".
! 2178: ** + Keep track of the row number in p->nLine.
! 2179: ** + Store the character that terminates the field in p->cTerm. Store
! 2180: ** EOF on end-of-file.
! 2181: ** + Report syntax errors on stderr
! 2182: */
! 2183: static char *ascii_read_one_field(ImportCtx *p){
! 2184: int c;
! 2185: int cSep = p->cColSep;
! 2186: int rSep = p->cRowSep;
! 2187: p->n = 0;
! 2188: c = fgetc(p->in);
! 2189: if( c==EOF || seenInterrupt ){
! 2190: p->cTerm = EOF;
! 2191: return 0;
! 2192: }
! 2193: while( c!=EOF && c!=cSep && c!=rSep ){
! 2194: import_append_char(p, c);
! 2195: c = fgetc(p->in);
! 2196: }
! 2197: if( c==rSep ){
! 2198: p->nLine++;
! 2199: }
! 2200: p->cTerm = c;
! 2201: if( p->z ) p->z[p->n] = 0;
! 2202: return p->z;
! 2203: }
! 2204:
1.1.1.7 jturner 2205: /*
1.1.1.8 jturner 2206: ** Try to transfer data for table zTable. If an error is seen while
2207: ** moving forward, try to go backwards. The backwards movement won't
2208: ** work for WITHOUT ROWID tables.
2209: */
2210: static void tryToCloneData(
1.1.1.10 jturner 2211: ShellState *p,
1.1.1.8 jturner 2212: sqlite3 *newDb,
2213: const char *zTable
2214: ){
2215: sqlite3_stmt *pQuery = 0;
2216: sqlite3_stmt *pInsert = 0;
2217: char *zQuery = 0;
2218: char *zInsert = 0;
2219: int rc;
2220: int i, j, n;
2221: int nTable = (int)strlen(zTable);
2222: int k = 0;
2223: int cnt = 0;
2224: const int spinRate = 10000;
2225:
2226: zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable);
2227: rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
2228: if( rc ){
2229: fprintf(stderr, "Error %d: %s on [%s]\n",
2230: sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
2231: zQuery);
2232: goto end_data_xfer;
2233: }
2234: n = sqlite3_column_count(pQuery);
2235: zInsert = sqlite3_malloc(200 + nTable + n*3);
2236: if( zInsert==0 ){
2237: fprintf(stderr, "out of memory\n");
2238: goto end_data_xfer;
2239: }
2240: sqlite3_snprintf(200+nTable,zInsert,
2241: "INSERT OR IGNORE INTO \"%s\" VALUES(?", zTable);
2242: i = (int)strlen(zInsert);
2243: for(j=1; j<n; j++){
2244: memcpy(zInsert+i, ",?", 2);
2245: i += 2;
2246: }
2247: memcpy(zInsert+i, ");", 3);
2248: rc = sqlite3_prepare_v2(newDb, zInsert, -1, &pInsert, 0);
2249: if( rc ){
2250: fprintf(stderr, "Error %d: %s on [%s]\n",
2251: sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb),
2252: zQuery);
2253: goto end_data_xfer;
2254: }
2255: for(k=0; k<2; k++){
2256: while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
2257: for(i=0; i<n; i++){
2258: switch( sqlite3_column_type(pQuery, i) ){
2259: case SQLITE_NULL: {
2260: sqlite3_bind_null(pInsert, i+1);
2261: break;
2262: }
2263: case SQLITE_INTEGER: {
2264: sqlite3_bind_int64(pInsert, i+1, sqlite3_column_int64(pQuery,i));
2265: break;
2266: }
2267: case SQLITE_FLOAT: {
2268: sqlite3_bind_double(pInsert, i+1, sqlite3_column_double(pQuery,i));
2269: break;
2270: }
2271: case SQLITE_TEXT: {
2272: sqlite3_bind_text(pInsert, i+1,
2273: (const char*)sqlite3_column_text(pQuery,i),
2274: -1, SQLITE_STATIC);
2275: break;
2276: }
2277: case SQLITE_BLOB: {
2278: sqlite3_bind_blob(pInsert, i+1, sqlite3_column_blob(pQuery,i),
2279: sqlite3_column_bytes(pQuery,i),
2280: SQLITE_STATIC);
2281: break;
2282: }
2283: }
2284: } /* End for */
2285: rc = sqlite3_step(pInsert);
2286: if( rc!=SQLITE_OK && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
2287: fprintf(stderr, "Error %d: %s\n", sqlite3_extended_errcode(newDb),
2288: sqlite3_errmsg(newDb));
2289: }
2290: sqlite3_reset(pInsert);
2291: cnt++;
2292: if( (cnt%spinRate)==0 ){
2293: printf("%c\b", "|/-\\"[(cnt/spinRate)%4]);
2294: fflush(stdout);
2295: }
2296: } /* End while */
2297: if( rc==SQLITE_DONE ) break;
2298: sqlite3_finalize(pQuery);
2299: sqlite3_free(zQuery);
2300: zQuery = sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;",
2301: zTable);
2302: rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
2303: if( rc ){
2304: fprintf(stderr, "Warning: cannot step \"%s\" backwards", zTable);
2305: break;
2306: }
2307: } /* End for(k=0...) */
2308:
2309: end_data_xfer:
2310: sqlite3_finalize(pQuery);
2311: sqlite3_finalize(pInsert);
2312: sqlite3_free(zQuery);
2313: sqlite3_free(zInsert);
2314: }
2315:
2316:
2317: /*
2318: ** Try to transfer all rows of the schema that match zWhere. For
2319: ** each row, invoke xForEach() on the object defined by that row.
2320: ** If an error is encountered while moving forward through the
2321: ** sqlite_master table, try again moving backwards.
2322: */
2323: static void tryToCloneSchema(
1.1.1.10 jturner 2324: ShellState *p,
1.1.1.8 jturner 2325: sqlite3 *newDb,
2326: const char *zWhere,
1.1.1.10 jturner 2327: void (*xForEach)(ShellState*,sqlite3*,const char*)
1.1.1.8 jturner 2328: ){
2329: sqlite3_stmt *pQuery = 0;
2330: char *zQuery = 0;
2331: int rc;
2332: const unsigned char *zName;
2333: const unsigned char *zSql;
2334: char *zErrMsg = 0;
2335:
2336: zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
2337: " WHERE %s", zWhere);
2338: rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
2339: if( rc ){
2340: fprintf(stderr, "Error: (%d) %s on [%s]\n",
2341: sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
2342: zQuery);
2343: goto end_schema_xfer;
2344: }
2345: while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
2346: zName = sqlite3_column_text(pQuery, 0);
2347: zSql = sqlite3_column_text(pQuery, 1);
2348: printf("%s... ", zName); fflush(stdout);
2349: sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
2350: if( zErrMsg ){
2351: fprintf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
2352: sqlite3_free(zErrMsg);
2353: zErrMsg = 0;
2354: }
2355: if( xForEach ){
2356: xForEach(p, newDb, (const char*)zName);
2357: }
2358: printf("done\n");
2359: }
2360: if( rc!=SQLITE_DONE ){
2361: sqlite3_finalize(pQuery);
2362: sqlite3_free(zQuery);
2363: zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
2364: " WHERE %s ORDER BY rowid DESC", zWhere);
2365: rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
2366: if( rc ){
2367: fprintf(stderr, "Error: (%d) %s on [%s]\n",
2368: sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
2369: zQuery);
2370: goto end_schema_xfer;
2371: }
2372: while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
2373: zName = sqlite3_column_text(pQuery, 0);
2374: zSql = sqlite3_column_text(pQuery, 1);
2375: printf("%s... ", zName); fflush(stdout);
2376: sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
2377: if( zErrMsg ){
2378: fprintf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
2379: sqlite3_free(zErrMsg);
2380: zErrMsg = 0;
2381: }
2382: if( xForEach ){
2383: xForEach(p, newDb, (const char*)zName);
2384: }
2385: printf("done\n");
2386: }
2387: }
2388: end_schema_xfer:
2389: sqlite3_finalize(pQuery);
2390: sqlite3_free(zQuery);
2391: }
2392:
2393: /*
2394: ** Open a new database file named "zNewDb". Try to recover as much information
2395: ** as possible out of the main database (which might be corrupt) and write it
2396: ** into zNewDb.
2397: */
1.1.1.10 jturner 2398: static void tryToClone(ShellState *p, const char *zNewDb){
1.1.1.8 jturner 2399: int rc;
2400: sqlite3 *newDb = 0;
2401: if( access(zNewDb,0)==0 ){
2402: fprintf(stderr, "File \"%s\" already exists.\n", zNewDb);
2403: return;
2404: }
2405: rc = sqlite3_open(zNewDb, &newDb);
2406: if( rc ){
2407: fprintf(stderr, "Cannot create output database: %s\n",
2408: sqlite3_errmsg(newDb));
2409: }else{
1.1.1.9 jturner 2410: sqlite3_exec(p->db, "PRAGMA writable_schema=ON;", 0, 0, 0);
1.1.1.8 jturner 2411: sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0);
2412: tryToCloneSchema(p, newDb, "type='table'", tryToCloneData);
2413: tryToCloneSchema(p, newDb, "type!='table'", 0);
2414: sqlite3_exec(newDb, "COMMIT;", 0, 0, 0);
1.1.1.9 jturner 2415: sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
1.1.1.8 jturner 2416: }
2417: sqlite3_close(newDb);
2418: }
2419:
2420: /*
1.1.1.9 jturner 2421: ** Change the output file back to stdout
2422: */
1.1.1.10 jturner 2423: static void output_reset(ShellState *p){
1.1.1.9 jturner 2424: if( p->outfile[0]=='|' ){
2425: pclose(p->out);
2426: }else{
2427: output_file_close(p->out);
2428: }
2429: p->outfile[0] = 0;
2430: p->out = stdout;
2431: }
2432:
2433: /*
1.1 espie 2434: ** If an input line begins with "." then invoke this routine to
2435: ** process that line.
2436: **
2437: ** Return 1 on error, 2 to exit, and 0 otherwise.
2438: */
1.1.1.10 jturner 2439: static int do_meta_command(char *zLine, ShellState *p){
1.1 espie 2440: int i = 1;
2441: int nArg = 0;
2442: int n, c;
2443: int rc = 0;
2444: char *azArg[50];
2445:
2446: /* Parse the input line into tokens.
2447: */
2448: while( zLine[i] && nArg<ArraySize(azArg) ){
2449: while( IsSpace(zLine[i]) ){ i++; }
2450: if( zLine[i]==0 ) break;
2451: if( zLine[i]=='\'' || zLine[i]=='"' ){
2452: int delim = zLine[i++];
2453: azArg[nArg++] = &zLine[i];
1.1.1.7 jturner 2454: while( zLine[i] && zLine[i]!=delim ){
2455: if( zLine[i]=='\\' && delim=='"' && zLine[i+1]!=0 ) i++;
2456: i++;
2457: }
1.1 espie 2458: if( zLine[i]==delim ){
2459: zLine[i++] = 0;
2460: }
2461: if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
2462: }else{
2463: azArg[nArg++] = &zLine[i];
2464: while( zLine[i] && !IsSpace(zLine[i]) ){ i++; }
2465: if( zLine[i] ) zLine[i++] = 0;
2466: resolve_backslashes(azArg[nArg-1]);
2467: }
2468: }
2469:
2470: /* Process the input line.
2471: */
2472: if( nArg==0 ) return 0; /* no tokens, no error */
2473: n = strlen30(azArg[0]);
2474: c = azArg[0][0];
1.1.1.8 jturner 2475: if( (c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0)
2476: || (c=='s' && n>=3 && strncmp(azArg[0], "save", n)==0)
2477: ){
1.1.1.6 landry 2478: const char *zDestFile = 0;
2479: const char *zDb = 0;
1.1 espie 2480: sqlite3 *pDest;
2481: sqlite3_backup *pBackup;
1.1.1.6 landry 2482: int j;
2483: for(j=1; j<nArg; j++){
2484: const char *z = azArg[j];
2485: if( z[0]=='-' ){
2486: while( z[0]=='-' ) z++;
1.1.1.7 jturner 2487: /* No options to process at this time */
1.1.1.6 landry 2488: {
2489: fprintf(stderr, "unknown option: %s\n", azArg[j]);
2490: return 1;
2491: }
2492: }else if( zDestFile==0 ){
2493: zDestFile = azArg[j];
2494: }else if( zDb==0 ){
2495: zDb = zDestFile;
2496: zDestFile = azArg[j];
2497: }else{
2498: fprintf(stderr, "too many arguments to .backup\n");
2499: return 1;
2500: }
2501: }
2502: if( zDestFile==0 ){
2503: fprintf(stderr, "missing FILENAME argument on .backup\n");
2504: return 1;
1.1 espie 2505: }
1.1.1.6 landry 2506: if( zDb==0 ) zDb = "main";
1.1 espie 2507: rc = sqlite3_open(zDestFile, &pDest);
2508: if( rc!=SQLITE_OK ){
2509: fprintf(stderr, "Error: cannot open \"%s\"\n", zDestFile);
2510: sqlite3_close(pDest);
2511: return 1;
2512: }
1.1.1.8 jturner 2513: open_db(p, 0);
1.1 espie 2514: pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
2515: if( pBackup==0 ){
2516: fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
2517: sqlite3_close(pDest);
2518: return 1;
2519: }
2520: while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
2521: sqlite3_backup_finish(pBackup);
2522: if( rc==SQLITE_DONE ){
2523: rc = 0;
2524: }else{
2525: fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
2526: rc = 1;
2527: }
2528: sqlite3_close(pDest);
2529: }else
2530:
1.1.1.9 jturner 2531: if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 ){
2532: if( nArg==2 ){
2533: bail_on_error = booleanValue(azArg[1]);
2534: }else{
2535: fprintf(stderr, "Usage: .bail on|off\n");
2536: rc = 1;
2537: }
1.1 espie 2538: }else
2539:
1.1.1.2 espie 2540: /* The undocumented ".breakpoint" command causes a call to the no-op
2541: ** routine named test_breakpoint().
2542: */
2543: if( c=='b' && n>=3 && strncmp(azArg[0], "breakpoint", n)==0 ){
2544: test_breakpoint();
2545: }else
2546:
1.1.1.9 jturner 2547: if( c=='c' && strncmp(azArg[0], "clone", n)==0 ){
2548: if( nArg==2 ){
2549: tryToClone(p, azArg[1]);
2550: }else{
2551: fprintf(stderr, "Usage: .clone FILENAME\n");
2552: rc = 1;
2553: }
1.1.1.8 jturner 2554: }else
2555:
1.1.1.9 jturner 2556: if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){
1.1.1.10 jturner 2557: ShellState data;
1.1 espie 2558: char *zErrMsg = 0;
1.1.1.8 jturner 2559: open_db(p, 0);
1.1 espie 2560: memcpy(&data, p, sizeof(data));
2561: data.showHeader = 1;
2562: data.mode = MODE_Column;
2563: data.colWidth[0] = 3;
2564: data.colWidth[1] = 15;
2565: data.colWidth[2] = 58;
2566: data.cnt = 0;
2567: sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg);
2568: if( zErrMsg ){
2569: fprintf(stderr,"Error: %s\n", zErrMsg);
2570: sqlite3_free(zErrMsg);
2571: rc = 1;
2572: }
2573: }else
2574:
1.1.1.9 jturner 2575: if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
1.1.1.8 jturner 2576: open_db(p, 0);
1.1 espie 2577: /* When playing back a "dump", the content might appear in an order
2578: ** which causes immediate foreign key constraints to be violated.
2579: ** So disable foreign-key constraint enforcement to prevent problems. */
1.1.1.9 jturner 2580: if( nArg!=1 && nArg!=2 ){
2581: fprintf(stderr, "Usage: .dump ?LIKE-PATTERN?\n");
2582: rc = 1;
2583: goto meta_command_exit;
2584: }
1.1 espie 2585: fprintf(p->out, "PRAGMA foreign_keys=OFF;\n");
2586: fprintf(p->out, "BEGIN TRANSACTION;\n");
2587: p->writableSchema = 0;
2588: sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
2589: p->nErr = 0;
2590: if( nArg==1 ){
2591: run_schema_dump_query(p,
2592: "SELECT name, type, sql FROM sqlite_master "
2593: "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
2594: );
2595: run_schema_dump_query(p,
2596: "SELECT name, type, sql FROM sqlite_master "
2597: "WHERE name=='sqlite_sequence'"
2598: );
2599: run_table_dump_query(p,
2600: "SELECT sql FROM sqlite_master "
2601: "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
2602: );
2603: }else{
2604: int i;
2605: for(i=1; i<nArg; i++){
2606: zShellStatic = azArg[i];
2607: run_schema_dump_query(p,
2608: "SELECT name, type, sql FROM sqlite_master "
2609: "WHERE tbl_name LIKE shellstatic() AND type=='table'"
2610: " AND sql NOT NULL");
2611: run_table_dump_query(p,
2612: "SELECT sql FROM sqlite_master "
2613: "WHERE sql NOT NULL"
2614: " AND type IN ('index','trigger','view')"
2615: " AND tbl_name LIKE shellstatic()", 0
2616: );
2617: zShellStatic = 0;
2618: }
2619: }
2620: if( p->writableSchema ){
2621: fprintf(p->out, "PRAGMA writable_schema=OFF;\n");
2622: p->writableSchema = 0;
2623: }
2624: sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
2625: sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0);
2626: fprintf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
2627: }else
2628:
1.1.1.9 jturner 2629: if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){
2630: if( nArg==2 ){
2631: p->echoOn = booleanValue(azArg[1]);
2632: }else{
2633: fprintf(stderr, "Usage: .echo on|off\n");
2634: rc = 1;
2635: }
1.1 espie 2636: }else
2637:
1.1.1.9 jturner 2638: if( c=='e' && strncmp(azArg[0], "eqp", n)==0 ){
2639: if( nArg==2 ){
2640: p->autoEQP = booleanValue(azArg[1]);
2641: }else{
2642: fprintf(stderr, "Usage: .eqp on|off\n");
2643: rc = 1;
2644: }
1.1.1.8 jturner 2645: }else
2646:
1.1.1.6 landry 2647: if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){
1.1.1.7 jturner 2648: if( nArg>1 && (rc = (int)integerValue(azArg[1]))!=0 ) exit(rc);
1.1 espie 2649: rc = 2;
2650: }else
2651:
1.1.1.9 jturner 2652: if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){
1.1 espie 2653: int val = nArg>=2 ? booleanValue(azArg[1]) : 1;
2654: if(val == 1) {
1.1.1.10 jturner 2655: if(!p->normalMode.valid) {
2656: p->normalMode.valid = 1;
2657: p->normalMode.mode = p->mode;
2658: p->normalMode.showHeader = p->showHeader;
2659: memcpy(p->normalMode.colWidth,p->colWidth,sizeof(p->colWidth));
1.1 espie 2660: }
2661: /* We could put this code under the !p->explainValid
2662: ** condition so that it does not execute if we are already in
2663: ** explain mode. However, always executing it allows us an easy
2664: ** was to reset to explain mode in case the user previously
2665: ** did an .explain followed by a .width, .mode or .header
2666: ** command.
2667: */
2668: p->mode = MODE_Explain;
2669: p->showHeader = 1;
1.1.1.8 jturner 2670: memset(p->colWidth,0,sizeof(p->colWidth));
1.1 espie 2671: p->colWidth[0] = 4; /* addr */
2672: p->colWidth[1] = 13; /* opcode */
2673: p->colWidth[2] = 4; /* P1 */
2674: p->colWidth[3] = 4; /* P2 */
2675: p->colWidth[4] = 4; /* P3 */
2676: p->colWidth[5] = 13; /* P4 */
2677: p->colWidth[6] = 2; /* P5 */
2678: p->colWidth[7] = 13; /* Comment */
1.1.1.10 jturner 2679: }else if (p->normalMode.valid) {
2680: p->normalMode.valid = 0;
2681: p->mode = p->normalMode.mode;
2682: p->showHeader = p->normalMode.showHeader;
2683: memcpy(p->colWidth,p->normalMode.colWidth,sizeof(p->colWidth));
1.1 espie 2684: }
2685: }else
2686:
1.1.1.9 jturner 2687: if( c=='f' && strncmp(azArg[0], "fullschema", n)==0 ){
1.1.1.10 jturner 2688: ShellState data;
1.1.1.9 jturner 2689: char *zErrMsg = 0;
2690: int doStats = 0;
2691: if( nArg!=1 ){
2692: fprintf(stderr, "Usage: .fullschema\n");
2693: rc = 1;
2694: goto meta_command_exit;
2695: }
2696: open_db(p, 0);
2697: memcpy(&data, p, sizeof(data));
2698: data.showHeader = 0;
2699: data.mode = MODE_Semi;
2700: rc = sqlite3_exec(p->db,
2701: "SELECT sql FROM"
2702: " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
2703: " FROM sqlite_master UNION ALL"
2704: " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
1.1.1.10 jturner 2705: "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
1.1.1.9 jturner 2706: "ORDER BY rowid",
2707: callback, &data, &zErrMsg
2708: );
2709: if( rc==SQLITE_OK ){
2710: sqlite3_stmt *pStmt;
2711: rc = sqlite3_prepare_v2(p->db,
2712: "SELECT rowid FROM sqlite_master"
2713: " WHERE name GLOB 'sqlite_stat[134]'",
2714: -1, &pStmt, 0);
2715: doStats = sqlite3_step(pStmt)==SQLITE_ROW;
2716: sqlite3_finalize(pStmt);
2717: }
2718: if( doStats==0 ){
2719: fprintf(p->out, "/* No STAT tables available */\n");
2720: }else{
2721: fprintf(p->out, "ANALYZE sqlite_master;\n");
2722: sqlite3_exec(p->db, "SELECT 'ANALYZE sqlite_master'",
2723: callback, &data, &zErrMsg);
2724: data.mode = MODE_Insert;
2725: data.zDestTable = "sqlite_stat1";
2726: shell_exec(p->db, "SELECT * FROM sqlite_stat1",
2727: shell_callback, &data,&zErrMsg);
2728: data.zDestTable = "sqlite_stat3";
2729: shell_exec(p->db, "SELECT * FROM sqlite_stat3",
2730: shell_callback, &data,&zErrMsg);
2731: data.zDestTable = "sqlite_stat4";
2732: shell_exec(p->db, "SELECT * FROM sqlite_stat4",
2733: shell_callback, &data, &zErrMsg);
2734: fprintf(p->out, "ANALYZE sqlite_master;\n");
2735: }
1.1 espie 2736: }else
2737:
1.1.1.9 jturner 2738: if( c=='h' && strncmp(azArg[0], "headers", n)==0 ){
2739: if( nArg==2 ){
2740: p->showHeader = booleanValue(azArg[1]);
2741: }else{
2742: fprintf(stderr, "Usage: .headers on|off\n");
2743: rc = 1;
1.1 espie 2744: }
2745: }else
2746:
1.1.1.9 jturner 2747: if( c=='h' && strncmp(azArg[0], "help", n)==0 ){
2748: fprintf(p->out, "%s", zHelp);
2749: }else
2750:
2751: if( c=='i' && strncmp(azArg[0], "import", n)==0 ){
2752: char *zTable; /* Insert data into this table */
2753: char *zFile; /* Name of file to extra content from */
1.1 espie 2754: sqlite3_stmt *pStmt = NULL; /* A statement */
2755: int nCol; /* Number of columns in the table */
2756: int nByte; /* Number of bytes in an SQL string */
2757: int i, j; /* Loop counters */
1.1.1.7 jturner 2758: int needCommit; /* True to COMMIT or ROLLBACK at end */
1.1.1.11! jturner 2759: int nSep; /* Number of bytes in p->colSeparator[] */
1.1 espie 2760: char *zSql; /* An SQL statement */
1.1.1.11! jturner 2761: ImportCtx sCtx; /* Reader context */
! 2762: char *(*xRead)(ImportCtx*); /* Procedure to read one value */
1.1.1.7 jturner 2763: int (*xCloser)(FILE*); /* Procedure to close th3 connection */
1.1 espie 2764:
1.1.1.9 jturner 2765: if( nArg!=3 ){
2766: fprintf(stderr, "Usage: .import FILE TABLE\n");
2767: goto meta_command_exit;
2768: }
2769: zFile = azArg[1];
2770: zTable = azArg[2];
1.1.1.7 jturner 2771: seenInterrupt = 0;
1.1.1.11! jturner 2772: memset(&sCtx, 0, sizeof(sCtx));
1.1.1.8 jturner 2773: open_db(p, 0);
1.1.1.11! jturner 2774: nSep = strlen30(p->colSeparator);
1.1 espie 2775: if( nSep==0 ){
1.1.1.11! jturner 2776: fprintf(stderr, "Error: non-null column separator required for import\n");
1.1 espie 2777: return 1;
2778: }
1.1.1.7 jturner 2779: if( nSep>1 ){
1.1.1.11! jturner 2780: fprintf(stderr, "Error: multi-character column separators not allowed"
1.1.1.7 jturner 2781: " for import\n");
2782: return 1;
2783: }
1.1.1.11! jturner 2784: nSep = strlen30(p->rowSeparator);
! 2785: if( nSep==0 ){
! 2786: fprintf(stderr, "Error: non-null row separator required for import\n");
! 2787: return 1;
! 2788: }
! 2789: if( nSep==2 && p->mode==MODE_Csv && strcmp(p->rowSeparator, SEP_CrLf)==0 ){
! 2790: /* When importing CSV (only), if the row separator is set to the
! 2791: ** default output row separator, change it to the default input
! 2792: ** row separator. This avoids having to maintain different input
! 2793: ** and output row separators. */
! 2794: sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
! 2795: nSep = strlen30(p->rowSeparator);
! 2796: }
! 2797: if( nSep>1 ){
! 2798: fprintf(stderr, "Error: multi-character row separators not allowed"
! 2799: " for import\n");
! 2800: return 1;
! 2801: }
! 2802: sCtx.zFile = zFile;
! 2803: sCtx.nLine = 1;
! 2804: if( sCtx.zFile[0]=='|' ){
! 2805: sCtx.in = popen(sCtx.zFile+1, "r");
! 2806: sCtx.zFile = "<pipe>";
1.1.1.7 jturner 2807: xCloser = pclose;
2808: }else{
1.1.1.11! jturner 2809: sCtx.in = fopen(sCtx.zFile, "rb");
1.1.1.7 jturner 2810: xCloser = fclose;
2811: }
1.1.1.11! jturner 2812: if( p->mode==MODE_Ascii ){
! 2813: xRead = ascii_read_one_field;
! 2814: }else{
! 2815: xRead = csv_read_one_field;
! 2816: }
! 2817: if( sCtx.in==0 ){
1.1.1.7 jturner 2818: fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
2819: return 1;
2820: }
1.1.1.11! jturner 2821: sCtx.cColSep = p->colSeparator[0];
! 2822: sCtx.cRowSep = p->rowSeparator[0];
1.1 espie 2823: zSql = sqlite3_mprintf("SELECT * FROM %s", zTable);
2824: if( zSql==0 ){
2825: fprintf(stderr, "Error: out of memory\n");
1.1.1.11! jturner 2826: xCloser(sCtx.in);
1.1 espie 2827: return 1;
2828: }
2829: nByte = strlen30(zSql);
1.1.1.8 jturner 2830: rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
1.1.1.11! jturner 2831: import_append_char(&sCtx, 0); /* To ensure sCtx.z is allocated */
1.1.1.7 jturner 2832: if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(db))==0 ){
2833: char *zCreate = sqlite3_mprintf("CREATE TABLE %s", zTable);
2834: char cSep = '(';
1.1.1.11! jturner 2835: while( xRead(&sCtx) ){
! 2836: zCreate = sqlite3_mprintf("%z%c\n \"%s\" TEXT", zCreate, cSep, sCtx.z);
1.1.1.7 jturner 2837: cSep = ',';
1.1.1.11! jturner 2838: if( sCtx.cTerm!=sCtx.cColSep ) break;
1.1.1.7 jturner 2839: }
2840: if( cSep=='(' ){
2841: sqlite3_free(zCreate);
1.1.1.11! jturner 2842: sqlite3_free(sCtx.z);
! 2843: xCloser(sCtx.in);
! 2844: fprintf(stderr,"%s: empty file\n", sCtx.zFile);
1.1.1.7 jturner 2845: return 1;
2846: }
2847: zCreate = sqlite3_mprintf("%z\n)", zCreate);
2848: rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
2849: sqlite3_free(zCreate);
2850: if( rc ){
2851: fprintf(stderr, "CREATE TABLE %s(...) failed: %s\n", zTable,
2852: sqlite3_errmsg(db));
1.1.1.11! jturner 2853: sqlite3_free(sCtx.z);
! 2854: xCloser(sCtx.in);
1.1.1.7 jturner 2855: return 1;
2856: }
1.1.1.8 jturner 2857: rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
1.1.1.7 jturner 2858: }
1.1 espie 2859: sqlite3_free(zSql);
2860: if( rc ){
2861: if (pStmt) sqlite3_finalize(pStmt);
2862: fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
1.1.1.11! jturner 2863: xCloser(sCtx.in);
1.1 espie 2864: return 1;
2865: }
2866: nCol = sqlite3_column_count(pStmt);
2867: sqlite3_finalize(pStmt);
2868: pStmt = 0;
2869: if( nCol==0 ) return 0; /* no columns, no error */
1.1.1.7 jturner 2870: zSql = sqlite3_malloc( nByte*2 + 20 + nCol*2 );
1.1 espie 2871: if( zSql==0 ){
2872: fprintf(stderr, "Error: out of memory\n");
1.1.1.11! jturner 2873: xCloser(sCtx.in);
1.1 espie 2874: return 1;
2875: }
1.1.1.7 jturner 2876: sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable);
1.1 espie 2877: j = strlen30(zSql);
2878: for(i=1; i<nCol; i++){
2879: zSql[j++] = ',';
2880: zSql[j++] = '?';
2881: }
2882: zSql[j++] = ')';
2883: zSql[j] = 0;
1.1.1.8 jturner 2884: rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
1.1.1.7 jturner 2885: sqlite3_free(zSql);
1.1 espie 2886: if( rc ){
2887: fprintf(stderr, "Error: %s\n", sqlite3_errmsg(db));
2888: if (pStmt) sqlite3_finalize(pStmt);
1.1.1.11! jturner 2889: xCloser(sCtx.in);
1.1 espie 2890: return 1;
2891: }
1.1.1.7 jturner 2892: needCommit = sqlite3_get_autocommit(db);
2893: if( needCommit ) sqlite3_exec(db, "BEGIN", 0, 0, 0);
2894: do{
1.1.1.11! jturner 2895: int startLine = sCtx.nLine;
1.1.1.7 jturner 2896: for(i=0; i<nCol; i++){
1.1.1.11! jturner 2897: char *z = xRead(&sCtx);
! 2898: /*
! 2899: ** Did we reach end-of-file before finding any columns?
! 2900: ** If so, stop instead of NULL filling the remaining columns.
! 2901: */
1.1.1.7 jturner 2902: if( z==0 && i==0 ) break;
1.1.1.11! jturner 2903: /*
! 2904: ** Did we reach end-of-file OR end-of-line before finding any
! 2905: ** columns in ASCII mode? If so, stop instead of NULL filling
! 2906: ** the remaining columns.
! 2907: */
! 2908: if( p->mode==MODE_Ascii && (z==0 || z[0]==0) && i==0 ) break;
1.1.1.7 jturner 2909: sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT);
1.1.1.11! jturner 2910: if( i<nCol-1 && sCtx.cTerm!=sCtx.cColSep ){
1.1.1.7 jturner 2911: fprintf(stderr, "%s:%d: expected %d columns but found %d - "
2912: "filling the rest with NULL\n",
1.1.1.11! jturner 2913: sCtx.zFile, startLine, nCol, i+1);
1.1 espie 2914: i++;
1.1.1.9 jturner 2915: while( i<=nCol ){ sqlite3_bind_null(pStmt, i); i++; }
1.1 espie 2916: }
2917: }
1.1.1.11! jturner 2918: if( sCtx.cTerm==sCtx.cColSep ){
1.1.1.7 jturner 2919: do{
1.1.1.11! jturner 2920: xRead(&sCtx);
1.1.1.7 jturner 2921: i++;
1.1.1.11! jturner 2922: }while( sCtx.cTerm==sCtx.cColSep );
1.1.1.7 jturner 2923: fprintf(stderr, "%s:%d: expected %d columns but found %d - "
2924: "extras ignored\n",
1.1.1.11! jturner 2925: sCtx.zFile, startLine, nCol, i);
1.1.1.7 jturner 2926: }
2927: if( i>=nCol ){
2928: sqlite3_step(pStmt);
2929: rc = sqlite3_reset(pStmt);
2930: if( rc!=SQLITE_OK ){
1.1.1.11! jturner 2931: fprintf(stderr, "%s:%d: INSERT failed: %s\n", sCtx.zFile, startLine,
1.1.1.7 jturner 2932: sqlite3_errmsg(db));
1.1 espie 2933: }
2934: }
1.1.1.11! jturner 2935: }while( sCtx.cTerm!=EOF );
1.1.1.7 jturner 2936:
1.1.1.11! jturner 2937: xCloser(sCtx.in);
! 2938: sqlite3_free(sCtx.z);
1.1 espie 2939: sqlite3_finalize(pStmt);
1.1.1.7 jturner 2940: if( needCommit ) sqlite3_exec(db, "COMMIT", 0, 0, 0);
1.1 espie 2941: }else
2942:
1.1.1.9 jturner 2943: if( c=='i' && strncmp(azArg[0], "indices", n)==0 ){
1.1.1.10 jturner 2944: ShellState data;
1.1 espie 2945: char *zErrMsg = 0;
1.1.1.8 jturner 2946: open_db(p, 0);
1.1 espie 2947: memcpy(&data, p, sizeof(data));
2948: data.showHeader = 0;
2949: data.mode = MODE_List;
2950: if( nArg==1 ){
2951: rc = sqlite3_exec(p->db,
2952: "SELECT name FROM sqlite_master "
2953: "WHERE type='index' AND name NOT LIKE 'sqlite_%' "
2954: "UNION ALL "
2955: "SELECT name FROM sqlite_temp_master "
2956: "WHERE type='index' "
2957: "ORDER BY 1",
2958: callback, &data, &zErrMsg
2959: );
1.1.1.9 jturner 2960: }else if( nArg==2 ){
1.1 espie 2961: zShellStatic = azArg[1];
2962: rc = sqlite3_exec(p->db,
2963: "SELECT name FROM sqlite_master "
2964: "WHERE type='index' AND tbl_name LIKE shellstatic() "
2965: "UNION ALL "
2966: "SELECT name FROM sqlite_temp_master "
2967: "WHERE type='index' AND tbl_name LIKE shellstatic() "
2968: "ORDER BY 1",
2969: callback, &data, &zErrMsg
2970: );
2971: zShellStatic = 0;
1.1.1.9 jturner 2972: }else{
2973: fprintf(stderr, "Usage: .indices ?LIKE-PATTERN?\n");
2974: rc = 1;
2975: goto meta_command_exit;
1.1 espie 2976: }
2977: if( zErrMsg ){
2978: fprintf(stderr,"Error: %s\n", zErrMsg);
2979: sqlite3_free(zErrMsg);
2980: rc = 1;
2981: }else if( rc != SQLITE_OK ){
2982: fprintf(stderr,"Error: querying sqlite_master and sqlite_temp_master\n");
2983: rc = 1;
2984: }
2985: }else
2986:
2987: #ifdef SQLITE_ENABLE_IOTRACE
2988: if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){
2989: extern void (*sqlite3IoTrace)(const char*, ...);
2990: if( iotrace && iotrace!=stdout ) fclose(iotrace);
2991: iotrace = 0;
2992: if( nArg<2 ){
2993: sqlite3IoTrace = 0;
2994: }else if( strcmp(azArg[1], "-")==0 ){
2995: sqlite3IoTrace = iotracePrintf;
2996: iotrace = stdout;
2997: }else{
2998: iotrace = fopen(azArg[1], "w");
2999: if( iotrace==0 ){
3000: fprintf(stderr, "Error: cannot open \"%s\"\n", azArg[1]);
3001: sqlite3IoTrace = 0;
3002: rc = 1;
3003: }else{
3004: sqlite3IoTrace = iotracePrintf;
3005: }
3006: }
3007: }else
3008: #endif
3009:
3010: #ifndef SQLITE_OMIT_LOAD_EXTENSION
1.1.1.9 jturner 3011: if( c=='l' && strncmp(azArg[0], "load", n)==0 ){
1.1 espie 3012: const char *zFile, *zProc;
3013: char *zErrMsg = 0;
1.1.1.9 jturner 3014: if( nArg<2 ){
3015: fprintf(stderr, "Usage: .load FILE ?ENTRYPOINT?\n");
3016: rc = 1;
3017: goto meta_command_exit;
3018: }
1.1 espie 3019: zFile = azArg[1];
3020: zProc = nArg>=3 ? azArg[2] : 0;
1.1.1.8 jturner 3021: open_db(p, 0);
1.1 espie 3022: rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
3023: if( rc!=SQLITE_OK ){
3024: fprintf(stderr, "Error: %s\n", zErrMsg);
3025: sqlite3_free(zErrMsg);
3026: rc = 1;
3027: }
3028: }else
3029: #endif
3030:
1.1.1.9 jturner 3031: if( c=='l' && strncmp(azArg[0], "log", n)==0 ){
3032: if( nArg!=2 ){
3033: fprintf(stderr, "Usage: .log FILENAME\n");
3034: rc = 1;
3035: }else{
3036: const char *zFile = azArg[1];
3037: output_file_close(p->pLog);
3038: p->pLog = output_file_open(zFile);
3039: }
1.1 espie 3040: }else
3041:
1.1.1.9 jturner 3042: if( c=='m' && strncmp(azArg[0], "mode", n)==0 ){
3043: const char *zMode = nArg>=2 ? azArg[1] : "";
3044: int n2 = (int)strlen(zMode);
3045: int c2 = zMode[0];
3046: if( c2=='l' && n2>2 && strncmp(azArg[1],"lines",n2)==0 ){
1.1 espie 3047: p->mode = MODE_Line;
1.1.1.9 jturner 3048: }else if( c2=='c' && strncmp(azArg[1],"columns",n2)==0 ){
1.1 espie 3049: p->mode = MODE_Column;
1.1.1.9 jturner 3050: }else if( c2=='l' && n2>2 && strncmp(azArg[1],"list",n2)==0 ){
1.1 espie 3051: p->mode = MODE_List;
1.1.1.9 jturner 3052: }else if( c2=='h' && strncmp(azArg[1],"html",n2)==0 ){
1.1 espie 3053: p->mode = MODE_Html;
1.1.1.9 jturner 3054: }else if( c2=='t' && strncmp(azArg[1],"tcl",n2)==0 ){
1.1 espie 3055: p->mode = MODE_Tcl;
1.1.1.11! jturner 3056: sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Space);
1.1.1.9 jturner 3057: }else if( c2=='c' && strncmp(azArg[1],"csv",n2)==0 ){
1.1 espie 3058: p->mode = MODE_Csv;
1.1.1.11! jturner 3059: sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma);
! 3060: sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf);
1.1.1.9 jturner 3061: }else if( c2=='t' && strncmp(azArg[1],"tabs",n2)==0 ){
1.1 espie 3062: p->mode = MODE_List;
1.1.1.11! jturner 3063: sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Tab);
1.1.1.9 jturner 3064: }else if( c2=='i' && strncmp(azArg[1],"insert",n2)==0 ){
1.1 espie 3065: p->mode = MODE_Insert;
1.1.1.9 jturner 3066: set_table_name(p, nArg>=3 ? azArg[2] : "table");
1.1.1.11! jturner 3067: }else if( c2=='a' && strncmp(azArg[1],"ascii",n2)==0 ){
! 3068: p->mode = MODE_Ascii;
! 3069: sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Unit);
! 3070: sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Record);
1.1 espie 3071: }else {
3072: fprintf(stderr,"Error: mode should be one of: "
1.1.1.11! jturner 3073: "ascii column csv html insert line list tabs tcl\n");
1.1 espie 3074: rc = 1;
3075: }
3076: }else
3077:
1.1.1.9 jturner 3078: if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 ){
3079: if( nArg==2 ){
1.1.1.11! jturner 3080: sqlite3_snprintf(sizeof(p->nullValue), p->nullValue,
! 3081: "%.*s", (int)ArraySize(p->nullValue)-1, azArg[1]);
1.1.1.9 jturner 3082: }else{
3083: fprintf(stderr, "Usage: .nullvalue STRING\n");
1.1 espie 3084: rc = 1;
3085: }
3086: }else
3087:
1.1.1.8 jturner 3088: if( c=='o' && strncmp(azArg[0], "open", n)==0 && n>=2 ){
3089: sqlite3 *savedDb = p->db;
3090: const char *zSavedFilename = p->zDbFilename;
3091: char *zNewFilename = 0;
3092: p->db = 0;
3093: if( nArg>=2 ){
3094: p->zDbFilename = zNewFilename = sqlite3_mprintf("%s", azArg[1]);
3095: }
3096: open_db(p, 1);
3097: if( p->db!=0 ){
3098: sqlite3_close(savedDb);
3099: sqlite3_free(p->zFreeOnClose);
3100: p->zFreeOnClose = zNewFilename;
3101: }else{
3102: sqlite3_free(zNewFilename);
3103: p->db = savedDb;
3104: p->zDbFilename = zSavedFilename;
3105: }
3106: }else
3107:
1.1.1.9 jturner 3108: if( c=='o'
3109: && (strncmp(azArg[0], "output", n)==0 || strncmp(azArg[0], "once", n)==0)
3110: ){
3111: const char *zFile = nArg>=2 ? azArg[1] : "stdout";
3112: if( nArg>2 ){
3113: fprintf(stderr, "Usage: .%s FILE\n", azArg[0]);
3114: rc = 1;
3115: goto meta_command_exit;
3116: }
3117: if( n>1 && strncmp(azArg[0], "once", n)==0 ){
3118: if( nArg<2 ){
3119: fprintf(stderr, "Usage: .once FILE\n");
3120: rc = 1;
3121: goto meta_command_exit;
3122: }
3123: p->outCount = 2;
3124: }else{
3125: p->outCount = 0;
3126: }
3127: output_reset(p);
3128: if( zFile[0]=='|' ){
3129: p->out = popen(zFile + 1, "w");
1.1.1.2 espie 3130: if( p->out==0 ){
1.1.1.9 jturner 3131: fprintf(stderr,"Error: cannot open pipe \"%s\"\n", zFile + 1);
1.1.1.2 espie 3132: p->out = stdout;
3133: rc = 1;
3134: }else{
1.1.1.9 jturner 3135: sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
1.1.1.2 espie 3136: }
1.1 espie 3137: }else{
1.1.1.9 jturner 3138: p->out = output_file_open(zFile);
1.1 espie 3139: if( p->out==0 ){
1.1.1.9 jturner 3140: if( strcmp(zFile,"off")!=0 ){
3141: fprintf(stderr,"Error: cannot write to \"%s\"\n", zFile);
1.1.1.2 espie 3142: }
1.1 espie 3143: p->out = stdout;
3144: rc = 1;
3145: } else {
1.1.1.9 jturner 3146: sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
1.1 espie 3147: }
3148: }
3149: }else
3150:
1.1.1.5 espie 3151: if( c=='p' && n>=3 && strncmp(azArg[0], "print", n)==0 ){
3152: int i;
3153: for(i=1; i<nArg; i++){
3154: if( i>1 ) fprintf(p->out, " ");
3155: fprintf(p->out, "%s", azArg[i]);
3156: }
3157: fprintf(p->out, "\n");
3158: }else
3159:
1.1.1.9 jturner 3160: if( c=='p' && strncmp(azArg[0], "prompt", n)==0 ){
1.1 espie 3161: if( nArg >= 2) {
3162: strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
3163: }
3164: if( nArg >= 3) {
3165: strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
3166: }
3167: }else
3168:
1.1.1.9 jturner 3169: if( c=='q' && strncmp(azArg[0], "quit", n)==0 ){
1.1 espie 3170: rc = 2;
3171: }else
3172:
1.1.1.9 jturner 3173: if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 ){
3174: FILE *alt;
3175: if( nArg!=2 ){
3176: fprintf(stderr, "Usage: .read FILE\n");
3177: rc = 1;
3178: goto meta_command_exit;
3179: }
3180: alt = fopen(azArg[1], "rb");
1.1 espie 3181: if( alt==0 ){
3182: fprintf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
3183: rc = 1;
3184: }else{
3185: rc = process_input(p, alt);
3186: fclose(alt);
3187: }
3188: }else
3189:
1.1.1.9 jturner 3190: if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 ){
1.1 espie 3191: const char *zSrcFile;
3192: const char *zDb;
3193: sqlite3 *pSrc;
3194: sqlite3_backup *pBackup;
3195: int nTimeout = 0;
3196:
3197: if( nArg==2 ){
3198: zSrcFile = azArg[1];
3199: zDb = "main";
1.1.1.9 jturner 3200: }else if( nArg==3 ){
1.1 espie 3201: zSrcFile = azArg[2];
3202: zDb = azArg[1];
1.1.1.9 jturner 3203: }else{
3204: fprintf(stderr, "Usage: .restore ?DB? FILE\n");
3205: rc = 1;
3206: goto meta_command_exit;
1.1 espie 3207: }
3208: rc = sqlite3_open(zSrcFile, &pSrc);
3209: if( rc!=SQLITE_OK ){
3210: fprintf(stderr, "Error: cannot open \"%s\"\n", zSrcFile);
3211: sqlite3_close(pSrc);
3212: return 1;
3213: }
1.1.1.8 jturner 3214: open_db(p, 0);
1.1 espie 3215: pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
3216: if( pBackup==0 ){
3217: fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
3218: sqlite3_close(pSrc);
3219: return 1;
3220: }
3221: while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
3222: || rc==SQLITE_BUSY ){
3223: if( rc==SQLITE_BUSY ){
3224: if( nTimeout++ >= 3 ) break;
3225: sqlite3_sleep(100);
3226: }
3227: }
3228: sqlite3_backup_finish(pBackup);
3229: if( rc==SQLITE_DONE ){
3230: rc = 0;
3231: }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){
3232: fprintf(stderr, "Error: source database is busy\n");
3233: rc = 1;
3234: }else{
3235: fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
3236: rc = 1;
3237: }
3238: sqlite3_close(pSrc);
3239: }else
3240:
1.1.1.11! jturner 3241:
! 3242: if( c=='s' && strncmp(azArg[0], "scanstats", n)==0 ){
! 3243: if( nArg==2 ){
! 3244: p->scanstatsOn = booleanValue(azArg[1]);
! 3245: #ifndef SQLITE_ENABLE_STMT_SCANSTATUS
! 3246: fprintf(stderr, "Warning: .scanstats not available in this build.\n");
! 3247: #endif
! 3248: }else{
! 3249: fprintf(stderr, "Usage: .scanstats on|off\n");
! 3250: rc = 1;
! 3251: }
! 3252: }else
! 3253:
1.1.1.9 jturner 3254: if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){
1.1.1.10 jturner 3255: ShellState data;
1.1 espie 3256: char *zErrMsg = 0;
1.1.1.8 jturner 3257: open_db(p, 0);
1.1 espie 3258: memcpy(&data, p, sizeof(data));
3259: data.showHeader = 0;
3260: data.mode = MODE_Semi;
1.1.1.9 jturner 3261: if( nArg==2 ){
1.1 espie 3262: int i;
3263: for(i=0; azArg[1][i]; i++) azArg[1][i] = ToLower(azArg[1][i]);
3264: if( strcmp(azArg[1],"sqlite_master")==0 ){
3265: char *new_argv[2], *new_colv[2];
3266: new_argv[0] = "CREATE TABLE sqlite_master (\n"
3267: " type text,\n"
3268: " name text,\n"
3269: " tbl_name text,\n"
3270: " rootpage integer,\n"
3271: " sql text\n"
3272: ")";
3273: new_argv[1] = 0;
3274: new_colv[0] = "sql";
3275: new_colv[1] = 0;
3276: callback(&data, 1, new_argv, new_colv);
3277: rc = SQLITE_OK;
3278: }else if( strcmp(azArg[1],"sqlite_temp_master")==0 ){
3279: char *new_argv[2], *new_colv[2];
3280: new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n"
3281: " type text,\n"
3282: " name text,\n"
3283: " tbl_name text,\n"
3284: " rootpage integer,\n"
3285: " sql text\n"
3286: ")";
3287: new_argv[1] = 0;
3288: new_colv[0] = "sql";
3289: new_colv[1] = 0;
3290: callback(&data, 1, new_argv, new_colv);
3291: rc = SQLITE_OK;
3292: }else{
3293: zShellStatic = azArg[1];
3294: rc = sqlite3_exec(p->db,
3295: "SELECT sql FROM "
1.1.1.3 espie 3296: " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
1.1 espie 3297: " FROM sqlite_master UNION ALL"
1.1.1.3 espie 3298: " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
1.1 espie 3299: "WHERE lower(tbl_name) LIKE shellstatic()"
3300: " AND type!='meta' AND sql NOTNULL "
1.1.1.6 landry 3301: "ORDER BY rowid",
1.1 espie 3302: callback, &data, &zErrMsg);
3303: zShellStatic = 0;
3304: }
1.1.1.9 jturner 3305: }else if( nArg==1 ){
1.1 espie 3306: rc = sqlite3_exec(p->db,
3307: "SELECT sql FROM "
1.1.1.3 espie 3308: " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
1.1 espie 3309: " FROM sqlite_master UNION ALL"
1.1.1.3 espie 3310: " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
1.1.1.10 jturner 3311: "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
1.1.1.6 landry 3312: "ORDER BY rowid",
1.1 espie 3313: callback, &data, &zErrMsg
3314: );
1.1.1.9 jturner 3315: }else{
3316: fprintf(stderr, "Usage: .schema ?LIKE-PATTERN?\n");
3317: rc = 1;
3318: goto meta_command_exit;
1.1 espie 3319: }
3320: if( zErrMsg ){
3321: fprintf(stderr,"Error: %s\n", zErrMsg);
3322: sqlite3_free(zErrMsg);
3323: rc = 1;
3324: }else if( rc != SQLITE_OK ){
3325: fprintf(stderr,"Error: querying schema information\n");
3326: rc = 1;
3327: }else{
3328: rc = 0;
3329: }
3330: }else
3331:
1.1.1.10 jturner 3332:
3333: #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
3334: if( c=='s' && n==11 && strncmp(azArg[0], "selecttrace", n)==0 ){
3335: extern int sqlite3SelectTrace;
3336: sqlite3SelectTrace = nArg>=2 ? booleanValue(azArg[1]) : 0xff;
3337: }else
3338: #endif
3339:
3340:
1.1.1.7 jturner 3341: #ifdef SQLITE_DEBUG
3342: /* Undocumented commands for internal testing. Subject to change
3343: ** without notice. */
3344: if( c=='s' && n>=10 && strncmp(azArg[0], "selftest-", 9)==0 ){
3345: if( strncmp(azArg[0]+9, "boolean", n-9)==0 ){
3346: int i, v;
3347: for(i=1; i<nArg; i++){
3348: v = booleanValue(azArg[i]);
3349: fprintf(p->out, "%s: %d 0x%x\n", azArg[i], v, v);
3350: }
3351: }
3352: if( strncmp(azArg[0]+9, "integer", n-9)==0 ){
3353: int i; sqlite3_int64 v;
3354: for(i=1; i<nArg; i++){
3355: char zBuf[200];
3356: v = integerValue(azArg[i]);
1.1.1.9 jturner 3357: sqlite3_snprintf(sizeof(zBuf),zBuf,"%s: %lld 0x%llx\n", azArg[i],v,v);
1.1.1.7 jturner 3358: fprintf(p->out, "%s", zBuf);
3359: }
3360: }
3361: }else
3362: #endif
3363:
1.1.1.9 jturner 3364: if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){
3365: if( nArg<2 || nArg>3 ){
1.1.1.11! jturner 3366: fprintf(stderr, "Usage: .separator COL ?ROW?\n");
1.1.1.9 jturner 3367: rc = 1;
3368: }
3369: if( nArg>=2 ){
1.1.1.11! jturner 3370: sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator,
! 3371: "%.*s", (int)ArraySize(p->colSeparator)-1, azArg[1]);
1.1.1.9 jturner 3372: }
3373: if( nArg>=3 ){
1.1.1.11! jturner 3374: sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator,
! 3375: "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]);
1.1.1.9 jturner 3376: }
3377: }else
3378:
3379: if( c=='s'
3380: && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0)
3381: ){
3382: char *zCmd;
3383: int i, x;
3384: if( nArg<2 ){
3385: fprintf(stderr, "Usage: .system COMMAND\n");
3386: rc = 1;
3387: goto meta_command_exit;
3388: }
3389: zCmd = sqlite3_mprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]);
3390: for(i=2; i<nArg; i++){
3391: zCmd = sqlite3_mprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"",
3392: zCmd, azArg[i]);
3393: }
3394: x = system(zCmd);
3395: sqlite3_free(zCmd);
3396: if( x ) fprintf(stderr, "System command returns %d\n", x);
1.1 espie 3397: }else
3398:
1.1.1.9 jturner 3399: if( c=='s' && strncmp(azArg[0], "show", n)==0 ){
1.1 espie 3400: int i;
1.1.1.9 jturner 3401: if( nArg!=1 ){
3402: fprintf(stderr, "Usage: .show\n");
3403: rc = 1;
3404: goto meta_command_exit;
3405: }
1.1.1.11! jturner 3406: fprintf(p->out,"%12.12s: %s\n","echo", p->echoOn ? "on" : "off");
! 3407: fprintf(p->out,"%12.12s: %s\n","eqp", p->autoEQP ? "on" : "off");
1.1.1.10 jturner 3408: fprintf(p->out,"%9.9s: %s\n","explain", p->normalMode.valid ? "on" :"off");
1.1.1.11! jturner 3409: fprintf(p->out,"%12.12s: %s\n","headers", p->showHeader ? "on" : "off");
! 3410: fprintf(p->out,"%12.12s: %s\n","mode", modeDescr[p->mode]);
! 3411: fprintf(p->out,"%12.12s: ", "nullvalue");
! 3412: output_c_string(p->out, p->nullValue);
1.1 espie 3413: fprintf(p->out, "\n");
1.1.1.11! jturner 3414: fprintf(p->out,"%12.12s: %s\n","output",
1.1 espie 3415: strlen30(p->outfile) ? p->outfile : "stdout");
1.1.1.11! jturner 3416: fprintf(p->out,"%12.12s: ", "colseparator");
! 3417: output_c_string(p->out, p->colSeparator);
1.1 espie 3418: fprintf(p->out, "\n");
1.1.1.11! jturner 3419: fprintf(p->out,"%12.12s: ", "rowseparator");
! 3420: output_c_string(p->out, p->rowSeparator);
! 3421: fprintf(p->out, "\n");
! 3422: fprintf(p->out,"%12.12s: %s\n","stats", p->statsOn ? "on" : "off");
! 3423: fprintf(p->out,"%12.12s: ","width");
1.1 espie 3424: for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) {
3425: fprintf(p->out,"%d ",p->colWidth[i]);
3426: }
3427: fprintf(p->out,"\n");
3428: }else
3429:
1.1.1.9 jturner 3430: if( c=='s' && strncmp(azArg[0], "stats", n)==0 ){
3431: if( nArg==2 ){
3432: p->statsOn = booleanValue(azArg[1]);
3433: }else{
3434: fprintf(stderr, "Usage: .stats on|off\n");
3435: rc = 1;
3436: }
1.1 espie 3437: }else
3438:
1.1.1.9 jturner 3439: if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 ){
1.1.1.2 espie 3440: sqlite3_stmt *pStmt;
1.1 espie 3441: char **azResult;
1.1.1.2 espie 3442: int nRow, nAlloc;
3443: char *zSql = 0;
3444: int ii;
1.1.1.8 jturner 3445: open_db(p, 0);
1.1.1.2 espie 3446: rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
3447: if( rc ) return rc;
3448: zSql = sqlite3_mprintf(
3449: "SELECT name FROM sqlite_master"
3450: " WHERE type IN ('table','view')"
3451: " AND name NOT LIKE 'sqlite_%%'"
3452: " AND name LIKE ?1");
3453: while( sqlite3_step(pStmt)==SQLITE_ROW ){
3454: const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1);
3455: if( zDbName==0 || strcmp(zDbName,"main")==0 ) continue;
3456: if( strcmp(zDbName,"temp")==0 ){
3457: zSql = sqlite3_mprintf(
3458: "%z UNION ALL "
3459: "SELECT 'temp.' || name FROM sqlite_temp_master"
3460: " WHERE type IN ('table','view')"
3461: " AND name NOT LIKE 'sqlite_%%'"
3462: " AND name LIKE ?1", zSql);
3463: }else{
3464: zSql = sqlite3_mprintf(
3465: "%z UNION ALL "
3466: "SELECT '%q.' || name FROM \"%w\".sqlite_master"
3467: " WHERE type IN ('table','view')"
3468: " AND name NOT LIKE 'sqlite_%%'"
3469: " AND name LIKE ?1", zSql, zDbName, zDbName);
3470: }
1.1 espie 3471: }
1.1.1.2 espie 3472: sqlite3_finalize(pStmt);
3473: zSql = sqlite3_mprintf("%z ORDER BY 1", zSql);
3474: rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
3475: sqlite3_free(zSql);
3476: if( rc ) return rc;
3477: nRow = nAlloc = 0;
3478: azResult = 0;
3479: if( nArg>1 ){
3480: sqlite3_bind_text(pStmt, 1, azArg[1], -1, SQLITE_TRANSIENT);
1.1 espie 3481: }else{
1.1.1.2 espie 3482: sqlite3_bind_text(pStmt, 1, "%", -1, SQLITE_STATIC);
3483: }
3484: while( sqlite3_step(pStmt)==SQLITE_ROW ){
3485: if( nRow>=nAlloc ){
3486: char **azNew;
3487: int n = nAlloc*2 + 10;
3488: azNew = sqlite3_realloc(azResult, sizeof(azResult[0])*n);
3489: if( azNew==0 ){
3490: fprintf(stderr, "Error: out of memory\n");
3491: break;
3492: }
3493: nAlloc = n;
3494: azResult = azNew;
3495: }
3496: azResult[nRow] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0));
3497: if( azResult[nRow] ) nRow++;
3498: }
3499: sqlite3_finalize(pStmt);
3500: if( nRow>0 ){
1.1 espie 3501: int len, maxlen = 0;
3502: int i, j;
3503: int nPrintCol, nPrintRow;
1.1.1.2 espie 3504: for(i=0; i<nRow; i++){
1.1 espie 3505: len = strlen30(azResult[i]);
3506: if( len>maxlen ) maxlen = len;
3507: }
3508: nPrintCol = 80/(maxlen+2);
3509: if( nPrintCol<1 ) nPrintCol = 1;
3510: nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
3511: for(i=0; i<nPrintRow; i++){
1.1.1.2 espie 3512: for(j=i; j<nRow; j+=nPrintRow){
3513: char *zSp = j<nPrintRow ? "" : " ";
1.1.1.11! jturner 3514: fprintf(p->out, "%s%-*s", zSp, maxlen, azResult[j] ? azResult[j]:"");
1.1 espie 3515: }
1.1.1.6 landry 3516: fprintf(p->out, "\n");
1.1 espie 3517: }
3518: }
1.1.1.2 espie 3519: for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]);
3520: sqlite3_free(azResult);
1.1 espie 3521: }else
3522:
3523: if( c=='t' && n>=8 && strncmp(azArg[0], "testctrl", n)==0 && nArg>=2 ){
3524: static const struct {
3525: const char *zCtrlName; /* Name of a test-control option */
3526: int ctrlCode; /* Integer code for that option */
3527: } aCtrl[] = {
3528: { "prng_save", SQLITE_TESTCTRL_PRNG_SAVE },
3529: { "prng_restore", SQLITE_TESTCTRL_PRNG_RESTORE },
3530: { "prng_reset", SQLITE_TESTCTRL_PRNG_RESET },
3531: { "bitvec_test", SQLITE_TESTCTRL_BITVEC_TEST },
3532: { "fault_install", SQLITE_TESTCTRL_FAULT_INSTALL },
3533: { "benign_malloc_hooks", SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS },
3534: { "pending_byte", SQLITE_TESTCTRL_PENDING_BYTE },
3535: { "assert", SQLITE_TESTCTRL_ASSERT },
3536: { "always", SQLITE_TESTCTRL_ALWAYS },
3537: { "reserve", SQLITE_TESTCTRL_RESERVE },
3538: { "optimizations", SQLITE_TESTCTRL_OPTIMIZATIONS },
3539: { "iskeyword", SQLITE_TESTCTRL_ISKEYWORD },
3540: { "scratchmalloc", SQLITE_TESTCTRL_SCRATCHMALLOC },
1.1.1.9 jturner 3541: { "byteorder", SQLITE_TESTCTRL_BYTEORDER },
1.1 espie 3542: };
3543: int testctrl = -1;
3544: int rc = 0;
3545: int i, n;
1.1.1.8 jturner 3546: open_db(p, 0);
1.1 espie 3547:
3548: /* convert testctrl text option to value. allow any unique prefix
3549: ** of the option name, or a numerical value. */
3550: n = strlen30(azArg[1]);
3551: for(i=0; i<(int)(sizeof(aCtrl)/sizeof(aCtrl[0])); i++){
3552: if( strncmp(azArg[1], aCtrl[i].zCtrlName, n)==0 ){
3553: if( testctrl<0 ){
3554: testctrl = aCtrl[i].ctrlCode;
3555: }else{
3556: fprintf(stderr, "ambiguous option name: \"%s\"\n", azArg[1]);
3557: testctrl = -1;
3558: break;
3559: }
3560: }
3561: }
1.1.1.7 jturner 3562: if( testctrl<0 ) testctrl = (int)integerValue(azArg[1]);
1.1 espie 3563: if( (testctrl<SQLITE_TESTCTRL_FIRST) || (testctrl>SQLITE_TESTCTRL_LAST) ){
3564: fprintf(stderr,"Error: invalid testctrl option: %s\n", azArg[1]);
3565: }else{
3566: switch(testctrl){
3567:
3568: /* sqlite3_test_control(int, db, int) */
3569: case SQLITE_TESTCTRL_OPTIMIZATIONS:
3570: case SQLITE_TESTCTRL_RESERVE:
3571: if( nArg==3 ){
3572: int opt = (int)strtol(azArg[2], 0, 0);
3573: rc = sqlite3_test_control(testctrl, p->db, opt);
1.1.1.6 landry 3574: fprintf(p->out, "%d (0x%08x)\n", rc, rc);
1.1 espie 3575: } else {
3576: fprintf(stderr,"Error: testctrl %s takes a single int option\n",
3577: azArg[1]);
3578: }
3579: break;
3580:
3581: /* sqlite3_test_control(int) */
1.1.1.9 jturner 3582: case SQLITE_TESTCTRL_PRNG_SAVE:
3583: case SQLITE_TESTCTRL_PRNG_RESTORE:
1.1 espie 3584: case SQLITE_TESTCTRL_PRNG_RESET:
1.1.1.9 jturner 3585: case SQLITE_TESTCTRL_BYTEORDER:
1.1 espie 3586: if( nArg==2 ){
3587: rc = sqlite3_test_control(testctrl);
1.1.1.6 landry 3588: fprintf(p->out, "%d (0x%08x)\n", rc, rc);
1.1 espie 3589: } else {
3590: fprintf(stderr,"Error: testctrl %s takes no options\n", azArg[1]);
3591: }
3592: break;
3593:
3594: /* sqlite3_test_control(int, uint) */
3595: case SQLITE_TESTCTRL_PENDING_BYTE:
3596: if( nArg==3 ){
1.1.1.7 jturner 3597: unsigned int opt = (unsigned int)integerValue(azArg[2]);
1.1 espie 3598: rc = sqlite3_test_control(testctrl, opt);
1.1.1.6 landry 3599: fprintf(p->out, "%d (0x%08x)\n", rc, rc);
1.1 espie 3600: } else {
3601: fprintf(stderr,"Error: testctrl %s takes a single unsigned"
3602: " int option\n", azArg[1]);
3603: }
3604: break;
3605:
3606: /* sqlite3_test_control(int, int) */
3607: case SQLITE_TESTCTRL_ASSERT:
3608: case SQLITE_TESTCTRL_ALWAYS:
3609: if( nArg==3 ){
1.1.1.7 jturner 3610: int opt = booleanValue(azArg[2]);
1.1 espie 3611: rc = sqlite3_test_control(testctrl, opt);
1.1.1.6 landry 3612: fprintf(p->out, "%d (0x%08x)\n", rc, rc);
1.1 espie 3613: } else {
3614: fprintf(stderr,"Error: testctrl %s takes a single int option\n",
3615: azArg[1]);
3616: }
3617: break;
3618:
3619: /* sqlite3_test_control(int, char *) */
3620: #ifdef SQLITE_N_KEYWORD
3621: case SQLITE_TESTCTRL_ISKEYWORD:
3622: if( nArg==3 ){
3623: const char *opt = azArg[2];
3624: rc = sqlite3_test_control(testctrl, opt);
1.1.1.6 landry 3625: fprintf(p->out, "%d (0x%08x)\n", rc, rc);
1.1 espie 3626: } else {
3627: fprintf(stderr,"Error: testctrl %s takes a single char * option\n",
3628: azArg[1]);
3629: }
3630: break;
3631: #endif
3632:
3633: case SQLITE_TESTCTRL_BITVEC_TEST:
3634: case SQLITE_TESTCTRL_FAULT_INSTALL:
3635: case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS:
3636: case SQLITE_TESTCTRL_SCRATCHMALLOC:
3637: default:
3638: fprintf(stderr,"Error: CLI support for testctrl %s not implemented\n",
3639: azArg[1]);
3640: break;
3641: }
3642: }
3643: }else
3644:
1.1.1.9 jturner 3645: if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 ){
1.1.1.8 jturner 3646: open_db(p, 0);
1.1.1.9 jturner 3647: sqlite3_busy_timeout(p->db, nArg>=2 ? (int)integerValue(azArg[1]) : 0);
1.1 espie 3648: }else
3649:
1.1.1.9 jturner 3650: if( c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 ){
3651: if( nArg==2 ){
3652: enableTimer = booleanValue(azArg[1]);
3653: if( enableTimer && !HAS_TIMER ){
3654: fprintf(stderr, "Error: timer not available on this system.\n");
3655: enableTimer = 0;
3656: }
3657: }else{
3658: fprintf(stderr, "Usage: .timer on|off\n");
3659: rc = 1;
3660: }
1.1 espie 3661: }else
3662:
1.1.1.9 jturner 3663: if( c=='t' && strncmp(azArg[0], "trace", n)==0 ){
1.1.1.8 jturner 3664: open_db(p, 0);
1.1.1.2 espie 3665: output_file_close(p->traceOut);
1.1.1.9 jturner 3666: if( nArg!=2 ){
3667: fprintf(stderr, "Usage: .trace FILE|off\n");
3668: rc = 1;
3669: goto meta_command_exit;
3670: }
1.1.1.2 espie 3671: p->traceOut = output_file_open(azArg[1]);
1.1.1.4 espie 3672: #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)
1.1.1.2 espie 3673: if( p->traceOut==0 ){
3674: sqlite3_trace(p->db, 0, 0);
3675: }else{
3676: sqlite3_trace(p->db, sql_trace_callback, p->traceOut);
3677: }
3678: #endif
3679: }else
3680:
1.1.1.10 jturner 3681: #if SQLITE_USER_AUTHENTICATION
3682: if( c=='u' && strncmp(azArg[0], "user", n)==0 ){
3683: if( nArg<2 ){
3684: fprintf(stderr, "Usage: .user SUBCOMMAND ...\n");
3685: rc = 1;
3686: goto meta_command_exit;
3687: }
3688: open_db(p, 0);
3689: if( strcmp(azArg[1],"login")==0 ){
3690: if( nArg!=4 ){
3691: fprintf(stderr, "Usage: .user login USER PASSWORD\n");
3692: rc = 1;
3693: goto meta_command_exit;
3694: }
3695: rc = sqlite3_user_authenticate(p->db, azArg[2], azArg[3],
3696: (int)strlen(azArg[3]));
3697: if( rc ){
3698: fprintf(stderr, "Authentication failed for user %s\n", azArg[2]);
3699: rc = 1;
3700: }
3701: }else if( strcmp(azArg[1],"add")==0 ){
3702: if( nArg!=5 ){
3703: fprintf(stderr, "Usage: .user add USER PASSWORD ISADMIN\n");
3704: rc = 1;
3705: goto meta_command_exit;
3706: }
3707: rc = sqlite3_user_add(p->db, azArg[2],
3708: azArg[3], (int)strlen(azArg[3]),
3709: booleanValue(azArg[4]));
3710: if( rc ){
3711: fprintf(stderr, "User-Add failed: %d\n", rc);
3712: rc = 1;
3713: }
3714: }else if( strcmp(azArg[1],"edit")==0 ){
3715: if( nArg!=5 ){
3716: fprintf(stderr, "Usage: .user edit USER PASSWORD ISADMIN\n");
3717: rc = 1;
3718: goto meta_command_exit;
3719: }
3720: rc = sqlite3_user_change(p->db, azArg[2],
3721: azArg[3], (int)strlen(azArg[3]),
3722: booleanValue(azArg[4]));
3723: if( rc ){
3724: fprintf(stderr, "User-Edit failed: %d\n", rc);
3725: rc = 1;
3726: }
3727: }else if( strcmp(azArg[1],"delete")==0 ){
3728: if( nArg!=3 ){
3729: fprintf(stderr, "Usage: .user delete USER\n");
3730: rc = 1;
3731: goto meta_command_exit;
3732: }
3733: rc = sqlite3_user_delete(p->db, azArg[2]);
3734: if( rc ){
3735: fprintf(stderr, "User-Delete failed: %d\n", rc);
3736: rc = 1;
3737: }
3738: }else{
3739: fprintf(stderr, "Usage: .user login|add|edit|delete ...\n");
3740: rc = 1;
3741: goto meta_command_exit;
3742: }
3743: }else
3744: #endif /* SQLITE_USER_AUTHENTICATION */
3745:
1.1 espie 3746: if( c=='v' && strncmp(azArg[0], "version", n)==0 ){
1.1.1.6 landry 3747: fprintf(p->out, "SQLite %s %s\n" /*extra-version-info*/,
1.1 espie 3748: sqlite3_libversion(), sqlite3_sourceid());
3749: }else
3750:
3751: if( c=='v' && strncmp(azArg[0], "vfsname", n)==0 ){
3752: const char *zDbName = nArg==2 ? azArg[1] : "main";
3753: char *zVfsName = 0;
3754: if( p->db ){
3755: sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName);
3756: if( zVfsName ){
1.1.1.6 landry 3757: fprintf(p->out, "%s\n", zVfsName);
1.1 espie 3758: sqlite3_free(zVfsName);
3759: }
3760: }
3761: }else
3762:
1.1.1.5 espie 3763: #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
3764: if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){
3765: extern int sqlite3WhereTrace;
1.1.1.9 jturner 3766: sqlite3WhereTrace = nArg>=2 ? booleanValue(azArg[1]) : 0xff;
1.1.1.5 espie 3767: }else
3768: #endif
3769:
1.1.1.9 jturner 3770: if( c=='w' && strncmp(azArg[0], "width", n)==0 ){
1.1 espie 3771: int j;
3772: assert( nArg<=ArraySize(azArg) );
3773: for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){
1.1.1.7 jturner 3774: p->colWidth[j-1] = (int)integerValue(azArg[j]);
1.1 espie 3775: }
3776: }else
3777:
3778: {
3779: fprintf(stderr, "Error: unknown command or invalid arguments: "
3780: " \"%s\". Enter \".help\" for help\n", azArg[0]);
3781: rc = 1;
3782: }
3783:
1.1.1.9 jturner 3784: meta_command_exit:
3785: if( p->outCount ){
3786: p->outCount--;
3787: if( p->outCount==0 ) output_reset(p);
3788: }
1.1 espie 3789: return rc;
3790: }
3791:
3792: /*
3793: ** Return TRUE if a semicolon occurs anywhere in the first N characters
3794: ** of string z[].
3795: */
1.1.1.7 jturner 3796: static int line_contains_semicolon(const char *z, int N){
1.1 espie 3797: int i;
3798: for(i=0; i<N; i++){ if( z[i]==';' ) return 1; }
3799: return 0;
3800: }
3801:
3802: /*
3803: ** Test to see if a line consists entirely of whitespace.
3804: */
3805: static int _all_whitespace(const char *z){
3806: for(; *z; z++){
3807: if( IsSpace(z[0]) ) continue;
3808: if( *z=='/' && z[1]=='*' ){
3809: z += 2;
3810: while( *z && (*z!='*' || z[1]!='/') ){ z++; }
3811: if( *z==0 ) return 0;
3812: z++;
3813: continue;
3814: }
3815: if( *z=='-' && z[1]=='-' ){
3816: z += 2;
3817: while( *z && *z!='\n' ){ z++; }
3818: if( *z==0 ) return 1;
3819: continue;
3820: }
3821: return 0;
3822: }
3823: return 1;
3824: }
3825:
3826: /*
3827: ** Return TRUE if the line typed in is an SQL command terminator other
3828: ** than a semi-colon. The SQL Server style "go" command is understood
3829: ** as is the Oracle "/".
3830: */
1.1.1.7 jturner 3831: static int line_is_command_terminator(const char *zLine){
1.1 espie 3832: while( IsSpace(zLine[0]) ){ zLine++; };
3833: if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ){
3834: return 1; /* Oracle */
3835: }
3836: if( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o'
3837: && _all_whitespace(&zLine[2]) ){
3838: return 1; /* SQL Server */
3839: }
3840: return 0;
3841: }
3842:
3843: /*
3844: ** Return true if zSql is a complete SQL statement. Return false if it
3845: ** ends in the middle of a string literal or C-style comment.
3846: */
1.1.1.7 jturner 3847: static int line_is_complete(char *zSql, int nSql){
1.1 espie 3848: int rc;
3849: if( zSql==0 ) return 1;
3850: zSql[nSql] = ';';
3851: zSql[nSql+1] = 0;
3852: rc = sqlite3_complete(zSql);
3853: zSql[nSql] = 0;
3854: return rc;
3855: }
3856:
3857: /*
3858: ** Read input from *in and process it. If *in==0 then input
3859: ** is interactive - the user is typing it it. Otherwise, input
3860: ** is coming from a file or device. A prompt is issued and history
3861: ** is saved only if input is interactive. An interrupt signal will
3862: ** cause this routine to exit immediately, unless input is interactive.
3863: **
3864: ** Return the number of errors.
3865: */
1.1.1.10 jturner 3866: static int process_input(ShellState *p, FILE *in){
1.1.1.7 jturner 3867: char *zLine = 0; /* A single input line */
3868: char *zSql = 0; /* Accumulated SQL text */
3869: int nLine; /* Length of current line */
3870: int nSql = 0; /* Bytes of zSql[] used */
3871: int nAlloc = 0; /* Allocated zSql[] space */
3872: int nSqlPrior = 0; /* Bytes of zSql[] used by prior line */
3873: char *zErrMsg; /* Error message returned */
3874: int rc; /* Error code */
3875: int errCnt = 0; /* Number of errors seen */
3876: int lineno = 0; /* Current line number */
3877: int startline = 0; /* Line number for start of current input */
1.1 espie 3878:
3879: while( errCnt==0 || !bail_on_error || (in==0 && stdin_is_interactive) ){
3880: fflush(p->out);
1.1.1.7 jturner 3881: zLine = one_input_line(in, zLine, nSql>0);
1.1 espie 3882: if( zLine==0 ){
1.1.1.2 espie 3883: /* End of input */
3884: if( stdin_is_interactive ) printf("\n");
3885: break;
1.1 espie 3886: }
3887: if( seenInterrupt ){
3888: if( in!=0 ) break;
3889: seenInterrupt = 0;
3890: }
3891: lineno++;
1.1.1.8 jturner 3892: if( nSql==0 && _all_whitespace(zLine) ){
3893: if( p->echoOn ) printf("%s\n", zLine);
3894: continue;
3895: }
1.1 espie 3896: if( zLine && zLine[0]=='.' && nSql==0 ){
3897: if( p->echoOn ) printf("%s\n", zLine);
3898: rc = do_meta_command(zLine, p);
3899: if( rc==2 ){ /* exit requested */
3900: break;
3901: }else if( rc ){
3902: errCnt++;
3903: }
3904: continue;
3905: }
1.1.1.7 jturner 3906: if( line_is_command_terminator(zLine) && line_is_complete(zSql, nSql) ){
1.1 espie 3907: memcpy(zLine,";",2);
3908: }
1.1.1.7 jturner 3909: nLine = strlen30(zLine);
3910: if( nSql+nLine+2>=nAlloc ){
3911: nAlloc = nSql+nLine+100;
3912: zSql = realloc(zSql, nAlloc);
3913: if( zSql==0 ){
3914: fprintf(stderr, "Error: out of memory\n");
3915: exit(1);
3916: }
3917: }
1.1 espie 3918: nSqlPrior = nSql;
1.1.1.7 jturner 3919: if( nSql==0 ){
1.1 espie 3920: int i;
3921: for(i=0; zLine[i] && IsSpace(zLine[i]); i++){}
1.1.1.7 jturner 3922: assert( nAlloc>0 && zSql!=0 );
3923: memcpy(zSql, zLine+i, nLine+1-i);
3924: startline = lineno;
3925: nSql = nLine-i;
1.1 espie 3926: }else{
3927: zSql[nSql++] = '\n';
1.1.1.7 jturner 3928: memcpy(zSql+nSql, zLine, nLine+1);
3929: nSql += nLine;
1.1 espie 3930: }
1.1.1.7 jturner 3931: if( nSql && line_contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
1.1 espie 3932: && sqlite3_complete(zSql) ){
3933: p->cnt = 0;
1.1.1.8 jturner 3934: open_db(p, 0);
1.1 espie 3935: BEGIN_TIMER;
3936: rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
3937: END_TIMER;
3938: if( rc || zErrMsg ){
3939: char zPrefix[100];
3940: if( in!=0 || !stdin_is_interactive ){
3941: sqlite3_snprintf(sizeof(zPrefix), zPrefix,
3942: "Error: near line %d:", startline);
3943: }else{
3944: sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:");
3945: }
3946: if( zErrMsg!=0 ){
3947: fprintf(stderr, "%s %s\n", zPrefix, zErrMsg);
3948: sqlite3_free(zErrMsg);
3949: zErrMsg = 0;
3950: }else{
3951: fprintf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
3952: }
3953: errCnt++;
3954: }
3955: nSql = 0;
1.1.1.9 jturner 3956: if( p->outCount ){
3957: output_reset(p);
3958: p->outCount = 0;
3959: }
1.1.1.7 jturner 3960: }else if( nSql && _all_whitespace(zSql) ){
1.1.1.8 jturner 3961: if( p->echoOn ) printf("%s\n", zSql);
1.1.1.6 landry 3962: nSql = 0;
1.1 espie 3963: }
3964: }
1.1.1.7 jturner 3965: if( nSql ){
1.1 espie 3966: if( !_all_whitespace(zSql) ){
3967: fprintf(stderr, "Error: incomplete SQL: %s\n", zSql);
1.1.1.10 jturner 3968: errCnt++;
1.1 espie 3969: }
3970: free(zSql);
3971: }
3972: free(zLine);
1.1.1.5 espie 3973: return errCnt>0;
1.1 espie 3974: }
3975:
3976: /*
3977: ** Return a pathname which is the user's home directory. A
1.1.1.2 espie 3978: ** 0 return indicates an error of some kind.
1.1 espie 3979: */
3980: static char *find_home_dir(void){
1.1.1.2 espie 3981: static char *home_dir = NULL;
3982: if( home_dir ) return home_dir;
1.1 espie 3983:
1.1.1.11! jturner 3984: #if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) \
! 3985: && !defined(__RTP__) && !defined(_WRS_KERNEL)
1.1.1.4 espie 3986: {
3987: struct passwd *pwent;
3988: uid_t uid = getuid();
3989: if( (pwent=getpwuid(uid)) != NULL) {
3990: home_dir = pwent->pw_dir;
3991: }
1.1 espie 3992: }
3993: #endif
3994:
3995: #if defined(_WIN32_WCE)
3996: /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
3997: */
1.1.1.2 espie 3998: home_dir = "/";
1.1 espie 3999: #else
4000:
1.1.1.4 espie 4001: #if defined(_WIN32) || defined(WIN32)
1.1 espie 4002: if (!home_dir) {
4003: home_dir = getenv("USERPROFILE");
4004: }
4005: #endif
4006:
4007: if (!home_dir) {
4008: home_dir = getenv("HOME");
4009: }
4010:
1.1.1.4 espie 4011: #if defined(_WIN32) || defined(WIN32)
1.1 espie 4012: if (!home_dir) {
4013: char *zDrive, *zPath;
4014: int n;
4015: zDrive = getenv("HOMEDRIVE");
4016: zPath = getenv("HOMEPATH");
4017: if( zDrive && zPath ){
4018: n = strlen30(zDrive) + strlen30(zPath) + 1;
4019: home_dir = malloc( n );
4020: if( home_dir==0 ) return 0;
4021: sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath);
4022: return home_dir;
4023: }
4024: home_dir = "c:\\";
4025: }
4026: #endif
4027:
4028: #endif /* !_WIN32_WCE */
4029:
4030: if( home_dir ){
4031: int n = strlen30(home_dir) + 1;
4032: char *z = malloc( n );
4033: if( z ) memcpy(z, home_dir, n);
4034: home_dir = z;
4035: }
4036:
4037: return home_dir;
4038: }
4039:
4040: /*
4041: ** Read input from the file given by sqliterc_override. Or if that
4042: ** parameter is NULL, take input from ~/.sqliterc
4043: **
4044: ** Returns the number of errors.
4045: */
4046: static int process_sqliterc(
1.1.1.10 jturner 4047: ShellState *p, /* Configuration data */
1.1 espie 4048: const char *sqliterc_override /* Name of config file. NULL to use default */
4049: ){
4050: char *home_dir = NULL;
4051: const char *sqliterc = sqliterc_override;
4052: char *zBuf = 0;
4053: FILE *in = NULL;
4054: int rc = 0;
4055:
4056: if (sqliterc == NULL) {
4057: home_dir = find_home_dir();
4058: if( home_dir==0 ){
4059: #if !defined(__RTP__) && !defined(_WRS_KERNEL)
4060: fprintf(stderr,"%s: Error: cannot locate your home directory\n", Argv0);
4061: #endif
4062: return 1;
4063: }
1.1.1.4 espie 4064: sqlite3_initialize();
1.1.1.2 espie 4065: zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir);
4066: sqliterc = zBuf;
1.1 espie 4067: }
4068: in = fopen(sqliterc,"rb");
4069: if( in ){
4070: if( stdin_is_interactive ){
4071: fprintf(stderr,"-- Loading resources from %s\n",sqliterc);
4072: }
4073: rc = process_input(p,in);
4074: fclose(in);
4075: }
1.1.1.2 espie 4076: sqlite3_free(zBuf);
1.1 espie 4077: return rc;
4078: }
4079:
4080: /*
4081: ** Show available command line options
4082: */
4083: static const char zOptions[] =
1.1.1.11! jturner 4084: " -ascii set output mode to 'ascii'\n"
1.1 espie 4085: " -bail stop after hitting an error\n"
4086: " -batch force batch I/O\n"
4087: " -column set output mode to 'column'\n"
1.1.1.5 espie 4088: " -cmd COMMAND run \"COMMAND\" before reading stdin\n"
1.1 espie 4089: " -csv set output mode to 'csv'\n"
4090: " -echo print commands before execution\n"
1.1.1.5 espie 4091: " -init FILENAME read/process named file\n"
1.1 espie 4092: " -[no]header turn headers on or off\n"
1.1.1.5 espie 4093: #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
4094: " -heap SIZE Size of heap for memsys3 or memsys5\n"
4095: #endif
1.1 espie 4096: " -help show this message\n"
4097: " -html set output mode to HTML\n"
4098: " -interactive force interactive I/O\n"
4099: " -line set output mode to 'line'\n"
4100: " -list set output mode to 'list'\n"
1.1.1.10 jturner 4101: " -lookaside SIZE N use N entries of SZ bytes for lookaside memory\n"
1.1.1.6 landry 4102: " -mmap N default mmap size set to N\n"
1.1 espie 4103: #ifdef SQLITE_ENABLE_MULTIPLEX
4104: " -multiplex enable the multiplexor VFS\n"
4105: #endif
1.1.1.11! jturner 4106: " -newline SEP set output row separator. Default: '\\n'\n"
1.1.1.5 espie 4107: " -nullvalue TEXT set text string for NULL values. Default ''\n"
1.1.1.10 jturner 4108: " -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n"
4109: " -scratch SIZE N use N slots of SZ bytes each for scratch memory\n"
1.1.1.11! jturner 4110: " -separator SEP set output column separator. Default: '|'\n"
1.1 espie 4111: " -stats print memory stats before each finalize\n"
4112: " -version show SQLite version\n"
4113: " -vfs NAME use NAME as the default VFS\n"
4114: #ifdef SQLITE_ENABLE_VFSTRACE
4115: " -vfstrace enable tracing of all VFS calls\n"
4116: #endif
4117: ;
4118: static void usage(int showDetail){
4119: fprintf(stderr,
4120: "Usage: %s [OPTIONS] FILENAME [SQL]\n"
4121: "FILENAME is the name of an SQLite database. A new database is created\n"
4122: "if the file does not previously exist.\n", Argv0);
4123: if( showDetail ){
4124: fprintf(stderr, "OPTIONS include:\n%s", zOptions);
4125: }else{
4126: fprintf(stderr, "Use the -help option for additional information\n");
4127: }
4128: exit(1);
4129: }
4130:
4131: /*
4132: ** Initialize the state information in data
4133: */
1.1.1.10 jturner 4134: static void main_init(ShellState *data) {
1.1 espie 4135: memset(data, 0, sizeof(*data));
4136: data->mode = MODE_List;
1.1.1.11! jturner 4137: memcpy(data->colSeparator,SEP_Column, 2);
! 4138: memcpy(data->rowSeparator,SEP_Row, 2);
1.1 espie 4139: data->showHeader = 0;
1.1.1.10 jturner 4140: data->shellFlgs = SHFLG_Lookaside;
1.1 espie 4141: sqlite3_config(SQLITE_CONFIG_URI, 1);
4142: sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data);
1.1.1.10 jturner 4143: sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
1.1 espie 4144: sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");
4145: sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> ");
4146: }
4147:
1.1.1.5 espie 4148: /*
1.1.1.8 jturner 4149: ** Output text to the console in a font that attracts extra attention.
4150: */
4151: #ifdef _WIN32
4152: static void printBold(const char *zText){
4153: HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
4154: CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo;
4155: GetConsoleScreenBufferInfo(out, &defaultScreenInfo);
4156: SetConsoleTextAttribute(out,
4157: FOREGROUND_RED|FOREGROUND_INTENSITY
4158: );
4159: printf("%s", zText);
4160: SetConsoleTextAttribute(out, defaultScreenInfo.wAttributes);
4161: }
4162: #else
4163: static void printBold(const char *zText){
4164: printf("\033[1m%s\033[0m", zText);
4165: }
4166: #endif
4167:
4168: /*
1.1.1.5 espie 4169: ** Get the argument to an --option. Throw an error and die if no argument
4170: ** is available.
4171: */
4172: static char *cmdline_option_value(int argc, char **argv, int i){
4173: if( i==argc ){
4174: fprintf(stderr, "%s: Error: missing argument to %s\n",
4175: argv[0], argv[argc-1]);
4176: exit(1);
4177: }
4178: return argv[i];
4179: }
4180:
1.1 espie 4181: int main(int argc, char **argv){
4182: char *zErrMsg = 0;
1.1.1.10 jturner 4183: ShellState data;
1.1 espie 4184: const char *zInitFile = 0;
4185: int i;
4186: int rc = 0;
1.1.1.8 jturner 4187: int warnInmemoryDb = 0;
1.1.1.11! jturner 4188: int readStdin = 1;
! 4189: int nCmd = 0;
! 4190: char **azCmd = 0;
1.1 espie 4191:
1.1.1.8 jturner 4192: #if USE_SYSTEM_SQLITE+0!=1
1.1 espie 4193: if( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)!=0 ){
4194: fprintf(stderr, "SQLite header and source version mismatch\n%s\n%s\n",
4195: sqlite3_sourceid(), SQLITE_SOURCE_ID);
4196: exit(1);
4197: }
1.1.1.8 jturner 4198: #endif
1.1 espie 4199: Argv0 = argv[0];
4200: main_init(&data);
4201: stdin_is_interactive = isatty(0);
4202:
4203: /* Make sure we have a valid signal handler early, before anything
4204: ** else is done.
4205: */
4206: #ifdef SIGINT
4207: signal(SIGINT, interrupt_handler);
4208: #endif
4209:
1.1.1.11! jturner 4210: #ifdef SQLITE_SHELL_DBNAME_PROC
! 4211: {
! 4212: /* If the SQLITE_SHELL_DBNAME_PROC macro is defined, then it is the name
! 4213: ** of a C-function that will provide the name of the database file. Use
! 4214: ** this compile-time option to embed this shell program in larger
! 4215: ** applications. */
! 4216: extern void SQLITE_SHELL_DBNAME_PROC(const char**);
! 4217: SQLITE_SHELL_DBNAME_PROC(&data.zDbFilename);
! 4218: warnInmemoryDb = 0;
! 4219: }
! 4220: #endif
! 4221:
1.1 espie 4222: /* Do an initial pass through the command-line argument to locate
4223: ** the name of the database file, the name of the initialization file,
4224: ** the size of the alternative malloc heap,
4225: ** and the first command to execute.
4226: */
1.1.1.5 espie 4227: for(i=1; i<argc; i++){
1.1 espie 4228: char *z;
4229: z = argv[i];
1.1.1.5 espie 4230: if( z[0]!='-' ){
4231: if( data.zDbFilename==0 ){
4232: data.zDbFilename = z;
1.1.1.11! jturner 4233: }else{
! 4234: /* Excesss arguments are interpreted as SQL (or dot-commands) and
! 4235: ** mean that nothing is read from stdin */
! 4236: readStdin = 0;
! 4237: nCmd++;
! 4238: azCmd = realloc(azCmd, sizeof(azCmd[0])*nCmd);
! 4239: if( azCmd==0 ){
! 4240: fprintf(stderr, "out of memory\n");
! 4241: exit(1);
! 4242: }
! 4243: azCmd[nCmd-1] = z;
1.1.1.5 espie 4244: }
4245: }
1.1 espie 4246: if( z[1]=='-' ) z++;
4247: if( strcmp(z,"-separator")==0
4248: || strcmp(z,"-nullvalue")==0
1.1.1.9 jturner 4249: || strcmp(z,"-newline")==0
1.1 espie 4250: || strcmp(z,"-cmd")==0
4251: ){
1.1.1.5 espie 4252: (void)cmdline_option_value(argc, argv, ++i);
1.1 espie 4253: }else if( strcmp(z,"-init")==0 ){
1.1.1.5 espie 4254: zInitFile = cmdline_option_value(argc, argv, ++i);
1.1 espie 4255: }else if( strcmp(z,"-batch")==0 ){
1.1.1.5 espie 4256: /* Need to check for batch mode here to so we can avoid printing
4257: ** informational messages (like from process_sqliterc) before
4258: ** we do the actual processing of arguments later in a second pass.
4259: */
1.1 espie 4260: stdin_is_interactive = 0;
4261: }else if( strcmp(z,"-heap")==0 ){
4262: #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
4263: const char *zSize;
4264: sqlite3_int64 szHeap;
4265:
1.1.1.5 espie 4266: zSize = cmdline_option_value(argc, argv, ++i);
1.1.1.6 landry 4267: szHeap = integerValue(zSize);
1.1 espie 4268: if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000;
4269: sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64);
4270: #endif
1.1.1.10 jturner 4271: }else if( strcmp(z,"-scratch")==0 ){
4272: int n, sz;
4273: sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
4274: if( sz>400000 ) sz = 400000;
4275: if( sz<2500 ) sz = 2500;
4276: n = (int)integerValue(cmdline_option_value(argc,argv,++i));
4277: if( n>10 ) n = 10;
4278: if( n<1 ) n = 1;
4279: sqlite3_config(SQLITE_CONFIG_SCRATCH, malloc(n*sz+1), sz, n);
4280: data.shellFlgs |= SHFLG_Scratch;
4281: }else if( strcmp(z,"-pagecache")==0 ){
4282: int n, sz;
4283: sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
4284: if( sz>70000 ) sz = 70000;
4285: if( sz<800 ) sz = 800;
4286: n = (int)integerValue(cmdline_option_value(argc,argv,++i));
4287: if( n<10 ) n = 10;
4288: sqlite3_config(SQLITE_CONFIG_PAGECACHE, malloc(n*sz+1), sz, n);
4289: data.shellFlgs |= SHFLG_Pagecache;
4290: }else if( strcmp(z,"-lookaside")==0 ){
4291: int n, sz;
4292: sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
4293: if( sz<0 ) sz = 0;
4294: n = (int)integerValue(cmdline_option_value(argc,argv,++i));
4295: if( n<0 ) n = 0;
4296: sqlite3_config(SQLITE_CONFIG_LOOKASIDE, sz, n);
4297: if( sz*n==0 ) data.shellFlgs &= ~SHFLG_Lookaside;
1.1 espie 4298: #ifdef SQLITE_ENABLE_VFSTRACE
4299: }else if( strcmp(z,"-vfstrace")==0 ){
4300: extern int vfstrace_register(
4301: const char *zTraceName,
4302: const char *zOldVfsName,
4303: int (*xOut)(const char*,void*),
4304: void *pOutArg,
4305: int makeDefault
4306: );
4307: vfstrace_register("trace",0,(int(*)(const char*,void*))fputs,stderr,1);
4308: #endif
4309: #ifdef SQLITE_ENABLE_MULTIPLEX
4310: }else if( strcmp(z,"-multiplex")==0 ){
4311: extern int sqlite3_multiple_initialize(const char*,int);
4312: sqlite3_multiplex_initialize(0, 1);
4313: #endif
1.1.1.6 landry 4314: }else if( strcmp(z,"-mmap")==0 ){
4315: sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));
4316: sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz);
1.1 espie 4317: }else if( strcmp(z,"-vfs")==0 ){
1.1.1.5 espie 4318: sqlite3_vfs *pVfs = sqlite3_vfs_find(cmdline_option_value(argc,argv,++i));
1.1 espie 4319: if( pVfs ){
4320: sqlite3_vfs_register(pVfs, 1);
4321: }else{
4322: fprintf(stderr, "no such VFS: \"%s\"\n", argv[i]);
4323: exit(1);
4324: }
4325: }
4326: }
1.1.1.5 espie 4327: if( data.zDbFilename==0 ){
1.1 espie 4328: #ifndef SQLITE_OMIT_MEMORYDB
4329: data.zDbFilename = ":memory:";
1.1.1.8 jturner 4330: warnInmemoryDb = argc==1;
1.1 espie 4331: #else
4332: fprintf(stderr,"%s: Error: no database filename specified\n", Argv0);
4333: return 1;
4334: #endif
1.1.1.5 espie 4335: }
4336: data.out = stdout;
1.1 espie 4337:
4338: /* Go ahead and open the database file if it already exists. If the
4339: ** file does not exist, delay opening it. This prevents empty database
4340: ** files from being created if a user mistypes the database name argument
4341: ** to the sqlite command-line tool.
4342: */
4343: if( access(data.zDbFilename, 0)==0 ){
1.1.1.8 jturner 4344: open_db(&data, 0);
1.1 espie 4345: }
4346:
4347: /* Process the initialization file if there is one. If no -init option
4348: ** is given on the command line, look for a file named ~/.sqliterc and
4349: ** try to process it.
4350: */
4351: rc = process_sqliterc(&data,zInitFile);
4352: if( rc>0 ){
4353: return rc;
4354: }
4355:
4356: /* Make a second pass through the command-line argument and set
4357: ** options. This second pass is delayed until after the initialization
4358: ** file is processed so that the command-line arguments will override
4359: ** settings in the initialization file.
4360: */
1.1.1.5 espie 4361: for(i=1; i<argc; i++){
1.1 espie 4362: char *z = argv[i];
1.1.1.5 espie 4363: if( z[0]!='-' ) continue;
1.1 espie 4364: if( z[1]=='-' ){ z++; }
4365: if( strcmp(z,"-init")==0 ){
4366: i++;
4367: }else if( strcmp(z,"-html")==0 ){
4368: data.mode = MODE_Html;
4369: }else if( strcmp(z,"-list")==0 ){
4370: data.mode = MODE_List;
4371: }else if( strcmp(z,"-line")==0 ){
4372: data.mode = MODE_Line;
4373: }else if( strcmp(z,"-column")==0 ){
4374: data.mode = MODE_Column;
4375: }else if( strcmp(z,"-csv")==0 ){
4376: data.mode = MODE_Csv;
1.1.1.11! jturner 4377: memcpy(data.colSeparator,",",2);
! 4378: }else if( strcmp(z,"-ascii")==0 ){
! 4379: data.mode = MODE_Ascii;
! 4380: sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
! 4381: SEP_Unit);
! 4382: sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
! 4383: SEP_Record);
1.1 espie 4384: }else if( strcmp(z,"-separator")==0 ){
1.1.1.11! jturner 4385: sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
1.1.1.9 jturner 4386: "%s",cmdline_option_value(argc,argv,++i));
4387: }else if( strcmp(z,"-newline")==0 ){
1.1.1.11! jturner 4388: sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
1.1.1.5 espie 4389: "%s",cmdline_option_value(argc,argv,++i));
1.1 espie 4390: }else if( strcmp(z,"-nullvalue")==0 ){
1.1.1.11! jturner 4391: sqlite3_snprintf(sizeof(data.nullValue), data.nullValue,
1.1.1.5 espie 4392: "%s",cmdline_option_value(argc,argv,++i));
1.1 espie 4393: }else if( strcmp(z,"-header")==0 ){
4394: data.showHeader = 1;
4395: }else if( strcmp(z,"-noheader")==0 ){
4396: data.showHeader = 0;
4397: }else if( strcmp(z,"-echo")==0 ){
4398: data.echoOn = 1;
1.1.1.8 jturner 4399: }else if( strcmp(z,"-eqp")==0 ){
4400: data.autoEQP = 1;
1.1 espie 4401: }else if( strcmp(z,"-stats")==0 ){
4402: data.statsOn = 1;
1.1.1.11! jturner 4403: }else if( strcmp(z,"-scanstats")==0 ){
! 4404: data.scanstatsOn = 1;
1.1 espie 4405: }else if( strcmp(z,"-bail")==0 ){
4406: bail_on_error = 1;
4407: }else if( strcmp(z,"-version")==0 ){
4408: printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
4409: return 0;
4410: }else if( strcmp(z,"-interactive")==0 ){
4411: stdin_is_interactive = 1;
4412: }else if( strcmp(z,"-batch")==0 ){
4413: stdin_is_interactive = 0;
4414: }else if( strcmp(z,"-heap")==0 ){
4415: i++;
1.1.1.10 jturner 4416: }else if( strcmp(z,"-scratch")==0 ){
4417: i+=2;
4418: }else if( strcmp(z,"-pagecache")==0 ){
4419: i+=2;
4420: }else if( strcmp(z,"-lookaside")==0 ){
4421: i+=2;
1.1.1.6 landry 4422: }else if( strcmp(z,"-mmap")==0 ){
4423: i++;
1.1 espie 4424: }else if( strcmp(z,"-vfs")==0 ){
4425: i++;
4426: #ifdef SQLITE_ENABLE_VFSTRACE
4427: }else if( strcmp(z,"-vfstrace")==0 ){
4428: i++;
4429: #endif
4430: #ifdef SQLITE_ENABLE_MULTIPLEX
4431: }else if( strcmp(z,"-multiplex")==0 ){
4432: i++;
4433: #endif
4434: }else if( strcmp(z,"-help")==0 ){
4435: usage(1);
4436: }else if( strcmp(z,"-cmd")==0 ){
1.1.1.11! jturner 4437: /* Run commands that follow -cmd first and separately from commands
! 4438: ** that simply appear on the command-line. This seems goofy. It would
! 4439: ** be better if all commands ran in the order that they appear. But
! 4440: ** we retain the goofy behavior for historical compatibility. */
1.1 espie 4441: if( i==argc-1 ) break;
1.1.1.5 espie 4442: z = cmdline_option_value(argc,argv,++i);
1.1 espie 4443: if( z[0]=='.' ){
4444: rc = do_meta_command(z, &data);
1.1.1.6 landry 4445: if( rc && bail_on_error ) return rc==2 ? 0 : rc;
1.1 espie 4446: }else{
1.1.1.8 jturner 4447: open_db(&data, 0);
1.1 espie 4448: rc = shell_exec(data.db, z, shell_callback, &data, &zErrMsg);
4449: if( zErrMsg!=0 ){
4450: fprintf(stderr,"Error: %s\n", zErrMsg);
4451: if( bail_on_error ) return rc!=0 ? rc : 1;
4452: }else if( rc!=0 ){
4453: fprintf(stderr,"Error: unable to process SQL \"%s\"\n", z);
4454: if( bail_on_error ) return rc;
4455: }
4456: }
4457: }else{
4458: fprintf(stderr,"%s: Error: unknown option: %s\n", Argv0, z);
4459: fprintf(stderr,"Use -help for a list of options.\n");
4460: return 1;
4461: }
4462: }
4463:
1.1.1.11! jturner 4464: if( !readStdin ){
! 4465: /* Run all arguments that do not begin with '-' as if they were separate
! 4466: ** command-line inputs, except for the argToSkip argument which contains
! 4467: ** the database filename.
1.1 espie 4468: */
1.1.1.11! jturner 4469: for(i=0; i<nCmd; i++){
! 4470: if( azCmd[i][0]=='.' ){
! 4471: rc = do_meta_command(azCmd[i], &data);
! 4472: if( rc ) return rc==2 ? 0 : rc;
! 4473: }else{
! 4474: open_db(&data, 0);
! 4475: rc = shell_exec(data.db, azCmd[i], shell_callback, &data, &zErrMsg);
! 4476: if( zErrMsg!=0 ){
! 4477: fprintf(stderr,"Error: %s\n", zErrMsg);
! 4478: return rc!=0 ? rc : 1;
! 4479: }else if( rc!=0 ){
! 4480: fprintf(stderr,"Error: unable to process SQL: %s\n", azCmd[i]);
! 4481: return rc;
! 4482: }
1.1 espie 4483: }
4484: }
1.1.1.11! jturner 4485: free(azCmd);
1.1 espie 4486: }else{
4487: /* Run commands received from standard input
4488: */
4489: if( stdin_is_interactive ){
4490: char *zHome;
4491: char *zHistory = 0;
4492: int nHistory;
4493: printf(
4494: "SQLite version %s %.19s\n" /*extra-version-info*/
1.1.1.8 jturner 4495: "Enter \".help\" for usage hints.\n",
1.1 espie 4496: sqlite3_libversion(), sqlite3_sourceid()
4497: );
1.1.1.8 jturner 4498: if( warnInmemoryDb ){
4499: printf("Connected to a ");
4500: printBold("transient in-memory database");
4501: printf(".\nUse \".open FILENAME\" to reopen on a "
4502: "persistent database.\n");
4503: }
1.1 espie 4504: zHome = find_home_dir();
4505: if( zHome ){
4506: nHistory = strlen30(zHome) + 20;
4507: if( (zHistory = malloc(nHistory))!=0 ){
4508: sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
4509: }
4510: }
1.1.1.11! jturner 4511: if( zHistory ) shell_read_history(zHistory);
1.1 espie 4512: rc = process_input(&data, 0);
4513: if( zHistory ){
1.1.1.11! jturner 4514: shell_stifle_history(100);
! 4515: shell_write_history(zHistory);
1.1 espie 4516: free(zHistory);
4517: }
4518: }else{
4519: rc = process_input(&data, stdin);
4520: }
4521: }
4522: set_table_name(&data, 0);
4523: if( data.db ){
4524: sqlite3_close(data.db);
4525: }
1.1.1.8 jturner 4526: sqlite3_free(data.zFreeOnClose);
1.1 espie 4527: return rc;
4528: }
![[BACK]](/icons/back.gif){kind=icon}
Return to shell.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / sqlite3