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