Annotation of src/usr.bin/sqlite3/shell.c, Revision 1.13
1.1 espie 1: /*
2: ** 2001 September 15
3: **
4: ** The author disclaims copyright to this source code. In place of
5: ** a legal notice, here is a blessing:
6: **
7: ** May you do good and not evil.
8: ** May you find forgiveness for yourself and forgive others.
9: ** May you share freely, never taking more than you give.
10: **
11: *************************************************************************
12: ** This file contains code to implement the "sqlite" command line
13: ** utility for accessing SQLite databases.
14: */
15: #if (defined(_WIN32) || defined(WIN32)) && !defined(_CRT_SECURE_NO_WARNINGS)
16: /* This needs to come before any includes for MSVC compiler */
17: #define _CRT_SECURE_NO_WARNINGS
18: #endif
19:
20: /*
1.11 jturner 21: ** If requested, include the SQLite compiler options file for MSVC.
22: */
23: #if defined(INCLUDE_MSVC_H)
24: #include "msvc.h"
25: #endif
26:
27: /*
1.12 jturner 28: ** No support for loadable extensions in VxWorks.
29: */
30: #if (defined(__RTP__) || defined(_WRS_KERNEL)) && !SQLITE_OMIT_LOAD_EXTENSION
31: # define SQLITE_OMIT_LOAD_EXTENSION 1
32: #endif
33:
34: /*
1.1 espie 35: ** Enable large-file support for fopen() and friends on unix.
36: */
37: #ifndef SQLITE_DISABLE_LFS
38: # define _LARGE_FILE 1
39: # ifndef _FILE_OFFSET_BITS
40: # define _FILE_OFFSET_BITS 64
41: # endif
42: # define _LARGEFILE_SOURCE 1
43: #endif
44:
45: #include <stdlib.h>
46: #include <string.h>
47: #include <stdio.h>
48: #include <assert.h>
49: #include "sqlite3.h"
1.10 jturner 50: #if SQLITE_USER_AUTHENTICATION
51: # include "sqlite3userauth.h"
52: #endif
1.1 espie 53: #include <ctype.h>
54: #include <stdarg.h>
55:
1.4 espie 56: #if !defined(_WIN32) && !defined(WIN32)
1.1 espie 57: # include <signal.h>
58: # if !defined(__RTP__) && !defined(_WRS_KERNEL)
59: # include <pwd.h>
60: # endif
61: # include <unistd.h>
62: # include <sys/types.h>
63: #endif
64:
1.11 jturner 65: #if HAVE_READLINE
1.1 espie 66: # include <readline/readline.h>
67: # include <readline/history.h>
68: #endif
1.11 jturner 69:
70: #if HAVE_EDITLINE
1.8 jturner 71: # include <editline/readline.h>
72: #endif
1.11 jturner 73:
74: #if HAVE_EDITLINE || HAVE_READLINE
75:
76: # define shell_add_history(X) add_history(X)
77: # define shell_read_history(X) read_history(X)
78: # define shell_write_history(X) write_history(X)
79: # define shell_stifle_history(X) stifle_history(X)
80: # define shell_readline(X) readline(X)
81:
82: #elif HAVE_LINENOISE
83:
84: # include "linenoise.h"
85: # define shell_add_history(X) linenoiseHistoryAdd(X)
86: # define shell_read_history(X) linenoiseHistoryLoad(X)
87: # define shell_write_history(X) linenoiseHistorySave(X)
88: # define shell_stifle_history(X) linenoiseHistorySetMaxLen(X)
89: # define shell_readline(X) linenoise(X)
90:
91: #else
92:
93: # define shell_read_history(X)
94: # define shell_write_history(X)
95: # define shell_stifle_history(X)
96:
97: # define SHELL_USE_LOCAL_GETLINE 1
1.1 espie 98: #endif
99:
1.11 jturner 100:
1.1 espie 101: #if defined(_WIN32) || defined(WIN32)
102: # include <io.h>
1.9 jturner 103: # include <fcntl.h>
1.13 ! jturner 104: # define isatty(h) _isatty(h)
! 105: # ifndef access
! 106: # define access(f,m) _access((f),(m))
! 107: # endif
! 108: # undef popen
! 109: # define popen _popen
! 110: # undef pclose
! 111: # define pclose _pclose
1.1 espie 112: #else
1.13 ! jturner 113: /* Make sure isatty() has a prototype. */
! 114: extern int isatty(int);
1.12 jturner 115:
1.13 ! jturner 116: # if !defined(__RTP__) && !defined(_WRS_KERNEL)
! 117: /* popen and pclose are not C89 functions and so are
! 118: ** sometimes omitted from the <stdio.h> header */
! 119: extern FILE *popen(const char*,const char*);
! 120: extern int pclose(FILE*);
! 121: # else
! 122: # define SQLITE_OMIT_POPEN 1
! 123: # endif
1.8 jturner 124: #endif
1.7 jturner 125:
1.1 espie 126: #if defined(_WIN32_WCE)
127: /* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty()
128: * thus we always assume that we have a console. That can be
129: * overridden with the -batch command line option.
130: */
131: #define isatty(x) 1
132: #endif
133:
134: /* ctype macros that work with signed characters */
135: #define IsSpace(X) isspace((unsigned char)X)
136: #define IsDigit(X) isdigit((unsigned char)X)
137: #define ToLower(X) (char)tolower((unsigned char)X)
138:
1.12 jturner 139: /* On Windows, we normally run with output mode of TEXT so that \n characters
140: ** are automatically translated into \r\n. However, this behavior needs
141: ** to be disabled in some cases (ex: when generating CSV output and when
142: ** rendering quoted strings that contain \n characters). The following
143: ** routines take care of that.
144: */
145: #if defined(_WIN32) || defined(WIN32)
146: static void setBinaryMode(FILE *out){
147: fflush(out);
148: _setmode(_fileno(out), _O_BINARY);
149: }
150: static void setTextMode(FILE *out){
151: fflush(out);
152: _setmode(_fileno(out), _O_TEXT);
153: }
154: #else
155: # define setBinaryMode(X)
156: # define setTextMode(X)
157: #endif
158:
1.8 jturner 159:
160: /* True if the timer is enabled */
161: static int enableTimer = 0;
162:
163: /* Return the current wall-clock time */
164: static sqlite3_int64 timeOfDay(void){
165: static sqlite3_vfs *clockVfs = 0;
166: sqlite3_int64 t;
167: if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0);
168: if( clockVfs->iVersion>=1 && clockVfs->xCurrentTimeInt64!=0 ){
169: clockVfs->xCurrentTimeInt64(clockVfs, &t);
170: }else{
171: double r;
172: clockVfs->xCurrentTime(clockVfs, &r);
173: t = (sqlite3_int64)(r*86400000.0);
174: }
175: return t;
176: }
177:
1.12 jturner 178: #if !defined(_WIN32) && !defined(WIN32) && !defined(__minux)
1.1 espie 179: #include <sys/time.h>
180: #include <sys/resource.h>
181:
1.12 jturner 182: /* VxWorks does not support getrusage() as far as we can determine */
183: #if defined(_WRS_KERNEL) || defined(__RTP__)
184: struct rusage {
185: struct timeval ru_utime; /* user CPU time used */
186: struct timeval ru_stime; /* system CPU time used */
187: };
188: #define getrusage(A,B) memset(B,0,sizeof(*B))
189: #endif
190:
1.1 espie 191: /* Saved resource information for the beginning of an operation */
1.8 jturner 192: static struct rusage sBegin; /* CPU time at start */
193: static sqlite3_int64 iBegin; /* Wall-clock time at start */
1.1 espie 194:
195: /*
196: ** Begin timing an operation
197: */
198: static void beginTimer(void){
199: if( enableTimer ){
200: getrusage(RUSAGE_SELF, &sBegin);
1.8 jturner 201: iBegin = timeOfDay();
1.1 espie 202: }
203: }
204:
205: /* Return the difference of two time_structs in seconds */
206: static double timeDiff(struct timeval *pStart, struct timeval *pEnd){
207: return (pEnd->tv_usec - pStart->tv_usec)*0.000001 +
208: (double)(pEnd->tv_sec - pStart->tv_sec);
209: }
210:
211: /*
212: ** Print the timing results.
213: */
214: static void endTimer(void){
215: if( enableTimer ){
1.12 jturner 216: sqlite3_int64 iEnd = timeOfDay();
1.1 espie 217: struct rusage sEnd;
218: getrusage(RUSAGE_SELF, &sEnd);
1.8 jturner 219: printf("Run Time: real %.3f user %f sys %f\n",
220: (iEnd - iBegin)*0.001,
1.1 espie 221: timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
222: timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
223: }
224: }
225:
226: #define BEGIN_TIMER beginTimer()
227: #define END_TIMER endTimer()
228: #define HAS_TIMER 1
229:
230: #elif (defined(_WIN32) || defined(WIN32))
231:
232: #include <windows.h>
233:
234: /* Saved resource information for the beginning of an operation */
235: static HANDLE hProcess;
236: static FILETIME ftKernelBegin;
237: static FILETIME ftUserBegin;
1.8 jturner 238: static sqlite3_int64 ftWallBegin;
1.11 jturner 239: typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME,
240: LPFILETIME, LPFILETIME);
1.1 espie 241: static GETPROCTIMES getProcessTimesAddr = NULL;
242:
243: /*
244: ** Check to see if we have timer support. Return 1 if necessary
245: ** support found (or found previously).
246: */
247: static int hasTimer(void){
248: if( getProcessTimesAddr ){
249: return 1;
250: } else {
1.11 jturner 251: /* GetProcessTimes() isn't supported in WIN95 and some other Windows
252: ** versions. See if the version we are running on has it, and if it
253: ** does, save off a pointer to it and the current process handle.
1.1 espie 254: */
255: hProcess = GetCurrentProcess();
256: if( hProcess ){
257: HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll"));
258: if( NULL != hinstLib ){
1.11 jturner 259: getProcessTimesAddr =
260: (GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes");
1.1 espie 261: if( NULL != getProcessTimesAddr ){
262: return 1;
263: }
264: FreeLibrary(hinstLib);
265: }
266: }
267: }
268: return 0;
269: }
270:
271: /*
272: ** Begin timing an operation
273: */
274: static void beginTimer(void){
275: if( enableTimer && getProcessTimesAddr ){
276: FILETIME ftCreation, ftExit;
1.11 jturner 277: getProcessTimesAddr(hProcess,&ftCreation,&ftExit,
278: &ftKernelBegin,&ftUserBegin);
1.8 jturner 279: ftWallBegin = timeOfDay();
1.1 espie 280: }
281: }
282:
283: /* Return the difference of two FILETIME structs in seconds */
284: static double timeDiff(FILETIME *pStart, FILETIME *pEnd){
285: sqlite_int64 i64Start = *((sqlite_int64 *) pStart);
286: sqlite_int64 i64End = *((sqlite_int64 *) pEnd);
287: return (double) ((i64End - i64Start) / 10000000.0);
288: }
289:
290: /*
291: ** Print the timing results.
292: */
293: static void endTimer(void){
294: if( enableTimer && getProcessTimesAddr){
295: FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd;
1.8 jturner 296: sqlite3_int64 ftWallEnd = timeOfDay();
1.11 jturner 297: getProcessTimesAddr(hProcess,&ftCreation,&ftExit,&ftKernelEnd,&ftUserEnd);
1.8 jturner 298: printf("Run Time: real %.3f user %f sys %f\n",
299: (ftWallEnd - ftWallBegin)*0.001,
1.1 espie 300: timeDiff(&ftUserBegin, &ftUserEnd),
301: timeDiff(&ftKernelBegin, &ftKernelEnd));
302: }
303: }
304:
305: #define BEGIN_TIMER beginTimer()
306: #define END_TIMER endTimer()
307: #define HAS_TIMER hasTimer()
308:
309: #else
310: #define BEGIN_TIMER
311: #define END_TIMER
312: #define HAS_TIMER 0
313: #endif
314:
315: /*
316: ** Used to prevent warnings about unused parameters
317: */
318: #define UNUSED_PARAMETER(x) (void)(x)
319:
320: /*
321: ** If the following flag is set, then command execution stops
322: ** at an error if we are not interactive.
323: */
324: static int bail_on_error = 0;
325:
326: /*
327: ** Threat stdin as an interactive input if the following variable
328: ** is true. Otherwise, assume stdin is connected to a file or pipe.
329: */
330: static int stdin_is_interactive = 1;
331:
332: /*
333: ** The following is the open SQLite database. We make a pointer
334: ** to this database a static variable so that it can be accessed
335: ** by the SIGINT handler to interrupt database processing.
336: */
1.13 ! jturner 337: static sqlite3 *globalDb = 0;
1.1 espie 338:
339: /*
340: ** True if an interrupt (Control-C) has been received.
341: */
342: static volatile int seenInterrupt = 0;
343:
344: /*
345: ** This is the name of our program. It is set in main(), used
346: ** in a number of other places, mostly for error messages.
347: */
348: static char *Argv0;
349:
350: /*
351: ** Prompt strings. Initialized in main. Settable with
352: ** .prompt main continue
353: */
354: static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/
355: static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */
356:
357: /*
358: ** Write I/O traces to the following stream.
359: */
360: #ifdef SQLITE_ENABLE_IOTRACE
361: static FILE *iotrace = 0;
362: #endif
363:
364: /*
365: ** This routine works like printf in that its first argument is a
366: ** format string and subsequent arguments are values to be substituted
367: ** in place of % fields. The result of formatting this string
368: ** is written to iotrace.
369: */
370: #ifdef SQLITE_ENABLE_IOTRACE
1.12 jturner 371: static void SQLITE_CDECL iotracePrintf(const char *zFormat, ...){
1.1 espie 372: va_list ap;
373: char *z;
374: if( iotrace==0 ) return;
375: va_start(ap, zFormat);
376: z = sqlite3_vmprintf(zFormat, ap);
377: va_end(ap);
378: fprintf(iotrace, "%s", z);
379: sqlite3_free(z);
380: }
381: #endif
382:
383:
384: /*
385: ** Determines if a string is a number of not.
386: */
387: static int isNumber(const char *z, int *realnum){
388: if( *z=='-' || *z=='+' ) z++;
389: if( !IsDigit(*z) ){
390: return 0;
391: }
392: z++;
393: if( realnum ) *realnum = 0;
394: while( IsDigit(*z) ){ z++; }
395: if( *z=='.' ){
396: z++;
397: if( !IsDigit(*z) ) return 0;
398: while( IsDigit(*z) ){ z++; }
399: if( realnum ) *realnum = 1;
400: }
401: if( *z=='e' || *z=='E' ){
402: z++;
403: if( *z=='+' || *z=='-' ) z++;
404: if( !IsDigit(*z) ) return 0;
405: while( IsDigit(*z) ){ z++; }
406: if( realnum ) *realnum = 1;
407: }
408: return *z==0;
409: }
410:
411: /*
412: ** A global char* and an SQL function to access its current value
413: ** from within an SQL statement. This program used to use the
414: ** sqlite_exec_printf() API to substitue a string into an SQL statement.
415: ** The correct way to do this with sqlite3 is to use the bind API, but
416: ** since the shell is built around the callback paradigm it would be a lot
417: ** of work. Instead just use this hack, which is quite harmless.
418: */
419: static const char *zShellStatic = 0;
420: static void shellstaticFunc(
421: sqlite3_context *context,
422: int argc,
423: sqlite3_value **argv
424: ){
425: assert( 0==argc );
426: assert( zShellStatic );
427: UNUSED_PARAMETER(argc);
428: UNUSED_PARAMETER(argv);
429: sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC);
430: }
431:
432:
433: /*
434: ** This routine reads a line of text from FILE in, stores
435: ** the text in memory obtained from malloc() and returns a pointer
436: ** to the text. NULL is returned at end of file, or if malloc()
437: ** fails.
438: **
1.7 jturner 439: ** If zLine is not NULL then it is a malloced buffer returned from
440: ** a previous call to this routine that may be reused.
1.1 espie 441: */
1.7 jturner 442: static char *local_getline(char *zLine, FILE *in){
443: int nLine = zLine==0 ? 0 : 100;
444: int n = 0;
1.1 espie 445:
446: while( 1 ){
447: if( n+100>nLine ){
448: nLine = nLine*2 + 100;
449: zLine = realloc(zLine, nLine);
450: if( zLine==0 ) return 0;
451: }
452: if( fgets(&zLine[n], nLine - n, in)==0 ){
453: if( n==0 ){
454: free(zLine);
455: return 0;
456: }
457: zLine[n] = 0;
458: break;
459: }
1.7 jturner 460: while( zLine[n] ) n++;
461: if( n>0 && zLine[n-1]=='\n' ){
1.1 espie 462: n--;
463: if( n>0 && zLine[n-1]=='\r' ) n--;
464: zLine[n] = 0;
465: break;
466: }
467: }
468: return zLine;
469: }
470:
471: /*
472: ** Retrieve a single line of input text.
473: **
1.7 jturner 474: ** If in==0 then read from standard input and prompt before each line.
475: ** If isContinuation is true, then a continuation prompt is appropriate.
476: ** If isContinuation is zero, then the main prompt should be used.
477: **
478: ** If zPrior is not NULL then it is a buffer from a prior call to this
479: ** routine that can be reused.
480: **
481: ** The result is stored in space obtained from malloc() and must either
482: ** be freed by the caller or else passed back into this routine via the
483: ** zPrior argument for reuse.
1.1 espie 484: */
1.7 jturner 485: static char *one_input_line(FILE *in, char *zPrior, int isContinuation){
1.1 espie 486: char *zPrompt;
487: char *zResult;
488: if( in!=0 ){
1.7 jturner 489: zResult = local_getline(zPrior, in);
1.1 espie 490: }else{
1.7 jturner 491: zPrompt = isContinuation ? continuePrompt : mainPrompt;
1.11 jturner 492: #if SHELL_USE_LOCAL_GETLINE
1.7 jturner 493: printf("%s", zPrompt);
494: fflush(stdout);
495: zResult = local_getline(zPrior, stdin);
1.11 jturner 496: #else
497: free(zPrior);
498: zResult = shell_readline(zPrompt);
499: if( zResult && *zResult ) shell_add_history(zResult);
1.1 espie 500: #endif
1.7 jturner 501: }
1.1 espie 502: return zResult;
503: }
504:
1.10 jturner 505: /*
506: ** Shell output mode information from before ".explain on",
507: ** saved so that it can be restored by ".explain off"
508: */
509: typedef struct SavedModeInfo SavedModeInfo;
510: struct SavedModeInfo {
511: int valid; /* Is there legit data in here? */
512: int mode; /* Mode prior to ".explain on" */
513: int showHeader; /* The ".header" setting prior to ".explain on" */
514: int colWidth[100]; /* Column widths prior to ".explain on" */
1.1 espie 515: };
516:
517: /*
1.10 jturner 518: ** State information about the database connection is contained in an
519: ** instance of the following structure.
1.1 espie 520: */
1.10 jturner 521: typedef struct ShellState ShellState;
522: struct ShellState {
1.1 espie 523: sqlite3 *db; /* The database */
524: int echoOn; /* True to echo input commands */
1.9 jturner 525: int autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
1.1 espie 526: int statsOn; /* True to display memory stats before each finalize */
1.11 jturner 527: int scanstatsOn; /* True to display scan stats before each finalize */
1.13 ! jturner 528: int backslashOn; /* Resolve C-style \x escapes in SQL input text */
1.9 jturner 529: int outCount; /* Revert to stdout when reaching zero */
1.1 espie 530: int cnt; /* Number of records displayed so far */
531: FILE *out; /* Write results here */
1.2 espie 532: FILE *traceOut; /* Output for sqlite3_trace() */
1.1 espie 533: int nErr; /* Number of errors seen */
534: int mode; /* An output mode setting */
535: int writableSchema; /* True if PRAGMA writable_schema=ON */
536: int showHeader; /* True to show column names in List or Column mode */
1.10 jturner 537: unsigned shellFlgs; /* Various flags */
1.1 espie 538: char *zDestTable; /* Name of destination table when MODE_Insert */
1.11 jturner 539: char colSeparator[20]; /* Column separator character for several modes */
540: char rowSeparator[20]; /* Row separator character for MODE_Ascii */
1.1 espie 541: int colWidth[100]; /* Requested width of each column when in column mode*/
542: int actualWidth[100]; /* Actual width of each column */
1.11 jturner 543: char nullValue[20]; /* The text to print when a NULL comes back from
1.1 espie 544: ** the database */
1.10 jturner 545: SavedModeInfo normalMode;/* Holds the mode just before .explain ON */
1.1 espie 546: char outfile[FILENAME_MAX]; /* Filename for *out */
547: const char *zDbFilename; /* name of the database file */
1.8 jturner 548: char *zFreeOnClose; /* Filename to free when closing */
1.1 espie 549: const char *zVfs; /* Name of VFS to use */
550: sqlite3_stmt *pStmt; /* Current statement if any. */
551: FILE *pLog; /* Write log output here */
1.8 jturner 552: int *aiIndent; /* Array of indents used in MODE_Explain */
553: int nIndent; /* Size of array aiIndent[] */
554: int iIndent; /* Index of current op in aiIndent[] */
1.1 espie 555: };
556:
557: /*
1.10 jturner 558: ** These are the allowed shellFlgs values
559: */
560: #define SHFLG_Scratch 0x00001 /* The --scratch option is used */
561: #define SHFLG_Pagecache 0x00002 /* The --pagecache option is used */
562: #define SHFLG_Lookaside 0x00004 /* Lookaside memory is used */
563:
564: /*
1.1 espie 565: ** These are the allowed modes.
566: */
567: #define MODE_Line 0 /* One column per line. Blank line between records */
568: #define MODE_Column 1 /* One record per line in neat columns */
569: #define MODE_List 2 /* One record per line with a separator */
570: #define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */
571: #define MODE_Html 4 /* Generate an XHTML table */
572: #define MODE_Insert 5 /* Generate SQL "insert" statements */
573: #define MODE_Tcl 6 /* Generate ANSI-C or TCL quoted elements */
574: #define MODE_Csv 7 /* Quote strings, numbers are plain */
575: #define MODE_Explain 8 /* Like MODE_Column, but do not truncate data */
1.11 jturner 576: #define MODE_Ascii 9 /* Use ASCII unit and record separators (0x1F/0x1E) */
1.1 espie 577:
578: static const char *modeDescr[] = {
579: "line",
580: "column",
581: "list",
582: "semi",
583: "html",
584: "insert",
585: "tcl",
586: "csv",
587: "explain",
1.11 jturner 588: "ascii",
1.1 espie 589: };
590:
591: /*
1.11 jturner 592: ** These are the column/row/line separators used by the various
593: ** import/export modes.
594: */
595: #define SEP_Column "|"
596: #define SEP_Row "\n"
597: #define SEP_Tab "\t"
598: #define SEP_Space " "
599: #define SEP_Comma ","
600: #define SEP_CrLf "\r\n"
601: #define SEP_Unit "\x1F"
602: #define SEP_Record "\x1E"
603:
604: /*
1.1 espie 605: ** Number of elements in an array
606: */
607: #define ArraySize(X) (int)(sizeof(X)/sizeof(X[0]))
608:
609: /*
610: ** Compute a string length that is limited to what can be stored in
611: ** lower 30 bits of a 32-bit signed integer.
612: */
613: static int strlen30(const char *z){
614: const char *z2 = z;
615: while( *z2 ){ z2++; }
616: return 0x3fffffff & (int)(z2 - z);
617: }
618:
619: /*
620: ** A callback for the sqlite3_log() interface.
621: */
622: static void shellLog(void *pArg, int iErrCode, const char *zMsg){
1.10 jturner 623: ShellState *p = (ShellState*)pArg;
1.1 espie 624: if( p->pLog==0 ) return;
625: fprintf(p->pLog, "(%d) %s\n", iErrCode, zMsg);
626: fflush(p->pLog);
627: }
628:
629: /*
630: ** Output the given string as a hex-encoded blob (eg. X'1234' )
631: */
632: static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){
633: int i;
634: char *zBlob = (char *)pBlob;
635: fprintf(out,"X'");
1.2 espie 636: for(i=0; i<nBlob; i++){ fprintf(out,"%02x",zBlob[i]&0xff); }
1.1 espie 637: fprintf(out,"'");
638: }
639:
640: /*
641: ** Output the given string as a quoted string using SQL quoting conventions.
642: */
643: static void output_quoted_string(FILE *out, const char *z){
644: int i;
645: int nSingle = 0;
1.12 jturner 646: setBinaryMode(out);
1.1 espie 647: for(i=0; z[i]; i++){
648: if( z[i]=='\'' ) nSingle++;
649: }
650: if( nSingle==0 ){
651: fprintf(out,"'%s'",z);
652: }else{
653: fprintf(out,"'");
654: while( *z ){
655: for(i=0; z[i] && z[i]!='\''; i++){}
656: if( i==0 ){
657: fprintf(out,"''");
658: z++;
659: }else if( z[i]=='\'' ){
660: fprintf(out,"%.*s''",i,z);
661: z += i+1;
662: }else{
663: fprintf(out,"%s",z);
664: break;
665: }
666: }
667: fprintf(out,"'");
668: }
1.12 jturner 669: setTextMode(out);
1.1 espie 670: }
671:
672: /*
673: ** Output the given string as a quoted according to C or TCL quoting rules.
674: */
675: static void output_c_string(FILE *out, const char *z){
676: unsigned int c;
677: fputc('"', out);
678: while( (c = *(z++))!=0 ){
679: if( c=='\\' ){
680: fputc(c, out);
681: fputc(c, out);
1.5 espie 682: }else if( c=='"' ){
683: fputc('\\', out);
684: fputc('"', out);
1.1 espie 685: }else if( c=='\t' ){
686: fputc('\\', out);
687: fputc('t', out);
688: }else if( c=='\n' ){
689: fputc('\\', out);
690: fputc('n', out);
691: }else if( c=='\r' ){
692: fputc('\\', out);
693: fputc('r', out);
1.8 jturner 694: }else if( !isprint(c&0xff) ){
1.1 espie 695: fprintf(out, "\\%03o", c&0xff);
696: }else{
697: fputc(c, out);
698: }
699: }
700: fputc('"', out);
701: }
702:
703: /*
704: ** Output the given string with characters that are special to
705: ** HTML escaped.
706: */
707: static void output_html_string(FILE *out, const char *z){
708: int i;
1.8 jturner 709: if( z==0 ) z = "";
1.1 espie 710: while( *z ){
711: for(i=0; z[i]
712: && z[i]!='<'
713: && z[i]!='&'
714: && z[i]!='>'
715: && z[i]!='\"'
716: && z[i]!='\'';
717: i++){}
718: if( i>0 ){
719: fprintf(out,"%.*s",i,z);
720: }
721: if( z[i]=='<' ){
722: fprintf(out,"<");
723: }else if( z[i]=='&' ){
724: fprintf(out,"&");
725: }else if( z[i]=='>' ){
726: fprintf(out,">");
727: }else if( z[i]=='\"' ){
728: fprintf(out,""");
729: }else if( z[i]=='\'' ){
730: fprintf(out,"'");
731: }else{
732: break;
733: }
734: z += i + 1;
735: }
736: }
737:
738: /*
739: ** If a field contains any character identified by a 1 in the following
740: ** array, then the string must be quoted for CSV.
741: */
742: static const char needCsvQuote[] = {
743: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
744: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
745: 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
746: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
747: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
748: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
749: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
750: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
751: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
752: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
753: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
754: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
755: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
756: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
757: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
758: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
759: };
760:
761: /*
1.11 jturner 762: ** Output a single term of CSV. Actually, p->colSeparator is used for
763: ** the separator, which may or may not be a comma. p->nullValue is
1.9 jturner 764: ** the null value. Strings are quoted if necessary. The separator
765: ** is only issued if bSep is true.
1.1 espie 766: */
1.10 jturner 767: static void output_csv(ShellState *p, const char *z, int bSep){
1.1 espie 768: FILE *out = p->out;
769: if( z==0 ){
1.11 jturner 770: fprintf(out,"%s",p->nullValue);
1.1 espie 771: }else{
772: int i;
1.11 jturner 773: int nSep = strlen30(p->colSeparator);
1.1 espie 774: for(i=0; z[i]; i++){
775: if( needCsvQuote[((unsigned char*)z)[i]]
1.11 jturner 776: || (z[i]==p->colSeparator[0] &&
777: (nSep==1 || memcmp(z, p->colSeparator, nSep)==0)) ){
1.1 espie 778: i = 0;
779: break;
780: }
781: }
782: if( i==0 ){
783: putc('"', out);
784: for(i=0; z[i]; i++){
785: if( z[i]=='"' ) putc('"', out);
786: putc(z[i], out);
787: }
788: putc('"', out);
789: }else{
790: fprintf(out, "%s", z);
791: }
792: }
793: if( bSep ){
1.11 jturner 794: fprintf(p->out, "%s", p->colSeparator);
1.1 espie 795: }
796: }
797:
798: #ifdef SIGINT
799: /*
800: ** This routine runs when the user presses Ctrl-C
801: */
802: static void interrupt_handler(int NotUsed){
803: UNUSED_PARAMETER(NotUsed);
1.9 jturner 804: seenInterrupt++;
805: if( seenInterrupt>2 ) exit(1);
1.13 ! jturner 806: if( globalDb ) sqlite3_interrupt(globalDb);
1.1 espie 807: }
808: #endif
809:
810: /*
811: ** This is the callback routine that the shell
812: ** invokes for each row of a query result.
813: */
1.11 jturner 814: static int shell_callback(
815: void *pArg,
816: int nArg, /* Number of result columns */
817: char **azArg, /* Text of each result column */
818: char **azCol, /* Column names */
819: int *aiType /* Column types */
820: ){
1.1 espie 821: int i;
1.10 jturner 822: ShellState *p = (ShellState*)pArg;
1.1 espie 823:
824: switch( p->mode ){
825: case MODE_Line: {
826: int w = 5;
827: if( azArg==0 ) break;
828: for(i=0; i<nArg; i++){
829: int len = strlen30(azCol[i] ? azCol[i] : "");
830: if( len>w ) w = len;
831: }
1.11 jturner 832: if( p->cnt++>0 ) fprintf(p->out, "%s", p->rowSeparator);
1.1 espie 833: for(i=0; i<nArg; i++){
1.11 jturner 834: fprintf(p->out,"%*s = %s%s", w, azCol[i],
835: azArg[i] ? azArg[i] : p->nullValue, p->rowSeparator);
1.1 espie 836: }
837: break;
838: }
839: case MODE_Explain:
840: case MODE_Column: {
841: if( p->cnt++==0 ){
842: for(i=0; i<nArg; i++){
843: int w, n;
844: if( i<ArraySize(p->colWidth) ){
845: w = p->colWidth[i];
846: }else{
847: w = 0;
848: }
1.5 espie 849: if( w==0 ){
1.1 espie 850: w = strlen30(azCol[i] ? azCol[i] : "");
851: if( w<10 ) w = 10;
1.11 jturner 852: n = strlen30(azArg && azArg[i] ? azArg[i] : p->nullValue);
1.1 espie 853: if( w<n ) w = n;
854: }
855: if( i<ArraySize(p->actualWidth) ){
856: p->actualWidth[i] = w;
857: }
858: if( p->showHeader ){
1.5 espie 859: if( w<0 ){
1.11 jturner 860: fprintf(p->out,"%*.*s%s",-w,-w,azCol[i],
861: i==nArg-1 ? p->rowSeparator : " ");
1.5 espie 862: }else{
1.11 jturner 863: fprintf(p->out,"%-*.*s%s",w,w,azCol[i],
864: i==nArg-1 ? p->rowSeparator : " ");
1.5 espie 865: }
1.1 espie 866: }
867: }
868: if( p->showHeader ){
869: for(i=0; i<nArg; i++){
870: int w;
871: if( i<ArraySize(p->actualWidth) ){
872: w = p->actualWidth[i];
1.5 espie 873: if( w<0 ) w = -w;
1.1 espie 874: }else{
875: w = 10;
876: }
877: fprintf(p->out,"%-*.*s%s",w,w,"-----------------------------------"
878: "----------------------------------------------------------",
1.11 jturner 879: i==nArg-1 ? p->rowSeparator : " ");
1.1 espie 880: }
881: }
882: }
883: if( azArg==0 ) break;
884: for(i=0; i<nArg; i++){
885: int w;
886: if( i<ArraySize(p->actualWidth) ){
887: w = p->actualWidth[i];
888: }else{
889: w = 10;
890: }
1.8 jturner 891: if( p->mode==MODE_Explain && azArg[i] && strlen30(azArg[i])>w ){
1.1 espie 892: w = strlen30(azArg[i]);
893: }
1.8 jturner 894: if( i==1 && p->aiIndent && p->pStmt ){
895: if( p->iIndent<p->nIndent ){
896: fprintf(p->out, "%*.s", p->aiIndent[p->iIndent], "");
897: }
898: p->iIndent++;
899: }
1.5 espie 900: if( w<0 ){
901: fprintf(p->out,"%*.*s%s",-w,-w,
1.11 jturner 902: azArg[i] ? azArg[i] : p->nullValue,
903: i==nArg-1 ? p->rowSeparator : " ");
1.5 espie 904: }else{
905: fprintf(p->out,"%-*.*s%s",w,w,
1.11 jturner 906: azArg[i] ? azArg[i] : p->nullValue,
907: i==nArg-1 ? p->rowSeparator : " ");
1.5 espie 908: }
1.1 espie 909: }
910: break;
911: }
912: case MODE_Semi:
913: case MODE_List: {
914: if( p->cnt++==0 && p->showHeader ){
915: for(i=0; i<nArg; i++){
1.11 jturner 916: fprintf(p->out,"%s%s",azCol[i],
917: i==nArg-1 ? p->rowSeparator : p->colSeparator);
1.1 espie 918: }
919: }
920: if( azArg==0 ) break;
921: for(i=0; i<nArg; i++){
922: char *z = azArg[i];
1.11 jturner 923: if( z==0 ) z = p->nullValue;
1.1 espie 924: fprintf(p->out, "%s", z);
925: if( i<nArg-1 ){
1.11 jturner 926: fprintf(p->out, "%s", p->colSeparator);
1.1 espie 927: }else if( p->mode==MODE_Semi ){
1.11 jturner 928: fprintf(p->out, ";%s", p->rowSeparator);
1.1 espie 929: }else{
1.11 jturner 930: fprintf(p->out, "%s", p->rowSeparator);
1.1 espie 931: }
932: }
933: break;
934: }
935: case MODE_Html: {
936: if( p->cnt++==0 && p->showHeader ){
937: fprintf(p->out,"<TR>");
938: for(i=0; i<nArg; i++){
939: fprintf(p->out,"<TH>");
940: output_html_string(p->out, azCol[i]);
941: fprintf(p->out,"</TH>\n");
942: }
943: fprintf(p->out,"</TR>\n");
944: }
945: if( azArg==0 ) break;
946: fprintf(p->out,"<TR>");
947: for(i=0; i<nArg; i++){
948: fprintf(p->out,"<TD>");
1.11 jturner 949: output_html_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
1.1 espie 950: fprintf(p->out,"</TD>\n");
951: }
952: fprintf(p->out,"</TR>\n");
953: break;
954: }
955: case MODE_Tcl: {
956: if( p->cnt++==0 && p->showHeader ){
957: for(i=0; i<nArg; i++){
958: output_c_string(p->out,azCol[i] ? azCol[i] : "");
1.11 jturner 959: if(i<nArg-1) fprintf(p->out, "%s", p->colSeparator);
1.1 espie 960: }
1.11 jturner 961: fprintf(p->out, "%s", p->rowSeparator);
1.1 espie 962: }
963: if( azArg==0 ) break;
964: for(i=0; i<nArg; i++){
1.11 jturner 965: output_c_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
966: if(i<nArg-1) fprintf(p->out, "%s", p->colSeparator);
1.1 espie 967: }
1.11 jturner 968: fprintf(p->out, "%s", p->rowSeparator);
1.1 espie 969: break;
970: }
971: case MODE_Csv: {
1.12 jturner 972: setBinaryMode(p->out);
1.1 espie 973: if( p->cnt++==0 && p->showHeader ){
974: for(i=0; i<nArg; i++){
975: output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
976: }
1.11 jturner 977: fprintf(p->out, "%s", p->rowSeparator);
1.1 espie 978: }
1.11 jturner 979: if( nArg>0 ){
1.9 jturner 980: for(i=0; i<nArg; i++){
981: output_csv(p, azArg[i], i<nArg-1);
982: }
1.11 jturner 983: fprintf(p->out, "%s", p->rowSeparator);
1.1 espie 984: }
1.12 jturner 985: setTextMode(p->out);
1.1 espie 986: break;
987: }
988: case MODE_Insert: {
989: p->cnt++;
990: if( azArg==0 ) break;
1.13 ! jturner 991: fprintf(p->out,"INSERT INTO %s",p->zDestTable);
! 992: if( p->showHeader ){
! 993: fprintf(p->out,"(");
! 994: for(i=0; i<nArg; i++){
! 995: char *zSep = i>0 ? ",": "";
! 996: fprintf(p->out, "%s%s", zSep, azCol[i]);
! 997: }
! 998: fprintf(p->out,")");
! 999: }
! 1000: fprintf(p->out," VALUES(");
1.1 espie 1001: for(i=0; i<nArg; i++){
1002: char *zSep = i>0 ? ",": "";
1003: if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
1004: fprintf(p->out,"%sNULL",zSep);
1005: }else if( aiType && aiType[i]==SQLITE_TEXT ){
1006: if( zSep[0] ) fprintf(p->out,"%s",zSep);
1007: output_quoted_string(p->out, azArg[i]);
1.9 jturner 1008: }else if( aiType && (aiType[i]==SQLITE_INTEGER
1009: || aiType[i]==SQLITE_FLOAT) ){
1.1 espie 1010: fprintf(p->out,"%s%s",zSep, azArg[i]);
1011: }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
1012: const void *pBlob = sqlite3_column_blob(p->pStmt, i);
1013: int nBlob = sqlite3_column_bytes(p->pStmt, i);
1014: if( zSep[0] ) fprintf(p->out,"%s",zSep);
1015: output_hex_blob(p->out, pBlob, nBlob);
1016: }else if( isNumber(azArg[i], 0) ){
1017: fprintf(p->out,"%s%s",zSep, azArg[i]);
1018: }else{
1019: if( zSep[0] ) fprintf(p->out,"%s",zSep);
1020: output_quoted_string(p->out, azArg[i]);
1021: }
1022: }
1023: fprintf(p->out,");\n");
1024: break;
1025: }
1.11 jturner 1026: case MODE_Ascii: {
1027: if( p->cnt++==0 && p->showHeader ){
1028: for(i=0; i<nArg; i++){
1029: if( i>0 ) fprintf(p->out, "%s", p->colSeparator);
1030: fprintf(p->out,"%s",azCol[i] ? azCol[i] : "");
1031: }
1032: fprintf(p->out, "%s", p->rowSeparator);
1033: }
1034: if( azArg==0 ) break;
1035: for(i=0; i<nArg; i++){
1036: if( i>0 ) fprintf(p->out, "%s", p->colSeparator);
1037: fprintf(p->out,"%s",azArg[i] ? azArg[i] : p->nullValue);
1038: }
1039: fprintf(p->out, "%s", p->rowSeparator);
1040: break;
1041: }
1.1 espie 1042: }
1043: return 0;
1044: }
1045:
1046: /*
1047: ** This is the callback routine that the SQLite library
1048: ** invokes for each row of a query result.
1049: */
1050: static int callback(void *pArg, int nArg, char **azArg, char **azCol){
1051: /* since we don't have type info, call the shell_callback with a NULL value */
1052: return shell_callback(pArg, nArg, azArg, azCol, NULL);
1053: }
1054:
1055: /*
1.10 jturner 1056: ** Set the destination table field of the ShellState structure to
1.1 espie 1057: ** the name of the table given. Escape any quote characters in the
1058: ** table name.
1059: */
1.10 jturner 1060: static void set_table_name(ShellState *p, const char *zName){
1.1 espie 1061: int i, n;
1062: int needQuote;
1063: char *z;
1064:
1065: if( p->zDestTable ){
1066: free(p->zDestTable);
1067: p->zDestTable = 0;
1068: }
1069: if( zName==0 ) return;
1070: needQuote = !isalpha((unsigned char)*zName) && *zName!='_';
1071: for(i=n=0; zName[i]; i++, n++){
1072: if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){
1073: needQuote = 1;
1074: if( zName[i]=='\'' ) n++;
1075: }
1076: }
1077: if( needQuote ) n += 2;
1078: z = p->zDestTable = malloc( n+1 );
1079: if( z==0 ){
1080: fprintf(stderr,"Error: out of memory\n");
1081: exit(1);
1082: }
1083: n = 0;
1084: if( needQuote ) z[n++] = '\'';
1085: for(i=0; zName[i]; i++){
1086: z[n++] = zName[i];
1087: if( zName[i]=='\'' ) z[n++] = '\'';
1088: }
1089: if( needQuote ) z[n++] = '\'';
1090: z[n] = 0;
1091: }
1092:
1093: /* zIn is either a pointer to a NULL-terminated string in memory obtained
1094: ** from malloc(), or a NULL pointer. The string pointed to by zAppend is
1095: ** added to zIn, and the result returned in memory obtained from malloc().
1096: ** zIn, if it was not NULL, is freed.
1097: **
1098: ** If the third argument, quote, is not '\0', then it is used as a
1099: ** quote character for zAppend.
1100: */
1101: static char *appendText(char *zIn, char const *zAppend, char quote){
1102: int len;
1103: int i;
1104: int nAppend = strlen30(zAppend);
1105: int nIn = (zIn?strlen30(zIn):0);
1106:
1107: len = nAppend+nIn+1;
1108: if( quote ){
1109: len += 2;
1110: for(i=0; i<nAppend; i++){
1111: if( zAppend[i]==quote ) len++;
1112: }
1113: }
1114:
1115: zIn = (char *)realloc(zIn, len);
1116: if( !zIn ){
1117: return 0;
1118: }
1119:
1120: if( quote ){
1121: char *zCsr = &zIn[nIn];
1122: *zCsr++ = quote;
1123: for(i=0; i<nAppend; i++){
1124: *zCsr++ = zAppend[i];
1125: if( zAppend[i]==quote ) *zCsr++ = quote;
1126: }
1127: *zCsr++ = quote;
1128: *zCsr++ = '\0';
1129: assert( (zCsr-zIn)==len );
1130: }else{
1131: memcpy(&zIn[nIn], zAppend, nAppend);
1132: zIn[len-1] = '\0';
1133: }
1134:
1135: return zIn;
1136: }
1137:
1138:
1139: /*
1140: ** Execute a query statement that will generate SQL output. Print
1141: ** the result columns, comma-separated, on a line and then add a
1142: ** semicolon terminator to the end of that line.
1143: **
1144: ** If the number of columns is 1 and that column contains text "--"
1145: ** then write the semicolon on a separate line. That way, if a
1146: ** "--" comment occurs at the end of the statement, the comment
1147: ** won't consume the semicolon terminator.
1148: */
1149: static int run_table_dump_query(
1.10 jturner 1150: ShellState *p, /* Query context */
1.1 espie 1151: const char *zSelect, /* SELECT statement to extract content */
1152: const char *zFirstRow /* Print before first row, if not NULL */
1153: ){
1154: sqlite3_stmt *pSelect;
1155: int rc;
1156: int nResult;
1157: int i;
1158: const char *z;
1.8 jturner 1159: rc = sqlite3_prepare_v2(p->db, zSelect, -1, &pSelect, 0);
1.1 espie 1160: if( rc!=SQLITE_OK || !pSelect ){
1161: fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db));
1.8 jturner 1162: if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
1.1 espie 1163: return rc;
1164: }
1165: rc = sqlite3_step(pSelect);
1166: nResult = sqlite3_column_count(pSelect);
1167: while( rc==SQLITE_ROW ){
1168: if( zFirstRow ){
1169: fprintf(p->out, "%s", zFirstRow);
1170: zFirstRow = 0;
1171: }
1172: z = (const char*)sqlite3_column_text(pSelect, 0);
1173: fprintf(p->out, "%s", z);
1174: for(i=1; i<nResult; i++){
1175: fprintf(p->out, ",%s", sqlite3_column_text(pSelect, i));
1176: }
1177: if( z==0 ) z = "";
1178: while( z[0] && (z[0]!='-' || z[1]!='-') ) z++;
1179: if( z[0] ){
1180: fprintf(p->out, "\n;\n");
1181: }else{
1182: fprintf(p->out, ";\n");
1183: }
1184: rc = sqlite3_step(pSelect);
1185: }
1186: rc = sqlite3_finalize(pSelect);
1187: if( rc!=SQLITE_OK ){
1188: fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db));
1.8 jturner 1189: if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
1.1 espie 1190: }
1191: return rc;
1192: }
1193:
1194: /*
1195: ** Allocate space and save off current error string.
1196: */
1197: static char *save_err_msg(
1198: sqlite3 *db /* Database to query */
1199: ){
1200: int nErrMsg = 1+strlen30(sqlite3_errmsg(db));
1.13 ! jturner 1201: char *zErrMsg = sqlite3_malloc64(nErrMsg);
1.1 espie 1202: if( zErrMsg ){
1203: memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg);
1204: }
1205: return zErrMsg;
1206: }
1207:
1208: /*
1209: ** Display memory stats.
1210: */
1211: static int display_stats(
1212: sqlite3 *db, /* Database to query */
1.10 jturner 1213: ShellState *pArg, /* Pointer to ShellState */
1.1 espie 1214: int bReset /* True to reset the stats */
1215: ){
1216: int iCur;
1217: int iHiwtr;
1218:
1219: if( pArg && pArg->out ){
1220:
1221: iHiwtr = iCur = -1;
1222: sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, bReset);
1.11 jturner 1223: fprintf(pArg->out,
1224: "Memory Used: %d (max %d) bytes\n",
1225: iCur, iHiwtr);
1.1 espie 1226: iHiwtr = iCur = -1;
1227: sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset);
1.11 jturner 1228: fprintf(pArg->out, "Number of Outstanding Allocations: %d (max %d)\n",
1229: iCur, iHiwtr);
1.10 jturner 1230: if( pArg->shellFlgs & SHFLG_Pagecache ){
1231: iHiwtr = iCur = -1;
1232: sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset);
1.11 jturner 1233: fprintf(pArg->out,
1234: "Number of Pcache Pages Used: %d (max %d) pages\n",
1235: iCur, iHiwtr);
1.10 jturner 1236: }
1.1 espie 1237: iHiwtr = iCur = -1;
1238: sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset);
1.11 jturner 1239: fprintf(pArg->out,
1240: "Number of Pcache Overflow Bytes: %d (max %d) bytes\n",
1241: iCur, iHiwtr);
1.10 jturner 1242: if( pArg->shellFlgs & SHFLG_Scratch ){
1243: iHiwtr = iCur = -1;
1244: sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset);
1.11 jturner 1245: fprintf(pArg->out, "Number of Scratch Allocations Used: %d (max %d)\n",
1246: iCur, iHiwtr);
1.10 jturner 1247: }
1.1 espie 1248: iHiwtr = iCur = -1;
1249: sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset);
1.11 jturner 1250: fprintf(pArg->out,
1251: "Number of Scratch Overflow Bytes: %d (max %d) bytes\n",
1252: iCur, iHiwtr);
1.1 espie 1253: iHiwtr = iCur = -1;
1254: sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, bReset);
1.11 jturner 1255: fprintf(pArg->out, "Largest Allocation: %d bytes\n",
1256: iHiwtr);
1.1 espie 1257: iHiwtr = iCur = -1;
1258: sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, bReset);
1.11 jturner 1259: fprintf(pArg->out, "Largest Pcache Allocation: %d bytes\n",
1260: iHiwtr);
1.1 espie 1261: iHiwtr = iCur = -1;
1262: sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHiwtr, bReset);
1.11 jturner 1263: fprintf(pArg->out, "Largest Scratch Allocation: %d bytes\n",
1264: iHiwtr);
1.1 espie 1265: #ifdef YYTRACKMAXSTACKDEPTH
1266: iHiwtr = iCur = -1;
1267: sqlite3_status(SQLITE_STATUS_PARSER_STACK, &iCur, &iHiwtr, bReset);
1.11 jturner 1268: fprintf(pArg->out, "Deepest Parser Stack: %d (max %d)\n",
1269: iCur, iHiwtr);
1.1 espie 1270: #endif
1271: }
1272:
1273: if( pArg && pArg->out && db ){
1.10 jturner 1274: if( pArg->shellFlgs & SHFLG_Lookaside ){
1275: iHiwtr = iCur = -1;
1.11 jturner 1276: sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED,
1277: &iCur, &iHiwtr, bReset);
1278: fprintf(pArg->out, "Lookaside Slots Used: %d (max %d)\n",
1279: iCur, iHiwtr);
1280: sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT,
1281: &iCur, &iHiwtr, bReset);
1.10 jturner 1282: fprintf(pArg->out, "Successful lookaside attempts: %d\n", iHiwtr);
1.11 jturner 1283: sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE,
1284: &iCur, &iHiwtr, bReset);
1.10 jturner 1285: fprintf(pArg->out, "Lookaside failures due to size: %d\n", iHiwtr);
1.11 jturner 1286: sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL,
1287: &iCur, &iHiwtr, bReset);
1.10 jturner 1288: fprintf(pArg->out, "Lookaside failures due to OOM: %d\n", iHiwtr);
1289: }
1.1 espie 1290: iHiwtr = iCur = -1;
1291: sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);
1.11 jturner 1292: fprintf(pArg->out, "Pager Heap Usage: %d bytes\n",iCur);
1293: iHiwtr = iCur = -1;
1.1 espie 1294: sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1);
1295: fprintf(pArg->out, "Page cache hits: %d\n", iCur);
1296: iHiwtr = iCur = -1;
1297: sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1);
1298: fprintf(pArg->out, "Page cache misses: %d\n", iCur);
1299: iHiwtr = iCur = -1;
1.2 espie 1300: sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1);
1301: fprintf(pArg->out, "Page cache writes: %d\n", iCur);
1302: iHiwtr = iCur = -1;
1.1 espie 1303: sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset);
1.11 jturner 1304: fprintf(pArg->out, "Schema Heap Usage: %d bytes\n",iCur);
1.1 espie 1305: iHiwtr = iCur = -1;
1306: sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset);
1.11 jturner 1307: fprintf(pArg->out, "Statement Heap/Lookaside Usage: %d bytes\n",iCur);
1.1 espie 1308: }
1309:
1310: if( pArg && pArg->out && db && pArg->pStmt ){
1.11 jturner 1311: iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP,
1312: bReset);
1.1 espie 1313: fprintf(pArg->out, "Fullscan Steps: %d\n", iCur);
1314: iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset);
1315: fprintf(pArg->out, "Sort Operations: %d\n", iCur);
1.11 jturner 1316: iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX,bReset);
1.1 espie 1317: fprintf(pArg->out, "Autoindex Inserts: %d\n", iCur);
1.7 jturner 1318: iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset);
1319: fprintf(pArg->out, "Virtual Machine Steps: %d\n", iCur);
1.1 espie 1320: }
1321:
1322: return 0;
1323: }
1324:
1325: /*
1.11 jturner 1326: ** Display scan stats.
1327: */
1328: static void display_scanstats(
1329: sqlite3 *db, /* Database to query */
1330: ShellState *pArg /* Pointer to ShellState */
1331: ){
1.13 ! jturner 1332: #ifndef SQLITE_ENABLE_STMT_SCANSTATUS
! 1333: UNUSED_PARAMETER(db);
! 1334: UNUSED_PARAMETER(pArg);
! 1335: #else
1.11 jturner 1336: int i, k, n, mx;
1337: fprintf(pArg->out, "-------- scanstats --------\n");
1338: mx = 0;
1339: for(k=0; k<=mx; k++){
1340: double rEstLoop = 1.0;
1341: for(i=n=0; 1; i++){
1342: sqlite3_stmt *p = pArg->pStmt;
1343: sqlite3_int64 nLoop, nVisit;
1344: double rEst;
1345: int iSid;
1346: const char *zExplain;
1347: if( sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NLOOP, (void*)&nLoop) ){
1348: break;
1349: }
1350: sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_SELECTID, (void*)&iSid);
1351: if( iSid>mx ) mx = iSid;
1352: if( iSid!=k ) continue;
1353: if( n==0 ){
1354: rEstLoop = (double)nLoop;
1355: if( k>0 ) fprintf(pArg->out, "-------- subquery %d -------\n", k);
1356: }
1357: n++;
1358: sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NVISIT, (void*)&nVisit);
1359: sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EST, (void*)&rEst);
1360: sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EXPLAIN, (void*)&zExplain);
1361: fprintf(pArg->out, "Loop %2d: %s\n", n, zExplain);
1362: rEstLoop *= rEst;
1363: fprintf(pArg->out,
1364: " nLoop=%-8lld nRow=%-8lld estRow=%-8lld estRow/Loop=%-8g\n",
1365: nLoop, nVisit, (sqlite3_int64)(rEstLoop+0.5), rEst
1366: );
1367: }
1368: }
1369: fprintf(pArg->out, "---------------------------\n");
1370: #endif
1371: }
1372:
1373: /*
1.8 jturner 1374: ** Parameter azArray points to a zero-terminated array of strings. zStr
1375: ** points to a single nul-terminated string. Return non-zero if zStr
1376: ** is equal, according to strcmp(), to any of the strings in the array.
1377: ** Otherwise, return zero.
1378: */
1379: static int str_in_array(const char *zStr, const char **azArray){
1380: int i;
1381: for(i=0; azArray[i]; i++){
1382: if( 0==strcmp(zStr, azArray[i]) ) return 1;
1383: }
1384: return 0;
1385: }
1386:
1387: /*
1388: ** If compiled statement pSql appears to be an EXPLAIN statement, allocate
1.10 jturner 1389: ** and populate the ShellState.aiIndent[] array with the number of
1.8 jturner 1390: ** spaces each opcode should be indented before it is output.
1391: **
1392: ** The indenting rules are:
1393: **
1394: ** * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent
1395: ** all opcodes that occur between the p2 jump destination and the opcode
1396: ** itself by 2 spaces.
1397: **
1398: ** * For each "Goto", if the jump destination is earlier in the program
1399: ** and ends on one of:
1400: ** Yield SeekGt SeekLt RowSetRead Rewind
1401: ** or if the P1 parameter is one instead of zero,
1402: ** then indent all opcodes between the earlier instruction
1403: ** and "Goto" by 2 spaces.
1404: */
1.10 jturner 1405: static void explain_data_prepare(ShellState *p, sqlite3_stmt *pSql){
1.8 jturner 1406: const char *zSql; /* The text of the SQL statement */
1407: const char *z; /* Used to check if this is an EXPLAIN */
1408: int *abYield = 0; /* True if op is an OP_Yield */
1409: int nAlloc = 0; /* Allocated size of p->aiIndent[], abYield */
1410: int iOp; /* Index of operation in p->aiIndent[] */
1411:
1.9 jturner 1412: const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext",
1413: "NextIfOpen", "PrevIfOpen", 0 };
1.11 jturner 1414: const char *azYield[] = { "Yield", "SeekLT", "SeekGT", "RowSetRead",
1415: "Rewind", 0 };
1.8 jturner 1416: const char *azGoto[] = { "Goto", 0 };
1417:
1418: /* Try to figure out if this is really an EXPLAIN statement. If this
1419: ** cannot be verified, return early. */
1420: zSql = sqlite3_sql(pSql);
1421: if( zSql==0 ) return;
1422: for(z=zSql; *z==' ' || *z=='\t' || *z=='\n' || *z=='\f' || *z=='\r'; z++);
1423: if( sqlite3_strnicmp(z, "explain", 7) ) return;
1424:
1425: for(iOp=0; SQLITE_ROW==sqlite3_step(pSql); iOp++){
1426: int i;
1427: int iAddr = sqlite3_column_int(pSql, 0);
1428: const char *zOp = (const char*)sqlite3_column_text(pSql, 1);
1429:
1430: /* Set p2 to the P2 field of the current opcode. Then, assuming that
1431: ** p2 is an instruction address, set variable p2op to the index of that
1432: ** instruction in the aiIndent[] array. p2 and p2op may be different if
1433: ** the current instruction is part of a sub-program generated by an
1434: ** SQL trigger or foreign key. */
1435: int p2 = sqlite3_column_int(pSql, 3);
1436: int p2op = (p2 + (iOp-iAddr));
1437:
1438: /* Grow the p->aiIndent array as required */
1439: if( iOp>=nAlloc ){
1440: nAlloc += 100;
1.13 ! jturner 1441: p->aiIndent = (int*)sqlite3_realloc64(p->aiIndent, nAlloc*sizeof(int));
! 1442: abYield = (int*)sqlite3_realloc64(abYield, nAlloc*sizeof(int));
1.8 jturner 1443: }
1444: abYield[iOp] = str_in_array(zOp, azYield);
1445: p->aiIndent[iOp] = 0;
1446: p->nIndent = iOp+1;
1447:
1448: if( str_in_array(zOp, azNext) ){
1449: for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2;
1450: }
1451: if( str_in_array(zOp, azGoto) && p2op<p->nIndent
1452: && (abYield[p2op] || sqlite3_column_int(pSql, 2))
1453: ){
1454: for(i=p2op+1; i<iOp; i++) p->aiIndent[i] += 2;
1455: }
1456: }
1457:
1458: p->iIndent = 0;
1459: sqlite3_free(abYield);
1460: sqlite3_reset(pSql);
1461: }
1462:
1463: /*
1464: ** Free the array allocated by explain_data_prepare().
1465: */
1.10 jturner 1466: static void explain_data_delete(ShellState *p){
1.8 jturner 1467: sqlite3_free(p->aiIndent);
1468: p->aiIndent = 0;
1469: p->nIndent = 0;
1470: p->iIndent = 0;
1471: }
1472:
1473: /*
1.1 espie 1474: ** Execute a statement or set of statements. Print
1475: ** any result rows/columns depending on the current mode
1476: ** set via the supplied callback.
1477: **
1478: ** This is very similar to SQLite's built-in sqlite3_exec()
1479: ** function except it takes a slightly different callback
1480: ** and callback data argument.
1481: */
1482: static int shell_exec(
1.10 jturner 1483: sqlite3 *db, /* An open database */
1484: const char *zSql, /* SQL to be evaluated */
1.1 espie 1485: int (*xCallback)(void*,int,char**,char**,int*), /* Callback function */
1.10 jturner 1486: /* (not the same as sqlite3_exec) */
1487: ShellState *pArg, /* Pointer to ShellState */
1488: char **pzErrMsg /* Error msg written here */
1.1 espie 1489: ){
1490: sqlite3_stmt *pStmt = NULL; /* Statement to execute. */
1491: int rc = SQLITE_OK; /* Return Code */
1492: int rc2;
1493: const char *zLeftover; /* Tail of unprocessed SQL */
1494:
1495: if( pzErrMsg ){
1496: *pzErrMsg = NULL;
1497: }
1498:
1499: while( zSql[0] && (SQLITE_OK == rc) ){
1500: rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
1501: if( SQLITE_OK != rc ){
1502: if( pzErrMsg ){
1503: *pzErrMsg = save_err_msg(db);
1504: }
1505: }else{
1506: if( !pStmt ){
1507: /* this happens for a comment or white-space */
1508: zSql = zLeftover;
1509: while( IsSpace(zSql[0]) ) zSql++;
1510: continue;
1511: }
1512:
1513: /* save off the prepared statment handle and reset row count */
1514: if( pArg ){
1515: pArg->pStmt = pStmt;
1516: pArg->cnt = 0;
1517: }
1518:
1519: /* echo the sql statement if echo on */
1520: if( pArg && pArg->echoOn ){
1521: const char *zStmtSql = sqlite3_sql(pStmt);
1522: fprintf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
1523: }
1524:
1.8 jturner 1525: /* Show the EXPLAIN QUERY PLAN if .eqp is on */
1526: if( pArg && pArg->autoEQP ){
1527: sqlite3_stmt *pExplain;
1.11 jturner 1528: char *zEQP = sqlite3_mprintf("EXPLAIN QUERY PLAN %s",
1529: sqlite3_sql(pStmt));
1.8 jturner 1530: rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
1531: if( rc==SQLITE_OK ){
1532: while( sqlite3_step(pExplain)==SQLITE_ROW ){
1533: fprintf(pArg->out,"--EQP-- %d,", sqlite3_column_int(pExplain, 0));
1534: fprintf(pArg->out,"%d,", sqlite3_column_int(pExplain, 1));
1535: fprintf(pArg->out,"%d,", sqlite3_column_int(pExplain, 2));
1536: fprintf(pArg->out,"%s\n", sqlite3_column_text(pExplain, 3));
1537: }
1538: }
1539: sqlite3_finalize(pExplain);
1540: sqlite3_free(zEQP);
1541: }
1542:
1543: /* If the shell is currently in ".explain" mode, gather the extra
1544: ** data required to add indents to the output.*/
1545: if( pArg && pArg->mode==MODE_Explain ){
1546: explain_data_prepare(pArg, pStmt);
1547: }
1548:
1.1 espie 1549: /* perform the first step. this will tell us if we
1550: ** have a result set or not and how wide it is.
1551: */
1552: rc = sqlite3_step(pStmt);
1553: /* if we have a result set... */
1554: if( SQLITE_ROW == rc ){
1555: /* if we have a callback... */
1556: if( xCallback ){
1557: /* allocate space for col name ptr, value ptr, and type */
1558: int nCol = sqlite3_column_count(pStmt);
1.13 ! jturner 1559: void *pData = sqlite3_malloc64(3*nCol*sizeof(const char*) + 1);
1.1 espie 1560: if( !pData ){
1561: rc = SQLITE_NOMEM;
1562: }else{
1563: char **azCols = (char **)pData; /* Names of result columns */
1564: char **azVals = &azCols[nCol]; /* Results */
1565: int *aiTypes = (int *)&azVals[nCol]; /* Result types */
1.8 jturner 1566: int i, x;
1.1 espie 1567: assert(sizeof(int) <= sizeof(char *));
1568: /* save off ptrs to column names */
1569: for(i=0; i<nCol; i++){
1570: azCols[i] = (char *)sqlite3_column_name(pStmt, i);
1571: }
1572: do{
1573: /* extract the data and data types */
1574: for(i=0; i<nCol; i++){
1.8 jturner 1575: aiTypes[i] = x = sqlite3_column_type(pStmt, i);
1576: if( x==SQLITE_BLOB && pArg && pArg->mode==MODE_Insert ){
1577: azVals[i] = "";
1578: }else{
1579: azVals[i] = (char*)sqlite3_column_text(pStmt, i);
1580: }
1.1 espie 1581: if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){
1582: rc = SQLITE_NOMEM;
1583: break; /* from for */
1584: }
1585: } /* end for */
1586:
1587: /* if data and types extracted successfully... */
1588: if( SQLITE_ROW == rc ){
1589: /* call the supplied callback with the result row data */
1590: if( xCallback(pArg, nCol, azVals, azCols, aiTypes) ){
1591: rc = SQLITE_ABORT;
1592: }else{
1593: rc = sqlite3_step(pStmt);
1594: }
1595: }
1596: } while( SQLITE_ROW == rc );
1597: sqlite3_free(pData);
1598: }
1599: }else{
1600: do{
1601: rc = sqlite3_step(pStmt);
1602: } while( rc == SQLITE_ROW );
1603: }
1604: }
1605:
1.8 jturner 1606: explain_data_delete(pArg);
1607:
1.1 espie 1608: /* print usage stats if stats on */
1609: if( pArg && pArg->statsOn ){
1610: display_stats(db, pArg, 0);
1611: }
1612:
1.11 jturner 1613: /* print loop-counters if required */
1614: if( pArg && pArg->scanstatsOn ){
1615: display_scanstats(db, pArg);
1616: }
1617:
1.1 espie 1618: /* Finalize the statement just executed. If this fails, save a
1619: ** copy of the error message. Otherwise, set zSql to point to the
1620: ** next statement to execute. */
1621: rc2 = sqlite3_finalize(pStmt);
1622: if( rc!=SQLITE_NOMEM ) rc = rc2;
1623: if( rc==SQLITE_OK ){
1624: zSql = zLeftover;
1625: while( IsSpace(zSql[0]) ) zSql++;
1626: }else if( pzErrMsg ){
1627: *pzErrMsg = save_err_msg(db);
1628: }
1629:
1630: /* clear saved stmt handle */
1631: if( pArg ){
1632: pArg->pStmt = NULL;
1633: }
1634: }
1635: } /* end while */
1636:
1637: return rc;
1638: }
1639:
1640:
1641: /*
1642: ** This is a different callback routine used for dumping the database.
1643: ** Each row received by this callback consists of a table name,
1644: ** the table type ("index" or "table") and SQL to create the table.
1645: ** This routine should print text sufficient to recreate the table.
1646: */
1647: static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
1648: int rc;
1649: const char *zTable;
1650: const char *zType;
1651: const char *zSql;
1652: const char *zPrepStmt = 0;
1.10 jturner 1653: ShellState *p = (ShellState *)pArg;
1.1 espie 1654:
1655: UNUSED_PARAMETER(azCol);
1656: if( nArg!=3 ) return 1;
1657: zTable = azArg[0];
1658: zType = azArg[1];
1659: zSql = azArg[2];
1660:
1661: if( strcmp(zTable, "sqlite_sequence")==0 ){
1662: zPrepStmt = "DELETE FROM sqlite_sequence;\n";
1.8 jturner 1663: }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
1.1 espie 1664: fprintf(p->out, "ANALYZE sqlite_master;\n");
1665: }else if( strncmp(zTable, "sqlite_", 7)==0 ){
1666: return 0;
1667: }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
1668: char *zIns;
1669: if( !p->writableSchema ){
1670: fprintf(p->out, "PRAGMA writable_schema=ON;\n");
1671: p->writableSchema = 1;
1672: }
1673: zIns = sqlite3_mprintf(
1674: "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
1675: "VALUES('table','%q','%q',0,'%q');",
1676: zTable, zTable, zSql);
1677: fprintf(p->out, "%s\n", zIns);
1678: sqlite3_free(zIns);
1679: return 0;
1680: }else{
1681: fprintf(p->out, "%s;\n", zSql);
1682: }
1683:
1684: if( strcmp(zType, "table")==0 ){
1685: sqlite3_stmt *pTableInfo = 0;
1686: char *zSelect = 0;
1687: char *zTableInfo = 0;
1688: char *zTmp = 0;
1689: int nRow = 0;
1690:
1691: zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);
1692: zTableInfo = appendText(zTableInfo, zTable, '"');
1693: zTableInfo = appendText(zTableInfo, ");", 0);
1694:
1.8 jturner 1695: rc = sqlite3_prepare_v2(p->db, zTableInfo, -1, &pTableInfo, 0);
1.1 espie 1696: free(zTableInfo);
1697: if( rc!=SQLITE_OK || !pTableInfo ){
1698: return 1;
1699: }
1700:
1701: zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0);
1.2 espie 1702: /* Always quote the table name, even if it appears to be pure ascii,
1703: ** in case it is a keyword. Ex: INSERT INTO "table" ... */
1704: zTmp = appendText(zTmp, zTable, '"');
1.1 espie 1705: if( zTmp ){
1706: zSelect = appendText(zSelect, zTmp, '\'');
1.2 espie 1707: free(zTmp);
1.1 espie 1708: }
1709: zSelect = appendText(zSelect, " || ' VALUES(' || ", 0);
1710: rc = sqlite3_step(pTableInfo);
1711: while( rc==SQLITE_ROW ){
1712: const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1);
1713: zSelect = appendText(zSelect, "quote(", 0);
1714: zSelect = appendText(zSelect, zText, '"');
1715: rc = sqlite3_step(pTableInfo);
1716: if( rc==SQLITE_ROW ){
1717: zSelect = appendText(zSelect, "), ", 0);
1718: }else{
1719: zSelect = appendText(zSelect, ") ", 0);
1720: }
1721: nRow++;
1722: }
1723: rc = sqlite3_finalize(pTableInfo);
1724: if( rc!=SQLITE_OK || nRow==0 ){
1725: free(zSelect);
1726: return 1;
1727: }
1728: zSelect = appendText(zSelect, "|| ')' FROM ", 0);
1729: zSelect = appendText(zSelect, zTable, '"');
1730:
1731: rc = run_table_dump_query(p, zSelect, zPrepStmt);
1732: if( rc==SQLITE_CORRUPT ){
1733: zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);
1734: run_table_dump_query(p, zSelect, 0);
1735: }
1.2 espie 1736: free(zSelect);
1.1 espie 1737: }
1738: return 0;
1739: }
1740:
1741: /*
1742: ** Run zQuery. Use dump_callback() as the callback routine so that
1743: ** the contents of the query are output as SQL statements.
1744: **
1745: ** If we get a SQLITE_CORRUPT error, rerun the query after appending
1746: ** "ORDER BY rowid DESC" to the end.
1747: */
1748: static int run_schema_dump_query(
1.10 jturner 1749: ShellState *p,
1.1 espie 1750: const char *zQuery
1751: ){
1752: int rc;
1753: char *zErr = 0;
1754: rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr);
1755: if( rc==SQLITE_CORRUPT ){
1756: char *zQ2;
1757: int len = strlen30(zQuery);
1758: fprintf(p->out, "/****** CORRUPTION ERROR *******/\n");
1759: if( zErr ){
1760: fprintf(p->out, "/****** %s ******/\n", zErr);
1761: sqlite3_free(zErr);
1762: zErr = 0;
1763: }
1764: zQ2 = malloc( len+100 );
1765: if( zQ2==0 ) return rc;
1.2 espie 1766: sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery);
1.1 espie 1767: rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr);
1768: if( rc ){
1769: fprintf(p->out, "/****** ERROR: %s ******/\n", zErr);
1770: }else{
1771: rc = SQLITE_CORRUPT;
1772: }
1773: sqlite3_free(zErr);
1774: free(zQ2);
1775: }
1776: return rc;
1777: }
1778:
1779: /*
1780: ** Text of a help message
1781: */
1782: static char zHelp[] =
1783: ".backup ?DB? FILE Backup DB (default \"main\") to FILE\n"
1.9 jturner 1784: ".bail on|off Stop after hitting an error. Default OFF\n"
1.13 ! jturner 1785: ".binary on|off Turn binary output on or off. Default OFF\n"
1.8 jturner 1786: ".clone NEWDB Clone data into NEWDB from the existing database\n"
1.1 espie 1787: ".databases List names and files of attached databases\n"
1.12 jturner 1788: ".dbinfo ?DB? Show status information about the database\n"
1.1 espie 1789: ".dump ?TABLE? ... Dump the database in an SQL text format\n"
1790: " If TABLE specified, only dump tables matching\n"
1791: " LIKE pattern TABLE.\n"
1.9 jturner 1792: ".echo on|off Turn command echo on or off\n"
1793: ".eqp on|off Enable or disable automatic EXPLAIN QUERY PLAN\n"
1.1 espie 1794: ".exit Exit this program\n"
1.9 jturner 1795: ".explain ?on|off? Turn output mode suitable for EXPLAIN on or off.\n"
1.1 espie 1796: " With no args, it turns EXPLAIN on.\n"
1.9 jturner 1797: ".fullschema Show schema and the content of sqlite_stat tables\n"
1798: ".headers on|off Turn display of headers on or off\n"
1.1 espie 1799: ".help Show this message\n"
1800: ".import FILE TABLE Import data from FILE into TABLE\n"
1.12 jturner 1801: ".indexes ?TABLE? Show names of all indexes\n"
1802: " If TABLE specified, only show indexes for tables\n"
1.1 espie 1803: " matching LIKE pattern TABLE.\n"
1804: #ifdef SQLITE_ENABLE_IOTRACE
1805: ".iotrace FILE Enable I/O diagnostic logging to FILE\n"
1806: #endif
1.13 ! jturner 1807: ".limit ?LIMIT? ?VAL? Display or change the value of an SQLITE_LIMIT\n"
1.1 espie 1808: #ifndef SQLITE_OMIT_LOAD_EXTENSION
1809: ".load FILE ?ENTRY? Load an extension library\n"
1810: #endif
1811: ".log FILE|off Turn logging on or off. FILE can be stderr/stdout\n"
1812: ".mode MODE ?TABLE? Set output mode where MODE is one of:\n"
1.11 jturner 1813: " ascii Columns/rows delimited by 0x1F and 0x1E\n"
1.1 espie 1814: " csv Comma-separated values\n"
1815: " column Left-aligned columns. (See .width)\n"
1816: " html HTML <table> code\n"
1817: " insert SQL insert statements for TABLE\n"
1818: " line One value per line\n"
1.11 jturner 1819: " list Values delimited by .separator strings\n"
1.1 espie 1820: " tabs Tab-separated values\n"
1821: " tcl TCL list elements\n"
1.5 espie 1822: ".nullvalue STRING Use STRING in place of NULL values\n"
1.9 jturner 1823: ".once FILENAME Output for the next SQL command only to FILENAME\n"
1.8 jturner 1824: ".open ?FILENAME? Close existing database and reopen FILENAME\n"
1.9 jturner 1825: ".output ?FILENAME? Send output to FILENAME or stdout\n"
1.5 espie 1826: ".print STRING... Print literal STRING\n"
1.1 espie 1827: ".prompt MAIN CONTINUE Replace the standard prompts\n"
1828: ".quit Exit this program\n"
1829: ".read FILENAME Execute SQL in FILENAME\n"
1830: ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n"
1.8 jturner 1831: ".save FILE Write in-memory database into FILE\n"
1.11 jturner 1832: ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off\n"
1.1 espie 1833: ".schema ?TABLE? Show the CREATE statements\n"
1834: " If TABLE specified, only show tables matching\n"
1835: " LIKE pattern TABLE.\n"
1.11 jturner 1836: ".separator COL ?ROW? Change the column separator and optionally the row\n"
1837: " separator for both the output mode and .import\n"
1.9 jturner 1838: ".shell CMD ARGS... Run CMD ARGS... in a system shell\n"
1.1 espie 1839: ".show Show the current values for various settings\n"
1.9 jturner 1840: ".stats on|off Turn stats on or off\n"
1841: ".system CMD ARGS... Run CMD ARGS... in a system shell\n"
1.1 espie 1842: ".tables ?TABLE? List names of tables\n"
1843: " If TABLE specified, only list tables matching\n"
1844: " LIKE pattern TABLE.\n"
1845: ".timeout MS Try opening locked tables for MS milliseconds\n"
1.9 jturner 1846: ".timer on|off Turn SQL timer on or off\n"
1.2 espie 1847: ".trace FILE|off Output each SQL statement as it is run\n"
1.1 espie 1848: ".vfsname ?AUX? Print the name of the VFS stack\n"
1849: ".width NUM1 NUM2 ... Set column widths for \"column\" mode\n"
1.9 jturner 1850: " Negative values right-justify\n"
1.1 espie 1851: ;
1852:
1853: /* Forward reference */
1.10 jturner 1854: static int process_input(ShellState *p, FILE *in);
1.9 jturner 1855: /*
1856: ** Implementation of the "readfile(X)" SQL function. The entire content
1857: ** of the file named X is read and returned as a BLOB. NULL is returned
1858: ** if the file does not exist or is unreadable.
1859: */
1860: static void readfileFunc(
1861: sqlite3_context *context,
1862: int argc,
1863: sqlite3_value **argv
1864: ){
1865: const char *zName;
1866: FILE *in;
1867: long nIn;
1868: void *pBuf;
1869:
1.13 ! jturner 1870: UNUSED_PARAMETER(argc);
1.9 jturner 1871: zName = (const char*)sqlite3_value_text(argv[0]);
1872: if( zName==0 ) return;
1873: in = fopen(zName, "rb");
1874: if( in==0 ) return;
1875: fseek(in, 0, SEEK_END);
1876: nIn = ftell(in);
1877: rewind(in);
1.13 ! jturner 1878: pBuf = sqlite3_malloc64( nIn );
1.9 jturner 1879: if( pBuf && 1==fread(pBuf, nIn, 1, in) ){
1880: sqlite3_result_blob(context, pBuf, nIn, sqlite3_free);
1881: }else{
1882: sqlite3_free(pBuf);
1883: }
1884: fclose(in);
1885: }
1886:
1887: /*
1888: ** Implementation of the "writefile(X,Y)" SQL function. The argument Y
1889: ** is written into file X. The number of bytes written is returned. Or
1890: ** NULL is returned if something goes wrong, such as being unable to open
1891: ** file X for writing.
1892: */
1893: static void writefileFunc(
1894: sqlite3_context *context,
1895: int argc,
1896: sqlite3_value **argv
1897: ){
1898: FILE *out;
1899: const char *z;
1900: sqlite3_int64 rc;
1901: const char *zFile;
1902:
1.13 ! jturner 1903: UNUSED_PARAMETER(argc);
1.9 jturner 1904: zFile = (const char*)sqlite3_value_text(argv[0]);
1905: if( zFile==0 ) return;
1906: out = fopen(zFile, "wb");
1907: if( out==0 ) return;
1908: z = (const char*)sqlite3_value_blob(argv[1]);
1909: if( z==0 ){
1910: rc = 0;
1911: }else{
1912: rc = fwrite(z, 1, sqlite3_value_bytes(argv[1]), out);
1913: }
1914: fclose(out);
1915: sqlite3_result_int64(context, rc);
1916: }
1.1 espie 1917:
1918: /*
1919: ** Make sure the database is open. If it is not, then open it. If
1920: ** the database fails to open, print an error message and exit.
1921: */
1.10 jturner 1922: static void open_db(ShellState *p, int keepAlive){
1.1 espie 1923: if( p->db==0 ){
1.4 espie 1924: sqlite3_initialize();
1.1 espie 1925: sqlite3_open(p->zDbFilename, &p->db);
1.13 ! jturner 1926: globalDb = p->db;
! 1927: if( p->db && sqlite3_errcode(p->db)==SQLITE_OK ){
! 1928: sqlite3_create_function(p->db, "shellstatic", 0, SQLITE_UTF8, 0,
1.1 espie 1929: shellstaticFunc, 0, 0);
1930: }
1.13 ! jturner 1931: if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){
1.1 espie 1932: fprintf(stderr,"Error: unable to open database \"%s\": %s\n",
1.13 ! jturner 1933: p->zDbFilename, sqlite3_errmsg(p->db));
1.8 jturner 1934: if( keepAlive ) return;
1.1 espie 1935: exit(1);
1936: }
1937: #ifndef SQLITE_OMIT_LOAD_EXTENSION
1938: sqlite3_enable_load_extension(p->db, 1);
1939: #endif
1.13 ! jturner 1940: sqlite3_create_function(p->db, "readfile", 1, SQLITE_UTF8, 0,
1.9 jturner 1941: readfileFunc, 0, 0);
1.13 ! jturner 1942: sqlite3_create_function(p->db, "writefile", 2, SQLITE_UTF8, 0,
1.9 jturner 1943: writefileFunc, 0, 0);
1.1 espie 1944: }
1945: }
1946:
1947: /*
1948: ** Do C-language style dequoting.
1949: **
1.13 ! jturner 1950: ** \a -> alarm
! 1951: ** \b -> backspace
1.1 espie 1952: ** \t -> tab
1953: ** \n -> newline
1.13 ! jturner 1954: ** \v -> vertical tab
! 1955: ** \f -> form feed
1.1 espie 1956: ** \r -> carriage return
1.13 ! jturner 1957: ** \s -> space
1.7 jturner 1958: ** \" -> "
1.13 ! jturner 1959: ** \' -> '
! 1960: ** \\ -> backslash
1.1 espie 1961: ** \NNN -> ascii character NNN in octal
1962: */
1963: static void resolve_backslashes(char *z){
1964: int i, j;
1965: char c;
1.9 jturner 1966: while( *z && *z!='\\' ) z++;
1.1 espie 1967: for(i=j=0; (c = z[i])!=0; i++, j++){
1.13 ! jturner 1968: if( c=='\\' && z[i+1]!=0 ){
1.1 espie 1969: c = z[++i];
1.13 ! jturner 1970: if( c=='a' ){
! 1971: c = '\a';
! 1972: }else if( c=='b' ){
! 1973: c = '\b';
1.1 espie 1974: }else if( c=='t' ){
1975: c = '\t';
1.13 ! jturner 1976: }else if( c=='n' ){
! 1977: c = '\n';
! 1978: }else if( c=='v' ){
! 1979: c = '\v';
! 1980: }else if( c=='f' ){
! 1981: c = '\f';
1.1 espie 1982: }else if( c=='r' ){
1983: c = '\r';
1.13 ! jturner 1984: }else if( c=='"' ){
! 1985: c = '"';
! 1986: }else if( c=='\'' ){
! 1987: c = '\'';
1.7 jturner 1988: }else if( c=='\\' ){
1989: c = '\\';
1.1 espie 1990: }else if( c>='0' && c<='7' ){
1991: c -= '0';
1992: if( z[i+1]>='0' && z[i+1]<='7' ){
1993: i++;
1994: c = (c<<3) + z[i] - '0';
1995: if( z[i+1]>='0' && z[i+1]<='7' ){
1996: i++;
1997: c = (c<<3) + z[i] - '0';
1998: }
1999: }
2000: }
2001: }
2002: z[j] = c;
2003: }
1.9 jturner 2004: if( j<i ) z[j] = 0;
1.1 espie 2005: }
2006:
2007: /*
1.7 jturner 2008: ** Return the value of a hexadecimal digit. Return -1 if the input
2009: ** is not a hex digit.
1.1 espie 2010: */
1.7 jturner 2011: static int hexDigitValue(char c){
2012: if( c>='0' && c<='9' ) return c - '0';
2013: if( c>='a' && c<='f' ) return c - 'a' + 10;
2014: if( c>='A' && c<='F' ) return c - 'A' + 10;
2015: return -1;
1.6 landry 2016: }
2017:
2018: /*
2019: ** Interpret zArg as an integer value, possibly with suffixes.
2020: */
2021: static sqlite3_int64 integerValue(const char *zArg){
2022: sqlite3_int64 v = 0;
2023: static const struct { char *zSuffix; int iMult; } aMult[] = {
2024: { "KiB", 1024 },
2025: { "MiB", 1024*1024 },
2026: { "GiB", 1024*1024*1024 },
2027: { "KB", 1000 },
2028: { "MB", 1000000 },
2029: { "GB", 1000000000 },
2030: { "K", 1000 },
2031: { "M", 1000000 },
2032: { "G", 1000000000 },
2033: };
2034: int i;
2035: int isNeg = 0;
2036: if( zArg[0]=='-' ){
2037: isNeg = 1;
2038: zArg++;
2039: }else if( zArg[0]=='+' ){
2040: zArg++;
2041: }
1.7 jturner 2042: if( zArg[0]=='0' && zArg[1]=='x' ){
2043: int x;
2044: zArg += 2;
2045: while( (x = hexDigitValue(zArg[0]))>=0 ){
2046: v = (v<<4) + x;
2047: zArg++;
2048: }
2049: }else{
2050: while( IsDigit(zArg[0]) ){
2051: v = v*10 + zArg[0] - '0';
2052: zArg++;
2053: }
1.6 landry 2054: }
1.7 jturner 2055: for(i=0; i<ArraySize(aMult); i++){
1.6 landry 2056: if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){
2057: v *= aMult[i].iMult;
2058: break;
2059: }
1.1 espie 2060: }
1.6 landry 2061: return isNeg? -v : v;
1.1 espie 2062: }
2063:
2064: /*
1.7 jturner 2065: ** Interpret zArg as either an integer or a boolean value. Return 1 or 0
2066: ** for TRUE and FALSE. Return the integer value if appropriate.
2067: */
2068: static int booleanValue(char *zArg){
2069: int i;
2070: if( zArg[0]=='0' && zArg[1]=='x' ){
2071: for(i=2; hexDigitValue(zArg[i])>=0; i++){}
2072: }else{
2073: for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
2074: }
2075: if( i>0 && zArg[i]==0 ) return (int)(integerValue(zArg) & 0xffffffff);
2076: if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){
2077: return 1;
2078: }
2079: if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){
2080: return 0;
2081: }
2082: fprintf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
2083: zArg);
2084: return 0;
2085: }
2086:
2087: /*
1.2 espie 2088: ** Close an output file, assuming it is not stderr or stdout
2089: */
2090: static void output_file_close(FILE *f){
2091: if( f && f!=stdout && f!=stderr ) fclose(f);
2092: }
2093:
2094: /*
2095: ** Try to open an output file. The names "stdout" and "stderr" are
2096: ** recognized and do the right thing. NULL is returned if the output
2097: ** filename is "off".
2098: */
2099: static FILE *output_file_open(const char *zFile){
2100: FILE *f;
2101: if( strcmp(zFile,"stdout")==0 ){
2102: f = stdout;
2103: }else if( strcmp(zFile, "stderr")==0 ){
2104: f = stderr;
2105: }else if( strcmp(zFile, "off")==0 ){
2106: f = 0;
2107: }else{
2108: f = fopen(zFile, "wb");
2109: if( f==0 ){
2110: fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
2111: }
2112: }
2113: return f;
2114: }
2115:
2116: /*
2117: ** A routine for handling output from sqlite3_trace().
2118: */
2119: static void sql_trace_callback(void *pArg, const char *z){
2120: FILE *f = (FILE*)pArg;
1.10 jturner 2121: if( f ){
2122: int i = (int)strlen(z);
2123: while( i>0 && z[i-1]==';' ){ i--; }
2124: fprintf(f, "%.*s;\n", i, z);
2125: }
1.2 espie 2126: }
2127:
2128: /*
2129: ** A no-op routine that runs with the ".breakpoint" doc-command. This is
2130: ** a useful spot to set a debugger breakpoint.
2131: */
2132: static void test_breakpoint(void){
2133: static int nCall = 0;
2134: nCall++;
2135: }
2136:
2137: /*
1.11 jturner 2138: ** An object used to read a CSV and other files for import.
1.7 jturner 2139: */
1.11 jturner 2140: typedef struct ImportCtx ImportCtx;
2141: struct ImportCtx {
1.7 jturner 2142: const char *zFile; /* Name of the input file */
2143: FILE *in; /* Read the CSV text from this input stream */
2144: char *z; /* Accumulated text for a field */
2145: int n; /* Number of bytes in z */
2146: int nAlloc; /* Space allocated for z[] */
2147: int nLine; /* Current line number */
2148: int cTerm; /* Character that terminated the most recent field */
1.11 jturner 2149: int cColSep; /* The column separator character. (Usually ",") */
2150: int cRowSep; /* The row separator character. (Usually "\n") */
1.7 jturner 2151: };
2152:
2153: /* Append a single byte to z[] */
1.11 jturner 2154: static void import_append_char(ImportCtx *p, int c){
1.7 jturner 2155: if( p->n+1>=p->nAlloc ){
2156: p->nAlloc += p->nAlloc + 100;
1.13 ! jturner 2157: p->z = sqlite3_realloc64(p->z, p->nAlloc);
1.7 jturner 2158: if( p->z==0 ){
2159: fprintf(stderr, "out of memory\n");
2160: exit(1);
2161: }
2162: }
2163: p->z[p->n++] = (char)c;
2164: }
2165:
2166: /* Read a single field of CSV text. Compatible with rfc4180 and extended
2167: ** with the option of having a separator other than ",".
2168: **
2169: ** + Input comes from p->in.
2170: ** + Store results in p->z of length p->n. Space to hold p->z comes
1.13 ! jturner 2171: ** from sqlite3_malloc64().
1.11 jturner 2172: ** + Use p->cSep as the column separator. The default is ",".
2173: ** + Use p->rSep as the row separator. The default is "\n".
1.7 jturner 2174: ** + Keep track of the line number in p->nLine.
2175: ** + Store the character that terminates the field in p->cTerm. Store
2176: ** EOF on end-of-file.
2177: ** + Report syntax errors on stderr
2178: */
1.12 jturner 2179: static char *SQLITE_CDECL csv_read_one_field(ImportCtx *p){
1.11 jturner 2180: int c;
2181: int cSep = p->cColSep;
2182: int rSep = p->cRowSep;
1.7 jturner 2183: p->n = 0;
2184: c = fgetc(p->in);
2185: if( c==EOF || seenInterrupt ){
2186: p->cTerm = EOF;
2187: return 0;
2188: }
2189: if( c=='"' ){
1.11 jturner 2190: int pc, ppc;
1.7 jturner 2191: int startLine = p->nLine;
2192: int cQuote = c;
1.8 jturner 2193: pc = ppc = 0;
1.7 jturner 2194: while( 1 ){
2195: c = fgetc(p->in);
1.11 jturner 2196: if( c==rSep ) p->nLine++;
1.7 jturner 2197: if( c==cQuote ){
2198: if( pc==cQuote ){
2199: pc = 0;
2200: continue;
2201: }
2202: }
2203: if( (c==cSep && pc==cQuote)
1.11 jturner 2204: || (c==rSep && pc==cQuote)
2205: || (c==rSep && pc=='\r' && ppc==cQuote)
1.7 jturner 2206: || (c==EOF && pc==cQuote)
2207: ){
2208: do{ p->n--; }while( p->z[p->n]!=cQuote );
2209: p->cTerm = c;
2210: break;
2211: }
2212: if( pc==cQuote && c!='\r' ){
2213: fprintf(stderr, "%s:%d: unescaped %c character\n",
2214: p->zFile, p->nLine, cQuote);
2215: }
2216: if( c==EOF ){
2217: fprintf(stderr, "%s:%d: unterminated %c-quoted field\n",
2218: p->zFile, startLine, cQuote);
1.11 jturner 2219: p->cTerm = c;
1.7 jturner 2220: break;
2221: }
1.11 jturner 2222: import_append_char(p, c);
1.8 jturner 2223: ppc = pc;
1.7 jturner 2224: pc = c;
2225: }
2226: }else{
1.11 jturner 2227: while( c!=EOF && c!=cSep && c!=rSep ){
2228: import_append_char(p, c);
1.7 jturner 2229: c = fgetc(p->in);
2230: }
1.11 jturner 2231: if( c==rSep ){
1.7 jturner 2232: p->nLine++;
1.8 jturner 2233: if( p->n>0 && p->z[p->n-1]=='\r' ) p->n--;
1.7 jturner 2234: }
2235: p->cTerm = c;
2236: }
2237: if( p->z ) p->z[p->n] = 0;
2238: return p->z;
2239: }
2240:
1.11 jturner 2241: /* Read a single field of ASCII delimited text.
2242: **
2243: ** + Input comes from p->in.
2244: ** + Store results in p->z of length p->n. Space to hold p->z comes
1.13 ! jturner 2245: ** from sqlite3_malloc64().
1.11 jturner 2246: ** + Use p->cSep as the column separator. The default is "\x1F".
2247: ** + Use p->rSep as the row separator. The default is "\x1E".
2248: ** + Keep track of the row number in p->nLine.
2249: ** + Store the character that terminates the field in p->cTerm. Store
2250: ** EOF on end-of-file.
2251: ** + Report syntax errors on stderr
2252: */
1.12 jturner 2253: static char *SQLITE_CDECL ascii_read_one_field(ImportCtx *p){
1.11 jturner 2254: int c;
2255: int cSep = p->cColSep;
2256: int rSep = p->cRowSep;
2257: p->n = 0;
2258: c = fgetc(p->in);
2259: if( c==EOF || seenInterrupt ){
2260: p->cTerm = EOF;
2261: return 0;
2262: }
2263: while( c!=EOF && c!=cSep && c!=rSep ){
2264: import_append_char(p, c);
2265: c = fgetc(p->in);
2266: }
2267: if( c==rSep ){
2268: p->nLine++;
2269: }
2270: p->cTerm = c;
2271: if( p->z ) p->z[p->n] = 0;
2272: return p->z;
2273: }
2274:
1.7 jturner 2275: /*
1.8 jturner 2276: ** Try to transfer data for table zTable. If an error is seen while
2277: ** moving forward, try to go backwards. The backwards movement won't
2278: ** work for WITHOUT ROWID tables.
2279: */
2280: static void tryToCloneData(
1.10 jturner 2281: ShellState *p,
1.8 jturner 2282: sqlite3 *newDb,
2283: const char *zTable
2284: ){
2285: sqlite3_stmt *pQuery = 0;
2286: sqlite3_stmt *pInsert = 0;
2287: char *zQuery = 0;
2288: char *zInsert = 0;
2289: int rc;
2290: int i, j, n;
2291: int nTable = (int)strlen(zTable);
2292: int k = 0;
2293: int cnt = 0;
2294: const int spinRate = 10000;
2295:
2296: zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable);
2297: rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
2298: if( rc ){
2299: fprintf(stderr, "Error %d: %s on [%s]\n",
2300: sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
2301: zQuery);
2302: goto end_data_xfer;
2303: }
2304: n = sqlite3_column_count(pQuery);
1.13 ! jturner 2305: zInsert = sqlite3_malloc64(200 + nTable + n*3);
1.8 jturner 2306: if( zInsert==0 ){
2307: fprintf(stderr, "out of memory\n");
2308: goto end_data_xfer;
2309: }
2310: sqlite3_snprintf(200+nTable,zInsert,
2311: "INSERT OR IGNORE INTO \"%s\" VALUES(?", zTable);
2312: i = (int)strlen(zInsert);
2313: for(j=1; j<n; j++){
2314: memcpy(zInsert+i, ",?", 2);
2315: i += 2;
2316: }
2317: memcpy(zInsert+i, ");", 3);
2318: rc = sqlite3_prepare_v2(newDb, zInsert, -1, &pInsert, 0);
2319: if( rc ){
2320: fprintf(stderr, "Error %d: %s on [%s]\n",
2321: sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb),
2322: zQuery);
2323: goto end_data_xfer;
2324: }
2325: for(k=0; k<2; k++){
2326: while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
2327: for(i=0; i<n; i++){
2328: switch( sqlite3_column_type(pQuery, i) ){
2329: case SQLITE_NULL: {
2330: sqlite3_bind_null(pInsert, i+1);
2331: break;
2332: }
2333: case SQLITE_INTEGER: {
2334: sqlite3_bind_int64(pInsert, i+1, sqlite3_column_int64(pQuery,i));
2335: break;
2336: }
2337: case SQLITE_FLOAT: {
2338: sqlite3_bind_double(pInsert, i+1, sqlite3_column_double(pQuery,i));
2339: break;
2340: }
2341: case SQLITE_TEXT: {
2342: sqlite3_bind_text(pInsert, i+1,
2343: (const char*)sqlite3_column_text(pQuery,i),
2344: -1, SQLITE_STATIC);
2345: break;
2346: }
2347: case SQLITE_BLOB: {
2348: sqlite3_bind_blob(pInsert, i+1, sqlite3_column_blob(pQuery,i),
2349: sqlite3_column_bytes(pQuery,i),
2350: SQLITE_STATIC);
2351: break;
2352: }
2353: }
2354: } /* End for */
2355: rc = sqlite3_step(pInsert);
2356: if( rc!=SQLITE_OK && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
2357: fprintf(stderr, "Error %d: %s\n", sqlite3_extended_errcode(newDb),
2358: sqlite3_errmsg(newDb));
2359: }
2360: sqlite3_reset(pInsert);
2361: cnt++;
2362: if( (cnt%spinRate)==0 ){
2363: printf("%c\b", "|/-\\"[(cnt/spinRate)%4]);
2364: fflush(stdout);
2365: }
2366: } /* End while */
2367: if( rc==SQLITE_DONE ) break;
2368: sqlite3_finalize(pQuery);
2369: sqlite3_free(zQuery);
2370: zQuery = sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;",
2371: zTable);
2372: rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
2373: if( rc ){
2374: fprintf(stderr, "Warning: cannot step \"%s\" backwards", zTable);
2375: break;
2376: }
2377: } /* End for(k=0...) */
2378:
2379: end_data_xfer:
2380: sqlite3_finalize(pQuery);
2381: sqlite3_finalize(pInsert);
2382: sqlite3_free(zQuery);
2383: sqlite3_free(zInsert);
2384: }
2385:
2386:
2387: /*
2388: ** Try to transfer all rows of the schema that match zWhere. For
2389: ** each row, invoke xForEach() on the object defined by that row.
2390: ** If an error is encountered while moving forward through the
2391: ** sqlite_master table, try again moving backwards.
2392: */
2393: static void tryToCloneSchema(
1.10 jturner 2394: ShellState *p,
1.8 jturner 2395: sqlite3 *newDb,
2396: const char *zWhere,
1.10 jturner 2397: void (*xForEach)(ShellState*,sqlite3*,const char*)
1.8 jturner 2398: ){
2399: sqlite3_stmt *pQuery = 0;
2400: char *zQuery = 0;
2401: int rc;
2402: const unsigned char *zName;
2403: const unsigned char *zSql;
2404: char *zErrMsg = 0;
2405:
2406: zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
2407: " WHERE %s", zWhere);
2408: rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
2409: if( rc ){
2410: fprintf(stderr, "Error: (%d) %s on [%s]\n",
2411: sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
2412: zQuery);
2413: goto end_schema_xfer;
2414: }
2415: while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
2416: zName = sqlite3_column_text(pQuery, 0);
2417: zSql = sqlite3_column_text(pQuery, 1);
2418: printf("%s... ", zName); fflush(stdout);
2419: sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
2420: if( zErrMsg ){
2421: fprintf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
2422: sqlite3_free(zErrMsg);
2423: zErrMsg = 0;
2424: }
2425: if( xForEach ){
2426: xForEach(p, newDb, (const char*)zName);
2427: }
2428: printf("done\n");
2429: }
2430: if( rc!=SQLITE_DONE ){
2431: sqlite3_finalize(pQuery);
2432: sqlite3_free(zQuery);
2433: zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
2434: " WHERE %s ORDER BY rowid DESC", zWhere);
2435: rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
2436: if( rc ){
2437: fprintf(stderr, "Error: (%d) %s on [%s]\n",
2438: sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
2439: zQuery);
2440: goto end_schema_xfer;
2441: }
2442: while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
2443: zName = sqlite3_column_text(pQuery, 0);
2444: zSql = sqlite3_column_text(pQuery, 1);
2445: printf("%s... ", zName); fflush(stdout);
2446: sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
2447: if( zErrMsg ){
2448: fprintf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
2449: sqlite3_free(zErrMsg);
2450: zErrMsg = 0;
2451: }
2452: if( xForEach ){
2453: xForEach(p, newDb, (const char*)zName);
2454: }
2455: printf("done\n");
2456: }
2457: }
2458: end_schema_xfer:
2459: sqlite3_finalize(pQuery);
2460: sqlite3_free(zQuery);
2461: }
2462:
2463: /*
2464: ** Open a new database file named "zNewDb". Try to recover as much information
2465: ** as possible out of the main database (which might be corrupt) and write it
2466: ** into zNewDb.
2467: */
1.10 jturner 2468: static void tryToClone(ShellState *p, const char *zNewDb){
1.8 jturner 2469: int rc;
2470: sqlite3 *newDb = 0;
2471: if( access(zNewDb,0)==0 ){
2472: fprintf(stderr, "File \"%s\" already exists.\n", zNewDb);
2473: return;
2474: }
2475: rc = sqlite3_open(zNewDb, &newDb);
2476: if( rc ){
2477: fprintf(stderr, "Cannot create output database: %s\n",
2478: sqlite3_errmsg(newDb));
2479: }else{
1.9 jturner 2480: sqlite3_exec(p->db, "PRAGMA writable_schema=ON;", 0, 0, 0);
1.8 jturner 2481: sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0);
2482: tryToCloneSchema(p, newDb, "type='table'", tryToCloneData);
2483: tryToCloneSchema(p, newDb, "type!='table'", 0);
2484: sqlite3_exec(newDb, "COMMIT;", 0, 0, 0);
1.9 jturner 2485: sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
1.8 jturner 2486: }
2487: sqlite3_close(newDb);
2488: }
2489:
2490: /*
1.9 jturner 2491: ** Change the output file back to stdout
2492: */
1.10 jturner 2493: static void output_reset(ShellState *p){
1.9 jturner 2494: if( p->outfile[0]=='|' ){
1.12 jturner 2495: #ifndef SQLITE_OMIT_POPEN
1.9 jturner 2496: pclose(p->out);
1.12 jturner 2497: #endif
1.9 jturner 2498: }else{
2499: output_file_close(p->out);
2500: }
2501: p->outfile[0] = 0;
2502: p->out = stdout;
2503: }
2504:
2505: /*
1.12 jturner 2506: ** Run an SQL command and return the single integer result.
2507: */
2508: static int db_int(ShellState *p, const char *zSql){
2509: sqlite3_stmt *pStmt;
2510: int res = 0;
2511: sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2512: if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
2513: res = sqlite3_column_int(pStmt,0);
2514: }
2515: sqlite3_finalize(pStmt);
2516: return res;
2517: }
2518:
2519: /*
2520: ** Convert a 2-byte or 4-byte big-endian integer into a native integer
2521: */
2522: unsigned int get2byteInt(unsigned char *a){
2523: return (a[0]<<8) + a[1];
2524: }
2525: unsigned int get4byteInt(unsigned char *a){
2526: return (a[0]<<24) + (a[1]<<16) + (a[2]<<8) + a[3];
2527: }
2528:
2529: /*
2530: ** Implementation of the ".info" command.
2531: **
2532: ** Return 1 on error, 2 to exit, and 0 otherwise.
2533: */
2534: static int shell_dbinfo_command(ShellState *p, int nArg, char **azArg){
2535: static const struct { const char *zName; int ofst; } aField[] = {
2536: { "file change counter:", 24 },
2537: { "database page count:", 28 },
2538: { "freelist page count:", 36 },
2539: { "schema cookie:", 40 },
2540: { "schema format:", 44 },
2541: { "default cache size:", 48 },
2542: { "autovacuum top root:", 52 },
2543: { "incremental vacuum:", 64 },
2544: { "text encoding:", 56 },
2545: { "user version:", 60 },
2546: { "application id:", 68 },
2547: { "software version:", 96 },
2548: };
2549: static const struct { const char *zName; const char *zSql; } aQuery[] = {
2550: { "number of tables:",
2551: "SELECT count(*) FROM %s WHERE type='table'" },
2552: { "number of indexes:",
2553: "SELECT count(*) FROM %s WHERE type='index'" },
2554: { "number of triggers:",
2555: "SELECT count(*) FROM %s WHERE type='trigger'" },
2556: { "number of views:",
2557: "SELECT count(*) FROM %s WHERE type='view'" },
2558: { "schema size:",
2559: "SELECT total(length(sql)) FROM %s" },
2560: };
2561: sqlite3_file *pFile;
2562: int i;
2563: char *zSchemaTab;
2564: char *zDb = nArg>=2 ? azArg[1] : "main";
2565: unsigned char aHdr[100];
2566: open_db(p, 0);
2567: if( p->db==0 ) return 1;
2568: sqlite3_file_control(p->db, zDb, SQLITE_FCNTL_FILE_POINTER, &pFile);
2569: if( pFile==0 || pFile->pMethods==0 || pFile->pMethods->xRead==0 ){
2570: return 1;
2571: }
2572: i = pFile->pMethods->xRead(pFile, aHdr, 100, 0);
2573: if( i!=SQLITE_OK ){
2574: fprintf(stderr, "unable to read database header\n");
2575: return 1;
2576: }
2577: i = get2byteInt(aHdr+16);
2578: if( i==1 ) i = 65536;
2579: fprintf(p->out, "%-20s %d\n", "database page size:", i);
2580: fprintf(p->out, "%-20s %d\n", "write format:", aHdr[18]);
2581: fprintf(p->out, "%-20s %d\n", "read format:", aHdr[19]);
2582: fprintf(p->out, "%-20s %d\n", "reserved bytes:", aHdr[20]);
1.13 ! jturner 2583: for(i=0; i<ArraySize(aField); i++){
1.12 jturner 2584: int ofst = aField[i].ofst;
2585: unsigned int val = get4byteInt(aHdr + ofst);
2586: fprintf(p->out, "%-20s %u", aField[i].zName, val);
2587: switch( ofst ){
2588: case 56: {
2589: if( val==1 ) fprintf(p->out, " (utf8)");
2590: if( val==2 ) fprintf(p->out, " (utf16le)");
2591: if( val==3 ) fprintf(p->out, " (utf16be)");
2592: }
2593: }
2594: fprintf(p->out, "\n");
2595: }
2596: if( zDb==0 ){
2597: zSchemaTab = sqlite3_mprintf("main.sqlite_master");
2598: }else if( strcmp(zDb,"temp")==0 ){
2599: zSchemaTab = sqlite3_mprintf("%s", "sqlite_temp_master");
2600: }else{
2601: zSchemaTab = sqlite3_mprintf("\"%w\".sqlite_master", zDb);
2602: }
1.13 ! jturner 2603: for(i=0; i<ArraySize(aQuery); i++){
1.12 jturner 2604: char *zSql = sqlite3_mprintf(aQuery[i].zSql, zSchemaTab);
2605: int val = db_int(p, zSql);
2606: sqlite3_free(zSql);
2607: fprintf(p->out, "%-20s %d\n", aQuery[i].zName, val);
2608: }
2609: sqlite3_free(zSchemaTab);
2610: return 0;
2611: }
2612:
2613:
2614: /*
1.1 espie 2615: ** If an input line begins with "." then invoke this routine to
2616: ** process that line.
2617: **
2618: ** Return 1 on error, 2 to exit, and 0 otherwise.
2619: */
1.10 jturner 2620: static int do_meta_command(char *zLine, ShellState *p){
1.13 ! jturner 2621: int h = 1;
1.1 espie 2622: int nArg = 0;
2623: int n, c;
2624: int rc = 0;
2625: char *azArg[50];
2626:
2627: /* Parse the input line into tokens.
2628: */
1.13 ! jturner 2629: while( zLine[h] && nArg<ArraySize(azArg) ){
! 2630: while( IsSpace(zLine[h]) ){ h++; }
! 2631: if( zLine[h]==0 ) break;
! 2632: if( zLine[h]=='\'' || zLine[h]=='"' ){
! 2633: int delim = zLine[h++];
! 2634: azArg[nArg++] = &zLine[h];
! 2635: while( zLine[h] && zLine[h]!=delim ){
! 2636: if( zLine[h]=='\\' && delim=='"' && zLine[h+1]!=0 ) h++;
! 2637: h++;
1.7 jturner 2638: }
1.13 ! jturner 2639: if( zLine[h]==delim ){
! 2640: zLine[h++] = 0;
1.1 espie 2641: }
2642: if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
2643: }else{
1.13 ! jturner 2644: azArg[nArg++] = &zLine[h];
! 2645: while( zLine[h] && !IsSpace(zLine[h]) ){ h++; }
! 2646: if( zLine[h] ) zLine[h++] = 0;
1.1 espie 2647: resolve_backslashes(azArg[nArg-1]);
2648: }
2649: }
2650:
2651: /* Process the input line.
2652: */
2653: if( nArg==0 ) return 0; /* no tokens, no error */
2654: n = strlen30(azArg[0]);
2655: c = azArg[0][0];
1.8 jturner 2656: if( (c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0)
2657: || (c=='s' && n>=3 && strncmp(azArg[0], "save", n)==0)
2658: ){
1.6 landry 2659: const char *zDestFile = 0;
2660: const char *zDb = 0;
1.1 espie 2661: sqlite3 *pDest;
2662: sqlite3_backup *pBackup;
1.6 landry 2663: int j;
2664: for(j=1; j<nArg; j++){
2665: const char *z = azArg[j];
2666: if( z[0]=='-' ){
2667: while( z[0]=='-' ) z++;
1.7 jturner 2668: /* No options to process at this time */
1.6 landry 2669: {
2670: fprintf(stderr, "unknown option: %s\n", azArg[j]);
2671: return 1;
2672: }
2673: }else if( zDestFile==0 ){
2674: zDestFile = azArg[j];
2675: }else if( zDb==0 ){
2676: zDb = zDestFile;
2677: zDestFile = azArg[j];
2678: }else{
2679: fprintf(stderr, "too many arguments to .backup\n");
2680: return 1;
2681: }
2682: }
2683: if( zDestFile==0 ){
2684: fprintf(stderr, "missing FILENAME argument on .backup\n");
2685: return 1;
1.1 espie 2686: }
1.6 landry 2687: if( zDb==0 ) zDb = "main";
1.1 espie 2688: rc = sqlite3_open(zDestFile, &pDest);
2689: if( rc!=SQLITE_OK ){
2690: fprintf(stderr, "Error: cannot open \"%s\"\n", zDestFile);
2691: sqlite3_close(pDest);
2692: return 1;
2693: }
1.8 jturner 2694: open_db(p, 0);
1.1 espie 2695: pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
2696: if( pBackup==0 ){
2697: fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
2698: sqlite3_close(pDest);
2699: return 1;
2700: }
2701: while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
2702: sqlite3_backup_finish(pBackup);
2703: if( rc==SQLITE_DONE ){
2704: rc = 0;
2705: }else{
2706: fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
2707: rc = 1;
2708: }
2709: sqlite3_close(pDest);
2710: }else
2711:
1.9 jturner 2712: if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 ){
2713: if( nArg==2 ){
2714: bail_on_error = booleanValue(azArg[1]);
2715: }else{
2716: fprintf(stderr, "Usage: .bail on|off\n");
2717: rc = 1;
2718: }
1.1 espie 2719: }else
2720:
1.13 ! jturner 2721: if( c=='b' && n>=3 && strncmp(azArg[0], "binary", n)==0 ){
! 2722: if( nArg==2 ){
! 2723: if( booleanValue(azArg[1]) ){
! 2724: setBinaryMode(p->out);
! 2725: }else{
! 2726: setTextMode(p->out);
! 2727: }
! 2728: }else{
! 2729: fprintf(stderr, "Usage: .binary on|off\n");
! 2730: rc = 1;
! 2731: }
! 2732: }else
! 2733:
1.2 espie 2734: /* The undocumented ".breakpoint" command causes a call to the no-op
2735: ** routine named test_breakpoint().
2736: */
2737: if( c=='b' && n>=3 && strncmp(azArg[0], "breakpoint", n)==0 ){
2738: test_breakpoint();
2739: }else
2740:
1.9 jturner 2741: if( c=='c' && strncmp(azArg[0], "clone", n)==0 ){
2742: if( nArg==2 ){
2743: tryToClone(p, azArg[1]);
2744: }else{
2745: fprintf(stderr, "Usage: .clone FILENAME\n");
2746: rc = 1;
2747: }
1.8 jturner 2748: }else
2749:
1.9 jturner 2750: if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){
1.10 jturner 2751: ShellState data;
1.1 espie 2752: char *zErrMsg = 0;
1.8 jturner 2753: open_db(p, 0);
1.1 espie 2754: memcpy(&data, p, sizeof(data));
2755: data.showHeader = 1;
2756: data.mode = MODE_Column;
2757: data.colWidth[0] = 3;
2758: data.colWidth[1] = 15;
2759: data.colWidth[2] = 58;
2760: data.cnt = 0;
2761: sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg);
2762: if( zErrMsg ){
2763: fprintf(stderr,"Error: %s\n", zErrMsg);
2764: sqlite3_free(zErrMsg);
2765: rc = 1;
2766: }
2767: }else
2768:
1.12 jturner 2769: if( c=='d' && strncmp(azArg[0], "dbinfo", n)==0 ){
2770: rc = shell_dbinfo_command(p, nArg, azArg);
2771: }else
2772:
1.9 jturner 2773: if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
1.8 jturner 2774: open_db(p, 0);
1.1 espie 2775: /* When playing back a "dump", the content might appear in an order
2776: ** which causes immediate foreign key constraints to be violated.
2777: ** So disable foreign-key constraint enforcement to prevent problems. */
1.9 jturner 2778: if( nArg!=1 && nArg!=2 ){
2779: fprintf(stderr, "Usage: .dump ?LIKE-PATTERN?\n");
2780: rc = 1;
2781: goto meta_command_exit;
2782: }
1.1 espie 2783: fprintf(p->out, "PRAGMA foreign_keys=OFF;\n");
2784: fprintf(p->out, "BEGIN TRANSACTION;\n");
2785: p->writableSchema = 0;
2786: sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
2787: p->nErr = 0;
2788: if( nArg==1 ){
2789: run_schema_dump_query(p,
2790: "SELECT name, type, sql FROM sqlite_master "
2791: "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
2792: );
2793: run_schema_dump_query(p,
2794: "SELECT name, type, sql FROM sqlite_master "
2795: "WHERE name=='sqlite_sequence'"
2796: );
2797: run_table_dump_query(p,
2798: "SELECT sql FROM sqlite_master "
2799: "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
2800: );
2801: }else{
2802: int i;
2803: for(i=1; i<nArg; i++){
2804: zShellStatic = azArg[i];
2805: run_schema_dump_query(p,
2806: "SELECT name, type, sql FROM sqlite_master "
2807: "WHERE tbl_name LIKE shellstatic() AND type=='table'"
2808: " AND sql NOT NULL");
2809: run_table_dump_query(p,
2810: "SELECT sql FROM sqlite_master "
2811: "WHERE sql NOT NULL"
2812: " AND type IN ('index','trigger','view')"
2813: " AND tbl_name LIKE shellstatic()", 0
2814: );
2815: zShellStatic = 0;
2816: }
2817: }
2818: if( p->writableSchema ){
2819: fprintf(p->out, "PRAGMA writable_schema=OFF;\n");
2820: p->writableSchema = 0;
2821: }
2822: sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
2823: sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0);
2824: fprintf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
2825: }else
2826:
1.9 jturner 2827: if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){
2828: if( nArg==2 ){
2829: p->echoOn = booleanValue(azArg[1]);
2830: }else{
2831: fprintf(stderr, "Usage: .echo on|off\n");
2832: rc = 1;
2833: }
1.1 espie 2834: }else
2835:
1.9 jturner 2836: if( c=='e' && strncmp(azArg[0], "eqp", n)==0 ){
2837: if( nArg==2 ){
2838: p->autoEQP = booleanValue(azArg[1]);
2839: }else{
2840: fprintf(stderr, "Usage: .eqp on|off\n");
2841: rc = 1;
2842: }
1.8 jturner 2843: }else
2844:
1.6 landry 2845: if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){
1.7 jturner 2846: if( nArg>1 && (rc = (int)integerValue(azArg[1]))!=0 ) exit(rc);
1.1 espie 2847: rc = 2;
2848: }else
2849:
1.9 jturner 2850: if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){
1.1 espie 2851: int val = nArg>=2 ? booleanValue(azArg[1]) : 1;
2852: if(val == 1) {
1.10 jturner 2853: if(!p->normalMode.valid) {
2854: p->normalMode.valid = 1;
2855: p->normalMode.mode = p->mode;
2856: p->normalMode.showHeader = p->showHeader;
2857: memcpy(p->normalMode.colWidth,p->colWidth,sizeof(p->colWidth));
1.1 espie 2858: }
2859: /* We could put this code under the !p->explainValid
2860: ** condition so that it does not execute if we are already in
2861: ** explain mode. However, always executing it allows us an easy
2862: ** was to reset to explain mode in case the user previously
2863: ** did an .explain followed by a .width, .mode or .header
2864: ** command.
2865: */
2866: p->mode = MODE_Explain;
2867: p->showHeader = 1;
1.8 jturner 2868: memset(p->colWidth,0,sizeof(p->colWidth));
1.1 espie 2869: p->colWidth[0] = 4; /* addr */
2870: p->colWidth[1] = 13; /* opcode */
2871: p->colWidth[2] = 4; /* P1 */
2872: p->colWidth[3] = 4; /* P2 */
2873: p->colWidth[4] = 4; /* P3 */
2874: p->colWidth[5] = 13; /* P4 */
2875: p->colWidth[6] = 2; /* P5 */
2876: p->colWidth[7] = 13; /* Comment */
1.10 jturner 2877: }else if (p->normalMode.valid) {
2878: p->normalMode.valid = 0;
2879: p->mode = p->normalMode.mode;
2880: p->showHeader = p->normalMode.showHeader;
2881: memcpy(p->colWidth,p->normalMode.colWidth,sizeof(p->colWidth));
1.1 espie 2882: }
2883: }else
2884:
1.9 jturner 2885: if( c=='f' && strncmp(azArg[0], "fullschema", n)==0 ){
1.10 jturner 2886: ShellState data;
1.9 jturner 2887: char *zErrMsg = 0;
2888: int doStats = 0;
2889: if( nArg!=1 ){
2890: fprintf(stderr, "Usage: .fullschema\n");
2891: rc = 1;
2892: goto meta_command_exit;
2893: }
2894: open_db(p, 0);
2895: memcpy(&data, p, sizeof(data));
2896: data.showHeader = 0;
2897: data.mode = MODE_Semi;
2898: rc = sqlite3_exec(p->db,
2899: "SELECT sql FROM"
2900: " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
2901: " FROM sqlite_master UNION ALL"
2902: " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
1.10 jturner 2903: "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
1.9 jturner 2904: "ORDER BY rowid",
2905: callback, &data, &zErrMsg
2906: );
2907: if( rc==SQLITE_OK ){
2908: sqlite3_stmt *pStmt;
2909: rc = sqlite3_prepare_v2(p->db,
2910: "SELECT rowid FROM sqlite_master"
2911: " WHERE name GLOB 'sqlite_stat[134]'",
2912: -1, &pStmt, 0);
2913: doStats = sqlite3_step(pStmt)==SQLITE_ROW;
2914: sqlite3_finalize(pStmt);
2915: }
2916: if( doStats==0 ){
2917: fprintf(p->out, "/* No STAT tables available */\n");
2918: }else{
2919: fprintf(p->out, "ANALYZE sqlite_master;\n");
2920: sqlite3_exec(p->db, "SELECT 'ANALYZE sqlite_master'",
2921: callback, &data, &zErrMsg);
2922: data.mode = MODE_Insert;
2923: data.zDestTable = "sqlite_stat1";
2924: shell_exec(p->db, "SELECT * FROM sqlite_stat1",
2925: shell_callback, &data,&zErrMsg);
2926: data.zDestTable = "sqlite_stat3";
2927: shell_exec(p->db, "SELECT * FROM sqlite_stat3",
2928: shell_callback, &data,&zErrMsg);
2929: data.zDestTable = "sqlite_stat4";
2930: shell_exec(p->db, "SELECT * FROM sqlite_stat4",
2931: shell_callback, &data, &zErrMsg);
2932: fprintf(p->out, "ANALYZE sqlite_master;\n");
2933: }
2934: }else
2935:
2936: if( c=='h' && strncmp(azArg[0], "headers", n)==0 ){
2937: if( nArg==2 ){
2938: p->showHeader = booleanValue(azArg[1]);
2939: }else{
2940: fprintf(stderr, "Usage: .headers on|off\n");
2941: rc = 1;
2942: }
1.1 espie 2943: }else
2944:
2945: if( c=='h' && strncmp(azArg[0], "help", n)==0 ){
1.9 jturner 2946: fprintf(p->out, "%s", zHelp);
1.1 espie 2947: }else
2948:
1.9 jturner 2949: if( c=='i' && strncmp(azArg[0], "import", n)==0 ){
2950: char *zTable; /* Insert data into this table */
2951: char *zFile; /* Name of file to extra content from */
1.1 espie 2952: sqlite3_stmt *pStmt = NULL; /* A statement */
2953: int nCol; /* Number of columns in the table */
2954: int nByte; /* Number of bytes in an SQL string */
2955: int i, j; /* Loop counters */
1.7 jturner 2956: int needCommit; /* True to COMMIT or ROLLBACK at end */
1.11 jturner 2957: int nSep; /* Number of bytes in p->colSeparator[] */
1.1 espie 2958: char *zSql; /* An SQL statement */
1.11 jturner 2959: ImportCtx sCtx; /* Reader context */
1.12 jturner 2960: char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */
2961: int (SQLITE_CDECL *xCloser)(FILE*); /* Func to close file */
1.1 espie 2962:
1.9 jturner 2963: if( nArg!=3 ){
2964: fprintf(stderr, "Usage: .import FILE TABLE\n");
2965: goto meta_command_exit;
2966: }
2967: zFile = azArg[1];
2968: zTable = azArg[2];
1.7 jturner 2969: seenInterrupt = 0;
1.11 jturner 2970: memset(&sCtx, 0, sizeof(sCtx));
1.8 jturner 2971: open_db(p, 0);
1.11 jturner 2972: nSep = strlen30(p->colSeparator);
1.1 espie 2973: if( nSep==0 ){
1.11 jturner 2974: fprintf(stderr, "Error: non-null column separator required for import\n");
1.1 espie 2975: return 1;
2976: }
1.7 jturner 2977: if( nSep>1 ){
1.11 jturner 2978: fprintf(stderr, "Error: multi-character column separators not allowed"
1.7 jturner 2979: " for import\n");
2980: return 1;
2981: }
1.11 jturner 2982: nSep = strlen30(p->rowSeparator);
2983: if( nSep==0 ){
2984: fprintf(stderr, "Error: non-null row separator required for import\n");
2985: return 1;
2986: }
2987: if( nSep==2 && p->mode==MODE_Csv && strcmp(p->rowSeparator, SEP_CrLf)==0 ){
2988: /* When importing CSV (only), if the row separator is set to the
2989: ** default output row separator, change it to the default input
2990: ** row separator. This avoids having to maintain different input
2991: ** and output row separators. */
2992: sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
2993: nSep = strlen30(p->rowSeparator);
2994: }
2995: if( nSep>1 ){
2996: fprintf(stderr, "Error: multi-character row separators not allowed"
2997: " for import\n");
2998: return 1;
2999: }
3000: sCtx.zFile = zFile;
3001: sCtx.nLine = 1;
3002: if( sCtx.zFile[0]=='|' ){
1.12 jturner 3003: #ifdef SQLITE_OMIT_POPEN
3004: fprintf(stderr, "Error: pipes are not supported in this OS\n");
3005: return 1;
3006: #else
1.11 jturner 3007: sCtx.in = popen(sCtx.zFile+1, "r");
3008: sCtx.zFile = "<pipe>";
1.7 jturner 3009: xCloser = pclose;
1.12 jturner 3010: #endif
1.7 jturner 3011: }else{
1.11 jturner 3012: sCtx.in = fopen(sCtx.zFile, "rb");
1.7 jturner 3013: xCloser = fclose;
3014: }
1.11 jturner 3015: if( p->mode==MODE_Ascii ){
3016: xRead = ascii_read_one_field;
3017: }else{
3018: xRead = csv_read_one_field;
3019: }
3020: if( sCtx.in==0 ){
1.7 jturner 3021: fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
3022: return 1;
3023: }
1.11 jturner 3024: sCtx.cColSep = p->colSeparator[0];
3025: sCtx.cRowSep = p->rowSeparator[0];
1.1 espie 3026: zSql = sqlite3_mprintf("SELECT * FROM %s", zTable);
3027: if( zSql==0 ){
3028: fprintf(stderr, "Error: out of memory\n");
1.11 jturner 3029: xCloser(sCtx.in);
1.1 espie 3030: return 1;
3031: }
3032: nByte = strlen30(zSql);
1.8 jturner 3033: rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
1.11 jturner 3034: import_append_char(&sCtx, 0); /* To ensure sCtx.z is allocated */
1.13 ! jturner 3035: if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(p->db))==0 ){
1.7 jturner 3036: char *zCreate = sqlite3_mprintf("CREATE TABLE %s", zTable);
3037: char cSep = '(';
1.11 jturner 3038: while( xRead(&sCtx) ){
3039: zCreate = sqlite3_mprintf("%z%c\n \"%s\" TEXT", zCreate, cSep, sCtx.z);
1.7 jturner 3040: cSep = ',';
1.11 jturner 3041: if( sCtx.cTerm!=sCtx.cColSep ) break;
1.7 jturner 3042: }
3043: if( cSep=='(' ){
3044: sqlite3_free(zCreate);
1.11 jturner 3045: sqlite3_free(sCtx.z);
3046: xCloser(sCtx.in);
3047: fprintf(stderr,"%s: empty file\n", sCtx.zFile);
1.7 jturner 3048: return 1;
3049: }
3050: zCreate = sqlite3_mprintf("%z\n)", zCreate);
3051: rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
3052: sqlite3_free(zCreate);
3053: if( rc ){
3054: fprintf(stderr, "CREATE TABLE %s(...) failed: %s\n", zTable,
1.13 ! jturner 3055: sqlite3_errmsg(p->db));
1.11 jturner 3056: sqlite3_free(sCtx.z);
3057: xCloser(sCtx.in);
1.7 jturner 3058: return 1;
3059: }
1.8 jturner 3060: rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
1.7 jturner 3061: }
1.1 espie 3062: sqlite3_free(zSql);
3063: if( rc ){
3064: if (pStmt) sqlite3_finalize(pStmt);
1.13 ! jturner 3065: fprintf(stderr,"Error: %s\n", sqlite3_errmsg(p->db));
1.11 jturner 3066: xCloser(sCtx.in);
1.1 espie 3067: return 1;
3068: }
3069: nCol = sqlite3_column_count(pStmt);
3070: sqlite3_finalize(pStmt);
3071: pStmt = 0;
3072: if( nCol==0 ) return 0; /* no columns, no error */
1.13 ! jturner 3073: zSql = sqlite3_malloc64( nByte*2 + 20 + nCol*2 );
1.1 espie 3074: if( zSql==0 ){
3075: fprintf(stderr, "Error: out of memory\n");
1.11 jturner 3076: xCloser(sCtx.in);
1.1 espie 3077: return 1;
3078: }
1.7 jturner 3079: sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable);
1.1 espie 3080: j = strlen30(zSql);
3081: for(i=1; i<nCol; i++){
3082: zSql[j++] = ',';
3083: zSql[j++] = '?';
3084: }
3085: zSql[j++] = ')';
3086: zSql[j] = 0;
1.8 jturner 3087: rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
1.7 jturner 3088: sqlite3_free(zSql);
1.1 espie 3089: if( rc ){
1.13 ! jturner 3090: fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
1.1 espie 3091: if (pStmt) sqlite3_finalize(pStmt);
1.11 jturner 3092: xCloser(sCtx.in);
1.1 espie 3093: return 1;
3094: }
1.13 ! jturner 3095: needCommit = sqlite3_get_autocommit(p->db);
! 3096: if( needCommit ) sqlite3_exec(p->db, "BEGIN", 0, 0, 0);
1.7 jturner 3097: do{
1.11 jturner 3098: int startLine = sCtx.nLine;
1.7 jturner 3099: for(i=0; i<nCol; i++){
1.11 jturner 3100: char *z = xRead(&sCtx);
3101: /*
3102: ** Did we reach end-of-file before finding any columns?
3103: ** If so, stop instead of NULL filling the remaining columns.
3104: */
1.7 jturner 3105: if( z==0 && i==0 ) break;
1.11 jturner 3106: /*
3107: ** Did we reach end-of-file OR end-of-line before finding any
3108: ** columns in ASCII mode? If so, stop instead of NULL filling
3109: ** the remaining columns.
3110: */
3111: if( p->mode==MODE_Ascii && (z==0 || z[0]==0) && i==0 ) break;
1.7 jturner 3112: sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT);
1.11 jturner 3113: if( i<nCol-1 && sCtx.cTerm!=sCtx.cColSep ){
1.7 jturner 3114: fprintf(stderr, "%s:%d: expected %d columns but found %d - "
3115: "filling the rest with NULL\n",
1.11 jturner 3116: sCtx.zFile, startLine, nCol, i+1);
1.12 jturner 3117: i += 2;
1.9 jturner 3118: while( i<=nCol ){ sqlite3_bind_null(pStmt, i); i++; }
1.1 espie 3119: }
3120: }
1.11 jturner 3121: if( sCtx.cTerm==sCtx.cColSep ){
1.7 jturner 3122: do{
1.11 jturner 3123: xRead(&sCtx);
1.7 jturner 3124: i++;
1.11 jturner 3125: }while( sCtx.cTerm==sCtx.cColSep );
1.7 jturner 3126: fprintf(stderr, "%s:%d: expected %d columns but found %d - "
3127: "extras ignored\n",
1.11 jturner 3128: sCtx.zFile, startLine, nCol, i);
1.7 jturner 3129: }
3130: if( i>=nCol ){
3131: sqlite3_step(pStmt);
3132: rc = sqlite3_reset(pStmt);
3133: if( rc!=SQLITE_OK ){
1.11 jturner 3134: fprintf(stderr, "%s:%d: INSERT failed: %s\n", sCtx.zFile, startLine,
1.13 ! jturner 3135: sqlite3_errmsg(p->db));
1.1 espie 3136: }
3137: }
1.11 jturner 3138: }while( sCtx.cTerm!=EOF );
1.7 jturner 3139:
1.11 jturner 3140: xCloser(sCtx.in);
3141: sqlite3_free(sCtx.z);
1.1 espie 3142: sqlite3_finalize(pStmt);
1.13 ! jturner 3143: if( needCommit ) sqlite3_exec(p->db, "COMMIT", 0, 0, 0);
1.1 espie 3144: }else
3145:
1.12 jturner 3146: if( c=='i' && (strncmp(azArg[0], "indices", n)==0
3147: || strncmp(azArg[0], "indexes", n)==0) ){
1.10 jturner 3148: ShellState data;
1.1 espie 3149: char *zErrMsg = 0;
1.8 jturner 3150: open_db(p, 0);
1.1 espie 3151: memcpy(&data, p, sizeof(data));
3152: data.showHeader = 0;
3153: data.mode = MODE_List;
3154: if( nArg==1 ){
3155: rc = sqlite3_exec(p->db,
3156: "SELECT name FROM sqlite_master "
3157: "WHERE type='index' AND name NOT LIKE 'sqlite_%' "
3158: "UNION ALL "
3159: "SELECT name FROM sqlite_temp_master "
3160: "WHERE type='index' "
3161: "ORDER BY 1",
3162: callback, &data, &zErrMsg
3163: );
1.9 jturner 3164: }else if( nArg==2 ){
1.1 espie 3165: zShellStatic = azArg[1];
3166: rc = sqlite3_exec(p->db,
3167: "SELECT name FROM sqlite_master "
3168: "WHERE type='index' AND tbl_name LIKE shellstatic() "
3169: "UNION ALL "
3170: "SELECT name FROM sqlite_temp_master "
3171: "WHERE type='index' AND tbl_name LIKE shellstatic() "
3172: "ORDER BY 1",
3173: callback, &data, &zErrMsg
3174: );
3175: zShellStatic = 0;
1.9 jturner 3176: }else{
1.12 jturner 3177: fprintf(stderr, "Usage: .indexes ?LIKE-PATTERN?\n");
1.9 jturner 3178: rc = 1;
3179: goto meta_command_exit;
1.1 espie 3180: }
3181: if( zErrMsg ){
3182: fprintf(stderr,"Error: %s\n", zErrMsg);
3183: sqlite3_free(zErrMsg);
3184: rc = 1;
3185: }else if( rc != SQLITE_OK ){
3186: fprintf(stderr,"Error: querying sqlite_master and sqlite_temp_master\n");
3187: rc = 1;
3188: }
3189: }else
3190:
3191: #ifdef SQLITE_ENABLE_IOTRACE
3192: if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){
1.12 jturner 3193: SQLITE_API extern void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...);
1.1 espie 3194: if( iotrace && iotrace!=stdout ) fclose(iotrace);
3195: iotrace = 0;
3196: if( nArg<2 ){
3197: sqlite3IoTrace = 0;
3198: }else if( strcmp(azArg[1], "-")==0 ){
3199: sqlite3IoTrace = iotracePrintf;
3200: iotrace = stdout;
3201: }else{
3202: iotrace = fopen(azArg[1], "w");
3203: if( iotrace==0 ){
3204: fprintf(stderr, "Error: cannot open \"%s\"\n", azArg[1]);
3205: sqlite3IoTrace = 0;
3206: rc = 1;
3207: }else{
3208: sqlite3IoTrace = iotracePrintf;
3209: }
3210: }
3211: }else
3212: #endif
1.13 ! jturner 3213: if( c=='l' && n>=5 && strncmp(azArg[0], "limits", n)==0 ){
! 3214: static const struct {
! 3215: const char *zLimitName; /* Name of a limit */
! 3216: int limitCode; /* Integer code for that limit */
! 3217: } aLimit[] = {
! 3218: { "length", SQLITE_LIMIT_LENGTH },
! 3219: { "sql_length", SQLITE_LIMIT_SQL_LENGTH },
! 3220: { "column", SQLITE_LIMIT_COLUMN },
! 3221: { "expr_depth", SQLITE_LIMIT_EXPR_DEPTH },
! 3222: { "compound_select", SQLITE_LIMIT_COMPOUND_SELECT },
! 3223: { "vdbe_op", SQLITE_LIMIT_VDBE_OP },
! 3224: { "function_arg", SQLITE_LIMIT_FUNCTION_ARG },
! 3225: { "attached", SQLITE_LIMIT_ATTACHED },
! 3226: { "like_pattern_length", SQLITE_LIMIT_LIKE_PATTERN_LENGTH },
! 3227: { "variable_number", SQLITE_LIMIT_VARIABLE_NUMBER },
! 3228: { "trigger_depth", SQLITE_LIMIT_TRIGGER_DEPTH },
! 3229: { "worker_threads", SQLITE_LIMIT_WORKER_THREADS },
! 3230: };
! 3231: int i, n2;
! 3232: open_db(p, 0);
! 3233: if( nArg==1 ){
! 3234: for(i=0; i<ArraySize(aLimit); i++){
! 3235: printf("%20s %d\n", aLimit[i].zLimitName,
! 3236: sqlite3_limit(p->db, aLimit[i].limitCode, -1));
! 3237: }
! 3238: }else if( nArg>3 ){
! 3239: fprintf(stderr, "Usage: .limit NAME ?NEW-VALUE?\n");
! 3240: rc = 1;
! 3241: goto meta_command_exit;
! 3242: }else{
! 3243: int iLimit = -1;
! 3244: n2 = strlen30(azArg[1]);
! 3245: for(i=0; i<ArraySize(aLimit); i++){
! 3246: if( sqlite3_strnicmp(aLimit[i].zLimitName, azArg[1], n2)==0 ){
! 3247: if( iLimit<0 ){
! 3248: iLimit = i;
! 3249: }else{
! 3250: fprintf(stderr, "ambiguous limit: \"%s\"\n", azArg[1]);
! 3251: rc = 1;
! 3252: goto meta_command_exit;
! 3253: }
! 3254: }
! 3255: }
! 3256: if( iLimit<0 ){
! 3257: fprintf(stderr, "unknown limit: \"%s\"\n"
! 3258: "enter \".limits\" with no arguments for a list.\n",
! 3259: azArg[1]);
! 3260: rc = 1;
! 3261: goto meta_command_exit;
! 3262: }
! 3263: if( nArg==3 ){
! 3264: sqlite3_limit(p->db, aLimit[iLimit].limitCode,
! 3265: (int)integerValue(azArg[2]));
! 3266: }
! 3267: printf("%20s %d\n", aLimit[iLimit].zLimitName,
! 3268: sqlite3_limit(p->db, aLimit[iLimit].limitCode, -1));
! 3269: }
! 3270: }else
1.1 espie 3271:
3272: #ifndef SQLITE_OMIT_LOAD_EXTENSION
1.9 jturner 3273: if( c=='l' && strncmp(azArg[0], "load", n)==0 ){
1.1 espie 3274: const char *zFile, *zProc;
3275: char *zErrMsg = 0;
1.9 jturner 3276: if( nArg<2 ){
3277: fprintf(stderr, "Usage: .load FILE ?ENTRYPOINT?\n");
3278: rc = 1;
3279: goto meta_command_exit;
3280: }
1.1 espie 3281: zFile = azArg[1];
3282: zProc = nArg>=3 ? azArg[2] : 0;
1.8 jturner 3283: open_db(p, 0);
1.1 espie 3284: rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
3285: if( rc!=SQLITE_OK ){
3286: fprintf(stderr, "Error: %s\n", zErrMsg);
3287: sqlite3_free(zErrMsg);
3288: rc = 1;
3289: }
3290: }else
3291: #endif
3292:
1.9 jturner 3293: if( c=='l' && strncmp(azArg[0], "log", n)==0 ){
3294: if( nArg!=2 ){
3295: fprintf(stderr, "Usage: .log FILENAME\n");
3296: rc = 1;
3297: }else{
3298: const char *zFile = azArg[1];
3299: output_file_close(p->pLog);
3300: p->pLog = output_file_open(zFile);
3301: }
1.1 espie 3302: }else
3303:
1.9 jturner 3304: if( c=='m' && strncmp(azArg[0], "mode", n)==0 ){
3305: const char *zMode = nArg>=2 ? azArg[1] : "";
3306: int n2 = (int)strlen(zMode);
3307: int c2 = zMode[0];
3308: if( c2=='l' && n2>2 && strncmp(azArg[1],"lines",n2)==0 ){
1.1 espie 3309: p->mode = MODE_Line;
1.9 jturner 3310: }else if( c2=='c' && strncmp(azArg[1],"columns",n2)==0 ){
1.1 espie 3311: p->mode = MODE_Column;
1.9 jturner 3312: }else if( c2=='l' && n2>2 && strncmp(azArg[1],"list",n2)==0 ){
1.1 espie 3313: p->mode = MODE_List;
1.9 jturner 3314: }else if( c2=='h' && strncmp(azArg[1],"html",n2)==0 ){
1.1 espie 3315: p->mode = MODE_Html;
1.9 jturner 3316: }else if( c2=='t' && strncmp(azArg[1],"tcl",n2)==0 ){
1.1 espie 3317: p->mode = MODE_Tcl;
1.11 jturner 3318: sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Space);
1.9 jturner 3319: }else if( c2=='c' && strncmp(azArg[1],"csv",n2)==0 ){
1.1 espie 3320: p->mode = MODE_Csv;
1.11 jturner 3321: sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma);
3322: sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf);
1.9 jturner 3323: }else if( c2=='t' && strncmp(azArg[1],"tabs",n2)==0 ){
1.1 espie 3324: p->mode = MODE_List;
1.11 jturner 3325: sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Tab);
1.9 jturner 3326: }else if( c2=='i' && strncmp(azArg[1],"insert",n2)==0 ){
1.1 espie 3327: p->mode = MODE_Insert;
1.9 jturner 3328: set_table_name(p, nArg>=3 ? azArg[2] : "table");
1.11 jturner 3329: }else if( c2=='a' && strncmp(azArg[1],"ascii",n2)==0 ){
3330: p->mode = MODE_Ascii;
3331: sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Unit);
3332: sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Record);
1.1 espie 3333: }else {
3334: fprintf(stderr,"Error: mode should be one of: "
1.11 jturner 3335: "ascii column csv html insert line list tabs tcl\n");
1.1 espie 3336: rc = 1;
3337: }
3338: }else
3339:
1.9 jturner 3340: if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 ){
3341: if( nArg==2 ){
1.11 jturner 3342: sqlite3_snprintf(sizeof(p->nullValue), p->nullValue,
3343: "%.*s", (int)ArraySize(p->nullValue)-1, azArg[1]);
1.9 jturner 3344: }else{
3345: fprintf(stderr, "Usage: .nullvalue STRING\n");
1.1 espie 3346: rc = 1;
3347: }
3348: }else
3349:
1.8 jturner 3350: if( c=='o' && strncmp(azArg[0], "open", n)==0 && n>=2 ){
3351: sqlite3 *savedDb = p->db;
3352: const char *zSavedFilename = p->zDbFilename;
3353: char *zNewFilename = 0;
3354: p->db = 0;
1.13 ! jturner 3355: if( nArg>=2 ) zNewFilename = sqlite3_mprintf("%s", azArg[1]);
! 3356: p->zDbFilename = zNewFilename;
1.8 jturner 3357: open_db(p, 1);
3358: if( p->db!=0 ){
3359: sqlite3_close(savedDb);
3360: sqlite3_free(p->zFreeOnClose);
3361: p->zFreeOnClose = zNewFilename;
3362: }else{
3363: sqlite3_free(zNewFilename);
3364: p->db = savedDb;
3365: p->zDbFilename = zSavedFilename;
3366: }
3367: }else
3368:
1.9 jturner 3369: if( c=='o'
3370: && (strncmp(azArg[0], "output", n)==0 || strncmp(azArg[0], "once", n)==0)
3371: ){
3372: const char *zFile = nArg>=2 ? azArg[1] : "stdout";
3373: if( nArg>2 ){
3374: fprintf(stderr, "Usage: .%s FILE\n", azArg[0]);
3375: rc = 1;
3376: goto meta_command_exit;
3377: }
3378: if( n>1 && strncmp(azArg[0], "once", n)==0 ){
3379: if( nArg<2 ){
3380: fprintf(stderr, "Usage: .once FILE\n");
3381: rc = 1;
3382: goto meta_command_exit;
3383: }
3384: p->outCount = 2;
3385: }else{
3386: p->outCount = 0;
3387: }
3388: output_reset(p);
3389: if( zFile[0]=='|' ){
1.12 jturner 3390: #ifdef SQLITE_OMIT_POPEN
3391: fprintf(stderr,"Error: pipes are not supported in this OS\n");
3392: rc = 1;
3393: p->out = stdout;
3394: #else
1.9 jturner 3395: p->out = popen(zFile + 1, "w");
1.2 espie 3396: if( p->out==0 ){
1.9 jturner 3397: fprintf(stderr,"Error: cannot open pipe \"%s\"\n", zFile + 1);
1.2 espie 3398: p->out = stdout;
3399: rc = 1;
3400: }else{
1.9 jturner 3401: sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
1.2 espie 3402: }
1.12 jturner 3403: #endif
1.1 espie 3404: }else{
1.9 jturner 3405: p->out = output_file_open(zFile);
1.1 espie 3406: if( p->out==0 ){
1.9 jturner 3407: if( strcmp(zFile,"off")!=0 ){
3408: fprintf(stderr,"Error: cannot write to \"%s\"\n", zFile);
1.2 espie 3409: }
1.1 espie 3410: p->out = stdout;
3411: rc = 1;
3412: } else {
1.9 jturner 3413: sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
1.1 espie 3414: }
3415: }
3416: }else
3417:
1.5 espie 3418: if( c=='p' && n>=3 && strncmp(azArg[0], "print", n)==0 ){
3419: int i;
3420: for(i=1; i<nArg; i++){
3421: if( i>1 ) fprintf(p->out, " ");
3422: fprintf(p->out, "%s", azArg[i]);
3423: }
3424: fprintf(p->out, "\n");
3425: }else
3426:
1.9 jturner 3427: if( c=='p' && strncmp(azArg[0], "prompt", n)==0 ){
1.1 espie 3428: if( nArg >= 2) {
3429: strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
3430: }
3431: if( nArg >= 3) {
3432: strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
3433: }
3434: }else
3435:
1.9 jturner 3436: if( c=='q' && strncmp(azArg[0], "quit", n)==0 ){
1.1 espie 3437: rc = 2;
3438: }else
3439:
1.9 jturner 3440: if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 ){
3441: FILE *alt;
3442: if( nArg!=2 ){
3443: fprintf(stderr, "Usage: .read FILE\n");
3444: rc = 1;
3445: goto meta_command_exit;
3446: }
3447: alt = fopen(azArg[1], "rb");
1.1 espie 3448: if( alt==0 ){
3449: fprintf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
3450: rc = 1;
3451: }else{
3452: rc = process_input(p, alt);
3453: fclose(alt);
3454: }
3455: }else
3456:
1.9 jturner 3457: if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 ){
1.1 espie 3458: const char *zSrcFile;
3459: const char *zDb;
3460: sqlite3 *pSrc;
3461: sqlite3_backup *pBackup;
3462: int nTimeout = 0;
3463:
3464: if( nArg==2 ){
3465: zSrcFile = azArg[1];
3466: zDb = "main";
1.9 jturner 3467: }else if( nArg==3 ){
1.1 espie 3468: zSrcFile = azArg[2];
3469: zDb = azArg[1];
1.9 jturner 3470: }else{
3471: fprintf(stderr, "Usage: .restore ?DB? FILE\n");
3472: rc = 1;
3473: goto meta_command_exit;
1.1 espie 3474: }
3475: rc = sqlite3_open(zSrcFile, &pSrc);
3476: if( rc!=SQLITE_OK ){
3477: fprintf(stderr, "Error: cannot open \"%s\"\n", zSrcFile);
3478: sqlite3_close(pSrc);
3479: return 1;
3480: }
1.8 jturner 3481: open_db(p, 0);
1.1 espie 3482: pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
3483: if( pBackup==0 ){
3484: fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
3485: sqlite3_close(pSrc);
3486: return 1;
3487: }
3488: while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
3489: || rc==SQLITE_BUSY ){
3490: if( rc==SQLITE_BUSY ){
3491: if( nTimeout++ >= 3 ) break;
3492: sqlite3_sleep(100);
3493: }
3494: }
3495: sqlite3_backup_finish(pBackup);
3496: if( rc==SQLITE_DONE ){
3497: rc = 0;
3498: }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){
3499: fprintf(stderr, "Error: source database is busy\n");
3500: rc = 1;
3501: }else{
3502: fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
3503: rc = 1;
3504: }
3505: sqlite3_close(pSrc);
3506: }else
3507:
1.11 jturner 3508:
3509: if( c=='s' && strncmp(azArg[0], "scanstats", n)==0 ){
3510: if( nArg==2 ){
3511: p->scanstatsOn = booleanValue(azArg[1]);
3512: #ifndef SQLITE_ENABLE_STMT_SCANSTATUS
3513: fprintf(stderr, "Warning: .scanstats not available in this build.\n");
3514: #endif
3515: }else{
3516: fprintf(stderr, "Usage: .scanstats on|off\n");
3517: rc = 1;
3518: }
3519: }else
3520:
1.9 jturner 3521: if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){
1.10 jturner 3522: ShellState data;
1.1 espie 3523: char *zErrMsg = 0;
1.8 jturner 3524: open_db(p, 0);
1.1 espie 3525: memcpy(&data, p, sizeof(data));
3526: data.showHeader = 0;
3527: data.mode = MODE_Semi;
1.9 jturner 3528: if( nArg==2 ){
1.1 espie 3529: int i;
3530: for(i=0; azArg[1][i]; i++) azArg[1][i] = ToLower(azArg[1][i]);
3531: if( strcmp(azArg[1],"sqlite_master")==0 ){
3532: char *new_argv[2], *new_colv[2];
3533: new_argv[0] = "CREATE TABLE sqlite_master (\n"
3534: " type text,\n"
3535: " name text,\n"
3536: " tbl_name text,\n"
3537: " rootpage integer,\n"
3538: " sql text\n"
3539: ")";
3540: new_argv[1] = 0;
3541: new_colv[0] = "sql";
3542: new_colv[1] = 0;
3543: callback(&data, 1, new_argv, new_colv);
3544: rc = SQLITE_OK;
3545: }else if( strcmp(azArg[1],"sqlite_temp_master")==0 ){
3546: char *new_argv[2], *new_colv[2];
3547: new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n"
3548: " type text,\n"
3549: " name text,\n"
3550: " tbl_name text,\n"
3551: " rootpage integer,\n"
3552: " sql text\n"
3553: ")";
3554: new_argv[1] = 0;
3555: new_colv[0] = "sql";
3556: new_colv[1] = 0;
3557: callback(&data, 1, new_argv, new_colv);
3558: rc = SQLITE_OK;
3559: }else{
3560: zShellStatic = azArg[1];
3561: rc = sqlite3_exec(p->db,
3562: "SELECT sql FROM "
1.3 espie 3563: " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
1.1 espie 3564: " FROM sqlite_master UNION ALL"
1.3 espie 3565: " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
1.1 espie 3566: "WHERE lower(tbl_name) LIKE shellstatic()"
3567: " AND type!='meta' AND sql NOTNULL "
1.6 landry 3568: "ORDER BY rowid",
1.1 espie 3569: callback, &data, &zErrMsg);
3570: zShellStatic = 0;
3571: }
1.9 jturner 3572: }else if( nArg==1 ){
1.1 espie 3573: rc = sqlite3_exec(p->db,
3574: "SELECT sql FROM "
1.3 espie 3575: " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
1.1 espie 3576: " FROM sqlite_master UNION ALL"
1.3 espie 3577: " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
1.10 jturner 3578: "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
1.6 landry 3579: "ORDER BY rowid",
1.1 espie 3580: callback, &data, &zErrMsg
3581: );
1.9 jturner 3582: }else{
3583: fprintf(stderr, "Usage: .schema ?LIKE-PATTERN?\n");
3584: rc = 1;
3585: goto meta_command_exit;
1.1 espie 3586: }
3587: if( zErrMsg ){
3588: fprintf(stderr,"Error: %s\n", zErrMsg);
3589: sqlite3_free(zErrMsg);
3590: rc = 1;
3591: }else if( rc != SQLITE_OK ){
3592: fprintf(stderr,"Error: querying schema information\n");
3593: rc = 1;
3594: }else{
3595: rc = 0;
3596: }
3597: }else
3598:
1.10 jturner 3599:
3600: #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
3601: if( c=='s' && n==11 && strncmp(azArg[0], "selecttrace", n)==0 ){
3602: extern int sqlite3SelectTrace;
1.12 jturner 3603: sqlite3SelectTrace = integerValue(azArg[1]);
1.10 jturner 3604: }else
3605: #endif
3606:
3607:
1.7 jturner 3608: #ifdef SQLITE_DEBUG
3609: /* Undocumented commands for internal testing. Subject to change
3610: ** without notice. */
3611: if( c=='s' && n>=10 && strncmp(azArg[0], "selftest-", 9)==0 ){
3612: if( strncmp(azArg[0]+9, "boolean", n-9)==0 ){
3613: int i, v;
3614: for(i=1; i<nArg; i++){
3615: v = booleanValue(azArg[i]);
3616: fprintf(p->out, "%s: %d 0x%x\n", azArg[i], v, v);
3617: }
3618: }
3619: if( strncmp(azArg[0]+9, "integer", n-9)==0 ){
3620: int i; sqlite3_int64 v;
3621: for(i=1; i<nArg; i++){
3622: char zBuf[200];
3623: v = integerValue(azArg[i]);
1.9 jturner 3624: sqlite3_snprintf(sizeof(zBuf),zBuf,"%s: %lld 0x%llx\n", azArg[i],v,v);
1.7 jturner 3625: fprintf(p->out, "%s", zBuf);
3626: }
3627: }
3628: }else
3629: #endif
3630:
1.9 jturner 3631: if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){
3632: if( nArg<2 || nArg>3 ){
1.11 jturner 3633: fprintf(stderr, "Usage: .separator COL ?ROW?\n");
1.9 jturner 3634: rc = 1;
3635: }
3636: if( nArg>=2 ){
1.11 jturner 3637: sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator,
3638: "%.*s", (int)ArraySize(p->colSeparator)-1, azArg[1]);
1.9 jturner 3639: }
3640: if( nArg>=3 ){
1.11 jturner 3641: sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator,
3642: "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]);
1.9 jturner 3643: }
3644: }else
3645:
3646: if( c=='s'
3647: && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0)
3648: ){
3649: char *zCmd;
3650: int i, x;
3651: if( nArg<2 ){
3652: fprintf(stderr, "Usage: .system COMMAND\n");
3653: rc = 1;
3654: goto meta_command_exit;
3655: }
3656: zCmd = sqlite3_mprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]);
3657: for(i=2; i<nArg; i++){
3658: zCmd = sqlite3_mprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"",
3659: zCmd, azArg[i]);
3660: }
3661: x = system(zCmd);
3662: sqlite3_free(zCmd);
3663: if( x ) fprintf(stderr, "System command returns %d\n", x);
1.1 espie 3664: }else
3665:
1.9 jturner 3666: if( c=='s' && strncmp(azArg[0], "show", n)==0 ){
1.1 espie 3667: int i;
1.9 jturner 3668: if( nArg!=1 ){
3669: fprintf(stderr, "Usage: .show\n");
3670: rc = 1;
3671: goto meta_command_exit;
3672: }
1.11 jturner 3673: fprintf(p->out,"%12.12s: %s\n","echo", p->echoOn ? "on" : "off");
3674: fprintf(p->out,"%12.12s: %s\n","eqp", p->autoEQP ? "on" : "off");
1.10 jturner 3675: fprintf(p->out,"%9.9s: %s\n","explain", p->normalMode.valid ? "on" :"off");
1.11 jturner 3676: fprintf(p->out,"%12.12s: %s\n","headers", p->showHeader ? "on" : "off");
3677: fprintf(p->out,"%12.12s: %s\n","mode", modeDescr[p->mode]);
3678: fprintf(p->out,"%12.12s: ", "nullvalue");
3679: output_c_string(p->out, p->nullValue);
1.1 espie 3680: fprintf(p->out, "\n");
1.11 jturner 3681: fprintf(p->out,"%12.12s: %s\n","output",
1.1 espie 3682: strlen30(p->outfile) ? p->outfile : "stdout");
1.11 jturner 3683: fprintf(p->out,"%12.12s: ", "colseparator");
3684: output_c_string(p->out, p->colSeparator);
1.1 espie 3685: fprintf(p->out, "\n");
1.11 jturner 3686: fprintf(p->out,"%12.12s: ", "rowseparator");
3687: output_c_string(p->out, p->rowSeparator);
3688: fprintf(p->out, "\n");
3689: fprintf(p->out,"%12.12s: %s\n","stats", p->statsOn ? "on" : "off");
3690: fprintf(p->out,"%12.12s: ","width");
1.1 espie 3691: for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) {
3692: fprintf(p->out,"%d ",p->colWidth[i]);
3693: }
3694: fprintf(p->out,"\n");
3695: }else
3696:
1.9 jturner 3697: if( c=='s' && strncmp(azArg[0], "stats", n)==0 ){
3698: if( nArg==2 ){
3699: p->statsOn = booleanValue(azArg[1]);
3700: }else{
3701: fprintf(stderr, "Usage: .stats on|off\n");
3702: rc = 1;
3703: }
1.1 espie 3704: }else
3705:
1.9 jturner 3706: if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 ){
1.2 espie 3707: sqlite3_stmt *pStmt;
1.1 espie 3708: char **azResult;
1.2 espie 3709: int nRow, nAlloc;
3710: char *zSql = 0;
3711: int ii;
1.8 jturner 3712: open_db(p, 0);
1.2 espie 3713: rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
3714: if( rc ) return rc;
3715: zSql = sqlite3_mprintf(
3716: "SELECT name FROM sqlite_master"
3717: " WHERE type IN ('table','view')"
3718: " AND name NOT LIKE 'sqlite_%%'"
3719: " AND name LIKE ?1");
3720: while( sqlite3_step(pStmt)==SQLITE_ROW ){
3721: const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1);
3722: if( zDbName==0 || strcmp(zDbName,"main")==0 ) continue;
3723: if( strcmp(zDbName,"temp")==0 ){
3724: zSql = sqlite3_mprintf(
3725: "%z UNION ALL "
3726: "SELECT 'temp.' || name FROM sqlite_temp_master"
3727: " WHERE type IN ('table','view')"
3728: " AND name NOT LIKE 'sqlite_%%'"
3729: " AND name LIKE ?1", zSql);
3730: }else{
3731: zSql = sqlite3_mprintf(
3732: "%z UNION ALL "
3733: "SELECT '%q.' || name FROM \"%w\".sqlite_master"
3734: " WHERE type IN ('table','view')"
3735: " AND name NOT LIKE 'sqlite_%%'"
3736: " AND name LIKE ?1", zSql, zDbName, zDbName);
3737: }
3738: }
3739: sqlite3_finalize(pStmt);
3740: zSql = sqlite3_mprintf("%z ORDER BY 1", zSql);
3741: rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
3742: sqlite3_free(zSql);
3743: if( rc ) return rc;
3744: nRow = nAlloc = 0;
3745: azResult = 0;
3746: if( nArg>1 ){
3747: sqlite3_bind_text(pStmt, 1, azArg[1], -1, SQLITE_TRANSIENT);
1.1 espie 3748: }else{
1.2 espie 3749: sqlite3_bind_text(pStmt, 1, "%", -1, SQLITE_STATIC);
3750: }
3751: while( sqlite3_step(pStmt)==SQLITE_ROW ){
3752: if( nRow>=nAlloc ){
3753: char **azNew;
1.13 ! jturner 3754: int n2 = nAlloc*2 + 10;
! 3755: azNew = sqlite3_realloc64(azResult, sizeof(azResult[0])*n2);
1.2 espie 3756: if( azNew==0 ){
3757: fprintf(stderr, "Error: out of memory\n");
3758: break;
3759: }
1.13 ! jturner 3760: nAlloc = n2;
1.2 espie 3761: azResult = azNew;
3762: }
3763: azResult[nRow] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0));
3764: if( azResult[nRow] ) nRow++;
1.1 espie 3765: }
1.2 espie 3766: sqlite3_finalize(pStmt);
3767: if( nRow>0 ){
1.1 espie 3768: int len, maxlen = 0;
3769: int i, j;
3770: int nPrintCol, nPrintRow;
1.2 espie 3771: for(i=0; i<nRow; i++){
1.1 espie 3772: len = strlen30(azResult[i]);
3773: if( len>maxlen ) maxlen = len;
3774: }
3775: nPrintCol = 80/(maxlen+2);
3776: if( nPrintCol<1 ) nPrintCol = 1;
3777: nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
3778: for(i=0; i<nPrintRow; i++){
1.2 espie 3779: for(j=i; j<nRow; j+=nPrintRow){
3780: char *zSp = j<nPrintRow ? "" : " ";
1.11 jturner 3781: fprintf(p->out, "%s%-*s", zSp, maxlen, azResult[j] ? azResult[j]:"");
1.1 espie 3782: }
1.6 landry 3783: fprintf(p->out, "\n");
1.1 espie 3784: }
3785: }
1.2 espie 3786: for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]);
3787: sqlite3_free(azResult);
1.1 espie 3788: }else
3789:
3790: if( c=='t' && n>=8 && strncmp(azArg[0], "testctrl", n)==0 && nArg>=2 ){
3791: static const struct {
3792: const char *zCtrlName; /* Name of a test-control option */
3793: int ctrlCode; /* Integer code for that option */
3794: } aCtrl[] = {
3795: { "prng_save", SQLITE_TESTCTRL_PRNG_SAVE },
3796: { "prng_restore", SQLITE_TESTCTRL_PRNG_RESTORE },
3797: { "prng_reset", SQLITE_TESTCTRL_PRNG_RESET },
3798: { "bitvec_test", SQLITE_TESTCTRL_BITVEC_TEST },
3799: { "fault_install", SQLITE_TESTCTRL_FAULT_INSTALL },
3800: { "benign_malloc_hooks", SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS },
3801: { "pending_byte", SQLITE_TESTCTRL_PENDING_BYTE },
3802: { "assert", SQLITE_TESTCTRL_ASSERT },
3803: { "always", SQLITE_TESTCTRL_ALWAYS },
3804: { "reserve", SQLITE_TESTCTRL_RESERVE },
3805: { "optimizations", SQLITE_TESTCTRL_OPTIMIZATIONS },
3806: { "iskeyword", SQLITE_TESTCTRL_ISKEYWORD },
3807: { "scratchmalloc", SQLITE_TESTCTRL_SCRATCHMALLOC },
1.9 jturner 3808: { "byteorder", SQLITE_TESTCTRL_BYTEORDER },
1.12 jturner 3809: { "never_corrupt", SQLITE_TESTCTRL_NEVER_CORRUPT },
3810: { "imposter", SQLITE_TESTCTRL_IMPOSTER },
1.1 espie 3811: };
3812: int testctrl = -1;
1.13 ! jturner 3813: int rc2 = 0;
! 3814: int i, n2;
1.8 jturner 3815: open_db(p, 0);
1.1 espie 3816:
3817: /* convert testctrl text option to value. allow any unique prefix
3818: ** of the option name, or a numerical value. */
1.13 ! jturner 3819: n2 = strlen30(azArg[1]);
! 3820: for(i=0; i<ArraySize(aCtrl); i++){
! 3821: if( strncmp(azArg[1], aCtrl[i].zCtrlName, n2)==0 ){
1.1 espie 3822: if( testctrl<0 ){
3823: testctrl = aCtrl[i].ctrlCode;
3824: }else{
3825: fprintf(stderr, "ambiguous option name: \"%s\"\n", azArg[1]);
3826: testctrl = -1;
3827: break;
3828: }
3829: }
3830: }
1.7 jturner 3831: if( testctrl<0 ) testctrl = (int)integerValue(azArg[1]);
1.1 espie 3832: if( (testctrl<SQLITE_TESTCTRL_FIRST) || (testctrl>SQLITE_TESTCTRL_LAST) ){
3833: fprintf(stderr,"Error: invalid testctrl option: %s\n", azArg[1]);
3834: }else{
3835: switch(testctrl){
3836:
3837: /* sqlite3_test_control(int, db, int) */
3838: case SQLITE_TESTCTRL_OPTIMIZATIONS:
3839: case SQLITE_TESTCTRL_RESERVE:
3840: if( nArg==3 ){
3841: int opt = (int)strtol(azArg[2], 0, 0);
1.13 ! jturner 3842: rc2 = sqlite3_test_control(testctrl, p->db, opt);
! 3843: fprintf(p->out, "%d (0x%08x)\n", rc2, rc2);
1.1 espie 3844: } else {
3845: fprintf(stderr,"Error: testctrl %s takes a single int option\n",
3846: azArg[1]);
3847: }
3848: break;
3849:
3850: /* sqlite3_test_control(int) */
1.9 jturner 3851: case SQLITE_TESTCTRL_PRNG_SAVE:
3852: case SQLITE_TESTCTRL_PRNG_RESTORE:
1.1 espie 3853: case SQLITE_TESTCTRL_PRNG_RESET:
1.9 jturner 3854: case SQLITE_TESTCTRL_BYTEORDER:
1.1 espie 3855: if( nArg==2 ){
1.13 ! jturner 3856: rc2 = sqlite3_test_control(testctrl);
! 3857: fprintf(p->out, "%d (0x%08x)\n", rc2, rc2);
1.1 espie 3858: } else {
3859: fprintf(stderr,"Error: testctrl %s takes no options\n", azArg[1]);
3860: }
3861: break;
3862:
3863: /* sqlite3_test_control(int, uint) */
3864: case SQLITE_TESTCTRL_PENDING_BYTE:
3865: if( nArg==3 ){
1.7 jturner 3866: unsigned int opt = (unsigned int)integerValue(azArg[2]);
1.13 ! jturner 3867: rc2 = sqlite3_test_control(testctrl, opt);
! 3868: fprintf(p->out, "%d (0x%08x)\n", rc2, rc2);
1.1 espie 3869: } else {
3870: fprintf(stderr,"Error: testctrl %s takes a single unsigned"
3871: " int option\n", azArg[1]);
3872: }
3873: break;
3874:
3875: /* sqlite3_test_control(int, int) */
3876: case SQLITE_TESTCTRL_ASSERT:
1.12 jturner 3877: case SQLITE_TESTCTRL_ALWAYS:
3878: case SQLITE_TESTCTRL_NEVER_CORRUPT:
1.1 espie 3879: if( nArg==3 ){
1.7 jturner 3880: int opt = booleanValue(azArg[2]);
1.13 ! jturner 3881: rc2 = sqlite3_test_control(testctrl, opt);
! 3882: fprintf(p->out, "%d (0x%08x)\n", rc2, rc2);
1.1 espie 3883: } else {
3884: fprintf(stderr,"Error: testctrl %s takes a single int option\n",
3885: azArg[1]);
3886: }
3887: break;
3888:
3889: /* sqlite3_test_control(int, char *) */
3890: #ifdef SQLITE_N_KEYWORD
3891: case SQLITE_TESTCTRL_ISKEYWORD:
3892: if( nArg==3 ){
3893: const char *opt = azArg[2];
1.13 ! jturner 3894: rc2 = sqlite3_test_control(testctrl, opt);
! 3895: fprintf(p->out, "%d (0x%08x)\n", rc2, rc2);
1.1 espie 3896: } else {
3897: fprintf(stderr,"Error: testctrl %s takes a single char * option\n",
3898: azArg[1]);
3899: }
3900: break;
3901: #endif
3902:
1.12 jturner 3903: case SQLITE_TESTCTRL_IMPOSTER:
3904: if( nArg==5 ){
1.13 ! jturner 3905: rc2 = sqlite3_test_control(testctrl, p->db,
1.12 jturner 3906: azArg[2],
3907: integerValue(azArg[3]),
3908: integerValue(azArg[4]));
1.13 ! jturner 3909: fprintf(p->out, "%d (0x%08x)\n", rc2, rc2);
1.12 jturner 3910: }else{
3911: fprintf(stderr,"Usage: .testctrl imposter dbName onoff tnum\n");
3912: }
3913: break;
3914:
1.1 espie 3915: case SQLITE_TESTCTRL_BITVEC_TEST:
3916: case SQLITE_TESTCTRL_FAULT_INSTALL:
3917: case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS:
3918: case SQLITE_TESTCTRL_SCRATCHMALLOC:
3919: default:
3920: fprintf(stderr,"Error: CLI support for testctrl %s not implemented\n",
3921: azArg[1]);
3922: break;
3923: }
3924: }
3925: }else
3926:
1.9 jturner 3927: if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 ){
1.8 jturner 3928: open_db(p, 0);
1.9 jturner 3929: sqlite3_busy_timeout(p->db, nArg>=2 ? (int)integerValue(azArg[1]) : 0);
1.1 espie 3930: }else
3931:
1.9 jturner 3932: if( c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 ){
3933: if( nArg==2 ){
3934: enableTimer = booleanValue(azArg[1]);
3935: if( enableTimer && !HAS_TIMER ){
3936: fprintf(stderr, "Error: timer not available on this system.\n");
3937: enableTimer = 0;
3938: }
3939: }else{
3940: fprintf(stderr, "Usage: .timer on|off\n");
3941: rc = 1;
3942: }
1.1 espie 3943: }else
3944:
1.9 jturner 3945: if( c=='t' && strncmp(azArg[0], "trace", n)==0 ){
1.8 jturner 3946: open_db(p, 0);
1.9 jturner 3947: if( nArg!=2 ){
3948: fprintf(stderr, "Usage: .trace FILE|off\n");
3949: rc = 1;
3950: goto meta_command_exit;
3951: }
1.12 jturner 3952: output_file_close(p->traceOut);
1.2 espie 3953: p->traceOut = output_file_open(azArg[1]);
1.4 espie 3954: #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)
1.2 espie 3955: if( p->traceOut==0 ){
3956: sqlite3_trace(p->db, 0, 0);
3957: }else{
3958: sqlite3_trace(p->db, sql_trace_callback, p->traceOut);
3959: }
3960: #endif
3961: }else
3962:
1.10 jturner 3963: #if SQLITE_USER_AUTHENTICATION
3964: if( c=='u' && strncmp(azArg[0], "user", n)==0 ){
3965: if( nArg<2 ){
3966: fprintf(stderr, "Usage: .user SUBCOMMAND ...\n");
3967: rc = 1;
3968: goto meta_command_exit;
3969: }
3970: open_db(p, 0);
3971: if( strcmp(azArg[1],"login")==0 ){
3972: if( nArg!=4 ){
3973: fprintf(stderr, "Usage: .user login USER PASSWORD\n");
3974: rc = 1;
3975: goto meta_command_exit;
3976: }
3977: rc = sqlite3_user_authenticate(p->db, azArg[2], azArg[3],
3978: (int)strlen(azArg[3]));
3979: if( rc ){
3980: fprintf(stderr, "Authentication failed for user %s\n", azArg[2]);
3981: rc = 1;
3982: }
3983: }else if( strcmp(azArg[1],"add")==0 ){
3984: if( nArg!=5 ){
3985: fprintf(stderr, "Usage: .user add USER PASSWORD ISADMIN\n");
3986: rc = 1;
3987: goto meta_command_exit;
3988: }
3989: rc = sqlite3_user_add(p->db, azArg[2],
3990: azArg[3], (int)strlen(azArg[3]),
3991: booleanValue(azArg[4]));
3992: if( rc ){
3993: fprintf(stderr, "User-Add failed: %d\n", rc);
3994: rc = 1;
3995: }
3996: }else if( strcmp(azArg[1],"edit")==0 ){
3997: if( nArg!=5 ){
3998: fprintf(stderr, "Usage: .user edit USER PASSWORD ISADMIN\n");
3999: rc = 1;
4000: goto meta_command_exit;
4001: }
4002: rc = sqlite3_user_change(p->db, azArg[2],
4003: azArg[3], (int)strlen(azArg[3]),
4004: booleanValue(azArg[4]));
4005: if( rc ){
4006: fprintf(stderr, "User-Edit failed: %d\n", rc);
4007: rc = 1;
4008: }
4009: }else if( strcmp(azArg[1],"delete")==0 ){
4010: if( nArg!=3 ){
4011: fprintf(stderr, "Usage: .user delete USER\n");
4012: rc = 1;
4013: goto meta_command_exit;
4014: }
4015: rc = sqlite3_user_delete(p->db, azArg[2]);
4016: if( rc ){
4017: fprintf(stderr, "User-Delete failed: %d\n", rc);
4018: rc = 1;
4019: }
4020: }else{
4021: fprintf(stderr, "Usage: .user login|add|edit|delete ...\n");
4022: rc = 1;
4023: goto meta_command_exit;
4024: }
4025: }else
4026: #endif /* SQLITE_USER_AUTHENTICATION */
4027:
1.1 espie 4028: if( c=='v' && strncmp(azArg[0], "version", n)==0 ){
1.6 landry 4029: fprintf(p->out, "SQLite %s %s\n" /*extra-version-info*/,
1.1 espie 4030: sqlite3_libversion(), sqlite3_sourceid());
4031: }else
4032:
4033: if( c=='v' && strncmp(azArg[0], "vfsname", n)==0 ){
4034: const char *zDbName = nArg==2 ? azArg[1] : "main";
4035: char *zVfsName = 0;
4036: if( p->db ){
4037: sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName);
4038: if( zVfsName ){
1.6 landry 4039: fprintf(p->out, "%s\n", zVfsName);
1.1 espie 4040: sqlite3_free(zVfsName);
4041: }
4042: }
4043: }else
4044:
1.5 espie 4045: #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
4046: if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){
4047: extern int sqlite3WhereTrace;
1.9 jturner 4048: sqlite3WhereTrace = nArg>=2 ? booleanValue(azArg[1]) : 0xff;
1.5 espie 4049: }else
4050: #endif
4051:
1.9 jturner 4052: if( c=='w' && strncmp(azArg[0], "width", n)==0 ){
1.1 espie 4053: int j;
4054: assert( nArg<=ArraySize(azArg) );
4055: for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){
1.7 jturner 4056: p->colWidth[j-1] = (int)integerValue(azArg[j]);
1.1 espie 4057: }
4058: }else
4059:
4060: {
4061: fprintf(stderr, "Error: unknown command or invalid arguments: "
4062: " \"%s\". Enter \".help\" for help\n", azArg[0]);
4063: rc = 1;
4064: }
4065:
1.9 jturner 4066: meta_command_exit:
4067: if( p->outCount ){
4068: p->outCount--;
4069: if( p->outCount==0 ) output_reset(p);
4070: }
1.1 espie 4071: return rc;
4072: }
4073:
4074: /*
4075: ** Return TRUE if a semicolon occurs anywhere in the first N characters
4076: ** of string z[].
4077: */
1.7 jturner 4078: static int line_contains_semicolon(const char *z, int N){
1.1 espie 4079: int i;
4080: for(i=0; i<N; i++){ if( z[i]==';' ) return 1; }
4081: return 0;
4082: }
4083:
4084: /*
4085: ** Test to see if a line consists entirely of whitespace.
4086: */
4087: static int _all_whitespace(const char *z){
4088: for(; *z; z++){
4089: if( IsSpace(z[0]) ) continue;
4090: if( *z=='/' && z[1]=='*' ){
4091: z += 2;
4092: while( *z && (*z!='*' || z[1]!='/') ){ z++; }
4093: if( *z==0 ) return 0;
4094: z++;
4095: continue;
4096: }
4097: if( *z=='-' && z[1]=='-' ){
4098: z += 2;
4099: while( *z && *z!='\n' ){ z++; }
4100: if( *z==0 ) return 1;
4101: continue;
4102: }
4103: return 0;
4104: }
4105: return 1;
4106: }
4107:
4108: /*
4109: ** Return TRUE if the line typed in is an SQL command terminator other
4110: ** than a semi-colon. The SQL Server style "go" command is understood
4111: ** as is the Oracle "/".
4112: */
1.7 jturner 4113: static int line_is_command_terminator(const char *zLine){
1.1 espie 4114: while( IsSpace(zLine[0]) ){ zLine++; };
4115: if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ){
4116: return 1; /* Oracle */
4117: }
4118: if( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o'
4119: && _all_whitespace(&zLine[2]) ){
4120: return 1; /* SQL Server */
4121: }
4122: return 0;
4123: }
4124:
4125: /*
4126: ** Return true if zSql is a complete SQL statement. Return false if it
4127: ** ends in the middle of a string literal or C-style comment.
4128: */
1.7 jturner 4129: static int line_is_complete(char *zSql, int nSql){
1.1 espie 4130: int rc;
4131: if( zSql==0 ) return 1;
4132: zSql[nSql] = ';';
4133: zSql[nSql+1] = 0;
4134: rc = sqlite3_complete(zSql);
4135: zSql[nSql] = 0;
4136: return rc;
4137: }
4138:
4139: /*
4140: ** Read input from *in and process it. If *in==0 then input
4141: ** is interactive - the user is typing it it. Otherwise, input
4142: ** is coming from a file or device. A prompt is issued and history
4143: ** is saved only if input is interactive. An interrupt signal will
4144: ** cause this routine to exit immediately, unless input is interactive.
4145: **
4146: ** Return the number of errors.
4147: */
1.10 jturner 4148: static int process_input(ShellState *p, FILE *in){
1.7 jturner 4149: char *zLine = 0; /* A single input line */
4150: char *zSql = 0; /* Accumulated SQL text */
4151: int nLine; /* Length of current line */
4152: int nSql = 0; /* Bytes of zSql[] used */
4153: int nAlloc = 0; /* Allocated zSql[] space */
4154: int nSqlPrior = 0; /* Bytes of zSql[] used by prior line */
4155: char *zErrMsg; /* Error message returned */
4156: int rc; /* Error code */
4157: int errCnt = 0; /* Number of errors seen */
4158: int lineno = 0; /* Current line number */
4159: int startline = 0; /* Line number for start of current input */
1.1 espie 4160:
4161: while( errCnt==0 || !bail_on_error || (in==0 && stdin_is_interactive) ){
4162: fflush(p->out);
1.7 jturner 4163: zLine = one_input_line(in, zLine, nSql>0);
1.1 espie 4164: if( zLine==0 ){
1.2 espie 4165: /* End of input */
4166: if( stdin_is_interactive ) printf("\n");
4167: break;
1.1 espie 4168: }
4169: if( seenInterrupt ){
4170: if( in!=0 ) break;
4171: seenInterrupt = 0;
4172: }
4173: lineno++;
1.8 jturner 4174: if( nSql==0 && _all_whitespace(zLine) ){
4175: if( p->echoOn ) printf("%s\n", zLine);
4176: continue;
4177: }
1.1 espie 4178: if( zLine && zLine[0]=='.' && nSql==0 ){
4179: if( p->echoOn ) printf("%s\n", zLine);
4180: rc = do_meta_command(zLine, p);
4181: if( rc==2 ){ /* exit requested */
4182: break;
4183: }else if( rc ){
4184: errCnt++;
4185: }
4186: continue;
4187: }
1.7 jturner 4188: if( line_is_command_terminator(zLine) && line_is_complete(zSql, nSql) ){
1.1 espie 4189: memcpy(zLine,";",2);
4190: }
1.7 jturner 4191: nLine = strlen30(zLine);
4192: if( nSql+nLine+2>=nAlloc ){
4193: nAlloc = nSql+nLine+100;
4194: zSql = realloc(zSql, nAlloc);
4195: if( zSql==0 ){
4196: fprintf(stderr, "Error: out of memory\n");
4197: exit(1);
4198: }
4199: }
1.1 espie 4200: nSqlPrior = nSql;
1.7 jturner 4201: if( nSql==0 ){
1.1 espie 4202: int i;
4203: for(i=0; zLine[i] && IsSpace(zLine[i]); i++){}
1.7 jturner 4204: assert( nAlloc>0 && zSql!=0 );
4205: memcpy(zSql, zLine+i, nLine+1-i);
4206: startline = lineno;
4207: nSql = nLine-i;
1.1 espie 4208: }else{
4209: zSql[nSql++] = '\n';
1.7 jturner 4210: memcpy(zSql+nSql, zLine, nLine+1);
4211: nSql += nLine;
1.1 espie 4212: }
1.7 jturner 4213: if( nSql && line_contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
1.1 espie 4214: && sqlite3_complete(zSql) ){
4215: p->cnt = 0;
1.8 jturner 4216: open_db(p, 0);
1.13 ! jturner 4217: if( p->backslashOn ) resolve_backslashes(zSql);
1.1 espie 4218: BEGIN_TIMER;
4219: rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
4220: END_TIMER;
4221: if( rc || zErrMsg ){
4222: char zPrefix[100];
4223: if( in!=0 || !stdin_is_interactive ){
4224: sqlite3_snprintf(sizeof(zPrefix), zPrefix,
4225: "Error: near line %d:", startline);
4226: }else{
4227: sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:");
4228: }
4229: if( zErrMsg!=0 ){
4230: fprintf(stderr, "%s %s\n", zPrefix, zErrMsg);
4231: sqlite3_free(zErrMsg);
4232: zErrMsg = 0;
4233: }else{
4234: fprintf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
4235: }
4236: errCnt++;
4237: }
4238: nSql = 0;
1.9 jturner 4239: if( p->outCount ){
4240: output_reset(p);
4241: p->outCount = 0;
4242: }
1.7 jturner 4243: }else if( nSql && _all_whitespace(zSql) ){
1.8 jturner 4244: if( p->echoOn ) printf("%s\n", zSql);
1.6 landry 4245: nSql = 0;
1.1 espie 4246: }
4247: }
1.7 jturner 4248: if( nSql ){
1.1 espie 4249: if( !_all_whitespace(zSql) ){
4250: fprintf(stderr, "Error: incomplete SQL: %s\n", zSql);
1.10 jturner 4251: errCnt++;
1.1 espie 4252: }
4253: free(zSql);
4254: }
4255: free(zLine);
1.5 espie 4256: return errCnt>0;
1.1 espie 4257: }
4258:
4259: /*
4260: ** Return a pathname which is the user's home directory. A
1.2 espie 4261: ** 0 return indicates an error of some kind.
1.1 espie 4262: */
4263: static char *find_home_dir(void){
1.2 espie 4264: static char *home_dir = NULL;
4265: if( home_dir ) return home_dir;
1.1 espie 4266:
1.11 jturner 4267: #if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) \
4268: && !defined(__RTP__) && !defined(_WRS_KERNEL)
1.2 espie 4269: {
1.4 espie 4270: struct passwd *pwent;
4271: uid_t uid = getuid();
4272: if( (pwent=getpwuid(uid)) != NULL) {
4273: home_dir = pwent->pw_dir;
4274: }
1.1 espie 4275: }
4276: #endif
4277:
4278: #if defined(_WIN32_WCE)
4279: /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
4280: */
1.2 espie 4281: home_dir = "/";
1.1 espie 4282: #else
4283:
1.4 espie 4284: #if defined(_WIN32) || defined(WIN32)
1.1 espie 4285: if (!home_dir) {
4286: home_dir = getenv("USERPROFILE");
4287: }
4288: #endif
4289:
4290: if (!home_dir) {
4291: home_dir = getenv("HOME");
4292: }
4293:
1.4 espie 4294: #if defined(_WIN32) || defined(WIN32)
1.1 espie 4295: if (!home_dir) {
4296: char *zDrive, *zPath;
4297: int n;
4298: zDrive = getenv("HOMEDRIVE");
4299: zPath = getenv("HOMEPATH");
4300: if( zDrive && zPath ){
4301: n = strlen30(zDrive) + strlen30(zPath) + 1;
4302: home_dir = malloc( n );
4303: if( home_dir==0 ) return 0;
4304: sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath);
4305: return home_dir;
4306: }
4307: home_dir = "c:\\";
4308: }
4309: #endif
4310:
4311: #endif /* !_WIN32_WCE */
4312:
4313: if( home_dir ){
4314: int n = strlen30(home_dir) + 1;
4315: char *z = malloc( n );
4316: if( z ) memcpy(z, home_dir, n);
4317: home_dir = z;
4318: }
4319:
4320: return home_dir;
4321: }
4322:
4323: /*
4324: ** Read input from the file given by sqliterc_override. Or if that
4325: ** parameter is NULL, take input from ~/.sqliterc
4326: **
4327: ** Returns the number of errors.
4328: */
1.12 jturner 4329: static void process_sqliterc(
1.10 jturner 4330: ShellState *p, /* Configuration data */
1.1 espie 4331: const char *sqliterc_override /* Name of config file. NULL to use default */
4332: ){
4333: char *home_dir = NULL;
4334: const char *sqliterc = sqliterc_override;
4335: char *zBuf = 0;
4336: FILE *in = NULL;
4337:
4338: if (sqliterc == NULL) {
4339: home_dir = find_home_dir();
4340: if( home_dir==0 ){
1.12 jturner 4341: fprintf(stderr, "-- warning: cannot find home directory;"
4342: " cannot read ~/.sqliterc\n");
4343: return;
1.1 espie 4344: }
1.4 espie 4345: sqlite3_initialize();
1.2 espie 4346: zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir);
4347: sqliterc = zBuf;
1.1 espie 4348: }
4349: in = fopen(sqliterc,"rb");
4350: if( in ){
4351: if( stdin_is_interactive ){
4352: fprintf(stderr,"-- Loading resources from %s\n",sqliterc);
4353: }
1.12 jturner 4354: process_input(p,in);
1.1 espie 4355: fclose(in);
4356: }
1.2 espie 4357: sqlite3_free(zBuf);
1.1 espie 4358: }
4359:
4360: /*
4361: ** Show available command line options
4362: */
4363: static const char zOptions[] =
1.11 jturner 4364: " -ascii set output mode to 'ascii'\n"
1.1 espie 4365: " -bail stop after hitting an error\n"
4366: " -batch force batch I/O\n"
4367: " -column set output mode to 'column'\n"
1.5 espie 4368: " -cmd COMMAND run \"COMMAND\" before reading stdin\n"
1.1 espie 4369: " -csv set output mode to 'csv'\n"
4370: " -echo print commands before execution\n"
1.5 espie 4371: " -init FILENAME read/process named file\n"
1.1 espie 4372: " -[no]header turn headers on or off\n"
1.5 espie 4373: #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
4374: " -heap SIZE Size of heap for memsys3 or memsys5\n"
4375: #endif
1.1 espie 4376: " -help show this message\n"
4377: " -html set output mode to HTML\n"
4378: " -interactive force interactive I/O\n"
4379: " -line set output mode to 'line'\n"
4380: " -list set output mode to 'list'\n"
1.10 jturner 4381: " -lookaside SIZE N use N entries of SZ bytes for lookaside memory\n"
1.6 landry 4382: " -mmap N default mmap size set to N\n"
1.1 espie 4383: #ifdef SQLITE_ENABLE_MULTIPLEX
4384: " -multiplex enable the multiplexor VFS\n"
4385: #endif
1.11 jturner 4386: " -newline SEP set output row separator. Default: '\\n'\n"
1.5 espie 4387: " -nullvalue TEXT set text string for NULL values. Default ''\n"
1.10 jturner 4388: " -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n"
4389: " -scratch SIZE N use N slots of SZ bytes each for scratch memory\n"
1.11 jturner 4390: " -separator SEP set output column separator. Default: '|'\n"
1.1 espie 4391: " -stats print memory stats before each finalize\n"
4392: " -version show SQLite version\n"
4393: " -vfs NAME use NAME as the default VFS\n"
4394: #ifdef SQLITE_ENABLE_VFSTRACE
4395: " -vfstrace enable tracing of all VFS calls\n"
4396: #endif
4397: ;
4398: static void usage(int showDetail){
4399: fprintf(stderr,
4400: "Usage: %s [OPTIONS] FILENAME [SQL]\n"
4401: "FILENAME is the name of an SQLite database. A new database is created\n"
4402: "if the file does not previously exist.\n", Argv0);
4403: if( showDetail ){
4404: fprintf(stderr, "OPTIONS include:\n%s", zOptions);
4405: }else{
4406: fprintf(stderr, "Use the -help option for additional information\n");
4407: }
4408: exit(1);
4409: }
4410:
4411: /*
4412: ** Initialize the state information in data
4413: */
1.10 jturner 4414: static void main_init(ShellState *data) {
1.1 espie 4415: memset(data, 0, sizeof(*data));
4416: data->mode = MODE_List;
1.11 jturner 4417: memcpy(data->colSeparator,SEP_Column, 2);
4418: memcpy(data->rowSeparator,SEP_Row, 2);
1.1 espie 4419: data->showHeader = 0;
1.10 jturner 4420: data->shellFlgs = SHFLG_Lookaside;
1.1 espie 4421: sqlite3_config(SQLITE_CONFIG_URI, 1);
4422: sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data);
1.10 jturner 4423: sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
1.1 espie 4424: sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");
4425: sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> ");
4426: }
4427:
1.5 espie 4428: /*
1.8 jturner 4429: ** Output text to the console in a font that attracts extra attention.
4430: */
4431: #ifdef _WIN32
4432: static void printBold(const char *zText){
4433: HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
4434: CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo;
4435: GetConsoleScreenBufferInfo(out, &defaultScreenInfo);
4436: SetConsoleTextAttribute(out,
4437: FOREGROUND_RED|FOREGROUND_INTENSITY
4438: );
4439: printf("%s", zText);
4440: SetConsoleTextAttribute(out, defaultScreenInfo.wAttributes);
4441: }
4442: #else
4443: static void printBold(const char *zText){
4444: printf("\033[1m%s\033[0m", zText);
4445: }
4446: #endif
4447:
4448: /*
1.5 espie 4449: ** Get the argument to an --option. Throw an error and die if no argument
4450: ** is available.
4451: */
4452: static char *cmdline_option_value(int argc, char **argv, int i){
4453: if( i==argc ){
4454: fprintf(stderr, "%s: Error: missing argument to %s\n",
4455: argv[0], argv[argc-1]);
4456: exit(1);
4457: }
4458: return argv[i];
4459: }
4460:
1.12 jturner 4461: int SQLITE_CDECL main(int argc, char **argv){
1.1 espie 4462: char *zErrMsg = 0;
1.10 jturner 4463: ShellState data;
1.1 espie 4464: const char *zInitFile = 0;
4465: int i;
4466: int rc = 0;
1.8 jturner 4467: int warnInmemoryDb = 0;
1.11 jturner 4468: int readStdin = 1;
4469: int nCmd = 0;
4470: char **azCmd = 0;
1.1 espie 4471:
1.8 jturner 4472: #if USE_SYSTEM_SQLITE+0!=1
1.1 espie 4473: if( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)!=0 ){
4474: fprintf(stderr, "SQLite header and source version mismatch\n%s\n%s\n",
4475: sqlite3_sourceid(), SQLITE_SOURCE_ID);
4476: exit(1);
4477: }
1.8 jturner 4478: #endif
1.12 jturner 4479: setBinaryMode(stdin);
4480: setvbuf(stderr, 0, _IONBF, 0); /* Make sure stderr is unbuffered */
1.1 espie 4481: Argv0 = argv[0];
4482: main_init(&data);
4483: stdin_is_interactive = isatty(0);
4484:
4485: /* Make sure we have a valid signal handler early, before anything
4486: ** else is done.
4487: */
4488: #ifdef SIGINT
4489: signal(SIGINT, interrupt_handler);
4490: #endif
4491:
1.11 jturner 4492: #ifdef SQLITE_SHELL_DBNAME_PROC
4493: {
4494: /* If the SQLITE_SHELL_DBNAME_PROC macro is defined, then it is the name
4495: ** of a C-function that will provide the name of the database file. Use
4496: ** this compile-time option to embed this shell program in larger
4497: ** applications. */
4498: extern void SQLITE_SHELL_DBNAME_PROC(const char**);
4499: SQLITE_SHELL_DBNAME_PROC(&data.zDbFilename);
4500: warnInmemoryDb = 0;
4501: }
4502: #endif
4503:
1.1 espie 4504: /* Do an initial pass through the command-line argument to locate
4505: ** the name of the database file, the name of the initialization file,
4506: ** the size of the alternative malloc heap,
4507: ** and the first command to execute.
4508: */
1.5 espie 4509: for(i=1; i<argc; i++){
1.1 espie 4510: char *z;
4511: z = argv[i];
1.5 espie 4512: if( z[0]!='-' ){
4513: if( data.zDbFilename==0 ){
4514: data.zDbFilename = z;
1.11 jturner 4515: }else{
4516: /* Excesss arguments are interpreted as SQL (or dot-commands) and
4517: ** mean that nothing is read from stdin */
4518: readStdin = 0;
4519: nCmd++;
4520: azCmd = realloc(azCmd, sizeof(azCmd[0])*nCmd);
4521: if( azCmd==0 ){
4522: fprintf(stderr, "out of memory\n");
4523: exit(1);
4524: }
4525: azCmd[nCmd-1] = z;
1.5 espie 4526: }
4527: }
1.1 espie 4528: if( z[1]=='-' ) z++;
4529: if( strcmp(z,"-separator")==0
4530: || strcmp(z,"-nullvalue")==0
1.9 jturner 4531: || strcmp(z,"-newline")==0
1.1 espie 4532: || strcmp(z,"-cmd")==0
4533: ){
1.5 espie 4534: (void)cmdline_option_value(argc, argv, ++i);
1.1 espie 4535: }else if( strcmp(z,"-init")==0 ){
1.5 espie 4536: zInitFile = cmdline_option_value(argc, argv, ++i);
1.1 espie 4537: }else if( strcmp(z,"-batch")==0 ){
1.5 espie 4538: /* Need to check for batch mode here to so we can avoid printing
4539: ** informational messages (like from process_sqliterc) before
4540: ** we do the actual processing of arguments later in a second pass.
4541: */
1.1 espie 4542: stdin_is_interactive = 0;
4543: }else if( strcmp(z,"-heap")==0 ){
4544: #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
4545: const char *zSize;
4546: sqlite3_int64 szHeap;
4547:
1.5 espie 4548: zSize = cmdline_option_value(argc, argv, ++i);
1.6 landry 4549: szHeap = integerValue(zSize);
1.1 espie 4550: if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000;
4551: sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64);
4552: #endif
1.10 jturner 4553: }else if( strcmp(z,"-scratch")==0 ){
4554: int n, sz;
4555: sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
4556: if( sz>400000 ) sz = 400000;
4557: if( sz<2500 ) sz = 2500;
4558: n = (int)integerValue(cmdline_option_value(argc,argv,++i));
4559: if( n>10 ) n = 10;
4560: if( n<1 ) n = 1;
4561: sqlite3_config(SQLITE_CONFIG_SCRATCH, malloc(n*sz+1), sz, n);
4562: data.shellFlgs |= SHFLG_Scratch;
4563: }else if( strcmp(z,"-pagecache")==0 ){
4564: int n, sz;
4565: sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
4566: if( sz>70000 ) sz = 70000;
4567: if( sz<800 ) sz = 800;
4568: n = (int)integerValue(cmdline_option_value(argc,argv,++i));
4569: if( n<10 ) n = 10;
4570: sqlite3_config(SQLITE_CONFIG_PAGECACHE, malloc(n*sz+1), sz, n);
4571: data.shellFlgs |= SHFLG_Pagecache;
4572: }else if( strcmp(z,"-lookaside")==0 ){
4573: int n, sz;
4574: sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
4575: if( sz<0 ) sz = 0;
4576: n = (int)integerValue(cmdline_option_value(argc,argv,++i));
4577: if( n<0 ) n = 0;
4578: sqlite3_config(SQLITE_CONFIG_LOOKASIDE, sz, n);
4579: if( sz*n==0 ) data.shellFlgs &= ~SHFLG_Lookaside;
1.1 espie 4580: #ifdef SQLITE_ENABLE_VFSTRACE
4581: }else if( strcmp(z,"-vfstrace")==0 ){
4582: extern int vfstrace_register(
4583: const char *zTraceName,
4584: const char *zOldVfsName,
4585: int (*xOut)(const char*,void*),
4586: void *pOutArg,
4587: int makeDefault
4588: );
4589: vfstrace_register("trace",0,(int(*)(const char*,void*))fputs,stderr,1);
4590: #endif
4591: #ifdef SQLITE_ENABLE_MULTIPLEX
4592: }else if( strcmp(z,"-multiplex")==0 ){
4593: extern int sqlite3_multiple_initialize(const char*,int);
4594: sqlite3_multiplex_initialize(0, 1);
4595: #endif
1.6 landry 4596: }else if( strcmp(z,"-mmap")==0 ){
4597: sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));
4598: sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz);
1.1 espie 4599: }else if( strcmp(z,"-vfs")==0 ){
1.5 espie 4600: sqlite3_vfs *pVfs = sqlite3_vfs_find(cmdline_option_value(argc,argv,++i));
1.1 espie 4601: if( pVfs ){
4602: sqlite3_vfs_register(pVfs, 1);
4603: }else{
4604: fprintf(stderr, "no such VFS: \"%s\"\n", argv[i]);
4605: exit(1);
4606: }
4607: }
4608: }
1.5 espie 4609: if( data.zDbFilename==0 ){
1.1 espie 4610: #ifndef SQLITE_OMIT_MEMORYDB
4611: data.zDbFilename = ":memory:";
1.8 jturner 4612: warnInmemoryDb = argc==1;
1.1 espie 4613: #else
1.5 espie 4614: fprintf(stderr,"%s: Error: no database filename specified\n", Argv0);
4615: return 1;
1.1 espie 4616: #endif
4617: }
4618: data.out = stdout;
4619:
4620: /* Go ahead and open the database file if it already exists. If the
4621: ** file does not exist, delay opening it. This prevents empty database
4622: ** files from being created if a user mistypes the database name argument
4623: ** to the sqlite command-line tool.
4624: */
4625: if( access(data.zDbFilename, 0)==0 ){
1.8 jturner 4626: open_db(&data, 0);
1.1 espie 4627: }
4628:
4629: /* Process the initialization file if there is one. If no -init option
4630: ** is given on the command line, look for a file named ~/.sqliterc and
4631: ** try to process it.
4632: */
1.12 jturner 4633: process_sqliterc(&data,zInitFile);
1.1 espie 4634:
4635: /* Make a second pass through the command-line argument and set
4636: ** options. This second pass is delayed until after the initialization
4637: ** file is processed so that the command-line arguments will override
4638: ** settings in the initialization file.
4639: */
1.5 espie 4640: for(i=1; i<argc; i++){
1.1 espie 4641: char *z = argv[i];
1.5 espie 4642: if( z[0]!='-' ) continue;
1.1 espie 4643: if( z[1]=='-' ){ z++; }
4644: if( strcmp(z,"-init")==0 ){
4645: i++;
4646: }else if( strcmp(z,"-html")==0 ){
4647: data.mode = MODE_Html;
4648: }else if( strcmp(z,"-list")==0 ){
4649: data.mode = MODE_List;
4650: }else if( strcmp(z,"-line")==0 ){
4651: data.mode = MODE_Line;
4652: }else if( strcmp(z,"-column")==0 ){
4653: data.mode = MODE_Column;
4654: }else if( strcmp(z,"-csv")==0 ){
4655: data.mode = MODE_Csv;
1.11 jturner 4656: memcpy(data.colSeparator,",",2);
4657: }else if( strcmp(z,"-ascii")==0 ){
4658: data.mode = MODE_Ascii;
4659: sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
4660: SEP_Unit);
4661: sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
4662: SEP_Record);
1.1 espie 4663: }else if( strcmp(z,"-separator")==0 ){
1.11 jturner 4664: sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
1.9 jturner 4665: "%s",cmdline_option_value(argc,argv,++i));
4666: }else if( strcmp(z,"-newline")==0 ){
1.11 jturner 4667: sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
1.5 espie 4668: "%s",cmdline_option_value(argc,argv,++i));
1.1 espie 4669: }else if( strcmp(z,"-nullvalue")==0 ){
1.11 jturner 4670: sqlite3_snprintf(sizeof(data.nullValue), data.nullValue,
1.5 espie 4671: "%s",cmdline_option_value(argc,argv,++i));
1.1 espie 4672: }else if( strcmp(z,"-header")==0 ){
4673: data.showHeader = 1;
4674: }else if( strcmp(z,"-noheader")==0 ){
4675: data.showHeader = 0;
4676: }else if( strcmp(z,"-echo")==0 ){
4677: data.echoOn = 1;
1.8 jturner 4678: }else if( strcmp(z,"-eqp")==0 ){
4679: data.autoEQP = 1;
1.1 espie 4680: }else if( strcmp(z,"-stats")==0 ){
4681: data.statsOn = 1;
1.11 jturner 4682: }else if( strcmp(z,"-scanstats")==0 ){
4683: data.scanstatsOn = 1;
1.13 ! jturner 4684: }else if( strcmp(z,"-backslash")==0 ){
! 4685: /* Undocumented command-line option: -backslash
! 4686: ** Causes C-style backslash escapes to be evaluated in SQL statements
! 4687: ** prior to sending the SQL into SQLite. Useful for injecting
! 4688: ** crazy bytes in the middle of SQL statements for testing and debugging.
! 4689: */
! 4690: data.backslashOn = 1;
1.1 espie 4691: }else if( strcmp(z,"-bail")==0 ){
4692: bail_on_error = 1;
4693: }else if( strcmp(z,"-version")==0 ){
4694: printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
4695: return 0;
4696: }else if( strcmp(z,"-interactive")==0 ){
4697: stdin_is_interactive = 1;
4698: }else if( strcmp(z,"-batch")==0 ){
4699: stdin_is_interactive = 0;
4700: }else if( strcmp(z,"-heap")==0 ){
4701: i++;
1.10 jturner 4702: }else if( strcmp(z,"-scratch")==0 ){
4703: i+=2;
4704: }else if( strcmp(z,"-pagecache")==0 ){
4705: i+=2;
4706: }else if( strcmp(z,"-lookaside")==0 ){
4707: i+=2;
1.6 landry 4708: }else if( strcmp(z,"-mmap")==0 ){
4709: i++;
1.1 espie 4710: }else if( strcmp(z,"-vfs")==0 ){
4711: i++;
4712: #ifdef SQLITE_ENABLE_VFSTRACE
4713: }else if( strcmp(z,"-vfstrace")==0 ){
4714: i++;
4715: #endif
4716: #ifdef SQLITE_ENABLE_MULTIPLEX
4717: }else if( strcmp(z,"-multiplex")==0 ){
4718: i++;
4719: #endif
4720: }else if( strcmp(z,"-help")==0 ){
4721: usage(1);
4722: }else if( strcmp(z,"-cmd")==0 ){
1.11 jturner 4723: /* Run commands that follow -cmd first and separately from commands
4724: ** that simply appear on the command-line. This seems goofy. It would
4725: ** be better if all commands ran in the order that they appear. But
4726: ** we retain the goofy behavior for historical compatibility. */
1.1 espie 4727: if( i==argc-1 ) break;
1.5 espie 4728: z = cmdline_option_value(argc,argv,++i);
1.1 espie 4729: if( z[0]=='.' ){
4730: rc = do_meta_command(z, &data);
1.6 landry 4731: if( rc && bail_on_error ) return rc==2 ? 0 : rc;
1.1 espie 4732: }else{
1.8 jturner 4733: open_db(&data, 0);
1.1 espie 4734: rc = shell_exec(data.db, z, shell_callback, &data, &zErrMsg);
4735: if( zErrMsg!=0 ){
4736: fprintf(stderr,"Error: %s\n", zErrMsg);
4737: if( bail_on_error ) return rc!=0 ? rc : 1;
4738: }else if( rc!=0 ){
4739: fprintf(stderr,"Error: unable to process SQL \"%s\"\n", z);
4740: if( bail_on_error ) return rc;
4741: }
4742: }
4743: }else{
4744: fprintf(stderr,"%s: Error: unknown option: %s\n", Argv0, z);
4745: fprintf(stderr,"Use -help for a list of options.\n");
4746: return 1;
4747: }
4748: }
4749:
1.11 jturner 4750: if( !readStdin ){
4751: /* Run all arguments that do not begin with '-' as if they were separate
4752: ** command-line inputs, except for the argToSkip argument which contains
4753: ** the database filename.
1.1 espie 4754: */
1.11 jturner 4755: for(i=0; i<nCmd; i++){
4756: if( azCmd[i][0]=='.' ){
4757: rc = do_meta_command(azCmd[i], &data);
4758: if( rc ) return rc==2 ? 0 : rc;
4759: }else{
4760: open_db(&data, 0);
4761: rc = shell_exec(data.db, azCmd[i], shell_callback, &data, &zErrMsg);
4762: if( zErrMsg!=0 ){
4763: fprintf(stderr,"Error: %s\n", zErrMsg);
4764: return rc!=0 ? rc : 1;
4765: }else if( rc!=0 ){
4766: fprintf(stderr,"Error: unable to process SQL: %s\n", azCmd[i]);
4767: return rc;
4768: }
1.1 espie 4769: }
4770: }
1.11 jturner 4771: free(azCmd);
1.1 espie 4772: }else{
4773: /* Run commands received from standard input
4774: */
4775: if( stdin_is_interactive ){
4776: char *zHome;
4777: char *zHistory = 0;
4778: int nHistory;
4779: printf(
4780: "SQLite version %s %.19s\n" /*extra-version-info*/
1.8 jturner 4781: "Enter \".help\" for usage hints.\n",
1.1 espie 4782: sqlite3_libversion(), sqlite3_sourceid()
4783: );
1.8 jturner 4784: if( warnInmemoryDb ){
4785: printf("Connected to a ");
4786: printBold("transient in-memory database");
4787: printf(".\nUse \".open FILENAME\" to reopen on a "
4788: "persistent database.\n");
4789: }
1.1 espie 4790: zHome = find_home_dir();
4791: if( zHome ){
4792: nHistory = strlen30(zHome) + 20;
4793: if( (zHistory = malloc(nHistory))!=0 ){
4794: sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
4795: }
4796: }
1.13 ! jturner 4797: if( zHistory ){ shell_read_history(zHistory); }
1.1 espie 4798: rc = process_input(&data, 0);
4799: if( zHistory ){
1.11 jturner 4800: shell_stifle_history(100);
4801: shell_write_history(zHistory);
1.1 espie 4802: free(zHistory);
4803: }
4804: }else{
4805: rc = process_input(&data, stdin);
4806: }
4807: }
4808: set_table_name(&data, 0);
4809: if( data.db ){
4810: sqlite3_close(data.db);
4811: }
1.8 jturner 4812: sqlite3_free(data.zFreeOnClose);
1.1 espie 4813: return rc;
4814: }
![[BACK]](/icons/back.gif){kind=icon}
Return to shell.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / sqlite3