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