4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
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.
11 *************************************************************************
12 ** This file contains code to implement the "sqlite" command line
13 ** utility for accessing SQLite databases.
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
21 ** If requested, include the SQLite compiler options file for MSVC.
23 #if defined(INCLUDE_MSVC_H)
28 ** No support for loadable extensions in VxWorks.
30 #if (defined(__RTP__) || defined(_WRS_KERNEL)) && !SQLITE_OMIT_LOAD_EXTENSION
31 # define SQLITE_OMIT_LOAD_EXTENSION 1
35 ** Enable large-file support for fopen() and friends on unix.
37 #ifndef SQLITE_DISABLE_LFS
38 # define _LARGE_FILE 1
39 # ifndef _FILE_OFFSET_BITS
40 # define _FILE_OFFSET_BITS 64
42 # define _LARGEFILE_SOURCE 1
50 #if SQLITE_USER_AUTHENTICATION
51 # include "sqlite3userauth.h"
56 #if !defined(_WIN32) && !defined(WIN32)
58 # if !defined(__RTP__) && !defined(_WRS_KERNEL)
62 # include <sys/types.h>
66 # include <readline/readline.h>
67 # include <readline/history.h>
71 # include <editline/readline.h>
74 #if HAVE_EDITLINE || HAVE_READLINE
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)
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)
93 # define shell_read_history(X)
94 # define shell_write_history(X)
95 # define shell_stifle_history(X)
97 # define SHELL_USE_LOCAL_GETLINE 1
101 #if defined(_WIN32) || defined(WIN32)
104 # define isatty(h) _isatty(h)
106 # define access(f,m) _access((f),(m))
109 # define popen _popen
111 # define pclose _pclose
113 /* Make sure isatty() has a prototype. */
114 extern int isatty(int);
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*);
122 # define SQLITE_OMIT_POPEN 1
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.
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)
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.
145 #if defined(_WIN32) || defined(WIN32)
146 static void setBinaryMode(FILE *out
){
148 _setmode(_fileno(out
), _O_BINARY
);
150 static void setTextMode(FILE *out
){
152 _setmode(_fileno(out
), _O_TEXT
);
155 # define setBinaryMode(X)
156 # define setTextMode(X)
160 /* True if the timer is enabled */
161 static int enableTimer
= 0;
163 /* Return the current wall-clock time */
164 static sqlite3_int64
timeOfDay(void){
165 static sqlite3_vfs
*clockVfs
= 0;
167 if( clockVfs
==0 ) clockVfs
= sqlite3_vfs_find(0);
168 if( clockVfs
->iVersion
>=2 && clockVfs
->xCurrentTimeInt64
!=0 ){
169 clockVfs
->xCurrentTimeInt64(clockVfs
, &t
);
172 clockVfs
->xCurrentTime(clockVfs
, &r
);
173 t
= (sqlite3_int64
)(r
*86400000.0);
178 #if !defined(_WIN32) && !defined(WIN32) && !defined(__minux)
179 #include <sys/time.h>
180 #include <sys/resource.h>
182 /* VxWorks does not support getrusage() as far as we can determine */
183 #if defined(_WRS_KERNEL) || defined(__RTP__)
185 struct timeval ru_utime
; /* user CPU time used */
186 struct timeval ru_stime
; /* system CPU time used */
188 #define getrusage(A,B) memset(B,0,sizeof(*B))
191 /* Saved resource information for the beginning of an operation */
192 static struct rusage sBegin
; /* CPU time at start */
193 static sqlite3_int64 iBegin
; /* Wall-clock time at start */
196 ** Begin timing an operation
198 static void beginTimer(void){
200 getrusage(RUSAGE_SELF
, &sBegin
);
201 iBegin
= timeOfDay();
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
);
212 ** Print the timing results.
214 static void endTimer(void){
216 sqlite3_int64 iEnd
= timeOfDay();
218 getrusage(RUSAGE_SELF
, &sEnd
);
219 printf("Run Time: real %.3f user %f sys %f\n",
220 (iEnd
- iBegin
)*0.001,
221 timeDiff(&sBegin
.ru_utime
, &sEnd
.ru_utime
),
222 timeDiff(&sBegin
.ru_stime
, &sEnd
.ru_stime
));
226 #define BEGIN_TIMER beginTimer()
227 #define END_TIMER endTimer()
230 #elif (defined(_WIN32) || defined(WIN32))
234 /* Saved resource information for the beginning of an operation */
235 static HANDLE hProcess
;
236 static FILETIME ftKernelBegin
;
237 static FILETIME ftUserBegin
;
238 static sqlite3_int64 ftWallBegin
;
239 typedef BOOL (WINAPI
*GETPROCTIMES
)(HANDLE
, LPFILETIME
, LPFILETIME
,
240 LPFILETIME
, LPFILETIME
);
241 static GETPROCTIMES getProcessTimesAddr
= NULL
;
244 ** Check to see if we have timer support. Return 1 if necessary
245 ** support found (or found previously).
247 static int hasTimer(void){
248 if( getProcessTimesAddr
){
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.
255 hProcess
= GetCurrentProcess();
257 HINSTANCE hinstLib
= LoadLibrary(TEXT("Kernel32.dll"));
258 if( NULL
!= hinstLib
){
259 getProcessTimesAddr
=
260 (GETPROCTIMES
) GetProcAddress(hinstLib
, "GetProcessTimes");
261 if( NULL
!= getProcessTimesAddr
){
264 FreeLibrary(hinstLib
);
272 ** Begin timing an operation
274 static void beginTimer(void){
275 if( enableTimer
&& getProcessTimesAddr
){
276 FILETIME ftCreation
, ftExit
;
277 getProcessTimesAddr(hProcess
,&ftCreation
,&ftExit
,
278 &ftKernelBegin
,&ftUserBegin
);
279 ftWallBegin
= timeOfDay();
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);
291 ** Print the timing results.
293 static void endTimer(void){
294 if( enableTimer
&& getProcessTimesAddr
){
295 FILETIME ftCreation
, ftExit
, ftKernelEnd
, ftUserEnd
;
296 sqlite3_int64 ftWallEnd
= timeOfDay();
297 getProcessTimesAddr(hProcess
,&ftCreation
,&ftExit
,&ftKernelEnd
,&ftUserEnd
);
298 printf("Run Time: real %.3f user %f sys %f\n",
299 (ftWallEnd
- ftWallBegin
)*0.001,
300 timeDiff(&ftUserBegin
, &ftUserEnd
),
301 timeDiff(&ftKernelBegin
, &ftKernelEnd
));
305 #define BEGIN_TIMER beginTimer()
306 #define END_TIMER endTimer()
307 #define HAS_TIMER hasTimer()
316 ** Used to prevent warnings about unused parameters
318 #define UNUSED_PARAMETER(x) (void)(x)
321 ** If the following flag is set, then command execution stops
322 ** at an error if we are not interactive.
324 static int bail_on_error
= 0;
327 ** Threat stdin as an interactive input if the following variable
328 ** is true. Otherwise, assume stdin is connected to a file or pipe.
330 static int stdin_is_interactive
= 1;
333 ** On Windows systems we have to know if standard output is a console
334 ** in order to translate UTF-8 into MBCS. The following variable is
335 ** true if translation is required.
337 static int stdout_is_console
= 1;
340 ** The following is the open SQLite database. We make a pointer
341 ** to this database a static variable so that it can be accessed
342 ** by the SIGINT handler to interrupt database processing.
344 static sqlite3
*globalDb
= 0;
347 ** True if an interrupt (Control-C) has been received.
349 static volatile int seenInterrupt
= 0;
352 ** This is the name of our program. It is set in main(), used
353 ** in a number of other places, mostly for error messages.
358 ** Prompt strings. Initialized in main. Settable with
359 ** .prompt main continue
361 static char mainPrompt
[20]; /* First line prompt. default: "sqlite> "*/
362 static char continuePrompt
[20]; /* Continuation prompt. default: " ...> " */
365 ** Write I/O traces to the following stream.
367 #ifdef SQLITE_ENABLE_IOTRACE
368 static FILE *iotrace
= 0;
372 ** This routine works like printf in that its first argument is a
373 ** format string and subsequent arguments are values to be substituted
374 ** in place of % fields. The result of formatting this string
375 ** is written to iotrace.
377 #ifdef SQLITE_ENABLE_IOTRACE
378 static void SQLITE_CDECL
iotracePrintf(const char *zFormat
, ...){
381 if( iotrace
==0 ) return;
382 va_start(ap
, zFormat
);
383 z
= sqlite3_vmprintf(zFormat
, ap
);
385 fprintf(iotrace
, "%s", z
);
392 ** Determines if a string is a number of not.
394 static int isNumber(const char *z
, int *realnum
){
395 if( *z
=='-' || *z
=='+' ) z
++;
400 if( realnum
) *realnum
= 0;
401 while( IsDigit(*z
) ){ z
++; }
404 if( !IsDigit(*z
) ) return 0;
405 while( IsDigit(*z
) ){ z
++; }
406 if( realnum
) *realnum
= 1;
408 if( *z
=='e' || *z
=='E' ){
410 if( *z
=='+' || *z
=='-' ) z
++;
411 if( !IsDigit(*z
) ) return 0;
412 while( IsDigit(*z
) ){ z
++; }
413 if( realnum
) *realnum
= 1;
419 ** A global char* and an SQL function to access its current value
420 ** from within an SQL statement. This program used to use the
421 ** sqlite_exec_printf() API to substitue a string into an SQL statement.
422 ** The correct way to do this with sqlite3 is to use the bind API, but
423 ** since the shell is built around the callback paradigm it would be a lot
424 ** of work. Instead just use this hack, which is quite harmless.
426 static const char *zShellStatic
= 0;
427 static void shellstaticFunc(
428 sqlite3_context
*context
,
433 assert( zShellStatic
);
434 UNUSED_PARAMETER(argc
);
435 UNUSED_PARAMETER(argv
);
436 sqlite3_result_text(context
, zShellStatic
, -1, SQLITE_STATIC
);
441 ** Compute a string length that is limited to what can be stored in
442 ** lower 30 bits of a 32-bit signed integer.
444 static int strlen30(const char *z
){
446 while( *z2
){ z2
++; }
447 return 0x3fffffff & (int)(z2
- z
);
451 ** This routine reads a line of text from FILE in, stores
452 ** the text in memory obtained from malloc() and returns a pointer
453 ** to the text. NULL is returned at end of file, or if malloc()
456 ** If zLine is not NULL then it is a malloced buffer returned from
457 ** a previous call to this routine that may be reused.
459 static char *local_getline(char *zLine
, FILE *in
){
460 int nLine
= zLine
==0 ? 0 : 100;
465 nLine
= nLine
*2 + 100;
466 zLine
= realloc(zLine
, nLine
);
467 if( zLine
==0 ) return 0;
469 if( fgets(&zLine
[n
], nLine
- n
, in
)==0 ){
477 while( zLine
[n
] ) n
++;
478 if( n
>0 && zLine
[n
-1]=='\n' ){
480 if( n
>0 && zLine
[n
-1]=='\r' ) n
--;
485 #if defined(_WIN32) || defined(WIN32)
486 /* For interactive input on Windows systems, translate the
487 ** multi-byte characterset characters into UTF-8. */
488 if( stdin_is_interactive
){
489 extern char *sqlite3_win32_mbcs_to_utf8(const char*);
490 char *zTrans
= sqlite3_win32_mbcs_to_utf8(zLine
);
492 int nTrans
= strlen30(zTrans
)+1;
494 zLine
= realloc(zLine
, nTrans
);
496 sqlite3_free(zTrans
);
500 memcpy(zLine
, zTrans
, nTrans
);
501 sqlite3_free(zTrans
);
504 #endif /* defined(_WIN32) || defined(WIN32) */
509 ** Retrieve a single line of input text.
511 ** If in==0 then read from standard input and prompt before each line.
512 ** If isContinuation is true, then a continuation prompt is appropriate.
513 ** If isContinuation is zero, then the main prompt should be used.
515 ** If zPrior is not NULL then it is a buffer from a prior call to this
516 ** routine that can be reused.
518 ** The result is stored in space obtained from malloc() and must either
519 ** be freed by the caller or else passed back into this routine via the
520 ** zPrior argument for reuse.
522 static char *one_input_line(FILE *in
, char *zPrior
, int isContinuation
){
526 zResult
= local_getline(zPrior
, in
);
528 zPrompt
= isContinuation
? continuePrompt
: mainPrompt
;
529 #if SHELL_USE_LOCAL_GETLINE
530 printf("%s", zPrompt
);
532 zResult
= local_getline(zPrior
, stdin
);
535 zResult
= shell_readline(zPrompt
);
536 if( zResult
&& *zResult
) shell_add_history(zResult
);
543 ** Render output like fprintf(). Except, if the output is going to the
544 ** console and if this is running on a Windows machine, translate the
545 ** output from UTF-8 into MBCS.
547 #if defined(_WIN32) || defined(WIN32)
548 void utf8_printf(FILE *out
, const char *zFormat
, ...){
550 va_start(ap
, zFormat
);
551 if( stdout_is_console
&& (out
==stdout
|| out
==stderr
) ){
552 extern char *sqlite3_win32_utf8_to_mbcs(const char*);
553 char *z1
= sqlite3_vmprintf(zFormat
, ap
);
554 char *z2
= sqlite3_win32_utf8_to_mbcs(z1
);
559 vfprintf(out
, zFormat
, ap
);
563 #elif !defined(utf8_printf)
564 # define utf8_printf fprintf
568 ** Render output like fprintf(). This should not be used on anything that
569 ** includes string formatting (e.g. "%s").
571 #if !defined(raw_printf)
572 # define raw_printf fprintf
576 ** Shell output mode information from before ".explain on",
577 ** saved so that it can be restored by ".explain off"
579 typedef struct SavedModeInfo SavedModeInfo
;
580 struct SavedModeInfo
{
581 int valid
; /* Is there legit data in here? */
582 int mode
; /* Mode prior to ".explain on" */
583 int showHeader
; /* The ".header" setting prior to ".explain on" */
584 int colWidth
[100]; /* Column widths prior to ".explain on" */
588 ** State information about the database connection is contained in an
589 ** instance of the following structure.
591 typedef struct ShellState ShellState
;
593 sqlite3
*db
; /* The database */
594 int echoOn
; /* True to echo input commands */
595 int autoExplain
; /* Automatically turn on .explain mode */
596 int autoEQP
; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
597 int statsOn
; /* True to display memory stats before each finalize */
598 int scanstatsOn
; /* True to display scan stats before each finalize */
599 int countChanges
; /* True to display change counts */
600 int backslashOn
; /* Resolve C-style \x escapes in SQL input text */
601 int outCount
; /* Revert to stdout when reaching zero */
602 int cnt
; /* Number of records displayed so far */
603 FILE *out
; /* Write results here */
604 FILE *traceOut
; /* Output for sqlite3_trace() */
605 int nErr
; /* Number of errors seen */
606 int mode
; /* An output mode setting */
607 int cMode
; /* temporary output mode for the current query */
608 int normalMode
; /* Output mode before ".explain on" */
609 int writableSchema
; /* True if PRAGMA writable_schema=ON */
610 int showHeader
; /* True to show column names in List or Column mode */
611 unsigned shellFlgs
; /* Various flags */
612 char *zDestTable
; /* Name of destination table when MODE_Insert */
613 char colSeparator
[20]; /* Column separator character for several modes */
614 char rowSeparator
[20]; /* Row separator character for MODE_Ascii */
615 int colWidth
[100]; /* Requested width of each column when in column mode*/
616 int actualWidth
[100]; /* Actual width of each column */
617 char nullValue
[20]; /* The text to print when a NULL comes back from
619 char outfile
[FILENAME_MAX
]; /* Filename for *out */
620 const char *zDbFilename
; /* name of the database file */
621 char *zFreeOnClose
; /* Filename to free when closing */
622 const char *zVfs
; /* Name of VFS to use */
623 sqlite3_stmt
*pStmt
; /* Current statement if any. */
624 FILE *pLog
; /* Write log output here */
625 int *aiIndent
; /* Array of indents used in MODE_Explain */
626 int nIndent
; /* Size of array aiIndent[] */
627 int iIndent
; /* Index of current op in aiIndent[] */
631 ** These are the allowed shellFlgs values
633 #define SHFLG_Scratch 0x00001 /* The --scratch option is used */
634 #define SHFLG_Pagecache 0x00002 /* The --pagecache option is used */
635 #define SHFLG_Lookaside 0x00004 /* Lookaside memory is used */
638 ** These are the allowed modes.
640 #define MODE_Line 0 /* One column per line. Blank line between records */
641 #define MODE_Column 1 /* One record per line in neat columns */
642 #define MODE_List 2 /* One record per line with a separator */
643 #define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */
644 #define MODE_Html 4 /* Generate an XHTML table */
645 #define MODE_Insert 5 /* Generate SQL "insert" statements */
646 #define MODE_Tcl 6 /* Generate ANSI-C or TCL quoted elements */
647 #define MODE_Csv 7 /* Quote strings, numbers are plain */
648 #define MODE_Explain 8 /* Like MODE_Column, but do not truncate data */
649 #define MODE_Ascii 9 /* Use ASCII unit and record separators (0x1F/0x1E) */
651 static const char *modeDescr
[] = {
665 ** These are the column/row/line separators used by the various
666 ** import/export modes.
668 #define SEP_Column "|"
671 #define SEP_Space " "
672 #define SEP_Comma ","
673 #define SEP_CrLf "\r\n"
674 #define SEP_Unit "\x1F"
675 #define SEP_Record "\x1E"
678 ** Number of elements in an array
680 #define ArraySize(X) (int)(sizeof(X)/sizeof(X[0]))
683 ** A callback for the sqlite3_log() interface.
685 static void shellLog(void *pArg
, int iErrCode
, const char *zMsg
){
686 ShellState
*p
= (ShellState
*)pArg
;
687 if( p
->pLog
==0 ) return;
688 utf8_printf(p
->pLog
, "(%d) %s\n", iErrCode
, zMsg
);
693 ** Output the given string as a hex-encoded blob (eg. X'1234' )
695 static void output_hex_blob(FILE *out
, const void *pBlob
, int nBlob
){
697 char *zBlob
= (char *)pBlob
;
698 raw_printf(out
,"X'");
699 for(i
=0; i
<nBlob
; i
++){ raw_printf(out
,"%02x",zBlob
[i
]&0xff); }
704 ** Output the given string as a quoted string using SQL quoting conventions.
706 static void output_quoted_string(FILE *out
, const char *z
){
711 if( z
[i
]=='\'' ) nSingle
++;
714 utf8_printf(out
,"'%s'",z
);
718 for(i
=0; z
[i
] && z
[i
]!='\''; i
++){}
720 raw_printf(out
,"''");
722 }else if( z
[i
]=='\'' ){
723 utf8_printf(out
,"%.*s''",i
,z
);
726 utf8_printf(out
,"%s",z
);
736 ** Output the given string as a quoted according to C or TCL quoting rules.
738 static void output_c_string(FILE *out
, const char *z
){
741 while( (c
= *(z
++))!=0 ){
757 }else if( !isprint(c
&0xff) ){
758 raw_printf(out
, "\\%03o", c
&0xff);
767 ** Output the given string with characters that are special to
770 static void output_html_string(FILE *out
, const char *z
){
782 utf8_printf(out
,"%.*s",i
,z
);
785 raw_printf(out
,"<");
786 }else if( z
[i
]=='&' ){
787 raw_printf(out
,"&");
788 }else if( z
[i
]=='>' ){
789 raw_printf(out
,">");
790 }else if( z
[i
]=='\"' ){
791 raw_printf(out
,""");
792 }else if( z
[i
]=='\'' ){
793 raw_printf(out
,"'");
802 ** If a field contains any character identified by a 1 in the following
803 ** array, then the string must be quoted for CSV.
805 static const char needCsvQuote
[] = {
806 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
807 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
808 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
809 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
810 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
811 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
812 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
813 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
814 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
815 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
816 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
817 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
818 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
819 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
820 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
821 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
825 ** Output a single term of CSV. Actually, p->colSeparator is used for
826 ** the separator, which may or may not be a comma. p->nullValue is
827 ** the null value. Strings are quoted if necessary. The separator
828 ** is only issued if bSep is true.
830 static void output_csv(ShellState
*p
, const char *z
, int bSep
){
833 utf8_printf(out
,"%s",p
->nullValue
);
836 int nSep
= strlen30(p
->colSeparator
);
838 if( needCsvQuote
[((unsigned char*)z
)[i
]]
839 || (z
[i
]==p
->colSeparator
[0] &&
840 (nSep
==1 || memcmp(z
, p
->colSeparator
, nSep
)==0)) ){
848 if( z
[i
]=='"' ) putc('"', out
);
853 utf8_printf(out
, "%s", z
);
857 utf8_printf(p
->out
, "%s", p
->colSeparator
);
863 ** This routine runs when the user presses Ctrl-C
865 static void interrupt_handler(int NotUsed
){
866 UNUSED_PARAMETER(NotUsed
);
868 if( seenInterrupt
>2 ) exit(1);
869 if( globalDb
) sqlite3_interrupt(globalDb
);
874 ** This is the callback routine that the shell
875 ** invokes for each row of a query result.
877 static int shell_callback(
879 int nArg
, /* Number of result columns */
880 char **azArg
, /* Text of each result column */
881 char **azCol
, /* Column names */
882 int *aiType
/* Column types */
885 ShellState
*p
= (ShellState
*)pArg
;
890 if( azArg
==0 ) break;
891 for(i
=0; i
<nArg
; i
++){
892 int len
= strlen30(azCol
[i
] ? azCol
[i
] : "");
895 if( p
->cnt
++>0 ) utf8_printf(p
->out
, "%s", p
->rowSeparator
);
896 for(i
=0; i
<nArg
; i
++){
897 utf8_printf(p
->out
,"%*s = %s%s", w
, azCol
[i
],
898 azArg
[i
] ? azArg
[i
] : p
->nullValue
, p
->rowSeparator
);
904 static const int aExplainWidths
[] = {4, 13, 4, 4, 4, 13, 2, 13};
908 if( p
->cMode
==MODE_Column
){
909 colWidth
= p
->colWidth
;
910 showHdr
= p
->showHeader
;
911 rowSep
= p
->rowSeparator
;
913 colWidth
= aExplainWidths
;
918 for(i
=0; i
<nArg
; i
++){
920 if( i
<ArraySize(p
->colWidth
) ){
926 w
= strlen30(azCol
[i
] ? azCol
[i
] : "");
928 n
= strlen30(azArg
&& azArg
[i
] ? azArg
[i
] : p
->nullValue
);
931 if( i
<ArraySize(p
->actualWidth
) ){
932 p
->actualWidth
[i
] = w
;
936 utf8_printf(p
->out
,"%*.*s%s",-w
,-w
,azCol
[i
],
937 i
==nArg
-1 ? rowSep
: " ");
939 utf8_printf(p
->out
,"%-*.*s%s",w
,w
,azCol
[i
],
940 i
==nArg
-1 ? rowSep
: " ");
945 for(i
=0; i
<nArg
; i
++){
947 if( i
<ArraySize(p
->actualWidth
) ){
948 w
= p
->actualWidth
[i
];
953 utf8_printf(p
->out
,"%-*.*s%s",w
,w
,
954 "----------------------------------------------------------"
955 "----------------------------------------------------------",
956 i
==nArg
-1 ? rowSep
: " ");
960 if( azArg
==0 ) break;
961 for(i
=0; i
<nArg
; i
++){
963 if( i
<ArraySize(p
->actualWidth
) ){
964 w
= p
->actualWidth
[i
];
968 if( p
->cMode
==MODE_Explain
&& azArg
[i
] && strlen30(azArg
[i
])>w
){
969 w
= strlen30(azArg
[i
]);
971 if( i
==1 && p
->aiIndent
&& p
->pStmt
){
972 if( p
->iIndent
<p
->nIndent
){
973 utf8_printf(p
->out
, "%*.s", p
->aiIndent
[p
->iIndent
], "");
978 utf8_printf(p
->out
,"%*.*s%s",-w
,-w
,
979 azArg
[i
] ? azArg
[i
] : p
->nullValue
,
980 i
==nArg
-1 ? rowSep
: " ");
982 utf8_printf(p
->out
,"%-*.*s%s",w
,w
,
983 azArg
[i
] ? azArg
[i
] : p
->nullValue
,
984 i
==nArg
-1 ? rowSep
: " ");
991 if( p
->cnt
++==0 && p
->showHeader
){
992 for(i
=0; i
<nArg
; i
++){
993 utf8_printf(p
->out
,"%s%s",azCol
[i
],
994 i
==nArg
-1 ? p
->rowSeparator
: p
->colSeparator
);
997 if( azArg
==0 ) break;
998 for(i
=0; i
<nArg
; i
++){
1000 if( z
==0 ) z
= p
->nullValue
;
1001 utf8_printf(p
->out
, "%s", z
);
1003 utf8_printf(p
->out
, "%s", p
->colSeparator
);
1004 }else if( p
->cMode
==MODE_Semi
){
1005 utf8_printf(p
->out
, ";%s", p
->rowSeparator
);
1007 utf8_printf(p
->out
, "%s", p
->rowSeparator
);
1013 if( p
->cnt
++==0 && p
->showHeader
){
1014 raw_printf(p
->out
,"<TR>");
1015 for(i
=0; i
<nArg
; i
++){
1016 raw_printf(p
->out
,"<TH>");
1017 output_html_string(p
->out
, azCol
[i
]);
1018 raw_printf(p
->out
,"</TH>\n");
1020 raw_printf(p
->out
,"</TR>\n");
1022 if( azArg
==0 ) break;
1023 raw_printf(p
->out
,"<TR>");
1024 for(i
=0; i
<nArg
; i
++){
1025 raw_printf(p
->out
,"<TD>");
1026 output_html_string(p
->out
, azArg
[i
] ? azArg
[i
] : p
->nullValue
);
1027 raw_printf(p
->out
,"</TD>\n");
1029 raw_printf(p
->out
,"</TR>\n");
1033 if( p
->cnt
++==0 && p
->showHeader
){
1034 for(i
=0; i
<nArg
; i
++){
1035 output_c_string(p
->out
,azCol
[i
] ? azCol
[i
] : "");
1036 if(i
<nArg
-1) utf8_printf(p
->out
, "%s", p
->colSeparator
);
1038 utf8_printf(p
->out
, "%s", p
->rowSeparator
);
1040 if( azArg
==0 ) break;
1041 for(i
=0; i
<nArg
; i
++){
1042 output_c_string(p
->out
, azArg
[i
] ? azArg
[i
] : p
->nullValue
);
1043 if(i
<nArg
-1) utf8_printf(p
->out
, "%s", p
->colSeparator
);
1045 utf8_printf(p
->out
, "%s", p
->rowSeparator
);
1049 setBinaryMode(p
->out
);
1050 if( p
->cnt
++==0 && p
->showHeader
){
1051 for(i
=0; i
<nArg
; i
++){
1052 output_csv(p
, azCol
[i
] ? azCol
[i
] : "", i
<nArg
-1);
1054 utf8_printf(p
->out
, "%s", p
->rowSeparator
);
1057 for(i
=0; i
<nArg
; i
++){
1058 output_csv(p
, azArg
[i
], i
<nArg
-1);
1060 utf8_printf(p
->out
, "%s", p
->rowSeparator
);
1062 setTextMode(p
->out
);
1067 if( azArg
==0 ) break;
1068 utf8_printf(p
->out
,"INSERT INTO %s",p
->zDestTable
);
1069 if( p
->showHeader
){
1070 raw_printf(p
->out
,"(");
1071 for(i
=0; i
<nArg
; i
++){
1072 char *zSep
= i
>0 ? ",": "";
1073 utf8_printf(p
->out
, "%s%s", zSep
, azCol
[i
]);
1075 raw_printf(p
->out
,")");
1077 raw_printf(p
->out
," VALUES(");
1078 for(i
=0; i
<nArg
; i
++){
1079 char *zSep
= i
>0 ? ",": "";
1080 if( (azArg
[i
]==0) || (aiType
&& aiType
[i
]==SQLITE_NULL
) ){
1081 utf8_printf(p
->out
,"%sNULL",zSep
);
1082 }else if( aiType
&& aiType
[i
]==SQLITE_TEXT
){
1083 if( zSep
[0] ) utf8_printf(p
->out
,"%s",zSep
);
1084 output_quoted_string(p
->out
, azArg
[i
]);
1085 }else if( aiType
&& (aiType
[i
]==SQLITE_INTEGER
1086 || aiType
[i
]==SQLITE_FLOAT
) ){
1087 utf8_printf(p
->out
,"%s%s",zSep
, azArg
[i
]);
1088 }else if( aiType
&& aiType
[i
]==SQLITE_BLOB
&& p
->pStmt
){
1089 const void *pBlob
= sqlite3_column_blob(p
->pStmt
, i
);
1090 int nBlob
= sqlite3_column_bytes(p
->pStmt
, i
);
1091 if( zSep
[0] ) utf8_printf(p
->out
,"%s",zSep
);
1092 output_hex_blob(p
->out
, pBlob
, nBlob
);
1093 }else if( isNumber(azArg
[i
], 0) ){
1094 utf8_printf(p
->out
,"%s%s",zSep
, azArg
[i
]);
1096 if( zSep
[0] ) utf8_printf(p
->out
,"%s",zSep
);
1097 output_quoted_string(p
->out
, azArg
[i
]);
1100 raw_printf(p
->out
,");\n");
1104 if( p
->cnt
++==0 && p
->showHeader
){
1105 for(i
=0; i
<nArg
; i
++){
1106 if( i
>0 ) utf8_printf(p
->out
, "%s", p
->colSeparator
);
1107 utf8_printf(p
->out
,"%s",azCol
[i
] ? azCol
[i
] : "");
1109 utf8_printf(p
->out
, "%s", p
->rowSeparator
);
1111 if( azArg
==0 ) break;
1112 for(i
=0; i
<nArg
; i
++){
1113 if( i
>0 ) utf8_printf(p
->out
, "%s", p
->colSeparator
);
1114 utf8_printf(p
->out
,"%s",azArg
[i
] ? azArg
[i
] : p
->nullValue
);
1116 utf8_printf(p
->out
, "%s", p
->rowSeparator
);
1124 ** This is the callback routine that the SQLite library
1125 ** invokes for each row of a query result.
1127 static int callback(void *pArg
, int nArg
, char **azArg
, char **azCol
){
1128 /* since we don't have type info, call the shell_callback with a NULL value */
1129 return shell_callback(pArg
, nArg
, azArg
, azCol
, NULL
);
1133 ** Set the destination table field of the ShellState structure to
1134 ** the name of the table given. Escape any quote characters in the
1137 static void set_table_name(ShellState
*p
, const char *zName
){
1142 if( p
->zDestTable
){
1143 free(p
->zDestTable
);
1146 if( zName
==0 ) return;
1147 needQuote
= !isalpha((unsigned char)*zName
) && *zName
!='_';
1148 for(i
=n
=0; zName
[i
]; i
++, n
++){
1149 if( !isalnum((unsigned char)zName
[i
]) && zName
[i
]!='_' ){
1151 if( zName
[i
]=='\'' ) n
++;
1154 if( needQuote
) n
+= 2;
1155 z
= p
->zDestTable
= malloc( n
+1 );
1157 raw_printf(stderr
,"Error: out of memory\n");
1161 if( needQuote
) z
[n
++] = '\'';
1162 for(i
=0; zName
[i
]; i
++){
1164 if( zName
[i
]=='\'' ) z
[n
++] = '\'';
1166 if( needQuote
) z
[n
++] = '\'';
1170 /* zIn is either a pointer to a NULL-terminated string in memory obtained
1171 ** from malloc(), or a NULL pointer. The string pointed to by zAppend is
1172 ** added to zIn, and the result returned in memory obtained from malloc().
1173 ** zIn, if it was not NULL, is freed.
1175 ** If the third argument, quote, is not '\0', then it is used as a
1176 ** quote character for zAppend.
1178 static char *appendText(char *zIn
, char const *zAppend
, char quote
){
1181 int nAppend
= strlen30(zAppend
);
1182 int nIn
= (zIn
?strlen30(zIn
):0);
1184 len
= nAppend
+nIn
+1;
1187 for(i
=0; i
<nAppend
; i
++){
1188 if( zAppend
[i
]==quote
) len
++;
1192 zIn
= (char *)realloc(zIn
, len
);
1198 char *zCsr
= &zIn
[nIn
];
1200 for(i
=0; i
<nAppend
; i
++){
1201 *zCsr
++ = zAppend
[i
];
1202 if( zAppend
[i
]==quote
) *zCsr
++ = quote
;
1206 assert( (zCsr
-zIn
)==len
);
1208 memcpy(&zIn
[nIn
], zAppend
, nAppend
);
1217 ** Execute a query statement that will generate SQL output. Print
1218 ** the result columns, comma-separated, on a line and then add a
1219 ** semicolon terminator to the end of that line.
1221 ** If the number of columns is 1 and that column contains text "--"
1222 ** then write the semicolon on a separate line. That way, if a
1223 ** "--" comment occurs at the end of the statement, the comment
1224 ** won't consume the semicolon terminator.
1226 static int run_table_dump_query(
1227 ShellState
*p
, /* Query context */
1228 const char *zSelect
, /* SELECT statement to extract content */
1229 const char *zFirstRow
/* Print before first row, if not NULL */
1231 sqlite3_stmt
*pSelect
;
1236 rc
= sqlite3_prepare_v2(p
->db
, zSelect
, -1, &pSelect
, 0);
1237 if( rc
!=SQLITE_OK
|| !pSelect
){
1238 utf8_printf(p
->out
, "/**** ERROR: (%d) %s *****/\n", rc
,
1239 sqlite3_errmsg(p
->db
));
1240 if( (rc
&0xff)!=SQLITE_CORRUPT
) p
->nErr
++;
1243 rc
= sqlite3_step(pSelect
);
1244 nResult
= sqlite3_column_count(pSelect
);
1245 while( rc
==SQLITE_ROW
){
1247 utf8_printf(p
->out
, "%s", zFirstRow
);
1250 z
= (const char*)sqlite3_column_text(pSelect
, 0);
1251 utf8_printf(p
->out
, "%s", z
);
1252 for(i
=1; i
<nResult
; i
++){
1253 utf8_printf(p
->out
, ",%s", sqlite3_column_text(pSelect
, i
));
1256 while( z
[0] && (z
[0]!='-' || z
[1]!='-') ) z
++;
1258 raw_printf(p
->out
, "\n;\n");
1260 raw_printf(p
->out
, ";\n");
1262 rc
= sqlite3_step(pSelect
);
1264 rc
= sqlite3_finalize(pSelect
);
1265 if( rc
!=SQLITE_OK
){
1266 utf8_printf(p
->out
, "/**** ERROR: (%d) %s *****/\n", rc
,
1267 sqlite3_errmsg(p
->db
));
1268 if( (rc
&0xff)!=SQLITE_CORRUPT
) p
->nErr
++;
1274 ** Allocate space and save off current error string.
1276 static char *save_err_msg(
1277 sqlite3
*db
/* Database to query */
1279 int nErrMsg
= 1+strlen30(sqlite3_errmsg(db
));
1280 char *zErrMsg
= sqlite3_malloc64(nErrMsg
);
1282 memcpy(zErrMsg
, sqlite3_errmsg(db
), nErrMsg
);
1289 ** Attempt to display I/O stats on Linux using /proc/PID/io
1291 static void displayLinuxIoStats(FILE *out
){
1294 sqlite3_snprintf(sizeof(z
), z
, "/proc/%d/io", getpid());
1295 in
= fopen(z
, "rb");
1297 while( fgets(z
, sizeof(z
), in
)!=0 ){
1298 static const struct {
1299 const char *zPattern
;
1302 { "rchar: ", "Bytes received by read():" },
1303 { "wchar: ", "Bytes sent to write():" },
1304 { "syscr: ", "Read() system calls:" },
1305 { "syscw: ", "Write() system calls:" },
1306 { "read_bytes: ", "Bytes read from storage:" },
1307 { "write_bytes: ", "Bytes written to storage:" },
1308 { "cancelled_write_bytes: ", "Cancelled write bytes:" },
1311 for(i
=0; i
<ArraySize(aTrans
); i
++){
1312 int n
= (int)strlen(aTrans
[i
].zPattern
);
1313 if( strncmp(aTrans
[i
].zPattern
, z
, n
)==0 ){
1314 raw_printf(out
, "%-36s %s", aTrans
[i
].zDesc
, &z
[n
]);
1325 ** Display memory stats.
1327 static int display_stats(
1328 sqlite3
*db
, /* Database to query */
1329 ShellState
*pArg
, /* Pointer to ShellState */
1330 int bReset
/* True to reset the stats */
1335 if( pArg
&& pArg
->out
){
1338 sqlite3_status(SQLITE_STATUS_MEMORY_USED
, &iCur
, &iHiwtr
, bReset
);
1339 raw_printf(pArg
->out
,
1340 "Memory Used: %d (max %d) bytes\n",
1343 sqlite3_status(SQLITE_STATUS_MALLOC_COUNT
, &iCur
, &iHiwtr
, bReset
);
1344 raw_printf(pArg
->out
, "Number of Outstanding Allocations: %d (max %d)\n",
1346 if( pArg
->shellFlgs
& SHFLG_Pagecache
){
1348 sqlite3_status(SQLITE_STATUS_PAGECACHE_USED
, &iCur
, &iHiwtr
, bReset
);
1349 raw_printf(pArg
->out
,
1350 "Number of Pcache Pages Used: %d (max %d) pages\n",
1354 sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW
, &iCur
, &iHiwtr
, bReset
);
1355 raw_printf(pArg
->out
,
1356 "Number of Pcache Overflow Bytes: %d (max %d) bytes\n",
1358 if( pArg
->shellFlgs
& SHFLG_Scratch
){
1360 sqlite3_status(SQLITE_STATUS_SCRATCH_USED
, &iCur
, &iHiwtr
, bReset
);
1361 raw_printf(pArg
->out
,
1362 "Number of Scratch Allocations Used: %d (max %d)\n",
1366 sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW
, &iCur
, &iHiwtr
, bReset
);
1367 raw_printf(pArg
->out
,
1368 "Number of Scratch Overflow Bytes: %d (max %d) bytes\n",
1371 sqlite3_status(SQLITE_STATUS_MALLOC_SIZE
, &iCur
, &iHiwtr
, bReset
);
1372 raw_printf(pArg
->out
, "Largest Allocation: %d bytes\n",
1375 sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE
, &iCur
, &iHiwtr
, bReset
);
1376 raw_printf(pArg
->out
, "Largest Pcache Allocation: %d bytes\n",
1379 sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE
, &iCur
, &iHiwtr
, bReset
);
1380 raw_printf(pArg
->out
, "Largest Scratch Allocation: %d bytes\n",
1382 #ifdef YYTRACKMAXSTACKDEPTH
1384 sqlite3_status(SQLITE_STATUS_PARSER_STACK
, &iCur
, &iHiwtr
, bReset
);
1385 raw_printf(pArg
->out
, "Deepest Parser Stack: %d (max %d)\n",
1390 if( pArg
&& pArg
->out
&& db
){
1391 if( pArg
->shellFlgs
& SHFLG_Lookaside
){
1393 sqlite3_db_status(db
, SQLITE_DBSTATUS_LOOKASIDE_USED
,
1394 &iCur
, &iHiwtr
, bReset
);
1395 raw_printf(pArg
->out
,
1396 "Lookaside Slots Used: %d (max %d)\n",
1398 sqlite3_db_status(db
, SQLITE_DBSTATUS_LOOKASIDE_HIT
,
1399 &iCur
, &iHiwtr
, bReset
);
1400 raw_printf(pArg
->out
, "Successful lookaside attempts: %d\n",
1402 sqlite3_db_status(db
, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE
,
1403 &iCur
, &iHiwtr
, bReset
);
1404 raw_printf(pArg
->out
, "Lookaside failures due to size: %d\n",
1406 sqlite3_db_status(db
, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL
,
1407 &iCur
, &iHiwtr
, bReset
);
1408 raw_printf(pArg
->out
, "Lookaside failures due to OOM: %d\n",
1412 sqlite3_db_status(db
, SQLITE_DBSTATUS_CACHE_USED
, &iCur
, &iHiwtr
, bReset
);
1413 raw_printf(pArg
->out
, "Pager Heap Usage: %d bytes\n",
1416 sqlite3_db_status(db
, SQLITE_DBSTATUS_CACHE_HIT
, &iCur
, &iHiwtr
, 1);
1417 raw_printf(pArg
->out
, "Page cache hits: %d\n", iCur
);
1419 sqlite3_db_status(db
, SQLITE_DBSTATUS_CACHE_MISS
, &iCur
, &iHiwtr
, 1);
1420 raw_printf(pArg
->out
, "Page cache misses: %d\n", iCur
);
1422 sqlite3_db_status(db
, SQLITE_DBSTATUS_CACHE_WRITE
, &iCur
, &iHiwtr
, 1);
1423 raw_printf(pArg
->out
, "Page cache writes: %d\n", iCur
);
1425 sqlite3_db_status(db
, SQLITE_DBSTATUS_SCHEMA_USED
, &iCur
, &iHiwtr
, bReset
);
1426 raw_printf(pArg
->out
, "Schema Heap Usage: %d bytes\n",
1429 sqlite3_db_status(db
, SQLITE_DBSTATUS_STMT_USED
, &iCur
, &iHiwtr
, bReset
);
1430 raw_printf(pArg
->out
, "Statement Heap/Lookaside Usage: %d bytes\n",
1434 if( pArg
&& pArg
->out
&& db
&& pArg
->pStmt
){
1435 iCur
= sqlite3_stmt_status(pArg
->pStmt
, SQLITE_STMTSTATUS_FULLSCAN_STEP
,
1437 raw_printf(pArg
->out
, "Fullscan Steps: %d\n", iCur
);
1438 iCur
= sqlite3_stmt_status(pArg
->pStmt
, SQLITE_STMTSTATUS_SORT
, bReset
);
1439 raw_printf(pArg
->out
, "Sort Operations: %d\n", iCur
);
1440 iCur
= sqlite3_stmt_status(pArg
->pStmt
, SQLITE_STMTSTATUS_AUTOINDEX
,bReset
);
1441 raw_printf(pArg
->out
, "Autoindex Inserts: %d\n", iCur
);
1442 iCur
= sqlite3_stmt_status(pArg
->pStmt
, SQLITE_STMTSTATUS_VM_STEP
, bReset
);
1443 raw_printf(pArg
->out
, "Virtual Machine Steps: %d\n", iCur
);
1447 displayLinuxIoStats(pArg
->out
);
1450 /* Do not remove this machine readable comment: extra-stats-output-here */
1456 ** Display scan stats.
1458 static void display_scanstats(
1459 sqlite3
*db
, /* Database to query */
1460 ShellState
*pArg
/* Pointer to ShellState */
1462 #ifndef SQLITE_ENABLE_STMT_SCANSTATUS
1463 UNUSED_PARAMETER(db
);
1464 UNUSED_PARAMETER(pArg
);
1467 raw_printf(pArg
->out
, "-------- scanstats --------\n");
1469 for(k
=0; k
<=mx
; k
++){
1470 double rEstLoop
= 1.0;
1472 sqlite3_stmt
*p
= pArg
->pStmt
;
1473 sqlite3_int64 nLoop
, nVisit
;
1476 const char *zExplain
;
1477 if( sqlite3_stmt_scanstatus(p
, i
, SQLITE_SCANSTAT_NLOOP
, (void*)&nLoop
) ){
1480 sqlite3_stmt_scanstatus(p
, i
, SQLITE_SCANSTAT_SELECTID
, (void*)&iSid
);
1481 if( iSid
>mx
) mx
= iSid
;
1482 if( iSid
!=k
) continue;
1484 rEstLoop
= (double)nLoop
;
1485 if( k
>0 ) raw_printf(pArg
->out
, "-------- subquery %d -------\n", k
);
1488 sqlite3_stmt_scanstatus(p
, i
, SQLITE_SCANSTAT_NVISIT
, (void*)&nVisit
);
1489 sqlite3_stmt_scanstatus(p
, i
, SQLITE_SCANSTAT_EST
, (void*)&rEst
);
1490 sqlite3_stmt_scanstatus(p
, i
, SQLITE_SCANSTAT_EXPLAIN
, (void*)&zExplain
);
1491 utf8_printf(pArg
->out
, "Loop %2d: %s\n", n
, zExplain
);
1493 raw_printf(pArg
->out
,
1494 " nLoop=%-8lld nRow=%-8lld estRow=%-8lld estRow/Loop=%-8g\n",
1495 nLoop
, nVisit
, (sqlite3_int64
)(rEstLoop
+0.5), rEst
1499 raw_printf(pArg
->out
, "---------------------------\n");
1504 ** Parameter azArray points to a zero-terminated array of strings. zStr
1505 ** points to a single nul-terminated string. Return non-zero if zStr
1506 ** is equal, according to strcmp(), to any of the strings in the array.
1507 ** Otherwise, return zero.
1509 static int str_in_array(const char *zStr
, const char **azArray
){
1511 for(i
=0; azArray
[i
]; i
++){
1512 if( 0==strcmp(zStr
, azArray
[i
]) ) return 1;
1518 ** If compiled statement pSql appears to be an EXPLAIN statement, allocate
1519 ** and populate the ShellState.aiIndent[] array with the number of
1520 ** spaces each opcode should be indented before it is output.
1522 ** The indenting rules are:
1524 ** * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent
1525 ** all opcodes that occur between the p2 jump destination and the opcode
1526 ** itself by 2 spaces.
1528 ** * For each "Goto", if the jump destination is earlier in the program
1529 ** and ends on one of:
1530 ** Yield SeekGt SeekLt RowSetRead Rewind
1531 ** or if the P1 parameter is one instead of zero,
1532 ** then indent all opcodes between the earlier instruction
1533 ** and "Goto" by 2 spaces.
1535 static void explain_data_prepare(ShellState
*p
, sqlite3_stmt
*pSql
){
1536 const char *zSql
; /* The text of the SQL statement */
1537 const char *z
; /* Used to check if this is an EXPLAIN */
1538 int *abYield
= 0; /* True if op is an OP_Yield */
1539 int nAlloc
= 0; /* Allocated size of p->aiIndent[], abYield */
1540 int iOp
; /* Index of operation in p->aiIndent[] */
1542 const char *azNext
[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext",
1543 "NextIfOpen", "PrevIfOpen", 0 };
1544 const char *azYield
[] = { "Yield", "SeekLT", "SeekGT", "RowSetRead",
1546 const char *azGoto
[] = { "Goto", 0 };
1548 /* Try to figure out if this is really an EXPLAIN statement. If this
1549 ** cannot be verified, return early. */
1550 if( sqlite3_column_count(pSql
)!=8 ){
1554 zSql
= sqlite3_sql(pSql
);
1555 if( zSql
==0 ) return;
1556 for(z
=zSql
; *z
==' ' || *z
=='\t' || *z
=='\n' || *z
=='\f' || *z
=='\r'; z
++);
1557 if( sqlite3_strnicmp(z
, "explain", 7) ){
1562 for(iOp
=0; SQLITE_ROW
==sqlite3_step(pSql
); iOp
++){
1564 int iAddr
= sqlite3_column_int(pSql
, 0);
1565 const char *zOp
= (const char*)sqlite3_column_text(pSql
, 1);
1567 /* Set p2 to the P2 field of the current opcode. Then, assuming that
1568 ** p2 is an instruction address, set variable p2op to the index of that
1569 ** instruction in the aiIndent[] array. p2 and p2op may be different if
1570 ** the current instruction is part of a sub-program generated by an
1571 ** SQL trigger or foreign key. */
1572 int p2
= sqlite3_column_int(pSql
, 3);
1573 int p2op
= (p2
+ (iOp
-iAddr
));
1575 /* Grow the p->aiIndent array as required */
1578 /* Do further verfication that this is explain output. Abort if
1580 static const char *explainCols
[] = {
1581 "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment" };
1583 for(jj
=0; jj
<ArraySize(explainCols
); jj
++){
1584 if( strcmp(sqlite3_column_name(pSql
,jj
),explainCols
[jj
])!=0 ){
1586 sqlite3_reset(pSql
);
1592 p
->aiIndent
= (int*)sqlite3_realloc64(p
->aiIndent
, nAlloc
*sizeof(int));
1593 abYield
= (int*)sqlite3_realloc64(abYield
, nAlloc
*sizeof(int));
1595 abYield
[iOp
] = str_in_array(zOp
, azYield
);
1596 p
->aiIndent
[iOp
] = 0;
1599 if( str_in_array(zOp
, azNext
) ){
1600 for(i
=p2op
; i
<iOp
; i
++) p
->aiIndent
[i
] += 2;
1602 if( str_in_array(zOp
, azGoto
) && p2op
<p
->nIndent
1603 && (abYield
[p2op
] || sqlite3_column_int(pSql
, 2))
1605 for(i
=p2op
+1; i
<iOp
; i
++) p
->aiIndent
[i
] += 2;
1610 sqlite3_free(abYield
);
1611 sqlite3_reset(pSql
);
1615 ** Free the array allocated by explain_data_prepare().
1617 static void explain_data_delete(ShellState
*p
){
1618 sqlite3_free(p
->aiIndent
);
1625 ** Execute a statement or set of statements. Print
1626 ** any result rows/columns depending on the current mode
1627 ** set via the supplied callback.
1629 ** This is very similar to SQLite's built-in sqlite3_exec()
1630 ** function except it takes a slightly different callback
1631 ** and callback data argument.
1633 static int shell_exec(
1634 sqlite3
*db
, /* An open database */
1635 const char *zSql
, /* SQL to be evaluated */
1636 int (*xCallback
)(void*,int,char**,char**,int*), /* Callback function */
1637 /* (not the same as sqlite3_exec) */
1638 ShellState
*pArg
, /* Pointer to ShellState */
1639 char **pzErrMsg
/* Error msg written here */
1641 sqlite3_stmt
*pStmt
= NULL
; /* Statement to execute. */
1642 int rc
= SQLITE_OK
; /* Return Code */
1644 const char *zLeftover
; /* Tail of unprocessed SQL */
1650 while( zSql
[0] && (SQLITE_OK
== rc
) ){
1651 rc
= sqlite3_prepare_v2(db
, zSql
, -1, &pStmt
, &zLeftover
);
1652 if( SQLITE_OK
!= rc
){
1654 *pzErrMsg
= save_err_msg(db
);
1658 /* this happens for a comment or white-space */
1660 while( IsSpace(zSql
[0]) ) zSql
++;
1664 /* save off the prepared statment handle and reset row count */
1666 pArg
->pStmt
= pStmt
;
1670 /* echo the sql statement if echo on */
1671 if( pArg
&& pArg
->echoOn
){
1672 const char *zStmtSql
= sqlite3_sql(pStmt
);
1673 utf8_printf(pArg
->out
, "%s\n", zStmtSql
? zStmtSql
: zSql
);
1676 /* Show the EXPLAIN QUERY PLAN if .eqp is on */
1677 if( pArg
&& pArg
->autoEQP
){
1678 sqlite3_stmt
*pExplain
;
1679 char *zEQP
= sqlite3_mprintf("EXPLAIN QUERY PLAN %s",
1680 sqlite3_sql(pStmt
));
1681 rc
= sqlite3_prepare_v2(db
, zEQP
, -1, &pExplain
, 0);
1682 if( rc
==SQLITE_OK
){
1683 while( sqlite3_step(pExplain
)==SQLITE_ROW
){
1684 raw_printf(pArg
->out
,"--EQP-- %d,",sqlite3_column_int(pExplain
, 0));
1685 raw_printf(pArg
->out
,"%d,", sqlite3_column_int(pExplain
, 1));
1686 raw_printf(pArg
->out
,"%d,", sqlite3_column_int(pExplain
, 2));
1687 utf8_printf(pArg
->out
,"%s\n", sqlite3_column_text(pExplain
, 3));
1690 sqlite3_finalize(pExplain
);
1695 pArg
->cMode
= pArg
->mode
;
1696 if( pArg
->autoExplain
1697 && sqlite3_column_count(pStmt
)==8
1698 && sqlite3_strlike("%EXPLAIN%", sqlite3_sql(pStmt
),0)==0
1700 pArg
->cMode
= MODE_Explain
;
1703 /* If the shell is currently in ".explain" mode, gather the extra
1704 ** data required to add indents to the output.*/
1705 if( pArg
->cMode
==MODE_Explain
){
1706 explain_data_prepare(pArg
, pStmt
);
1710 /* perform the first step. this will tell us if we
1711 ** have a result set or not and how wide it is.
1713 rc
= sqlite3_step(pStmt
);
1714 /* if we have a result set... */
1715 if( SQLITE_ROW
== rc
){
1716 /* if we have a callback... */
1718 /* allocate space for col name ptr, value ptr, and type */
1719 int nCol
= sqlite3_column_count(pStmt
);
1720 void *pData
= sqlite3_malloc64(3*nCol
*sizeof(const char*) + 1);
1724 char **azCols
= (char **)pData
; /* Names of result columns */
1725 char **azVals
= &azCols
[nCol
]; /* Results */
1726 int *aiTypes
= (int *)&azVals
[nCol
]; /* Result types */
1728 assert(sizeof(int) <= sizeof(char *));
1729 /* save off ptrs to column names */
1730 for(i
=0; i
<nCol
; i
++){
1731 azCols
[i
] = (char *)sqlite3_column_name(pStmt
, i
);
1734 /* extract the data and data types */
1735 for(i
=0; i
<nCol
; i
++){
1736 aiTypes
[i
] = x
= sqlite3_column_type(pStmt
, i
);
1737 if( x
==SQLITE_BLOB
&& pArg
&& pArg
->cMode
==MODE_Insert
){
1740 azVals
[i
] = (char*)sqlite3_column_text(pStmt
, i
);
1742 if( !azVals
[i
] && (aiTypes
[i
]!=SQLITE_NULL
) ){
1744 break; /* from for */
1748 /* if data and types extracted successfully... */
1749 if( SQLITE_ROW
== rc
){
1750 /* call the supplied callback with the result row data */
1751 if( xCallback(pArg
, nCol
, azVals
, azCols
, aiTypes
) ){
1754 rc
= sqlite3_step(pStmt
);
1757 } while( SQLITE_ROW
== rc
);
1758 sqlite3_free(pData
);
1762 rc
= sqlite3_step(pStmt
);
1763 } while( rc
== SQLITE_ROW
);
1767 explain_data_delete(pArg
);
1769 /* print usage stats if stats on */
1770 if( pArg
&& pArg
->statsOn
){
1771 display_stats(db
, pArg
, 0);
1774 /* print loop-counters if required */
1775 if( pArg
&& pArg
->scanstatsOn
){
1776 display_scanstats(db
, pArg
);
1779 /* Finalize the statement just executed. If this fails, save a
1780 ** copy of the error message. Otherwise, set zSql to point to the
1781 ** next statement to execute. */
1782 rc2
= sqlite3_finalize(pStmt
);
1783 if( rc
!=SQLITE_NOMEM
) rc
= rc2
;
1784 if( rc
==SQLITE_OK
){
1786 while( IsSpace(zSql
[0]) ) zSql
++;
1787 }else if( pzErrMsg
){
1788 *pzErrMsg
= save_err_msg(db
);
1791 /* clear saved stmt handle */
1803 ** This is a different callback routine used for dumping the database.
1804 ** Each row received by this callback consists of a table name,
1805 ** the table type ("index" or "table") and SQL to create the table.
1806 ** This routine should print text sufficient to recreate the table.
1808 static int dump_callback(void *pArg
, int nArg
, char **azArg
, char **azCol
){
1813 const char *zPrepStmt
= 0;
1814 ShellState
*p
= (ShellState
*)pArg
;
1816 UNUSED_PARAMETER(azCol
);
1817 if( nArg
!=3 ) return 1;
1822 if( strcmp(zTable
, "sqlite_sequence")==0 ){
1823 zPrepStmt
= "DELETE FROM sqlite_sequence;\n";
1824 }else if( sqlite3_strglob("sqlite_stat?", zTable
)==0 ){
1825 raw_printf(p
->out
, "ANALYZE sqlite_master;\n");
1826 }else if( strncmp(zTable
, "sqlite_", 7)==0 ){
1828 }else if( strncmp(zSql
, "CREATE VIRTUAL TABLE", 20)==0 ){
1830 if( !p
->writableSchema
){
1831 raw_printf(p
->out
, "PRAGMA writable_schema=ON;\n");
1832 p
->writableSchema
= 1;
1834 zIns
= sqlite3_mprintf(
1835 "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
1836 "VALUES('table','%q','%q',0,'%q');",
1837 zTable
, zTable
, zSql
);
1838 utf8_printf(p
->out
, "%s\n", zIns
);
1842 utf8_printf(p
->out
, "%s;\n", zSql
);
1845 if( strcmp(zType
, "table")==0 ){
1846 sqlite3_stmt
*pTableInfo
= 0;
1848 char *zTableInfo
= 0;
1852 zTableInfo
= appendText(zTableInfo
, "PRAGMA table_info(", 0);
1853 zTableInfo
= appendText(zTableInfo
, zTable
, '"');
1854 zTableInfo
= appendText(zTableInfo
, ");", 0);
1856 rc
= sqlite3_prepare_v2(p
->db
, zTableInfo
, -1, &pTableInfo
, 0);
1858 if( rc
!=SQLITE_OK
|| !pTableInfo
){
1862 zSelect
= appendText(zSelect
, "SELECT 'INSERT INTO ' || ", 0);
1863 /* Always quote the table name, even if it appears to be pure ascii,
1864 ** in case it is a keyword. Ex: INSERT INTO "table" ... */
1865 zTmp
= appendText(zTmp
, zTable
, '"');
1867 zSelect
= appendText(zSelect
, zTmp
, '\'');
1870 zSelect
= appendText(zSelect
, " || ' VALUES(' || ", 0);
1871 rc
= sqlite3_step(pTableInfo
);
1872 while( rc
==SQLITE_ROW
){
1873 const char *zText
= (const char *)sqlite3_column_text(pTableInfo
, 1);
1874 zSelect
= appendText(zSelect
, "quote(", 0);
1875 zSelect
= appendText(zSelect
, zText
, '"');
1876 rc
= sqlite3_step(pTableInfo
);
1877 if( rc
==SQLITE_ROW
){
1878 zSelect
= appendText(zSelect
, "), ", 0);
1880 zSelect
= appendText(zSelect
, ") ", 0);
1884 rc
= sqlite3_finalize(pTableInfo
);
1885 if( rc
!=SQLITE_OK
|| nRow
==0 ){
1889 zSelect
= appendText(zSelect
, "|| ')' FROM ", 0);
1890 zSelect
= appendText(zSelect
, zTable
, '"');
1892 rc
= run_table_dump_query(p
, zSelect
, zPrepStmt
);
1893 if( rc
==SQLITE_CORRUPT
){
1894 zSelect
= appendText(zSelect
, " ORDER BY rowid DESC", 0);
1895 run_table_dump_query(p
, zSelect
, 0);
1903 ** Run zQuery. Use dump_callback() as the callback routine so that
1904 ** the contents of the query are output as SQL statements.
1906 ** If we get a SQLITE_CORRUPT error, rerun the query after appending
1907 ** "ORDER BY rowid DESC" to the end.
1909 static int run_schema_dump_query(
1915 rc
= sqlite3_exec(p
->db
, zQuery
, dump_callback
, p
, &zErr
);
1916 if( rc
==SQLITE_CORRUPT
){
1918 int len
= strlen30(zQuery
);
1919 raw_printf(p
->out
, "/****** CORRUPTION ERROR *******/\n");
1921 utf8_printf(p
->out
, "/****** %s ******/\n", zErr
);
1925 zQ2
= malloc( len
+100 );
1926 if( zQ2
==0 ) return rc
;
1927 sqlite3_snprintf(len
+100, zQ2
, "%s ORDER BY rowid DESC", zQuery
);
1928 rc
= sqlite3_exec(p
->db
, zQ2
, dump_callback
, p
, &zErr
);
1930 utf8_printf(p
->out
, "/****** ERROR: %s ******/\n", zErr
);
1932 rc
= SQLITE_CORRUPT
;
1941 ** Text of a help message
1943 static char zHelp
[] =
1944 ".backup ?DB? FILE Backup DB (default \"main\") to FILE\n"
1945 ".bail on|off Stop after hitting an error. Default OFF\n"
1946 ".binary on|off Turn binary output on or off. Default OFF\n"
1947 ".changes on|off Show number of rows changed by SQL\n"
1948 ".clone NEWDB Clone data into NEWDB from the existing database\n"
1949 ".databases List names and files of attached databases\n"
1950 ".dbinfo ?DB? Show status information about the database\n"
1951 ".dump ?TABLE? ... Dump the database in an SQL text format\n"
1952 " If TABLE specified, only dump tables matching\n"
1953 " LIKE pattern TABLE.\n"
1954 ".echo on|off Turn command echo on or off\n"
1955 ".eqp on|off Enable or disable automatic EXPLAIN QUERY PLAN\n"
1956 ".exit Exit this program\n"
1957 ".explain ?on|off|auto? Turn EXPLAIN output mode on or off or to automatic\n"
1958 ".fullschema Show schema and the content of sqlite_stat tables\n"
1959 ".headers on|off Turn display of headers on or off\n"
1960 ".help Show this message\n"
1961 ".import FILE TABLE Import data from FILE into TABLE\n"
1962 ".indexes ?TABLE? Show names of all indexes\n"
1963 " If TABLE specified, only show indexes for tables\n"
1964 " matching LIKE pattern TABLE.\n"
1965 #ifdef SQLITE_ENABLE_IOTRACE
1966 ".iotrace FILE Enable I/O diagnostic logging to FILE\n"
1968 ".limit ?LIMIT? ?VAL? Display or change the value of an SQLITE_LIMIT\n"
1969 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1970 ".load FILE ?ENTRY? Load an extension library\n"
1972 ".log FILE|off Turn logging on or off. FILE can be stderr/stdout\n"
1973 ".mode MODE ?TABLE? Set output mode where MODE is one of:\n"
1974 " ascii Columns/rows delimited by 0x1F and 0x1E\n"
1975 " csv Comma-separated values\n"
1976 " column Left-aligned columns. (See .width)\n"
1977 " html HTML <table> code\n"
1978 " insert SQL insert statements for TABLE\n"
1979 " line One value per line\n"
1980 " list Values delimited by .separator strings\n"
1981 " tabs Tab-separated values\n"
1982 " tcl TCL list elements\n"
1983 ".nullvalue STRING Use STRING in place of NULL values\n"
1984 ".once FILENAME Output for the next SQL command only to FILENAME\n"
1985 ".open ?FILENAME? Close existing database and reopen FILENAME\n"
1986 ".output ?FILENAME? Send output to FILENAME or stdout\n"
1987 ".print STRING... Print literal STRING\n"
1988 ".prompt MAIN CONTINUE Replace the standard prompts\n"
1989 ".quit Exit this program\n"
1990 ".read FILENAME Execute SQL in FILENAME\n"
1991 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n"
1992 ".save FILE Write in-memory database into FILE\n"
1993 ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off\n"
1994 ".schema ?TABLE? Show the CREATE statements\n"
1995 " If TABLE specified, only show tables matching\n"
1996 " LIKE pattern TABLE.\n"
1997 ".separator COL ?ROW? Change the column separator and optionally the row\n"
1998 " separator for both the output mode and .import\n"
1999 ".shell CMD ARGS... Run CMD ARGS... in a system shell\n"
2000 ".show Show the current values for various settings\n"
2001 ".stats ?on|off? Show stats or turn stats on or off\n"
2002 ".system CMD ARGS... Run CMD ARGS... in a system shell\n"
2003 ".tables ?TABLE? List names of tables\n"
2004 " If TABLE specified, only list tables matching\n"
2005 " LIKE pattern TABLE.\n"
2006 ".timeout MS Try opening locked tables for MS milliseconds\n"
2007 ".timer on|off Turn SQL timer on or off\n"
2008 ".trace FILE|off Output each SQL statement as it is run\n"
2009 ".vfsinfo ?AUX? Information about the top-level VFS\n"
2010 ".vfslist List all available VFSes\n"
2011 ".vfsname ?AUX? Print the name of the VFS stack\n"
2012 ".width NUM1 NUM2 ... Set column widths for \"column\" mode\n"
2013 " Negative values right-justify\n"
2016 /* Forward reference */
2017 static int process_input(ShellState
*p
, FILE *in
);
2019 ** Implementation of the "readfile(X)" SQL function. The entire content
2020 ** of the file named X is read and returned as a BLOB. NULL is returned
2021 ** if the file does not exist or is unreadable.
2023 static void readfileFunc(
2024 sqlite3_context
*context
,
2026 sqlite3_value
**argv
2033 UNUSED_PARAMETER(argc
);
2034 zName
= (const char*)sqlite3_value_text(argv
[0]);
2035 if( zName
==0 ) return;
2036 in
= fopen(zName
, "rb");
2038 fseek(in
, 0, SEEK_END
);
2041 pBuf
= sqlite3_malloc64( nIn
);
2042 if( pBuf
&& 1==fread(pBuf
, nIn
, 1, in
) ){
2043 sqlite3_result_blob(context
, pBuf
, nIn
, sqlite3_free
);
2051 ** Implementation of the "writefile(X,Y)" SQL function. The argument Y
2052 ** is written into file X. The number of bytes written is returned. Or
2053 ** NULL is returned if something goes wrong, such as being unable to open
2054 ** file X for writing.
2056 static void writefileFunc(
2057 sqlite3_context
*context
,
2059 sqlite3_value
**argv
2066 UNUSED_PARAMETER(argc
);
2067 zFile
= (const char*)sqlite3_value_text(argv
[0]);
2068 if( zFile
==0 ) return;
2069 out
= fopen(zFile
, "wb");
2070 if( out
==0 ) return;
2071 z
= (const char*)sqlite3_value_blob(argv
[1]);
2075 rc
= fwrite(z
, 1, sqlite3_value_bytes(argv
[1]), out
);
2078 sqlite3_result_int64(context
, rc
);
2082 ** Make sure the database is open. If it is not, then open it. If
2083 ** the database fails to open, print an error message and exit.
2085 static void open_db(ShellState
*p
, int keepAlive
){
2087 sqlite3_initialize();
2088 sqlite3_open(p
->zDbFilename
, &p
->db
);
2090 if( p
->db
&& sqlite3_errcode(p
->db
)==SQLITE_OK
){
2091 sqlite3_create_function(p
->db
, "shellstatic", 0, SQLITE_UTF8
, 0,
2092 shellstaticFunc
, 0, 0);
2094 if( p
->db
==0 || SQLITE_OK
!=sqlite3_errcode(p
->db
) ){
2095 utf8_printf(stderr
,"Error: unable to open database \"%s\": %s\n",
2096 p
->zDbFilename
, sqlite3_errmsg(p
->db
));
2097 if( keepAlive
) return;
2100 #ifndef SQLITE_OMIT_LOAD_EXTENSION
2101 sqlite3_enable_load_extension(p
->db
, 1);
2103 sqlite3_create_function(p
->db
, "readfile", 1, SQLITE_UTF8
, 0,
2104 readfileFunc
, 0, 0);
2105 sqlite3_create_function(p
->db
, "writefile", 2, SQLITE_UTF8
, 0,
2106 writefileFunc
, 0, 0);
2111 ** Do C-language style dequoting.
2117 ** \v -> vertical tab
2119 ** \r -> carriage return
2124 ** \NNN -> ascii character NNN in octal
2126 static void resolve_backslashes(char *z
){
2129 while( *z
&& *z
!='\\' ) z
++;
2130 for(i
=j
=0; (c
= z
[i
])!=0; i
++, j
++){
2131 if( c
=='\\' && z
[i
+1]!=0 ){
2149 }else if( c
=='\'' ){
2151 }else if( c
=='\\' ){
2153 }else if( c
>='0' && c
<='7' ){
2155 if( z
[i
+1]>='0' && z
[i
+1]<='7' ){
2157 c
= (c
<<3) + z
[i
] - '0';
2158 if( z
[i
+1]>='0' && z
[i
+1]<='7' ){
2160 c
= (c
<<3) + z
[i
] - '0';
2171 ** Return the value of a hexadecimal digit. Return -1 if the input
2172 ** is not a hex digit.
2174 static int hexDigitValue(char c
){
2175 if( c
>='0' && c
<='9' ) return c
- '0';
2176 if( c
>='a' && c
<='f' ) return c
- 'a' + 10;
2177 if( c
>='A' && c
<='F' ) return c
- 'A' + 10;
2182 ** Interpret zArg as an integer value, possibly with suffixes.
2184 static sqlite3_int64
integerValue(const char *zArg
){
2185 sqlite3_int64 v
= 0;
2186 static const struct { char *zSuffix
; int iMult
; } aMult
[] = {
2188 { "MiB", 1024*1024 },
2189 { "GiB", 1024*1024*1024 },
2192 { "GB", 1000000000 },
2195 { "G", 1000000000 },
2202 }else if( zArg
[0]=='+' ){
2205 if( zArg
[0]=='0' && zArg
[1]=='x' ){
2208 while( (x
= hexDigitValue(zArg
[0]))>=0 ){
2213 while( IsDigit(zArg
[0]) ){
2214 v
= v
*10 + zArg
[0] - '0';
2218 for(i
=0; i
<ArraySize(aMult
); i
++){
2219 if( sqlite3_stricmp(aMult
[i
].zSuffix
, zArg
)==0 ){
2220 v
*= aMult
[i
].iMult
;
2224 return isNeg
? -v
: v
;
2228 ** Interpret zArg as either an integer or a boolean value. Return 1 or 0
2229 ** for TRUE and FALSE. Return the integer value if appropriate.
2231 static int booleanValue(char *zArg
){
2233 if( zArg
[0]=='0' && zArg
[1]=='x' ){
2234 for(i
=2; hexDigitValue(zArg
[i
])>=0; i
++){}
2236 for(i
=0; zArg
[i
]>='0' && zArg
[i
]<='9'; i
++){}
2238 if( i
>0 && zArg
[i
]==0 ) return (int)(integerValue(zArg
) & 0xffffffff);
2239 if( sqlite3_stricmp(zArg
, "on")==0 || sqlite3_stricmp(zArg
,"yes")==0 ){
2242 if( sqlite3_stricmp(zArg
, "off")==0 || sqlite3_stricmp(zArg
,"no")==0 ){
2245 utf8_printf(stderr
, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
2251 ** Close an output file, assuming it is not stderr or stdout
2253 static void output_file_close(FILE *f
){
2254 if( f
&& f
!=stdout
&& f
!=stderr
) fclose(f
);
2258 ** Try to open an output file. The names "stdout" and "stderr" are
2259 ** recognized and do the right thing. NULL is returned if the output
2260 ** filename is "off".
2262 static FILE *output_file_open(const char *zFile
){
2264 if( strcmp(zFile
,"stdout")==0 ){
2266 }else if( strcmp(zFile
, "stderr")==0 ){
2268 }else if( strcmp(zFile
, "off")==0 ){
2271 f
= fopen(zFile
, "wb");
2273 utf8_printf(stderr
, "Error: cannot open \"%s\"\n", zFile
);
2280 ** A routine for handling output from sqlite3_trace().
2282 static void sql_trace_callback(void *pArg
, const char *z
){
2283 FILE *f
= (FILE*)pArg
;
2285 int i
= (int)strlen(z
);
2286 while( i
>0 && z
[i
-1]==';' ){ i
--; }
2287 utf8_printf(f
, "%.*s;\n", i
, z
);
2292 ** A no-op routine that runs with the ".breakpoint" doc-command. This is
2293 ** a useful spot to set a debugger breakpoint.
2295 static void test_breakpoint(void){
2296 static int nCall
= 0;
2301 ** An object used to read a CSV and other files for import.
2303 typedef struct ImportCtx ImportCtx
;
2305 const char *zFile
; /* Name of the input file */
2306 FILE *in
; /* Read the CSV text from this input stream */
2307 char *z
; /* Accumulated text for a field */
2308 int n
; /* Number of bytes in z */
2309 int nAlloc
; /* Space allocated for z[] */
2310 int nLine
; /* Current line number */
2311 int cTerm
; /* Character that terminated the most recent field */
2312 int cColSep
; /* The column separator character. (Usually ",") */
2313 int cRowSep
; /* The row separator character. (Usually "\n") */
2316 /* Append a single byte to z[] */
2317 static void import_append_char(ImportCtx
*p
, int c
){
2318 if( p
->n
+1>=p
->nAlloc
){
2319 p
->nAlloc
+= p
->nAlloc
+ 100;
2320 p
->z
= sqlite3_realloc64(p
->z
, p
->nAlloc
);
2322 raw_printf(stderr
, "out of memory\n");
2326 p
->z
[p
->n
++] = (char)c
;
2329 /* Read a single field of CSV text. Compatible with rfc4180 and extended
2330 ** with the option of having a separator other than ",".
2332 ** + Input comes from p->in.
2333 ** + Store results in p->z of length p->n. Space to hold p->z comes
2334 ** from sqlite3_malloc64().
2335 ** + Use p->cSep as the column separator. The default is ",".
2336 ** + Use p->rSep as the row separator. The default is "\n".
2337 ** + Keep track of the line number in p->nLine.
2338 ** + Store the character that terminates the field in p->cTerm. Store
2339 ** EOF on end-of-file.
2340 ** + Report syntax errors on stderr
2342 static char *SQLITE_CDECL
csv_read_one_field(ImportCtx
*p
){
2344 int cSep
= p
->cColSep
;
2345 int rSep
= p
->cRowSep
;
2348 if( c
==EOF
|| seenInterrupt
){
2354 int startLine
= p
->nLine
;
2359 if( c
==rSep
) p
->nLine
++;
2366 if( (c
==cSep
&& pc
==cQuote
)
2367 || (c
==rSep
&& pc
==cQuote
)
2368 || (c
==rSep
&& pc
=='\r' && ppc
==cQuote
)
2369 || (c
==EOF
&& pc
==cQuote
)
2371 do{ p
->n
--; }while( p
->z
[p
->n
]!=cQuote
);
2375 if( pc
==cQuote
&& c
!='\r' ){
2376 utf8_printf(stderr
, "%s:%d: unescaped %c character\n",
2377 p
->zFile
, p
->nLine
, cQuote
);
2380 utf8_printf(stderr
, "%s:%d: unterminated %c-quoted field\n",
2381 p
->zFile
, startLine
, cQuote
);
2385 import_append_char(p
, c
);
2390 while( c
!=EOF
&& c
!=cSep
&& c
!=rSep
){
2391 import_append_char(p
, c
);
2396 if( p
->n
>0 && p
->z
[p
->n
-1]=='\r' ) p
->n
--;
2400 if( p
->z
) p
->z
[p
->n
] = 0;
2404 /* Read a single field of ASCII delimited text.
2406 ** + Input comes from p->in.
2407 ** + Store results in p->z of length p->n. Space to hold p->z comes
2408 ** from sqlite3_malloc64().
2409 ** + Use p->cSep as the column separator. The default is "\x1F".
2410 ** + Use p->rSep as the row separator. The default is "\x1E".
2411 ** + Keep track of the row number in p->nLine.
2412 ** + Store the character that terminates the field in p->cTerm. Store
2413 ** EOF on end-of-file.
2414 ** + Report syntax errors on stderr
2416 static char *SQLITE_CDECL
ascii_read_one_field(ImportCtx
*p
){
2418 int cSep
= p
->cColSep
;
2419 int rSep
= p
->cRowSep
;
2422 if( c
==EOF
|| seenInterrupt
){
2426 while( c
!=EOF
&& c
!=cSep
&& c
!=rSep
){
2427 import_append_char(p
, c
);
2434 if( p
->z
) p
->z
[p
->n
] = 0;
2439 ** Try to transfer data for table zTable. If an error is seen while
2440 ** moving forward, try to go backwards. The backwards movement won't
2441 ** work for WITHOUT ROWID tables.
2443 static void tryToCloneData(
2448 sqlite3_stmt
*pQuery
= 0;
2449 sqlite3_stmt
*pInsert
= 0;
2454 int nTable
= (int)strlen(zTable
);
2457 const int spinRate
= 10000;
2459 zQuery
= sqlite3_mprintf("SELECT * FROM \"%w\"", zTable
);
2460 rc
= sqlite3_prepare_v2(p
->db
, zQuery
, -1, &pQuery
, 0);
2462 utf8_printf(stderr
, "Error %d: %s on [%s]\n",
2463 sqlite3_extended_errcode(p
->db
), sqlite3_errmsg(p
->db
),
2467 n
= sqlite3_column_count(pQuery
);
2468 zInsert
= sqlite3_malloc64(200 + nTable
+ n
*3);
2470 raw_printf(stderr
, "out of memory\n");
2473 sqlite3_snprintf(200+nTable
,zInsert
,
2474 "INSERT OR IGNORE INTO \"%s\" VALUES(?", zTable
);
2475 i
= (int)strlen(zInsert
);
2477 memcpy(zInsert
+i
, ",?", 2);
2480 memcpy(zInsert
+i
, ");", 3);
2481 rc
= sqlite3_prepare_v2(newDb
, zInsert
, -1, &pInsert
, 0);
2483 utf8_printf(stderr
, "Error %d: %s on [%s]\n",
2484 sqlite3_extended_errcode(newDb
), sqlite3_errmsg(newDb
),
2489 while( (rc
= sqlite3_step(pQuery
))==SQLITE_ROW
){
2491 switch( sqlite3_column_type(pQuery
, i
) ){
2493 sqlite3_bind_null(pInsert
, i
+1);
2496 case SQLITE_INTEGER
: {
2497 sqlite3_bind_int64(pInsert
, i
+1, sqlite3_column_int64(pQuery
,i
));
2500 case SQLITE_FLOAT
: {
2501 sqlite3_bind_double(pInsert
, i
+1, sqlite3_column_double(pQuery
,i
));
2505 sqlite3_bind_text(pInsert
, i
+1,
2506 (const char*)sqlite3_column_text(pQuery
,i
),
2511 sqlite3_bind_blob(pInsert
, i
+1, sqlite3_column_blob(pQuery
,i
),
2512 sqlite3_column_bytes(pQuery
,i
),
2518 rc
= sqlite3_step(pInsert
);
2519 if( rc
!=SQLITE_OK
&& rc
!=SQLITE_ROW
&& rc
!=SQLITE_DONE
){
2520 utf8_printf(stderr
, "Error %d: %s\n", sqlite3_extended_errcode(newDb
),
2521 sqlite3_errmsg(newDb
));
2523 sqlite3_reset(pInsert
);
2525 if( (cnt
%spinRate
)==0 ){
2526 printf("%c\b", "|/-\\"[(cnt
/spinRate
)%4]);
2530 if( rc
==SQLITE_DONE
) break;
2531 sqlite3_finalize(pQuery
);
2532 sqlite3_free(zQuery
);
2533 zQuery
= sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;",
2535 rc
= sqlite3_prepare_v2(p
->db
, zQuery
, -1, &pQuery
, 0);
2537 utf8_printf(stderr
, "Warning: cannot step \"%s\" backwards", zTable
);
2540 } /* End for(k=0...) */
2543 sqlite3_finalize(pQuery
);
2544 sqlite3_finalize(pInsert
);
2545 sqlite3_free(zQuery
);
2546 sqlite3_free(zInsert
);
2551 ** Try to transfer all rows of the schema that match zWhere. For
2552 ** each row, invoke xForEach() on the object defined by that row.
2553 ** If an error is encountered while moving forward through the
2554 ** sqlite_master table, try again moving backwards.
2556 static void tryToCloneSchema(
2560 void (*xForEach
)(ShellState
*,sqlite3
*,const char*)
2562 sqlite3_stmt
*pQuery
= 0;
2565 const unsigned char *zName
;
2566 const unsigned char *zSql
;
2569 zQuery
= sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
2570 " WHERE %s", zWhere
);
2571 rc
= sqlite3_prepare_v2(p
->db
, zQuery
, -1, &pQuery
, 0);
2573 utf8_printf(stderr
, "Error: (%d) %s on [%s]\n",
2574 sqlite3_extended_errcode(p
->db
), sqlite3_errmsg(p
->db
),
2576 goto end_schema_xfer
;
2578 while( (rc
= sqlite3_step(pQuery
))==SQLITE_ROW
){
2579 zName
= sqlite3_column_text(pQuery
, 0);
2580 zSql
= sqlite3_column_text(pQuery
, 1);
2581 printf("%s... ", zName
); fflush(stdout
);
2582 sqlite3_exec(newDb
, (const char*)zSql
, 0, 0, &zErrMsg
);
2584 utf8_printf(stderr
, "Error: %s\nSQL: [%s]\n", zErrMsg
, zSql
);
2585 sqlite3_free(zErrMsg
);
2589 xForEach(p
, newDb
, (const char*)zName
);
2593 if( rc
!=SQLITE_DONE
){
2594 sqlite3_finalize(pQuery
);
2595 sqlite3_free(zQuery
);
2596 zQuery
= sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
2597 " WHERE %s ORDER BY rowid DESC", zWhere
);
2598 rc
= sqlite3_prepare_v2(p
->db
, zQuery
, -1, &pQuery
, 0);
2600 utf8_printf(stderr
, "Error: (%d) %s on [%s]\n",
2601 sqlite3_extended_errcode(p
->db
), sqlite3_errmsg(p
->db
),
2603 goto end_schema_xfer
;
2605 while( (rc
= sqlite3_step(pQuery
))==SQLITE_ROW
){
2606 zName
= sqlite3_column_text(pQuery
, 0);
2607 zSql
= sqlite3_column_text(pQuery
, 1);
2608 printf("%s... ", zName
); fflush(stdout
);
2609 sqlite3_exec(newDb
, (const char*)zSql
, 0, 0, &zErrMsg
);
2611 utf8_printf(stderr
, "Error: %s\nSQL: [%s]\n", zErrMsg
, zSql
);
2612 sqlite3_free(zErrMsg
);
2616 xForEach(p
, newDb
, (const char*)zName
);
2622 sqlite3_finalize(pQuery
);
2623 sqlite3_free(zQuery
);
2627 ** Open a new database file named "zNewDb". Try to recover as much information
2628 ** as possible out of the main database (which might be corrupt) and write it
2631 static void tryToClone(ShellState
*p
, const char *zNewDb
){
2634 if( access(zNewDb
,0)==0 ){
2635 utf8_printf(stderr
, "File \"%s\" already exists.\n", zNewDb
);
2638 rc
= sqlite3_open(zNewDb
, &newDb
);
2640 utf8_printf(stderr
, "Cannot create output database: %s\n",
2641 sqlite3_errmsg(newDb
));
2643 sqlite3_exec(p
->db
, "PRAGMA writable_schema=ON;", 0, 0, 0);
2644 sqlite3_exec(newDb
, "BEGIN EXCLUSIVE;", 0, 0, 0);
2645 tryToCloneSchema(p
, newDb
, "type='table'", tryToCloneData
);
2646 tryToCloneSchema(p
, newDb
, "type!='table'", 0);
2647 sqlite3_exec(newDb
, "COMMIT;", 0, 0, 0);
2648 sqlite3_exec(p
->db
, "PRAGMA writable_schema=OFF;", 0, 0, 0);
2650 sqlite3_close(newDb
);
2654 ** Change the output file back to stdout
2656 static void output_reset(ShellState
*p
){
2657 if( p
->outfile
[0]=='|' ){
2658 #ifndef SQLITE_OMIT_POPEN
2662 output_file_close(p
->out
);
2669 ** Run an SQL command and return the single integer result.
2671 static int db_int(ShellState
*p
, const char *zSql
){
2672 sqlite3_stmt
*pStmt
;
2674 sqlite3_prepare_v2(p
->db
, zSql
, -1, &pStmt
, 0);
2675 if( pStmt
&& sqlite3_step(pStmt
)==SQLITE_ROW
){
2676 res
= sqlite3_column_int(pStmt
,0);
2678 sqlite3_finalize(pStmt
);
2683 ** Convert a 2-byte or 4-byte big-endian integer into a native integer
2685 unsigned int get2byteInt(unsigned char *a
){
2686 return (a
[0]<<8) + a
[1];
2688 unsigned int get4byteInt(unsigned char *a
){
2689 return (a
[0]<<24) + (a
[1]<<16) + (a
[2]<<8) + a
[3];
2693 ** Implementation of the ".info" command.
2695 ** Return 1 on error, 2 to exit, and 0 otherwise.
2697 static int shell_dbinfo_command(ShellState
*p
, int nArg
, char **azArg
){
2698 static const struct { const char *zName
; int ofst
; } aField
[] = {
2699 { "file change counter:", 24 },
2700 { "database page count:", 28 },
2701 { "freelist page count:", 36 },
2702 { "schema cookie:", 40 },
2703 { "schema format:", 44 },
2704 { "default cache size:", 48 },
2705 { "autovacuum top root:", 52 },
2706 { "incremental vacuum:", 64 },
2707 { "text encoding:", 56 },
2708 { "user version:", 60 },
2709 { "application id:", 68 },
2710 { "software version:", 96 },
2712 static const struct { const char *zName
; const char *zSql
; } aQuery
[] = {
2713 { "number of tables:",
2714 "SELECT count(*) FROM %s WHERE type='table'" },
2715 { "number of indexes:",
2716 "SELECT count(*) FROM %s WHERE type='index'" },
2717 { "number of triggers:",
2718 "SELECT count(*) FROM %s WHERE type='trigger'" },
2719 { "number of views:",
2720 "SELECT count(*) FROM %s WHERE type='view'" },
2722 "SELECT total(length(sql)) FROM %s" },
2724 sqlite3_file
*pFile
= 0;
2727 char *zDb
= nArg
>=2 ? azArg
[1] : "main";
2728 unsigned char aHdr
[100];
2730 if( p
->db
==0 ) return 1;
2731 sqlite3_file_control(p
->db
, zDb
, SQLITE_FCNTL_FILE_POINTER
, &pFile
);
2732 if( pFile
==0 || pFile
->pMethods
==0 || pFile
->pMethods
->xRead
==0 ){
2735 i
= pFile
->pMethods
->xRead(pFile
, aHdr
, 100, 0);
2737 raw_printf(stderr
, "unable to read database header\n");
2740 i
= get2byteInt(aHdr
+16);
2741 if( i
==1 ) i
= 65536;
2742 utf8_printf(p
->out
, "%-20s %d\n", "database page size:", i
);
2743 utf8_printf(p
->out
, "%-20s %d\n", "write format:", aHdr
[18]);
2744 utf8_printf(p
->out
, "%-20s %d\n", "read format:", aHdr
[19]);
2745 utf8_printf(p
->out
, "%-20s %d\n", "reserved bytes:", aHdr
[20]);
2746 for(i
=0; i
<ArraySize(aField
); i
++){
2747 int ofst
= aField
[i
].ofst
;
2748 unsigned int val
= get4byteInt(aHdr
+ ofst
);
2749 utf8_printf(p
->out
, "%-20s %u", aField
[i
].zName
, val
);
2752 if( val
==1 ) raw_printf(p
->out
, " (utf8)");
2753 if( val
==2 ) raw_printf(p
->out
, " (utf16le)");
2754 if( val
==3 ) raw_printf(p
->out
, " (utf16be)");
2757 raw_printf(p
->out
, "\n");
2760 zSchemaTab
= sqlite3_mprintf("main.sqlite_master");
2761 }else if( strcmp(zDb
,"temp")==0 ){
2762 zSchemaTab
= sqlite3_mprintf("%s", "sqlite_temp_master");
2764 zSchemaTab
= sqlite3_mprintf("\"%w\".sqlite_master", zDb
);
2766 for(i
=0; i
<ArraySize(aQuery
); i
++){
2767 char *zSql
= sqlite3_mprintf(aQuery
[i
].zSql
, zSchemaTab
);
2768 int val
= db_int(p
, zSql
);
2770 utf8_printf(p
->out
, "%-20s %d\n", aQuery
[i
].zName
, val
);
2772 sqlite3_free(zSchemaTab
);
2777 ** Print the current sqlite3_errmsg() value to stderr and return 1.
2779 static int shellDatabaseError(sqlite3
*db
){
2780 const char *zErr
= sqlite3_errmsg(db
);
2781 utf8_printf(stderr
, "Error: %s\n", zErr
);
2786 ** Print an out-of-memory message to stderr and return 1.
2788 static int shellNomemError(void){
2789 raw_printf(stderr
, "Error: out of memory\n");
2794 ** If an input line begins with "." then invoke this routine to
2795 ** process that line.
2797 ** Return 1 on error, 2 to exit, and 0 otherwise.
2799 static int do_meta_command(char *zLine
, ShellState
*p
){
2806 /* Parse the input line into tokens.
2808 while( zLine
[h
] && nArg
<ArraySize(azArg
) ){
2809 while( IsSpace(zLine
[h
]) ){ h
++; }
2810 if( zLine
[h
]==0 ) break;
2811 if( zLine
[h
]=='\'' || zLine
[h
]=='"' ){
2812 int delim
= zLine
[h
++];
2813 azArg
[nArg
++] = &zLine
[h
];
2814 while( zLine
[h
] && zLine
[h
]!=delim
){
2815 if( zLine
[h
]=='\\' && delim
=='"' && zLine
[h
+1]!=0 ) h
++;
2818 if( zLine
[h
]==delim
){
2821 if( delim
=='"' ) resolve_backslashes(azArg
[nArg
-1]);
2823 azArg
[nArg
++] = &zLine
[h
];
2824 while( zLine
[h
] && !IsSpace(zLine
[h
]) ){ h
++; }
2825 if( zLine
[h
] ) zLine
[h
++] = 0;
2826 resolve_backslashes(azArg
[nArg
-1]);
2830 /* Process the input line.
2832 if( nArg
==0 ) return 0; /* no tokens, no error */
2833 n
= strlen30(azArg
[0]);
2835 if( (c
=='b' && n
>=3 && strncmp(azArg
[0], "backup", n
)==0)
2836 || (c
=='s' && n
>=3 && strncmp(azArg
[0], "save", n
)==0)
2838 const char *zDestFile
= 0;
2839 const char *zDb
= 0;
2841 sqlite3_backup
*pBackup
;
2843 for(j
=1; j
<nArg
; j
++){
2844 const char *z
= azArg
[j
];
2846 while( z
[0]=='-' ) z
++;
2847 /* No options to process at this time */
2849 utf8_printf(stderr
, "unknown option: %s\n", azArg
[j
]);
2852 }else if( zDestFile
==0 ){
2853 zDestFile
= azArg
[j
];
2856 zDestFile
= azArg
[j
];
2858 raw_printf(stderr
, "too many arguments to .backup\n");
2863 raw_printf(stderr
, "missing FILENAME argument on .backup\n");
2866 if( zDb
==0 ) zDb
= "main";
2867 rc
= sqlite3_open(zDestFile
, &pDest
);
2868 if( rc
!=SQLITE_OK
){
2869 utf8_printf(stderr
, "Error: cannot open \"%s\"\n", zDestFile
);
2870 sqlite3_close(pDest
);
2874 pBackup
= sqlite3_backup_init(pDest
, "main", p
->db
, zDb
);
2876 utf8_printf(stderr
, "Error: %s\n", sqlite3_errmsg(pDest
));
2877 sqlite3_close(pDest
);
2880 while( (rc
= sqlite3_backup_step(pBackup
,100))==SQLITE_OK
){}
2881 sqlite3_backup_finish(pBackup
);
2882 if( rc
==SQLITE_DONE
){
2885 utf8_printf(stderr
, "Error: %s\n", sqlite3_errmsg(pDest
));
2888 sqlite3_close(pDest
);
2891 if( c
=='b' && n
>=3 && strncmp(azArg
[0], "bail", n
)==0 ){
2893 bail_on_error
= booleanValue(azArg
[1]);
2895 raw_printf(stderr
, "Usage: .bail on|off\n");
2900 if( c
=='b' && n
>=3 && strncmp(azArg
[0], "binary", n
)==0 ){
2902 if( booleanValue(azArg
[1]) ){
2903 setBinaryMode(p
->out
);
2905 setTextMode(p
->out
);
2908 raw_printf(stderr
, "Usage: .binary on|off\n");
2913 /* The undocumented ".breakpoint" command causes a call to the no-op
2914 ** routine named test_breakpoint().
2916 if( c
=='b' && n
>=3 && strncmp(azArg
[0], "breakpoint", n
)==0 ){
2920 if( c
=='c' && n
>=3 && strncmp(azArg
[0], "changes", n
)==0 ){
2922 p
->countChanges
= booleanValue(azArg
[1]);
2924 raw_printf(stderr
, "Usage: .changes on|off\n");
2929 if( c
=='c' && strncmp(azArg
[0], "clone", n
)==0 ){
2931 tryToClone(p
, azArg
[1]);
2933 raw_printf(stderr
, "Usage: .clone FILENAME\n");
2938 if( c
=='d' && n
>1 && strncmp(azArg
[0], "databases", n
)==0 ){
2942 memcpy(&data
, p
, sizeof(data
));
2943 data
.showHeader
= 1;
2944 data
.cMode
= data
.mode
= MODE_Column
;
2945 data
.colWidth
[0] = 3;
2946 data
.colWidth
[1] = 15;
2947 data
.colWidth
[2] = 58;
2949 sqlite3_exec(p
->db
, "PRAGMA database_list; ", callback
, &data
, &zErrMsg
);
2951 utf8_printf(stderr
,"Error: %s\n", zErrMsg
);
2952 sqlite3_free(zErrMsg
);
2957 if( c
=='d' && strncmp(azArg
[0], "dbinfo", n
)==0 ){
2958 rc
= shell_dbinfo_command(p
, nArg
, azArg
);
2961 if( c
=='d' && strncmp(azArg
[0], "dump", n
)==0 ){
2963 /* When playing back a "dump", the content might appear in an order
2964 ** which causes immediate foreign key constraints to be violated.
2965 ** So disable foreign-key constraint enforcement to prevent problems. */
2966 if( nArg
!=1 && nArg
!=2 ){
2967 raw_printf(stderr
, "Usage: .dump ?LIKE-PATTERN?\n");
2969 goto meta_command_exit
;
2971 raw_printf(p
->out
, "PRAGMA foreign_keys=OFF;\n");
2972 raw_printf(p
->out
, "BEGIN TRANSACTION;\n");
2973 p
->writableSchema
= 0;
2974 sqlite3_exec(p
->db
, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
2977 run_schema_dump_query(p
,
2978 "SELECT name, type, sql FROM sqlite_master "
2979 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
2981 run_schema_dump_query(p
,
2982 "SELECT name, type, sql FROM sqlite_master "
2983 "WHERE name=='sqlite_sequence'"
2985 run_table_dump_query(p
,
2986 "SELECT sql FROM sqlite_master "
2987 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
2991 for(i
=1; i
<nArg
; i
++){
2992 zShellStatic
= azArg
[i
];
2993 run_schema_dump_query(p
,
2994 "SELECT name, type, sql FROM sqlite_master "
2995 "WHERE tbl_name LIKE shellstatic() AND type=='table'"
2996 " AND sql NOT NULL");
2997 run_table_dump_query(p
,
2998 "SELECT sql FROM sqlite_master "
2999 "WHERE sql NOT NULL"
3000 " AND type IN ('index','trigger','view')"
3001 " AND tbl_name LIKE shellstatic()", 0
3006 if( p
->writableSchema
){
3007 raw_printf(p
->out
, "PRAGMA writable_schema=OFF;\n");
3008 p
->writableSchema
= 0;
3010 sqlite3_exec(p
->db
, "PRAGMA writable_schema=OFF;", 0, 0, 0);
3011 sqlite3_exec(p
->db
, "RELEASE dump;", 0, 0, 0);
3012 raw_printf(p
->out
, p
->nErr
? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
3015 if( c
=='e' && strncmp(azArg
[0], "echo", n
)==0 ){
3017 p
->echoOn
= booleanValue(azArg
[1]);
3019 raw_printf(stderr
, "Usage: .echo on|off\n");
3024 if( c
=='e' && strncmp(azArg
[0], "eqp", n
)==0 ){
3026 p
->autoEQP
= booleanValue(azArg
[1]);
3028 raw_printf(stderr
, "Usage: .eqp on|off\n");
3033 if( c
=='e' && strncmp(azArg
[0], "exit", n
)==0 ){
3034 if( nArg
>1 && (rc
= (int)integerValue(azArg
[1]))!=0 ) exit(rc
);
3038 if( c
=='e' && strncmp(azArg
[0], "explain", n
)==0 ){
3041 if( strcmp(azArg
[1],"auto")==0 ){
3044 val
= booleanValue(azArg
[1]);
3047 if( val
==1 && p
->mode
!=MODE_Explain
){
3048 p
->normalMode
= p
->mode
;
3049 p
->mode
= MODE_Explain
;
3052 if( p
->mode
==MODE_Explain
) p
->mode
= p
->normalMode
;
3054 }else if( val
==99 ){
3055 if( p
->mode
==MODE_Explain
) p
->mode
= p
->normalMode
;
3060 if( c
=='f' && strncmp(azArg
[0], "fullschema", n
)==0 ){
3065 raw_printf(stderr
, "Usage: .fullschema\n");
3067 goto meta_command_exit
;
3070 memcpy(&data
, p
, sizeof(data
));
3071 data
.showHeader
= 0;
3072 data
.cMode
= data
.mode
= MODE_Semi
;
3073 rc
= sqlite3_exec(p
->db
,
3075 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
3076 " FROM sqlite_master UNION ALL"
3077 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
3078 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
3080 callback
, &data
, &zErrMsg
3082 if( rc
==SQLITE_OK
){
3083 sqlite3_stmt
*pStmt
;
3084 rc
= sqlite3_prepare_v2(p
->db
,
3085 "SELECT rowid FROM sqlite_master"
3086 " WHERE name GLOB 'sqlite_stat[134]'",
3088 doStats
= sqlite3_step(pStmt
)==SQLITE_ROW
;
3089 sqlite3_finalize(pStmt
);
3092 raw_printf(p
->out
, "/* No STAT tables available */\n");
3094 raw_printf(p
->out
, "ANALYZE sqlite_master;\n");
3095 sqlite3_exec(p
->db
, "SELECT 'ANALYZE sqlite_master'",
3096 callback
, &data
, &zErrMsg
);
3097 data
.cMode
= data
.mode
= MODE_Insert
;
3098 data
.zDestTable
= "sqlite_stat1";
3099 shell_exec(p
->db
, "SELECT * FROM sqlite_stat1",
3100 shell_callback
, &data
,&zErrMsg
);
3101 data
.zDestTable
= "sqlite_stat3";
3102 shell_exec(p
->db
, "SELECT * FROM sqlite_stat3",
3103 shell_callback
, &data
,&zErrMsg
);
3104 data
.zDestTable
= "sqlite_stat4";
3105 shell_exec(p
->db
, "SELECT * FROM sqlite_stat4",
3106 shell_callback
, &data
, &zErrMsg
);
3107 raw_printf(p
->out
, "ANALYZE sqlite_master;\n");
3111 if( c
=='h' && strncmp(azArg
[0], "headers", n
)==0 ){
3113 p
->showHeader
= booleanValue(azArg
[1]);
3115 raw_printf(stderr
, "Usage: .headers on|off\n");
3120 if( c
=='h' && strncmp(azArg
[0], "help", n
)==0 ){
3121 utf8_printf(p
->out
, "%s", zHelp
);
3124 if( c
=='i' && strncmp(azArg
[0], "import", n
)==0 ){
3125 char *zTable
; /* Insert data into this table */
3126 char *zFile
; /* Name of file to extra content from */
3127 sqlite3_stmt
*pStmt
= NULL
; /* A statement */
3128 int nCol
; /* Number of columns in the table */
3129 int nByte
; /* Number of bytes in an SQL string */
3130 int i
, j
; /* Loop counters */
3131 int needCommit
; /* True to COMMIT or ROLLBACK at end */
3132 int nSep
; /* Number of bytes in p->colSeparator[] */
3133 char *zSql
; /* An SQL statement */
3134 ImportCtx sCtx
; /* Reader context */
3135 char *(SQLITE_CDECL
*xRead
)(ImportCtx
*); /* Func to read one value */
3136 int (SQLITE_CDECL
*xCloser
)(FILE*); /* Func to close file */
3139 raw_printf(stderr
, "Usage: .import FILE TABLE\n");
3140 goto meta_command_exit
;
3145 memset(&sCtx
, 0, sizeof(sCtx
));
3147 nSep
= strlen30(p
->colSeparator
);
3150 "Error: non-null column separator required for import\n");
3154 raw_printf(stderr
, "Error: multi-character column separators not allowed"
3158 nSep
= strlen30(p
->rowSeparator
);
3160 raw_printf(stderr
, "Error: non-null row separator required for import\n");
3163 if( nSep
==2 && p
->mode
==MODE_Csv
&& strcmp(p
->rowSeparator
, SEP_CrLf
)==0 ){
3164 /* When importing CSV (only), if the row separator is set to the
3165 ** default output row separator, change it to the default input
3166 ** row separator. This avoids having to maintain different input
3167 ** and output row separators. */
3168 sqlite3_snprintf(sizeof(p
->rowSeparator
), p
->rowSeparator
, SEP_Row
);
3169 nSep
= strlen30(p
->rowSeparator
);
3172 raw_printf(stderr
, "Error: multi-character row separators not allowed"
3178 if( sCtx
.zFile
[0]=='|' ){
3179 #ifdef SQLITE_OMIT_POPEN
3180 raw_printf(stderr
, "Error: pipes are not supported in this OS\n");
3183 sCtx
.in
= popen(sCtx
.zFile
+1, "r");
3184 sCtx
.zFile
= "<pipe>";
3188 sCtx
.in
= fopen(sCtx
.zFile
, "rb");
3191 if( p
->mode
==MODE_Ascii
){
3192 xRead
= ascii_read_one_field
;
3194 xRead
= csv_read_one_field
;
3197 utf8_printf(stderr
, "Error: cannot open \"%s\"\n", zFile
);
3200 sCtx
.cColSep
= p
->colSeparator
[0];
3201 sCtx
.cRowSep
= p
->rowSeparator
[0];
3202 zSql
= sqlite3_mprintf("SELECT * FROM %s", zTable
);
3204 raw_printf(stderr
, "Error: out of memory\n");
3208 nByte
= strlen30(zSql
);
3209 rc
= sqlite3_prepare_v2(p
->db
, zSql
, -1, &pStmt
, 0);
3210 import_append_char(&sCtx
, 0); /* To ensure sCtx.z is allocated */
3211 if( rc
&& sqlite3_strglob("no such table: *", sqlite3_errmsg(p
->db
))==0 ){
3212 char *zCreate
= sqlite3_mprintf("CREATE TABLE %s", zTable
);
3214 while( xRead(&sCtx
) ){
3215 zCreate
= sqlite3_mprintf("%z%c\n \"%w\" TEXT", zCreate
, cSep
, sCtx
.z
);
3217 if( sCtx
.cTerm
!=sCtx
.cColSep
) break;
3220 sqlite3_free(zCreate
);
3221 sqlite3_free(sCtx
.z
);
3223 utf8_printf(stderr
,"%s: empty file\n", sCtx
.zFile
);
3226 zCreate
= sqlite3_mprintf("%z\n)", zCreate
);
3227 rc
= sqlite3_exec(p
->db
, zCreate
, 0, 0, 0);
3228 sqlite3_free(zCreate
);
3230 utf8_printf(stderr
, "CREATE TABLE %s(...) failed: %s\n", zTable
,
3231 sqlite3_errmsg(p
->db
));
3232 sqlite3_free(sCtx
.z
);
3236 rc
= sqlite3_prepare_v2(p
->db
, zSql
, -1, &pStmt
, 0);
3240 if (pStmt
) sqlite3_finalize(pStmt
);
3241 utf8_printf(stderr
,"Error: %s\n", sqlite3_errmsg(p
->db
));
3245 nCol
= sqlite3_column_count(pStmt
);
3246 sqlite3_finalize(pStmt
);
3248 if( nCol
==0 ) return 0; /* no columns, no error */
3249 zSql
= sqlite3_malloc64( nByte
*2 + 20 + nCol
*2 );
3251 raw_printf(stderr
, "Error: out of memory\n");
3255 sqlite3_snprintf(nByte
+20, zSql
, "INSERT INTO \"%w\" VALUES(?", zTable
);
3257 for(i
=1; i
<nCol
; i
++){
3263 rc
= sqlite3_prepare_v2(p
->db
, zSql
, -1, &pStmt
, 0);
3266 utf8_printf(stderr
, "Error: %s\n", sqlite3_errmsg(p
->db
));
3267 if (pStmt
) sqlite3_finalize(pStmt
);
3271 needCommit
= sqlite3_get_autocommit(p
->db
);
3272 if( needCommit
) sqlite3_exec(p
->db
, "BEGIN", 0, 0, 0);
3274 int startLine
= sCtx
.nLine
;
3275 for(i
=0; i
<nCol
; i
++){
3276 char *z
= xRead(&sCtx
);
3278 ** Did we reach end-of-file before finding any columns?
3279 ** If so, stop instead of NULL filling the remaining columns.
3281 if( z
==0 && i
==0 ) break;
3283 ** Did we reach end-of-file OR end-of-line before finding any
3284 ** columns in ASCII mode? If so, stop instead of NULL filling
3285 ** the remaining columns.
3287 if( p
->mode
==MODE_Ascii
&& (z
==0 || z
[0]==0) && i
==0 ) break;
3288 sqlite3_bind_text(pStmt
, i
+1, z
, -1, SQLITE_TRANSIENT
);
3289 if( i
<nCol
-1 && sCtx
.cTerm
!=sCtx
.cColSep
){
3290 utf8_printf(stderr
, "%s:%d: expected %d columns but found %d - "
3291 "filling the rest with NULL\n",
3292 sCtx
.zFile
, startLine
, nCol
, i
+1);
3294 while( i
<=nCol
){ sqlite3_bind_null(pStmt
, i
); i
++; }
3297 if( sCtx
.cTerm
==sCtx
.cColSep
){
3301 }while( sCtx
.cTerm
==sCtx
.cColSep
);
3302 utf8_printf(stderr
, "%s:%d: expected %d columns but found %d - "
3304 sCtx
.zFile
, startLine
, nCol
, i
);
3307 sqlite3_step(pStmt
);
3308 rc
= sqlite3_reset(pStmt
);
3309 if( rc
!=SQLITE_OK
){
3310 utf8_printf(stderr
, "%s:%d: INSERT failed: %s\n", sCtx
.zFile
,
3311 startLine
, sqlite3_errmsg(p
->db
));
3314 }while( sCtx
.cTerm
!=EOF
);
3317 sqlite3_free(sCtx
.z
);
3318 sqlite3_finalize(pStmt
);
3319 if( needCommit
) sqlite3_exec(p
->db
, "COMMIT", 0, 0, 0);
3322 if( c
=='i' && (strncmp(azArg
[0], "indices", n
)==0
3323 || strncmp(azArg
[0], "indexes", n
)==0) ){
3327 memcpy(&data
, p
, sizeof(data
));
3328 data
.showHeader
= 0;
3329 data
.cMode
= data
.mode
= MODE_List
;
3331 rc
= sqlite3_exec(p
->db
,
3332 "SELECT name FROM sqlite_master "
3333 "WHERE type='index' AND name NOT LIKE 'sqlite_%' "
3335 "SELECT name FROM sqlite_temp_master "
3336 "WHERE type='index' "
3338 callback
, &data
, &zErrMsg
3340 }else if( nArg
==2 ){
3341 zShellStatic
= azArg
[1];
3342 rc
= sqlite3_exec(p
->db
,
3343 "SELECT name FROM sqlite_master "
3344 "WHERE type='index' AND tbl_name LIKE shellstatic() "
3346 "SELECT name FROM sqlite_temp_master "
3347 "WHERE type='index' AND tbl_name LIKE shellstatic() "
3349 callback
, &data
, &zErrMsg
3353 raw_printf(stderr
, "Usage: .indexes ?LIKE-PATTERN?\n");
3355 goto meta_command_exit
;
3358 utf8_printf(stderr
,"Error: %s\n", zErrMsg
);
3359 sqlite3_free(zErrMsg
);
3361 }else if( rc
!= SQLITE_OK
){
3363 "Error: querying sqlite_master and sqlite_temp_master\n");
3368 #ifdef SQLITE_ENABLE_IOTRACE
3369 if( c
=='i' && strncmp(azArg
[0], "iotrace", n
)==0 ){
3370 SQLITE_API
extern void (SQLITE_CDECL
*sqlite3IoTrace
)(const char*, ...);
3371 if( iotrace
&& iotrace
!=stdout
) fclose(iotrace
);
3375 }else if( strcmp(azArg
[1], "-")==0 ){
3376 sqlite3IoTrace
= iotracePrintf
;
3379 iotrace
= fopen(azArg
[1], "w");
3381 utf8_printf(stderr
, "Error: cannot open \"%s\"\n", azArg
[1]);
3385 sqlite3IoTrace
= iotracePrintf
;
3390 if( c
=='l' && n
>=5 && strncmp(azArg
[0], "limits", n
)==0 ){
3391 static const struct {
3392 const char *zLimitName
; /* Name of a limit */
3393 int limitCode
; /* Integer code for that limit */
3395 { "length", SQLITE_LIMIT_LENGTH
},
3396 { "sql_length", SQLITE_LIMIT_SQL_LENGTH
},
3397 { "column", SQLITE_LIMIT_COLUMN
},
3398 { "expr_depth", SQLITE_LIMIT_EXPR_DEPTH
},
3399 { "compound_select", SQLITE_LIMIT_COMPOUND_SELECT
},
3400 { "vdbe_op", SQLITE_LIMIT_VDBE_OP
},
3401 { "function_arg", SQLITE_LIMIT_FUNCTION_ARG
},
3402 { "attached", SQLITE_LIMIT_ATTACHED
},
3403 { "like_pattern_length", SQLITE_LIMIT_LIKE_PATTERN_LENGTH
},
3404 { "variable_number", SQLITE_LIMIT_VARIABLE_NUMBER
},
3405 { "trigger_depth", SQLITE_LIMIT_TRIGGER_DEPTH
},
3406 { "worker_threads", SQLITE_LIMIT_WORKER_THREADS
},
3411 for(i
=0; i
<ArraySize(aLimit
); i
++){
3412 printf("%20s %d\n", aLimit
[i
].zLimitName
,
3413 sqlite3_limit(p
->db
, aLimit
[i
].limitCode
, -1));
3416 raw_printf(stderr
, "Usage: .limit NAME ?NEW-VALUE?\n");
3418 goto meta_command_exit
;
3421 n2
= strlen30(azArg
[1]);
3422 for(i
=0; i
<ArraySize(aLimit
); i
++){
3423 if( sqlite3_strnicmp(aLimit
[i
].zLimitName
, azArg
[1], n2
)==0 ){
3427 utf8_printf(stderr
, "ambiguous limit: \"%s\"\n", azArg
[1]);
3429 goto meta_command_exit
;
3434 utf8_printf(stderr
, "unknown limit: \"%s\"\n"
3435 "enter \".limits\" with no arguments for a list.\n",
3438 goto meta_command_exit
;
3441 sqlite3_limit(p
->db
, aLimit
[iLimit
].limitCode
,
3442 (int)integerValue(azArg
[2]));
3444 printf("%20s %d\n", aLimit
[iLimit
].zLimitName
,
3445 sqlite3_limit(p
->db
, aLimit
[iLimit
].limitCode
, -1));
3449 #ifndef SQLITE_OMIT_LOAD_EXTENSION
3450 if( c
=='l' && strncmp(azArg
[0], "load", n
)==0 ){
3451 const char *zFile
, *zProc
;
3454 raw_printf(stderr
, "Usage: .load FILE ?ENTRYPOINT?\n");
3456 goto meta_command_exit
;
3459 zProc
= nArg
>=3 ? azArg
[2] : 0;
3461 rc
= sqlite3_load_extension(p
->db
, zFile
, zProc
, &zErrMsg
);
3462 if( rc
!=SQLITE_OK
){
3463 utf8_printf(stderr
, "Error: %s\n", zErrMsg
);
3464 sqlite3_free(zErrMsg
);
3470 if( c
=='l' && strncmp(azArg
[0], "log", n
)==0 ){
3472 raw_printf(stderr
, "Usage: .log FILENAME\n");
3475 const char *zFile
= azArg
[1];
3476 output_file_close(p
->pLog
);
3477 p
->pLog
= output_file_open(zFile
);
3481 if( c
=='m' && strncmp(azArg
[0], "mode", n
)==0 ){
3482 const char *zMode
= nArg
>=2 ? azArg
[1] : "";
3483 int n2
= (int)strlen(zMode
);
3485 if( c2
=='l' && n2
>2 && strncmp(azArg
[1],"lines",n2
)==0 ){
3486 p
->mode
= MODE_Line
;
3487 }else if( c2
=='c' && strncmp(azArg
[1],"columns",n2
)==0 ){
3488 p
->mode
= MODE_Column
;
3489 }else if( c2
=='l' && n2
>2 && strncmp(azArg
[1],"list",n2
)==0 ){
3490 p
->mode
= MODE_List
;
3491 }else if( c2
=='h' && strncmp(azArg
[1],"html",n2
)==0 ){
3492 p
->mode
= MODE_Html
;
3493 }else if( c2
=='t' && strncmp(azArg
[1],"tcl",n2
)==0 ){
3495 sqlite3_snprintf(sizeof(p
->colSeparator
), p
->colSeparator
, SEP_Space
);
3496 }else if( c2
=='c' && strncmp(azArg
[1],"csv",n2
)==0 ){
3498 sqlite3_snprintf(sizeof(p
->colSeparator
), p
->colSeparator
, SEP_Comma
);
3499 sqlite3_snprintf(sizeof(p
->rowSeparator
), p
->rowSeparator
, SEP_CrLf
);
3500 }else if( c2
=='t' && strncmp(azArg
[1],"tabs",n2
)==0 ){
3501 p
->mode
= MODE_List
;
3502 sqlite3_snprintf(sizeof(p
->colSeparator
), p
->colSeparator
, SEP_Tab
);
3503 }else if( c2
=='i' && strncmp(azArg
[1],"insert",n2
)==0 ){
3504 p
->mode
= MODE_Insert
;
3505 set_table_name(p
, nArg
>=3 ? azArg
[2] : "table");
3506 }else if( c2
=='a' && strncmp(azArg
[1],"ascii",n2
)==0 ){
3507 p
->mode
= MODE_Ascii
;
3508 sqlite3_snprintf(sizeof(p
->colSeparator
), p
->colSeparator
, SEP_Unit
);
3509 sqlite3_snprintf(sizeof(p
->rowSeparator
), p
->rowSeparator
, SEP_Record
);
3511 raw_printf(stderr
, "Error: mode should be one of: "
3512 "ascii column csv html insert line list tabs tcl\n");
3518 if( c
=='n' && strncmp(azArg
[0], "nullvalue", n
)==0 ){
3520 sqlite3_snprintf(sizeof(p
->nullValue
), p
->nullValue
,
3521 "%.*s", (int)ArraySize(p
->nullValue
)-1, azArg
[1]);
3523 raw_printf(stderr
, "Usage: .nullvalue STRING\n");
3528 if( c
=='o' && strncmp(azArg
[0], "open", n
)==0 && n
>=2 ){
3529 sqlite3
*savedDb
= p
->db
;
3530 const char *zSavedFilename
= p
->zDbFilename
;
3531 char *zNewFilename
= 0;
3533 if( nArg
>=2 ) zNewFilename
= sqlite3_mprintf("%s", azArg
[1]);
3534 p
->zDbFilename
= zNewFilename
;
3537 sqlite3_close(savedDb
);
3538 sqlite3_free(p
->zFreeOnClose
);
3539 p
->zFreeOnClose
= zNewFilename
;
3541 sqlite3_free(zNewFilename
);
3543 p
->zDbFilename
= zSavedFilename
;
3548 && (strncmp(azArg
[0], "output", n
)==0 || strncmp(azArg
[0], "once", n
)==0)
3550 const char *zFile
= nArg
>=2 ? azArg
[1] : "stdout";
3552 utf8_printf(stderr
, "Usage: .%s FILE\n", azArg
[0]);
3554 goto meta_command_exit
;
3556 if( n
>1 && strncmp(azArg
[0], "once", n
)==0 ){
3558 raw_printf(stderr
, "Usage: .once FILE\n");
3560 goto meta_command_exit
;
3567 if( zFile
[0]=='|' ){
3568 #ifdef SQLITE_OMIT_POPEN
3569 raw_printf(stderr
, "Error: pipes are not supported in this OS\n");
3573 p
->out
= popen(zFile
+ 1, "w");
3575 utf8_printf(stderr
,"Error: cannot open pipe \"%s\"\n", zFile
+ 1);
3579 sqlite3_snprintf(sizeof(p
->outfile
), p
->outfile
, "%s", zFile
);
3583 p
->out
= output_file_open(zFile
);
3585 if( strcmp(zFile
,"off")!=0 ){
3586 utf8_printf(stderr
,"Error: cannot write to \"%s\"\n", zFile
);
3591 sqlite3_snprintf(sizeof(p
->outfile
), p
->outfile
, "%s", zFile
);
3596 if( c
=='p' && n
>=3 && strncmp(azArg
[0], "print", n
)==0 ){
3598 for(i
=1; i
<nArg
; i
++){
3599 if( i
>1 ) raw_printf(p
->out
, " ");
3600 utf8_printf(p
->out
, "%s", azArg
[i
]);
3602 raw_printf(p
->out
, "\n");
3605 if( c
=='p' && strncmp(azArg
[0], "prompt", n
)==0 ){
3607 strncpy(mainPrompt
,azArg
[1],(int)ArraySize(mainPrompt
)-1);
3610 strncpy(continuePrompt
,azArg
[2],(int)ArraySize(continuePrompt
)-1);
3614 if( c
=='q' && strncmp(azArg
[0], "quit", n
)==0 ){
3618 if( c
=='r' && n
>=3 && strncmp(azArg
[0], "read", n
)==0 ){
3621 raw_printf(stderr
, "Usage: .read FILE\n");
3623 goto meta_command_exit
;
3625 alt
= fopen(azArg
[1], "rb");
3627 utf8_printf(stderr
,"Error: cannot open \"%s\"\n", azArg
[1]);
3630 rc
= process_input(p
, alt
);
3635 if( c
=='r' && n
>=3 && strncmp(azArg
[0], "restore", n
)==0 ){
3636 const char *zSrcFile
;
3639 sqlite3_backup
*pBackup
;
3643 zSrcFile
= azArg
[1];
3645 }else if( nArg
==3 ){
3646 zSrcFile
= azArg
[2];
3649 raw_printf(stderr
, "Usage: .restore ?DB? FILE\n");
3651 goto meta_command_exit
;
3653 rc
= sqlite3_open(zSrcFile
, &pSrc
);
3654 if( rc
!=SQLITE_OK
){
3655 utf8_printf(stderr
, "Error: cannot open \"%s\"\n", zSrcFile
);
3656 sqlite3_close(pSrc
);
3660 pBackup
= sqlite3_backup_init(p
->db
, zDb
, pSrc
, "main");
3662 utf8_printf(stderr
, "Error: %s\n", sqlite3_errmsg(p
->db
));
3663 sqlite3_close(pSrc
);
3666 while( (rc
= sqlite3_backup_step(pBackup
,100))==SQLITE_OK
3667 || rc
==SQLITE_BUSY
){
3668 if( rc
==SQLITE_BUSY
){
3669 if( nTimeout
++ >= 3 ) break;
3673 sqlite3_backup_finish(pBackup
);
3674 if( rc
==SQLITE_DONE
){
3676 }else if( rc
==SQLITE_BUSY
|| rc
==SQLITE_LOCKED
){
3677 raw_printf(stderr
, "Error: source database is busy\n");
3680 utf8_printf(stderr
, "Error: %s\n", sqlite3_errmsg(p
->db
));
3683 sqlite3_close(pSrc
);
3687 if( c
=='s' && strncmp(azArg
[0], "scanstats", n
)==0 ){
3689 p
->scanstatsOn
= booleanValue(azArg
[1]);
3690 #ifndef SQLITE_ENABLE_STMT_SCANSTATUS
3691 raw_printf(stderr
, "Warning: .scanstats not available in this build.\n");
3694 raw_printf(stderr
, "Usage: .scanstats on|off\n");
3699 if( c
=='s' && strncmp(azArg
[0], "schema", n
)==0 ){
3703 memcpy(&data
, p
, sizeof(data
));
3704 data
.showHeader
= 0;
3705 data
.cMode
= data
.mode
= MODE_Semi
;
3708 for(i
=0; azArg
[1][i
]; i
++) azArg
[1][i
] = ToLower(azArg
[1][i
]);
3709 if( strcmp(azArg
[1],"sqlite_master")==0 ){
3710 char *new_argv
[2], *new_colv
[2];
3711 new_argv
[0] = "CREATE TABLE sqlite_master (\n"
3715 " rootpage integer,\n"
3719 new_colv
[0] = "sql";
3721 callback(&data
, 1, new_argv
, new_colv
);
3723 }else if( strcmp(azArg
[1],"sqlite_temp_master")==0 ){
3724 char *new_argv
[2], *new_colv
[2];
3725 new_argv
[0] = "CREATE TEMP TABLE sqlite_temp_master (\n"
3729 " rootpage integer,\n"
3733 new_colv
[0] = "sql";
3735 callback(&data
, 1, new_argv
, new_colv
);
3738 zShellStatic
= azArg
[1];
3739 rc
= sqlite3_exec(p
->db
,
3741 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
3742 " FROM sqlite_master UNION ALL"
3743 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
3744 "WHERE lower(tbl_name) LIKE shellstatic()"
3745 " AND type!='meta' AND sql NOTNULL "
3747 callback
, &data
, &zErrMsg
);
3750 }else if( nArg
==1 ){
3751 rc
= sqlite3_exec(p
->db
,
3753 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
3754 " FROM sqlite_master UNION ALL"
3755 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
3756 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
3758 callback
, &data
, &zErrMsg
3761 raw_printf(stderr
, "Usage: .schema ?LIKE-PATTERN?\n");
3763 goto meta_command_exit
;
3766 utf8_printf(stderr
,"Error: %s\n", zErrMsg
);
3767 sqlite3_free(zErrMsg
);
3769 }else if( rc
!= SQLITE_OK
){
3770 raw_printf(stderr
,"Error: querying schema information\n");
3778 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
3779 if( c
=='s' && n
==11 && strncmp(azArg
[0], "selecttrace", n
)==0 ){
3780 extern int sqlite3SelectTrace
;
3781 sqlite3SelectTrace
= integerValue(azArg
[1]);
3787 /* Undocumented commands for internal testing. Subject to change
3788 ** without notice. */
3789 if( c
=='s' && n
>=10 && strncmp(azArg
[0], "selftest-", 9)==0 ){
3790 if( strncmp(azArg
[0]+9, "boolean", n
-9)==0 ){
3792 for(i
=1; i
<nArg
; i
++){
3793 v
= booleanValue(azArg
[i
]);
3794 utf8_printf(p
->out
, "%s: %d 0x%x\n", azArg
[i
], v
, v
);
3797 if( strncmp(azArg
[0]+9, "integer", n
-9)==0 ){
3798 int i
; sqlite3_int64 v
;
3799 for(i
=1; i
<nArg
; i
++){
3801 v
= integerValue(azArg
[i
]);
3802 sqlite3_snprintf(sizeof(zBuf
),zBuf
,"%s: %lld 0x%llx\n", azArg
[i
],v
,v
);
3803 utf8_printf(p
->out
, "%s", zBuf
);
3809 if( c
=='s' && strncmp(azArg
[0], "separator", n
)==0 ){
3810 if( nArg
<2 || nArg
>3 ){
3811 raw_printf(stderr
, "Usage: .separator COL ?ROW?\n");
3815 sqlite3_snprintf(sizeof(p
->colSeparator
), p
->colSeparator
,
3816 "%.*s", (int)ArraySize(p
->colSeparator
)-1, azArg
[1]);
3819 sqlite3_snprintf(sizeof(p
->rowSeparator
), p
->rowSeparator
,
3820 "%.*s", (int)ArraySize(p
->rowSeparator
)-1, azArg
[2]);
3825 && (strncmp(azArg
[0], "shell", n
)==0 || strncmp(azArg
[0],"system",n
)==0)
3830 raw_printf(stderr
, "Usage: .system COMMAND\n");
3832 goto meta_command_exit
;
3834 zCmd
= sqlite3_mprintf(strchr(azArg
[1],' ')==0?"%s":"\"%s\"", azArg
[1]);
3835 for(i
=2; i
<nArg
; i
++){
3836 zCmd
= sqlite3_mprintf(strchr(azArg
[i
],' ')==0?"%z %s":"%z \"%s\"",
3841 if( x
) raw_printf(stderr
, "System command returns %d\n", x
);
3844 if( c
=='s' && strncmp(azArg
[0], "show", n
)==0 ){
3847 raw_printf(stderr
, "Usage: .show\n");
3849 goto meta_command_exit
;
3851 utf8_printf(p
->out
, "%12.12s: %s\n","echo", p
->echoOn
? "on" : "off");
3852 utf8_printf(p
->out
, "%12.12s: %s\n","eqp", p
->autoEQP
? "on" : "off");
3853 utf8_printf(p
->out
, "%12.12s: %s\n","explain",
3854 p
->mode
==MODE_Explain
? "on" : p
->autoExplain
? "auto" : "off");
3855 utf8_printf(p
->out
,"%12.12s: %s\n","headers", p
->showHeader
? "on" : "off");
3856 utf8_printf(p
->out
, "%12.12s: %s\n","mode", modeDescr
[p
->mode
]);
3857 utf8_printf(p
->out
, "%12.12s: ", "nullvalue");
3858 output_c_string(p
->out
, p
->nullValue
);
3859 raw_printf(p
->out
, "\n");
3860 utf8_printf(p
->out
,"%12.12s: %s\n","output",
3861 strlen30(p
->outfile
) ? p
->outfile
: "stdout");
3862 utf8_printf(p
->out
,"%12.12s: ", "colseparator");
3863 output_c_string(p
->out
, p
->colSeparator
);
3864 raw_printf(p
->out
, "\n");
3865 utf8_printf(p
->out
,"%12.12s: ", "rowseparator");
3866 output_c_string(p
->out
, p
->rowSeparator
);
3867 raw_printf(p
->out
, "\n");
3868 utf8_printf(p
->out
, "%12.12s: %s\n","stats", p
->statsOn
? "on" : "off");
3869 utf8_printf(p
->out
, "%12.12s: ", "width");
3870 for (i
=0;i
<(int)ArraySize(p
->colWidth
) && p
->colWidth
[i
] != 0;i
++) {
3871 raw_printf(p
->out
, "%d ", p
->colWidth
[i
]);
3873 raw_printf(p
->out
, "\n");
3876 if( c
=='s' && strncmp(azArg
[0], "stats", n
)==0 ){
3878 p
->statsOn
= booleanValue(azArg
[1]);
3879 }else if( nArg
==1 ){
3880 display_stats(p
->db
, p
, 0);
3882 raw_printf(stderr
, "Usage: .stats ?on|off?\n");
3887 if( c
=='t' && n
>1 && strncmp(azArg
[0], "tables", n
)==0 ){
3888 sqlite3_stmt
*pStmt
;
3894 rc
= sqlite3_prepare_v2(p
->db
, "PRAGMA database_list", -1, &pStmt
, 0);
3895 if( rc
) return shellDatabaseError(p
->db
);
3897 /* Create an SQL statement to query for the list of tables in the
3898 ** main and all attached databases where the table name matches the
3899 ** LIKE pattern bound to variable "?1". */
3900 zSql
= sqlite3_mprintf(
3901 "SELECT name FROM sqlite_master"
3902 " WHERE type IN ('table','view')"
3903 " AND name NOT LIKE 'sqlite_%%'"
3904 " AND name LIKE ?1");
3905 while( zSql
&& sqlite3_step(pStmt
)==SQLITE_ROW
){
3906 const char *zDbName
= (const char*)sqlite3_column_text(pStmt
, 1);
3907 if( zDbName
==0 || strcmp(zDbName
,"main")==0 ) continue;
3908 if( strcmp(zDbName
,"temp")==0 ){
3909 zSql
= sqlite3_mprintf(
3911 "SELECT 'temp.' || name FROM sqlite_temp_master"
3912 " WHERE type IN ('table','view')"
3913 " AND name NOT LIKE 'sqlite_%%'"
3914 " AND name LIKE ?1", zSql
);
3916 zSql
= sqlite3_mprintf(
3918 "SELECT '%q.' || name FROM \"%w\".sqlite_master"
3919 " WHERE type IN ('table','view')"
3920 " AND name NOT LIKE 'sqlite_%%'"
3921 " AND name LIKE ?1", zSql
, zDbName
, zDbName
);
3924 rc
= sqlite3_finalize(pStmt
);
3925 if( zSql
&& rc
==SQLITE_OK
){
3926 zSql
= sqlite3_mprintf("%z ORDER BY 1", zSql
);
3927 if( zSql
) rc
= sqlite3_prepare_v2(p
->db
, zSql
, -1, &pStmt
, 0);
3930 if( !zSql
) return shellNomemError();
3931 if( rc
) return shellDatabaseError(p
->db
);
3933 /* Run the SQL statement prepared by the above block. Store the results
3934 ** as an array of nul-terminated strings in azResult[]. */
3938 sqlite3_bind_text(pStmt
, 1, azArg
[1], -1, SQLITE_TRANSIENT
);
3940 sqlite3_bind_text(pStmt
, 1, "%", -1, SQLITE_STATIC
);
3942 while( sqlite3_step(pStmt
)==SQLITE_ROW
){
3945 int n2
= nAlloc
*2 + 10;
3946 azNew
= sqlite3_realloc64(azResult
, sizeof(azResult
[0])*n2
);
3948 rc
= shellNomemError();
3954 azResult
[nRow
] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt
, 0));
3955 if( 0==azResult
[nRow
] ){
3956 rc
= shellNomemError();
3961 if( sqlite3_finalize(pStmt
)!=SQLITE_OK
){
3962 rc
= shellDatabaseError(p
->db
);
3965 /* Pretty-print the contents of array azResult[] to the output */
3966 if( rc
==0 && nRow
>0 ){
3967 int len
, maxlen
= 0;
3969 int nPrintCol
, nPrintRow
;
3970 for(i
=0; i
<nRow
; i
++){
3971 len
= strlen30(azResult
[i
]);
3972 if( len
>maxlen
) maxlen
= len
;
3974 nPrintCol
= 80/(maxlen
+2);
3975 if( nPrintCol
<1 ) nPrintCol
= 1;
3976 nPrintRow
= (nRow
+ nPrintCol
- 1)/nPrintCol
;
3977 for(i
=0; i
<nPrintRow
; i
++){
3978 for(j
=i
; j
<nRow
; j
+=nPrintRow
){
3979 char *zSp
= j
<nPrintRow
? "" : " ";
3980 utf8_printf(p
->out
, "%s%-*s", zSp
, maxlen
,
3981 azResult
[j
] ? azResult
[j
]:"");
3983 raw_printf(p
->out
, "\n");
3987 for(ii
=0; ii
<nRow
; ii
++) sqlite3_free(azResult
[ii
]);
3988 sqlite3_free(azResult
);
3991 if( c
=='t' && n
>=8 && strncmp(azArg
[0], "testctrl", n
)==0 && nArg
>=2 ){
3992 static const struct {
3993 const char *zCtrlName
; /* Name of a test-control option */
3994 int ctrlCode
; /* Integer code for that option */
3996 { "prng_save", SQLITE_TESTCTRL_PRNG_SAVE
},
3997 { "prng_restore", SQLITE_TESTCTRL_PRNG_RESTORE
},
3998 { "prng_reset", SQLITE_TESTCTRL_PRNG_RESET
},
3999 { "bitvec_test", SQLITE_TESTCTRL_BITVEC_TEST
},
4000 { "fault_install", SQLITE_TESTCTRL_FAULT_INSTALL
},
4001 { "benign_malloc_hooks", SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS
},
4002 { "pending_byte", SQLITE_TESTCTRL_PENDING_BYTE
},
4003 { "assert", SQLITE_TESTCTRL_ASSERT
},
4004 { "always", SQLITE_TESTCTRL_ALWAYS
},
4005 { "reserve", SQLITE_TESTCTRL_RESERVE
},
4006 { "optimizations", SQLITE_TESTCTRL_OPTIMIZATIONS
},
4007 { "iskeyword", SQLITE_TESTCTRL_ISKEYWORD
},
4008 { "scratchmalloc", SQLITE_TESTCTRL_SCRATCHMALLOC
},
4009 { "byteorder", SQLITE_TESTCTRL_BYTEORDER
},
4010 { "never_corrupt", SQLITE_TESTCTRL_NEVER_CORRUPT
},
4011 { "imposter", SQLITE_TESTCTRL_IMPOSTER
},
4018 /* convert testctrl text option to value. allow any unique prefix
4019 ** of the option name, or a numerical value. */
4020 n2
= strlen30(azArg
[1]);
4021 for(i
=0; i
<ArraySize(aCtrl
); i
++){
4022 if( strncmp(azArg
[1], aCtrl
[i
].zCtrlName
, n2
)==0 ){
4024 testctrl
= aCtrl
[i
].ctrlCode
;
4026 utf8_printf(stderr
, "ambiguous option name: \"%s\"\n", azArg
[1]);
4032 if( testctrl
<0 ) testctrl
= (int)integerValue(azArg
[1]);
4033 if( (testctrl
<SQLITE_TESTCTRL_FIRST
) || (testctrl
>SQLITE_TESTCTRL_LAST
) ){
4034 utf8_printf(stderr
,"Error: invalid testctrl option: %s\n", azArg
[1]);
4038 /* sqlite3_test_control(int, db, int) */
4039 case SQLITE_TESTCTRL_OPTIMIZATIONS
:
4040 case SQLITE_TESTCTRL_RESERVE
:
4042 int opt
= (int)strtol(azArg
[2], 0, 0);
4043 rc2
= sqlite3_test_control(testctrl
, p
->db
, opt
);
4044 raw_printf(p
->out
, "%d (0x%08x)\n", rc2
, rc2
);
4046 utf8_printf(stderr
,"Error: testctrl %s takes a single int option\n",
4051 /* sqlite3_test_control(int) */
4052 case SQLITE_TESTCTRL_PRNG_SAVE
:
4053 case SQLITE_TESTCTRL_PRNG_RESTORE
:
4054 case SQLITE_TESTCTRL_PRNG_RESET
:
4055 case SQLITE_TESTCTRL_BYTEORDER
:
4057 rc2
= sqlite3_test_control(testctrl
);
4058 raw_printf(p
->out
, "%d (0x%08x)\n", rc2
, rc2
);
4060 utf8_printf(stderr
,"Error: testctrl %s takes no options\n",
4065 /* sqlite3_test_control(int, uint) */
4066 case SQLITE_TESTCTRL_PENDING_BYTE
:
4068 unsigned int opt
= (unsigned int)integerValue(azArg
[2]);
4069 rc2
= sqlite3_test_control(testctrl
, opt
);
4070 raw_printf(p
->out
, "%d (0x%08x)\n", rc2
, rc2
);
4072 utf8_printf(stderr
,"Error: testctrl %s takes a single unsigned"
4073 " int option\n", azArg
[1]);
4077 /* sqlite3_test_control(int, int) */
4078 case SQLITE_TESTCTRL_ASSERT
:
4079 case SQLITE_TESTCTRL_ALWAYS
:
4080 case SQLITE_TESTCTRL_NEVER_CORRUPT
:
4082 int opt
= booleanValue(azArg
[2]);
4083 rc2
= sqlite3_test_control(testctrl
, opt
);
4084 raw_printf(p
->out
, "%d (0x%08x)\n", rc2
, rc2
);
4086 utf8_printf(stderr
,"Error: testctrl %s takes a single int option\n",
4091 /* sqlite3_test_control(int, char *) */
4092 #ifdef SQLITE_N_KEYWORD
4093 case SQLITE_TESTCTRL_ISKEYWORD
:
4095 const char *opt
= azArg
[2];
4096 rc2
= sqlite3_test_control(testctrl
, opt
);
4097 raw_printf(p
->out
, "%d (0x%08x)\n", rc2
, rc2
);
4100 "Error: testctrl %s takes a single char * option\n",
4106 case SQLITE_TESTCTRL_IMPOSTER
:
4108 rc2
= sqlite3_test_control(testctrl
, p
->db
,
4110 integerValue(azArg
[3]),
4111 integerValue(azArg
[4]));
4112 raw_printf(p
->out
, "%d (0x%08x)\n", rc2
, rc2
);
4114 raw_printf(stderr
,"Usage: .testctrl imposter dbName onoff tnum\n");
4118 case SQLITE_TESTCTRL_BITVEC_TEST
:
4119 case SQLITE_TESTCTRL_FAULT_INSTALL
:
4120 case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS
:
4121 case SQLITE_TESTCTRL_SCRATCHMALLOC
:
4124 "Error: CLI support for testctrl %s not implemented\n",
4131 if( c
=='t' && n
>4 && strncmp(azArg
[0], "timeout", n
)==0 ){
4133 sqlite3_busy_timeout(p
->db
, nArg
>=2 ? (int)integerValue(azArg
[1]) : 0);
4136 if( c
=='t' && n
>=5 && strncmp(azArg
[0], "timer", n
)==0 ){
4138 enableTimer
= booleanValue(azArg
[1]);
4139 if( enableTimer
&& !HAS_TIMER
){
4140 raw_printf(stderr
, "Error: timer not available on this system.\n");
4144 raw_printf(stderr
, "Usage: .timer on|off\n");
4149 if( c
=='t' && strncmp(azArg
[0], "trace", n
)==0 ){
4152 raw_printf(stderr
, "Usage: .trace FILE|off\n");
4154 goto meta_command_exit
;
4156 output_file_close(p
->traceOut
);
4157 p
->traceOut
= output_file_open(azArg
[1]);
4158 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)
4159 if( p
->traceOut
==0 ){
4160 sqlite3_trace(p
->db
, 0, 0);
4162 sqlite3_trace(p
->db
, sql_trace_callback
, p
->traceOut
);
4167 #if SQLITE_USER_AUTHENTICATION
4168 if( c
=='u' && strncmp(azArg
[0], "user", n
)==0 ){
4170 raw_printf(stderr
, "Usage: .user SUBCOMMAND ...\n");
4172 goto meta_command_exit
;
4175 if( strcmp(azArg
[1],"login")==0 ){
4177 raw_printf(stderr
, "Usage: .user login USER PASSWORD\n");
4179 goto meta_command_exit
;
4181 rc
= sqlite3_user_authenticate(p
->db
, azArg
[2], azArg
[3],
4182 (int)strlen(azArg
[3]));
4184 utf8_printf(stderr
, "Authentication failed for user %s\n", azArg
[2]);
4187 }else if( strcmp(azArg
[1],"add")==0 ){
4189 raw_printf(stderr
, "Usage: .user add USER PASSWORD ISADMIN\n");
4191 goto meta_command_exit
;
4193 rc
= sqlite3_user_add(p
->db
, azArg
[2],
4194 azArg
[3], (int)strlen(azArg
[3]),
4195 booleanValue(azArg
[4]));
4197 raw_printf(stderr
, "User-Add failed: %d\n", rc
);
4200 }else if( strcmp(azArg
[1],"edit")==0 ){
4202 raw_printf(stderr
, "Usage: .user edit USER PASSWORD ISADMIN\n");
4204 goto meta_command_exit
;
4206 rc
= sqlite3_user_change(p
->db
, azArg
[2],
4207 azArg
[3], (int)strlen(azArg
[3]),
4208 booleanValue(azArg
[4]));
4210 raw_printf(stderr
, "User-Edit failed: %d\n", rc
);
4213 }else if( strcmp(azArg
[1],"delete")==0 ){
4215 raw_printf(stderr
, "Usage: .user delete USER\n");
4217 goto meta_command_exit
;
4219 rc
= sqlite3_user_delete(p
->db
, azArg
[2]);
4221 raw_printf(stderr
, "User-Delete failed: %d\n", rc
);
4225 raw_printf(stderr
, "Usage: .user login|add|edit|delete ...\n");
4227 goto meta_command_exit
;
4230 #endif /* SQLITE_USER_AUTHENTICATION */
4232 if( c
=='v' && strncmp(azArg
[0], "version", n
)==0 ){
4233 utf8_printf(p
->out
, "SQLite %s %s\n" /*extra-version-info*/,
4234 sqlite3_libversion(), sqlite3_sourceid());
4237 if( c
=='v' && strncmp(azArg
[0], "vfsinfo", n
)==0 ){
4238 const char *zDbName
= nArg
==2 ? azArg
[1] : "main";
4241 sqlite3_file_control(p
->db
, zDbName
, SQLITE_FCNTL_VFS_POINTER
, &pVfs
);
4243 utf8_printf(p
->out
, "vfs.zName = \"%s\"\n", pVfs
->zName
);
4244 raw_printf(p
->out
, "vfs.iVersion = %d\n", pVfs
->iVersion
);
4245 raw_printf(p
->out
, "vfs.szOsFile = %d\n", pVfs
->szOsFile
);
4246 raw_printf(p
->out
, "vfs.mxPathname = %d\n", pVfs
->mxPathname
);
4251 if( c
=='v' && strncmp(azArg
[0], "vfslist", n
)==0 ){
4253 sqlite3_vfs
*pCurrent
= 0;
4255 sqlite3_file_control(p
->db
, "main", SQLITE_FCNTL_VFS_POINTER
, &pCurrent
);
4257 for(pVfs
=sqlite3_vfs_find(0); pVfs
; pVfs
=pVfs
->pNext
){
4258 utf8_printf(p
->out
, "vfs.zName = \"%s\"%s\n", pVfs
->zName
,
4259 pVfs
==pCurrent
? " <--- CURRENT" : "");
4260 raw_printf(p
->out
, "vfs.iVersion = %d\n", pVfs
->iVersion
);
4261 raw_printf(p
->out
, "vfs.szOsFile = %d\n", pVfs
->szOsFile
);
4262 raw_printf(p
->out
, "vfs.mxPathname = %d\n", pVfs
->mxPathname
);
4264 raw_printf(p
->out
, "-----------------------------------\n");
4269 if( c
=='v' && strncmp(azArg
[0], "vfsname", n
)==0 ){
4270 const char *zDbName
= nArg
==2 ? azArg
[1] : "main";
4273 sqlite3_file_control(p
->db
, zDbName
, SQLITE_FCNTL_VFSNAME
, &zVfsName
);
4275 utf8_printf(p
->out
, "%s\n", zVfsName
);
4276 sqlite3_free(zVfsName
);
4281 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
4282 if( c
=='w' && strncmp(azArg
[0], "wheretrace", n
)==0 ){
4283 extern int sqlite3WhereTrace
;
4284 sqlite3WhereTrace
= nArg
>=2 ? booleanValue(azArg
[1]) : 0xff;
4288 if( c
=='w' && strncmp(azArg
[0], "width", n
)==0 ){
4290 assert( nArg
<=ArraySize(azArg
) );
4291 for(j
=1; j
<nArg
&& j
<ArraySize(p
->colWidth
); j
++){
4292 p
->colWidth
[j
-1] = (int)integerValue(azArg
[j
]);
4297 utf8_printf(stderr
, "Error: unknown command or invalid arguments: "
4298 " \"%s\". Enter \".help\" for help\n", azArg
[0]);
4305 if( p
->outCount
==0 ) output_reset(p
);
4311 ** Return TRUE if a semicolon occurs anywhere in the first N characters
4314 static int line_contains_semicolon(const char *z
, int N
){
4316 for(i
=0; i
<N
; i
++){ if( z
[i
]==';' ) return 1; }
4321 ** Test to see if a line consists entirely of whitespace.
4323 static int _all_whitespace(const char *z
){
4325 if( IsSpace(z
[0]) ) continue;
4326 if( *z
=='/' && z
[1]=='*' ){
4328 while( *z
&& (*z
!='*' || z
[1]!='/') ){ z
++; }
4329 if( *z
==0 ) return 0;
4333 if( *z
=='-' && z
[1]=='-' ){
4335 while( *z
&& *z
!='\n' ){ z
++; }
4336 if( *z
==0 ) return 1;
4345 ** Return TRUE if the line typed in is an SQL command terminator other
4346 ** than a semi-colon. The SQL Server style "go" command is understood
4347 ** as is the Oracle "/".
4349 static int line_is_command_terminator(const char *zLine
){
4350 while( IsSpace(zLine
[0]) ){ zLine
++; };
4351 if( zLine
[0]=='/' && _all_whitespace(&zLine
[1]) ){
4352 return 1; /* Oracle */
4354 if( ToLower(zLine
[0])=='g' && ToLower(zLine
[1])=='o'
4355 && _all_whitespace(&zLine
[2]) ){
4356 return 1; /* SQL Server */
4362 ** Return true if zSql is a complete SQL statement. Return false if it
4363 ** ends in the middle of a string literal or C-style comment.
4365 static int line_is_complete(char *zSql
, int nSql
){
4367 if( zSql
==0 ) return 1;
4370 rc
= sqlite3_complete(zSql
);
4376 ** Read input from *in and process it. If *in==0 then input
4377 ** is interactive - the user is typing it it. Otherwise, input
4378 ** is coming from a file or device. A prompt is issued and history
4379 ** is saved only if input is interactive. An interrupt signal will
4380 ** cause this routine to exit immediately, unless input is interactive.
4382 ** Return the number of errors.
4384 static int process_input(ShellState
*p
, FILE *in
){
4385 char *zLine
= 0; /* A single input line */
4386 char *zSql
= 0; /* Accumulated SQL text */
4387 int nLine
; /* Length of current line */
4388 int nSql
= 0; /* Bytes of zSql[] used */
4389 int nAlloc
= 0; /* Allocated zSql[] space */
4390 int nSqlPrior
= 0; /* Bytes of zSql[] used by prior line */
4391 char *zErrMsg
; /* Error message returned */
4392 int rc
; /* Error code */
4393 int errCnt
= 0; /* Number of errors seen */
4394 int lineno
= 0; /* Current line number */
4395 int startline
= 0; /* Line number for start of current input */
4397 while( errCnt
==0 || !bail_on_error
|| (in
==0 && stdin_is_interactive
) ){
4399 zLine
= one_input_line(in
, zLine
, nSql
>0);
4402 if( stdin_is_interactive
) printf("\n");
4405 if( seenInterrupt
){
4410 if( nSql
==0 && _all_whitespace(zLine
) ){
4411 if( p
->echoOn
) printf("%s\n", zLine
);
4414 if( zLine
&& zLine
[0]=='.' && nSql
==0 ){
4415 if( p
->echoOn
) printf("%s\n", zLine
);
4416 rc
= do_meta_command(zLine
, p
);
4417 if( rc
==2 ){ /* exit requested */
4424 if( line_is_command_terminator(zLine
) && line_is_complete(zSql
, nSql
) ){
4425 memcpy(zLine
,";",2);
4427 nLine
= strlen30(zLine
);
4428 if( nSql
+nLine
+2>=nAlloc
){
4429 nAlloc
= nSql
+nLine
+100;
4430 zSql
= realloc(zSql
, nAlloc
);
4432 raw_printf(stderr
, "Error: out of memory\n");
4439 for(i
=0; zLine
[i
] && IsSpace(zLine
[i
]); i
++){}
4440 assert( nAlloc
>0 && zSql
!=0 );
4441 memcpy(zSql
, zLine
+i
, nLine
+1-i
);
4445 zSql
[nSql
++] = '\n';
4446 memcpy(zSql
+nSql
, zLine
, nLine
+1);
4449 if( nSql
&& line_contains_semicolon(&zSql
[nSqlPrior
], nSql
-nSqlPrior
)
4450 && sqlite3_complete(zSql
) ){
4453 if( p
->backslashOn
) resolve_backslashes(zSql
);
4455 rc
= shell_exec(p
->db
, zSql
, shell_callback
, p
, &zErrMsg
);
4457 if( rc
|| zErrMsg
){
4459 if( in
!=0 || !stdin_is_interactive
){
4460 sqlite3_snprintf(sizeof(zPrefix
), zPrefix
,
4461 "Error: near line %d:", startline
);
4463 sqlite3_snprintf(sizeof(zPrefix
), zPrefix
, "Error:");
4466 utf8_printf(stderr
, "%s %s\n", zPrefix
, zErrMsg
);
4467 sqlite3_free(zErrMsg
);
4470 utf8_printf(stderr
, "%s %s\n", zPrefix
, sqlite3_errmsg(p
->db
));
4473 }else if( p
->countChanges
){
4474 raw_printf(p
->out
, "changes: %3d total_changes: %d\n",
4475 sqlite3_changes(p
->db
), sqlite3_total_changes(p
->db
));
4482 }else if( nSql
&& _all_whitespace(zSql
) ){
4483 if( p
->echoOn
) printf("%s\n", zSql
);
4488 if( !_all_whitespace(zSql
) ){
4489 utf8_printf(stderr
, "Error: incomplete SQL: %s\n", zSql
);
4499 ** Return a pathname which is the user's home directory. A
4500 ** 0 return indicates an error of some kind.
4502 static char *find_home_dir(void){
4503 static char *home_dir
= NULL
;
4504 if( home_dir
) return home_dir
;
4506 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) \
4507 && !defined(__RTP__) && !defined(_WRS_KERNEL)
4509 struct passwd
*pwent
;
4510 uid_t uid
= getuid();
4511 if( (pwent
=getpwuid(uid
)) != NULL
) {
4512 home_dir
= pwent
->pw_dir
;
4517 #if defined(_WIN32_WCE)
4518 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
4523 #if defined(_WIN32) || defined(WIN32)
4525 home_dir
= getenv("USERPROFILE");
4530 home_dir
= getenv("HOME");
4533 #if defined(_WIN32) || defined(WIN32)
4535 char *zDrive
, *zPath
;
4537 zDrive
= getenv("HOMEDRIVE");
4538 zPath
= getenv("HOMEPATH");
4539 if( zDrive
&& zPath
){
4540 n
= strlen30(zDrive
) + strlen30(zPath
) + 1;
4541 home_dir
= malloc( n
);
4542 if( home_dir
==0 ) return 0;
4543 sqlite3_snprintf(n
, home_dir
, "%s%s", zDrive
, zPath
);
4550 #endif /* !_WIN32_WCE */
4553 int n
= strlen30(home_dir
) + 1;
4554 char *z
= malloc( n
);
4555 if( z
) memcpy(z
, home_dir
, n
);
4563 ** Read input from the file given by sqliterc_override. Or if that
4564 ** parameter is NULL, take input from ~/.sqliterc
4566 ** Returns the number of errors.
4568 static void process_sqliterc(
4569 ShellState
*p
, /* Configuration data */
4570 const char *sqliterc_override
/* Name of config file. NULL to use default */
4572 char *home_dir
= NULL
;
4573 const char *sqliterc
= sqliterc_override
;
4577 if (sqliterc
== NULL
) {
4578 home_dir
= find_home_dir();
4580 raw_printf(stderr
, "-- warning: cannot find home directory;"
4581 " cannot read ~/.sqliterc\n");
4584 sqlite3_initialize();
4585 zBuf
= sqlite3_mprintf("%s/.sqliterc",home_dir
);
4588 in
= fopen(sqliterc
,"rb");
4590 if( stdin_is_interactive
){
4591 utf8_printf(stderr
,"-- Loading resources from %s\n",sqliterc
);
4593 process_input(p
,in
);
4600 ** Show available command line options
4602 static const char zOptions
[] =
4603 " -ascii set output mode to 'ascii'\n"
4604 " -bail stop after hitting an error\n"
4605 " -batch force batch I/O\n"
4606 " -column set output mode to 'column'\n"
4607 " -cmd COMMAND run \"COMMAND\" before reading stdin\n"
4608 " -csv set output mode to 'csv'\n"
4609 " -echo print commands before execution\n"
4610 " -init FILENAME read/process named file\n"
4611 " -[no]header turn headers on or off\n"
4612 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
4613 " -heap SIZE Size of heap for memsys3 or memsys5\n"
4615 " -help show this message\n"
4616 " -html set output mode to HTML\n"
4617 " -interactive force interactive I/O\n"
4618 " -line set output mode to 'line'\n"
4619 " -list set output mode to 'list'\n"
4620 " -lookaside SIZE N use N entries of SZ bytes for lookaside memory\n"
4621 " -mmap N default mmap size set to N\n"
4622 #ifdef SQLITE_ENABLE_MULTIPLEX
4623 " -multiplex enable the multiplexor VFS\n"
4625 " -newline SEP set output row separator. Default: '\\n'\n"
4626 " -nullvalue TEXT set text string for NULL values. Default ''\n"
4627 " -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n"
4628 " -scratch SIZE N use N slots of SZ bytes each for scratch memory\n"
4629 " -separator SEP set output column separator. Default: '|'\n"
4630 " -stats print memory stats before each finalize\n"
4631 " -version show SQLite version\n"
4632 " -vfs NAME use NAME as the default VFS\n"
4633 #ifdef SQLITE_ENABLE_VFSTRACE
4634 " -vfstrace enable tracing of all VFS calls\n"
4637 static void usage(int showDetail
){
4639 "Usage: %s [OPTIONS] FILENAME [SQL]\n"
4640 "FILENAME is the name of an SQLite database. A new database is created\n"
4641 "if the file does not previously exist.\n", Argv0
);
4643 utf8_printf(stderr
, "OPTIONS include:\n%s", zOptions
);
4645 raw_printf(stderr
, "Use the -help option for additional information\n");
4651 ** Initialize the state information in data
4653 static void main_init(ShellState
*data
) {
4654 memset(data
, 0, sizeof(*data
));
4655 data
->normalMode
= data
->cMode
= data
->mode
= MODE_List
;
4656 data
->autoExplain
= 1;
4657 memcpy(data
->colSeparator
,SEP_Column
, 2);
4658 memcpy(data
->rowSeparator
,SEP_Row
, 2);
4659 data
->showHeader
= 0;
4660 data
->shellFlgs
= SHFLG_Lookaside
;
4661 sqlite3_config(SQLITE_CONFIG_URI
, 1);
4662 sqlite3_config(SQLITE_CONFIG_LOG
, shellLog
, data
);
4663 sqlite3_config(SQLITE_CONFIG_MULTITHREAD
);
4664 sqlite3_snprintf(sizeof(mainPrompt
), mainPrompt
,"sqlite> ");
4665 sqlite3_snprintf(sizeof(continuePrompt
), continuePrompt
," ...> ");
4669 ** Output text to the console in a font that attracts extra attention.
4672 static void printBold(const char *zText
){
4673 HANDLE out
= GetStdHandle(STD_OUTPUT_HANDLE
);
4674 CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo
;
4675 GetConsoleScreenBufferInfo(out
, &defaultScreenInfo
);
4676 SetConsoleTextAttribute(out
,
4677 FOREGROUND_RED
|FOREGROUND_INTENSITY
4679 printf("%s", zText
);
4680 SetConsoleTextAttribute(out
, defaultScreenInfo
.wAttributes
);
4683 static void printBold(const char *zText
){
4684 printf("\033[1m%s\033[0m", zText
);
4689 ** Get the argument to an --option. Throw an error and die if no argument
4692 static char *cmdline_option_value(int argc
, char **argv
, int i
){
4694 utf8_printf(stderr
, "%s: Error: missing argument to %s\n",
4695 argv
[0], argv
[argc
-1]);
4701 int SQLITE_CDECL
main(int argc
, char **argv
){
4704 const char *zInitFile
= 0;
4707 int warnInmemoryDb
= 0;
4712 #if USE_SYSTEM_SQLITE+0!=1
4713 if( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID
)!=0 ){
4714 utf8_printf(stderr
, "SQLite header and source version mismatch\n%s\n%s\n",
4715 sqlite3_sourceid(), SQLITE_SOURCE_ID
);
4719 setBinaryMode(stdin
);
4720 setvbuf(stderr
, 0, _IONBF
, 0); /* Make sure stderr is unbuffered */
4723 stdin_is_interactive
= isatty(0);
4724 stdout_is_console
= isatty(1);
4726 /* Make sure we have a valid signal handler early, before anything
4730 signal(SIGINT
, interrupt_handler
);
4733 #ifdef SQLITE_SHELL_DBNAME_PROC
4735 /* If the SQLITE_SHELL_DBNAME_PROC macro is defined, then it is the name
4736 ** of a C-function that will provide the name of the database file. Use
4737 ** this compile-time option to embed this shell program in larger
4739 extern void SQLITE_SHELL_DBNAME_PROC(const char**);
4740 SQLITE_SHELL_DBNAME_PROC(&data
.zDbFilename
);
4745 /* Do an initial pass through the command-line argument to locate
4746 ** the name of the database file, the name of the initialization file,
4747 ** the size of the alternative malloc heap,
4748 ** and the first command to execute.
4750 for(i
=1; i
<argc
; i
++){
4754 if( data
.zDbFilename
==0 ){
4755 data
.zDbFilename
= z
;
4757 /* Excesss arguments are interpreted as SQL (or dot-commands) and
4758 ** mean that nothing is read from stdin */
4761 azCmd
= realloc(azCmd
, sizeof(azCmd
[0])*nCmd
);
4763 raw_printf(stderr
, "out of memory\n");
4769 if( z
[1]=='-' ) z
++;
4770 if( strcmp(z
,"-separator")==0
4771 || strcmp(z
,"-nullvalue")==0
4772 || strcmp(z
,"-newline")==0
4773 || strcmp(z
,"-cmd")==0
4775 (void)cmdline_option_value(argc
, argv
, ++i
);
4776 }else if( strcmp(z
,"-init")==0 ){
4777 zInitFile
= cmdline_option_value(argc
, argv
, ++i
);
4778 }else if( strcmp(z
,"-batch")==0 ){
4779 /* Need to check for batch mode here to so we can avoid printing
4780 ** informational messages (like from process_sqliterc) before
4781 ** we do the actual processing of arguments later in a second pass.
4783 stdin_is_interactive
= 0;
4784 }else if( strcmp(z
,"-heap")==0 ){
4785 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
4787 sqlite3_int64 szHeap
;
4789 zSize
= cmdline_option_value(argc
, argv
, ++i
);
4790 szHeap
= integerValue(zSize
);
4791 if( szHeap
>0x7fff0000 ) szHeap
= 0x7fff0000;
4792 sqlite3_config(SQLITE_CONFIG_HEAP
, malloc((int)szHeap
), (int)szHeap
, 64);
4794 }else if( strcmp(z
,"-scratch")==0 ){
4796 sz
= (int)integerValue(cmdline_option_value(argc
,argv
,++i
));
4797 if( sz
>400000 ) sz
= 400000;
4798 if( sz
<2500 ) sz
= 2500;
4799 n
= (int)integerValue(cmdline_option_value(argc
,argv
,++i
));
4802 sqlite3_config(SQLITE_CONFIG_SCRATCH
, malloc(n
*sz
+1), sz
, n
);
4803 data
.shellFlgs
|= SHFLG_Scratch
;
4804 }else if( strcmp(z
,"-pagecache")==0 ){
4806 sz
= (int)integerValue(cmdline_option_value(argc
,argv
,++i
));
4807 if( sz
>70000 ) sz
= 70000;
4809 n
= (int)integerValue(cmdline_option_value(argc
,argv
,++i
));
4810 sqlite3_config(SQLITE_CONFIG_PAGECACHE
,
4811 (n
>0 && sz
>0) ? malloc(n
*sz
) : 0, sz
, n
);
4812 data
.shellFlgs
|= SHFLG_Pagecache
;
4813 }else if( strcmp(z
,"-lookaside")==0 ){
4815 sz
= (int)integerValue(cmdline_option_value(argc
,argv
,++i
));
4817 n
= (int)integerValue(cmdline_option_value(argc
,argv
,++i
));
4819 sqlite3_config(SQLITE_CONFIG_LOOKASIDE
, sz
, n
);
4820 if( sz
*n
==0 ) data
.shellFlgs
&= ~SHFLG_Lookaside
;
4821 #ifdef SQLITE_ENABLE_VFSTRACE
4822 }else if( strcmp(z
,"-vfstrace")==0 ){
4823 extern int vfstrace_register(
4824 const char *zTraceName
,
4825 const char *zOldVfsName
,
4826 int (*xOut
)(const char*,void*),
4830 vfstrace_register("trace",0,(int(*)(const char*,void*))fputs
,stderr
,1);
4832 #ifdef SQLITE_ENABLE_MULTIPLEX
4833 }else if( strcmp(z
,"-multiplex")==0 ){
4834 extern int sqlite3_multiple_initialize(const char*,int);
4835 sqlite3_multiplex_initialize(0, 1);
4837 }else if( strcmp(z
,"-mmap")==0 ){
4838 sqlite3_int64 sz
= integerValue(cmdline_option_value(argc
,argv
,++i
));
4839 sqlite3_config(SQLITE_CONFIG_MMAP_SIZE
, sz
, sz
);
4840 }else if( strcmp(z
,"-vfs")==0 ){
4841 sqlite3_vfs
*pVfs
= sqlite3_vfs_find(cmdline_option_value(argc
,argv
,++i
));
4843 sqlite3_vfs_register(pVfs
, 1);
4845 utf8_printf(stderr
, "no such VFS: \"%s\"\n", argv
[i
]);
4850 if( data
.zDbFilename
==0 ){
4851 #ifndef SQLITE_OMIT_MEMORYDB
4852 data
.zDbFilename
= ":memory:";
4853 warnInmemoryDb
= argc
==1;
4855 utf8_printf(stderr
,"%s: Error: no database filename specified\n", Argv0
);
4861 /* Go ahead and open the database file if it already exists. If the
4862 ** file does not exist, delay opening it. This prevents empty database
4863 ** files from being created if a user mistypes the database name argument
4864 ** to the sqlite command-line tool.
4866 if( access(data
.zDbFilename
, 0)==0 ){
4870 /* Process the initialization file if there is one. If no -init option
4871 ** is given on the command line, look for a file named ~/.sqliterc and
4872 ** try to process it.
4874 process_sqliterc(&data
,zInitFile
);
4876 /* Make a second pass through the command-line argument and set
4877 ** options. This second pass is delayed until after the initialization
4878 ** file is processed so that the command-line arguments will override
4879 ** settings in the initialization file.
4881 for(i
=1; i
<argc
; i
++){
4883 if( z
[0]!='-' ) continue;
4884 if( z
[1]=='-' ){ z
++; }
4885 if( strcmp(z
,"-init")==0 ){
4887 }else if( strcmp(z
,"-html")==0 ){
4888 data
.mode
= MODE_Html
;
4889 }else if( strcmp(z
,"-list")==0 ){
4890 data
.mode
= MODE_List
;
4891 }else if( strcmp(z
,"-line")==0 ){
4892 data
.mode
= MODE_Line
;
4893 }else if( strcmp(z
,"-column")==0 ){
4894 data
.mode
= MODE_Column
;
4895 }else if( strcmp(z
,"-csv")==0 ){
4896 data
.mode
= MODE_Csv
;
4897 memcpy(data
.colSeparator
,",",2);
4898 }else if( strcmp(z
,"-ascii")==0 ){
4899 data
.mode
= MODE_Ascii
;
4900 sqlite3_snprintf(sizeof(data
.colSeparator
), data
.colSeparator
,
4902 sqlite3_snprintf(sizeof(data
.rowSeparator
), data
.rowSeparator
,
4904 }else if( strcmp(z
,"-separator")==0 ){
4905 sqlite3_snprintf(sizeof(data
.colSeparator
), data
.colSeparator
,
4906 "%s",cmdline_option_value(argc
,argv
,++i
));
4907 }else if( strcmp(z
,"-newline")==0 ){
4908 sqlite3_snprintf(sizeof(data
.rowSeparator
), data
.rowSeparator
,
4909 "%s",cmdline_option_value(argc
,argv
,++i
));
4910 }else if( strcmp(z
,"-nullvalue")==0 ){
4911 sqlite3_snprintf(sizeof(data
.nullValue
), data
.nullValue
,
4912 "%s",cmdline_option_value(argc
,argv
,++i
));
4913 }else if( strcmp(z
,"-header")==0 ){
4914 data
.showHeader
= 1;
4915 }else if( strcmp(z
,"-noheader")==0 ){
4916 data
.showHeader
= 0;
4917 }else if( strcmp(z
,"-echo")==0 ){
4919 }else if( strcmp(z
,"-eqp")==0 ){
4921 }else if( strcmp(z
,"-stats")==0 ){
4923 }else if( strcmp(z
,"-scanstats")==0 ){
4924 data
.scanstatsOn
= 1;
4925 }else if( strcmp(z
,"-backslash")==0 ){
4926 /* Undocumented command-line option: -backslash
4927 ** Causes C-style backslash escapes to be evaluated in SQL statements
4928 ** prior to sending the SQL into SQLite. Useful for injecting
4929 ** crazy bytes in the middle of SQL statements for testing and debugging.
4931 data
.backslashOn
= 1;
4932 }else if( strcmp(z
,"-bail")==0 ){
4934 }else if( strcmp(z
,"-version")==0 ){
4935 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
4937 }else if( strcmp(z
,"-interactive")==0 ){
4938 stdin_is_interactive
= 1;
4939 }else if( strcmp(z
,"-batch")==0 ){
4940 stdin_is_interactive
= 0;
4941 }else if( strcmp(z
,"-heap")==0 ){
4943 }else if( strcmp(z
,"-scratch")==0 ){
4945 }else if( strcmp(z
,"-pagecache")==0 ){
4947 }else if( strcmp(z
,"-lookaside")==0 ){
4949 }else if( strcmp(z
,"-mmap")==0 ){
4951 }else if( strcmp(z
,"-vfs")==0 ){
4953 #ifdef SQLITE_ENABLE_VFSTRACE
4954 }else if( strcmp(z
,"-vfstrace")==0 ){
4957 #ifdef SQLITE_ENABLE_MULTIPLEX
4958 }else if( strcmp(z
,"-multiplex")==0 ){
4961 }else if( strcmp(z
,"-help")==0 ){
4963 }else if( strcmp(z
,"-cmd")==0 ){
4964 /* Run commands that follow -cmd first and separately from commands
4965 ** that simply appear on the command-line. This seems goofy. It would
4966 ** be better if all commands ran in the order that they appear. But
4967 ** we retain the goofy behavior for historical compatibility. */
4968 if( i
==argc
-1 ) break;
4969 z
= cmdline_option_value(argc
,argv
,++i
);
4971 rc
= do_meta_command(z
, &data
);
4972 if( rc
&& bail_on_error
) return rc
==2 ? 0 : rc
;
4975 rc
= shell_exec(data
.db
, z
, shell_callback
, &data
, &zErrMsg
);
4977 utf8_printf(stderr
,"Error: %s\n", zErrMsg
);
4978 if( bail_on_error
) return rc
!=0 ? rc
: 1;
4980 utf8_printf(stderr
,"Error: unable to process SQL \"%s\"\n", z
);
4981 if( bail_on_error
) return rc
;
4985 utf8_printf(stderr
,"%s: Error: unknown option: %s\n", Argv0
, z
);
4986 raw_printf(stderr
,"Use -help for a list of options.\n");
4989 data
.cMode
= data
.mode
;
4993 /* Run all arguments that do not begin with '-' as if they were separate
4994 ** command-line inputs, except for the argToSkip argument which contains
4995 ** the database filename.
4997 for(i
=0; i
<nCmd
; i
++){
4998 if( azCmd
[i
][0]=='.' ){
4999 rc
= do_meta_command(azCmd
[i
], &data
);
5000 if( rc
) return rc
==2 ? 0 : rc
;
5003 rc
= shell_exec(data
.db
, azCmd
[i
], shell_callback
, &data
, &zErrMsg
);
5005 utf8_printf(stderr
,"Error: %s\n", zErrMsg
);
5006 return rc
!=0 ? rc
: 1;
5008 utf8_printf(stderr
,"Error: unable to process SQL: %s\n", azCmd
[i
]);
5015 /* Run commands received from standard input
5017 if( stdin_is_interactive
){
5022 "SQLite version %s %.19s\n" /*extra-version-info*/
5023 "Enter \".help\" for usage hints.\n",
5024 sqlite3_libversion(), sqlite3_sourceid()
5026 if( warnInmemoryDb
){
5027 printf("Connected to a ");
5028 printBold("transient in-memory database");
5029 printf(".\nUse \".open FILENAME\" to reopen on a "
5030 "persistent database.\n");
5032 zHome
= find_home_dir();
5034 nHistory
= strlen30(zHome
) + 20;
5035 if( (zHistory
= malloc(nHistory
))!=0 ){
5036 sqlite3_snprintf(nHistory
, zHistory
,"%s/.sqlite_history", zHome
);
5039 if( zHistory
){ shell_read_history(zHistory
); }
5040 rc
= process_input(&data
, 0);
5042 shell_stifle_history(100);
5043 shell_write_history(zHistory
);
5047 rc
= process_input(&data
, stdin
);
5050 set_table_name(&data
, 0);
5052 sqlite3_close(data
.db
);
5054 sqlite3_free(data
.zFreeOnClose
);