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