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