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