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