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 ** Enable large-file support for fopen() and friends on unix.
30 #ifndef SQLITE_DISABLE_LFS
31 # define _LARGE_FILE 1
32 # ifndef _FILE_OFFSET_BITS
33 # define _FILE_OFFSET_BITS 64
35 # define _LARGEFILE_SOURCE 1
43 #if SQLITE_USER_AUTHENTICATION
44 # include "sqlite3userauth.h"
49 #if !defined(_WIN32) && !defined(WIN32)
51 # if !defined(__RTP__) && !defined(_WRS_KERNEL)
55 # include <sys/types.h>
59 # include <readline/readline.h>
60 # include <readline/history.h>
64 # include <editline/readline.h>
67 #if HAVE_EDITLINE || HAVE_READLINE
69 # define shell_add_history(X) add_history(X)
70 # define shell_read_history(X) read_history(X)
71 # define shell_write_history(X) write_history(X)
72 # define shell_stifle_history(X) stifle_history(X)
73 # define shell_readline(X) readline(X)
77 # include "linenoise.h"
78 # define shell_add_history(X) linenoiseHistoryAdd(X)
79 # define shell_read_history(X) linenoiseHistoryLoad(X)
80 # define shell_write_history(X) linenoiseHistorySave(X)
81 # define shell_stifle_history(X) linenoiseHistorySetMaxLen(X)
82 # define shell_readline(X) linenoise(X)
86 # define shell_read_history(X)
87 # define shell_write_history(X)
88 # define shell_stifle_history(X)
90 # define SHELL_USE_LOCAL_GETLINE 1
94 #if defined(_WIN32) || defined(WIN32)
97 #define isatty(h) _isatty(h)
99 # define access(f,m) _access((f),(m))
104 #define pclose _pclose
106 /* Make sure isatty() has a prototype.
108 extern int isatty(int);
110 /* popen and pclose are not C89 functions and so are sometimes omitted from
111 ** the <stdio.h> header */
112 extern FILE *popen(const char*,const char*);
113 extern int pclose(FILE*);
116 #if defined(_WIN32_WCE)
117 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty()
118 * thus we always assume that we have a console. That can be
119 * overridden with the -batch command line option.
124 /* ctype macros that work with signed characters */
125 #define IsSpace(X) isspace((unsigned char)X)
126 #define IsDigit(X) isdigit((unsigned char)X)
127 #define ToLower(X) (char)tolower((unsigned char)X)
130 /* True if the timer is enabled */
131 static int enableTimer
= 0;
133 /* Return the current wall-clock time */
134 static sqlite3_int64
timeOfDay(void){
135 static sqlite3_vfs
*clockVfs
= 0;
137 if( clockVfs
==0 ) clockVfs
= sqlite3_vfs_find(0);
138 if( clockVfs
->iVersion
>=1 && clockVfs
->xCurrentTimeInt64
!=0 ){
139 clockVfs
->xCurrentTimeInt64(clockVfs
, &t
);
142 clockVfs
->xCurrentTime(clockVfs
, &r
);
143 t
= (sqlite3_int64
)(r
*86400000.0);
148 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WRS_KERNEL) \
150 #include <sys/time.h>
151 #include <sys/resource.h>
153 /* Saved resource information for the beginning of an operation */
154 static struct rusage sBegin
; /* CPU time at start */
155 static sqlite3_int64 iBegin
; /* Wall-clock time at start */
158 ** Begin timing an operation
160 static void beginTimer(void){
162 getrusage(RUSAGE_SELF
, &sBegin
);
163 iBegin
= timeOfDay();
167 /* Return the difference of two time_structs in seconds */
168 static double timeDiff(struct timeval
*pStart
, struct timeval
*pEnd
){
169 return (pEnd
->tv_usec
- pStart
->tv_usec
)*0.000001 +
170 (double)(pEnd
->tv_sec
- pStart
->tv_sec
);
174 ** Print the timing results.
176 static void endTimer(void){
179 sqlite3_int64 iEnd
= timeOfDay();
180 getrusage(RUSAGE_SELF
, &sEnd
);
181 printf("Run Time: real %.3f user %f sys %f\n",
182 (iEnd
- iBegin
)*0.001,
183 timeDiff(&sBegin
.ru_utime
, &sEnd
.ru_utime
),
184 timeDiff(&sBegin
.ru_stime
, &sEnd
.ru_stime
));
188 #define BEGIN_TIMER beginTimer()
189 #define END_TIMER endTimer()
192 #elif (defined(_WIN32) || defined(WIN32))
196 /* Saved resource information for the beginning of an operation */
197 static HANDLE hProcess
;
198 static FILETIME ftKernelBegin
;
199 static FILETIME ftUserBegin
;
200 static sqlite3_int64 ftWallBegin
;
201 typedef BOOL (WINAPI
*GETPROCTIMES
)(HANDLE
, LPFILETIME
, LPFILETIME
,
202 LPFILETIME
, LPFILETIME
);
203 static GETPROCTIMES getProcessTimesAddr
= NULL
;
206 ** Check to see if we have timer support. Return 1 if necessary
207 ** support found (or found previously).
209 static int hasTimer(void){
210 if( getProcessTimesAddr
){
213 /* GetProcessTimes() isn't supported in WIN95 and some other Windows
214 ** versions. See if the version we are running on has it, and if it
215 ** does, save off a pointer to it and the current process handle.
217 hProcess
= GetCurrentProcess();
219 HINSTANCE hinstLib
= LoadLibrary(TEXT("Kernel32.dll"));
220 if( NULL
!= hinstLib
){
221 getProcessTimesAddr
=
222 (GETPROCTIMES
) GetProcAddress(hinstLib
, "GetProcessTimes");
223 if( NULL
!= getProcessTimesAddr
){
226 FreeLibrary(hinstLib
);
234 ** Begin timing an operation
236 static void beginTimer(void){
237 if( enableTimer
&& getProcessTimesAddr
){
238 FILETIME ftCreation
, ftExit
;
239 getProcessTimesAddr(hProcess
,&ftCreation
,&ftExit
,
240 &ftKernelBegin
,&ftUserBegin
);
241 ftWallBegin
= timeOfDay();
245 /* Return the difference of two FILETIME structs in seconds */
246 static double timeDiff(FILETIME
*pStart
, FILETIME
*pEnd
){
247 sqlite_int64 i64Start
= *((sqlite_int64
*) pStart
);
248 sqlite_int64 i64End
= *((sqlite_int64
*) pEnd
);
249 return (double) ((i64End
- i64Start
) / 10000000.0);
253 ** Print the timing results.
255 static void endTimer(void){
256 if( enableTimer
&& getProcessTimesAddr
){
257 FILETIME ftCreation
, ftExit
, ftKernelEnd
, ftUserEnd
;
258 sqlite3_int64 ftWallEnd
= timeOfDay();
259 getProcessTimesAddr(hProcess
,&ftCreation
,&ftExit
,&ftKernelEnd
,&ftUserEnd
);
260 printf("Run Time: real %.3f user %f sys %f\n",
261 (ftWallEnd
- ftWallBegin
)*0.001,
262 timeDiff(&ftUserBegin
, &ftUserEnd
),
263 timeDiff(&ftKernelBegin
, &ftKernelEnd
));
267 #define BEGIN_TIMER beginTimer()
268 #define END_TIMER endTimer()
269 #define HAS_TIMER hasTimer()
278 ** Used to prevent warnings about unused parameters
280 #define UNUSED_PARAMETER(x) (void)(x)
283 ** If the following flag is set, then command execution stops
284 ** at an error if we are not interactive.
286 static int bail_on_error
= 0;
289 ** Threat stdin as an interactive input if the following variable
290 ** is true. Otherwise, assume stdin is connected to a file or pipe.
292 static int stdin_is_interactive
= 1;
295 ** The following is the open SQLite database. We make a pointer
296 ** to this database a static variable so that it can be accessed
297 ** by the SIGINT handler to interrupt database processing.
299 static sqlite3
*db
= 0;
302 ** True if an interrupt (Control-C) has been received.
304 static volatile int seenInterrupt
= 0;
307 ** This is the name of our program. It is set in main(), used
308 ** in a number of other places, mostly for error messages.
313 ** Prompt strings. Initialized in main. Settable with
314 ** .prompt main continue
316 static char mainPrompt
[20]; /* First line prompt. default: "sqlite> "*/
317 static char continuePrompt
[20]; /* Continuation prompt. default: " ...> " */
320 ** Write I/O traces to the following stream.
322 #ifdef SQLITE_ENABLE_IOTRACE
323 static FILE *iotrace
= 0;
327 ** This routine works like printf in that its first argument is a
328 ** format string and subsequent arguments are values to be substituted
329 ** in place of % fields. The result of formatting this string
330 ** is written to iotrace.
332 #ifdef SQLITE_ENABLE_IOTRACE
333 static void iotracePrintf(const char *zFormat
, ...){
336 if( iotrace
==0 ) return;
337 va_start(ap
, zFormat
);
338 z
= sqlite3_vmprintf(zFormat
, ap
);
340 fprintf(iotrace
, "%s", z
);
347 ** Determines if a string is a number of not.
349 static int isNumber(const char *z
, int *realnum
){
350 if( *z
=='-' || *z
=='+' ) z
++;
355 if( realnum
) *realnum
= 0;
356 while( IsDigit(*z
) ){ z
++; }
359 if( !IsDigit(*z
) ) return 0;
360 while( IsDigit(*z
) ){ z
++; }
361 if( realnum
) *realnum
= 1;
363 if( *z
=='e' || *z
=='E' ){
365 if( *z
=='+' || *z
=='-' ) z
++;
366 if( !IsDigit(*z
) ) return 0;
367 while( IsDigit(*z
) ){ z
++; }
368 if( realnum
) *realnum
= 1;
374 ** A global char* and an SQL function to access its current value
375 ** from within an SQL statement. This program used to use the
376 ** sqlite_exec_printf() API to substitue a string into an SQL statement.
377 ** The correct way to do this with sqlite3 is to use the bind API, but
378 ** since the shell is built around the callback paradigm it would be a lot
379 ** of work. Instead just use this hack, which is quite harmless.
381 static const char *zShellStatic
= 0;
382 static void shellstaticFunc(
383 sqlite3_context
*context
,
388 assert( zShellStatic
);
389 UNUSED_PARAMETER(argc
);
390 UNUSED_PARAMETER(argv
);
391 sqlite3_result_text(context
, zShellStatic
, -1, SQLITE_STATIC
);
396 ** This routine reads a line of text from FILE in, stores
397 ** the text in memory obtained from malloc() and returns a pointer
398 ** to the text. NULL is returned at end of file, or if malloc()
401 ** If zLine is not NULL then it is a malloced buffer returned from
402 ** a previous call to this routine that may be reused.
404 static char *local_getline(char *zLine
, FILE *in
){
405 int nLine
= zLine
==0 ? 0 : 100;
410 nLine
= nLine
*2 + 100;
411 zLine
= realloc(zLine
, nLine
);
412 if( zLine
==0 ) return 0;
414 if( fgets(&zLine
[n
], nLine
- n
, in
)==0 ){
422 while( zLine
[n
] ) n
++;
423 if( n
>0 && zLine
[n
-1]=='\n' ){
425 if( n
>0 && zLine
[n
-1]=='\r' ) n
--;
434 ** Retrieve a single line of input text.
436 ** If in==0 then read from standard input and prompt before each line.
437 ** If isContinuation is true, then a continuation prompt is appropriate.
438 ** If isContinuation is zero, then the main prompt should be used.
440 ** If zPrior is not NULL then it is a buffer from a prior call to this
441 ** routine that can be reused.
443 ** The result is stored in space obtained from malloc() and must either
444 ** be freed by the caller or else passed back into this routine via the
445 ** zPrior argument for reuse.
447 static char *one_input_line(FILE *in
, char *zPrior
, int isContinuation
){
451 zResult
= local_getline(zPrior
, in
);
453 zPrompt
= isContinuation
? continuePrompt
: mainPrompt
;
454 #if SHELL_USE_LOCAL_GETLINE
455 printf("%s", zPrompt
);
457 zResult
= local_getline(zPrior
, stdin
);
460 zResult
= shell_readline(zPrompt
);
461 if( zResult
&& *zResult
) shell_add_history(zResult
);
468 ** Shell output mode information from before ".explain on",
469 ** saved so that it can be restored by ".explain off"
471 typedef struct SavedModeInfo SavedModeInfo
;
472 struct SavedModeInfo
{
473 int valid
; /* Is there legit data in here? */
474 int mode
; /* Mode prior to ".explain on" */
475 int showHeader
; /* The ".header" setting prior to ".explain on" */
476 int colWidth
[100]; /* Column widths prior to ".explain on" */
480 ** State information about the database connection is contained in an
481 ** instance of the following structure.
483 typedef struct ShellState ShellState
;
485 sqlite3
*db
; /* The database */
486 int echoOn
; /* True to echo input commands */
487 int autoEQP
; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
488 int statsOn
; /* True to display memory stats before each finalize */
489 int scanstatsOn
; /* True to display scan stats before each finalize */
490 int outCount
; /* Revert to stdout when reaching zero */
491 int cnt
; /* Number of records displayed so far */
492 FILE *out
; /* Write results here */
493 FILE *traceOut
; /* Output for sqlite3_trace() */
494 int nErr
; /* Number of errors seen */
495 int mode
; /* An output mode setting */
496 int writableSchema
; /* True if PRAGMA writable_schema=ON */
497 int showHeader
; /* True to show column names in List or Column mode */
498 unsigned shellFlgs
; /* Various flags */
499 char *zDestTable
; /* Name of destination table when MODE_Insert */
500 char colSeparator
[20]; /* Column separator character for several modes */
501 char rowSeparator
[20]; /* Row separator character for MODE_Ascii */
502 int colWidth
[100]; /* Requested width of each column when in column mode*/
503 int actualWidth
[100]; /* Actual width of each column */
504 char nullValue
[20]; /* The text to print when a NULL comes back from
506 SavedModeInfo normalMode
;/* Holds the mode just before .explain ON */
507 char outfile
[FILENAME_MAX
]; /* Filename for *out */
508 const char *zDbFilename
; /* name of the database file */
509 char *zFreeOnClose
; /* Filename to free when closing */
510 const char *zVfs
; /* Name of VFS to use */
511 sqlite3_stmt
*pStmt
; /* Current statement if any. */
512 FILE *pLog
; /* Write log output here */
513 int *aiIndent
; /* Array of indents used in MODE_Explain */
514 int nIndent
; /* Size of array aiIndent[] */
515 int iIndent
; /* Index of current op in aiIndent[] */
519 ** These are the allowed shellFlgs values
521 #define SHFLG_Scratch 0x00001 /* The --scratch option is used */
522 #define SHFLG_Pagecache 0x00002 /* The --pagecache option is used */
523 #define SHFLG_Lookaside 0x00004 /* Lookaside memory is used */
526 ** These are the allowed modes.
528 #define MODE_Line 0 /* One column per line. Blank line between records */
529 #define MODE_Column 1 /* One record per line in neat columns */
530 #define MODE_List 2 /* One record per line with a separator */
531 #define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */
532 #define MODE_Html 4 /* Generate an XHTML table */
533 #define MODE_Insert 5 /* Generate SQL "insert" statements */
534 #define MODE_Tcl 6 /* Generate ANSI-C or TCL quoted elements */
535 #define MODE_Csv 7 /* Quote strings, numbers are plain */
536 #define MODE_Explain 8 /* Like MODE_Column, but do not truncate data */
537 #define MODE_Ascii 9 /* Use ASCII unit and record separators (0x1F/0x1E) */
539 static const char *modeDescr
[] = {
553 ** These are the column/row/line separators used by the various
554 ** import/export modes.
556 #define SEP_Column "|"
559 #define SEP_Space " "
560 #define SEP_Comma ","
561 #define SEP_CrLf "\r\n"
562 #define SEP_Unit "\x1F"
563 #define SEP_Record "\x1E"
566 ** Number of elements in an array
568 #define ArraySize(X) (int)(sizeof(X)/sizeof(X[0]))
571 ** Compute a string length that is limited to what can be stored in
572 ** lower 30 bits of a 32-bit signed integer.
574 static int strlen30(const char *z
){
576 while( *z2
){ z2
++; }
577 return 0x3fffffff & (int)(z2
- z
);
581 ** A callback for the sqlite3_log() interface.
583 static void shellLog(void *pArg
, int iErrCode
, const char *zMsg
){
584 ShellState
*p
= (ShellState
*)pArg
;
585 if( p
->pLog
==0 ) return;
586 fprintf(p
->pLog
, "(%d) %s\n", iErrCode
, zMsg
);
591 ** Output the given string as a hex-encoded blob (eg. X'1234' )
593 static void output_hex_blob(FILE *out
, const void *pBlob
, int nBlob
){
595 char *zBlob
= (char *)pBlob
;
597 for(i
=0; i
<nBlob
; i
++){ fprintf(out
,"%02x",zBlob
[i
]&0xff); }
602 ** Output the given string as a quoted string using SQL quoting conventions.
604 static void output_quoted_string(FILE *out
, const char *z
){
608 if( z
[i
]=='\'' ) nSingle
++;
611 fprintf(out
,"'%s'",z
);
615 for(i
=0; z
[i
] && z
[i
]!='\''; i
++){}
619 }else if( z
[i
]=='\'' ){
620 fprintf(out
,"%.*s''",i
,z
);
632 ** Output the given string as a quoted according to C or TCL quoting rules.
634 static void output_c_string(FILE *out
, const char *z
){
637 while( (c
= *(z
++))!=0 ){
653 }else if( !isprint(c
&0xff) ){
654 fprintf(out
, "\\%03o", c
&0xff);
663 ** Output the given string with characters that are special to
666 static void output_html_string(FILE *out
, const char *z
){
678 fprintf(out
,"%.*s",i
,z
);
682 }else if( z
[i
]=='&' ){
683 fprintf(out
,"&");
684 }else if( z
[i
]=='>' ){
686 }else if( z
[i
]=='\"' ){
687 fprintf(out
,""");
688 }else if( z
[i
]=='\'' ){
689 fprintf(out
,"'");
698 ** If a field contains any character identified by a 1 in the following
699 ** array, then the string must be quoted for CSV.
701 static const char needCsvQuote
[] = {
702 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
703 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
704 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
705 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
706 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
707 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
708 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
709 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
710 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
711 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
712 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
713 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
714 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
715 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
716 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
717 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
721 ** Output a single term of CSV. Actually, p->colSeparator is used for
722 ** the separator, which may or may not be a comma. p->nullValue is
723 ** the null value. Strings are quoted if necessary. The separator
724 ** is only issued if bSep is true.
726 static void output_csv(ShellState
*p
, const char *z
, int bSep
){
729 fprintf(out
,"%s",p
->nullValue
);
732 int nSep
= strlen30(p
->colSeparator
);
734 if( needCsvQuote
[((unsigned char*)z
)[i
]]
735 || (z
[i
]==p
->colSeparator
[0] &&
736 (nSep
==1 || memcmp(z
, p
->colSeparator
, nSep
)==0)) ){
744 if( z
[i
]=='"' ) putc('"', out
);
749 fprintf(out
, "%s", z
);
753 fprintf(p
->out
, "%s", p
->colSeparator
);
759 ** This routine runs when the user presses Ctrl-C
761 static void interrupt_handler(int NotUsed
){
762 UNUSED_PARAMETER(NotUsed
);
764 if( seenInterrupt
>2 ) exit(1);
765 if( db
) sqlite3_interrupt(db
);
770 ** This is the callback routine that the shell
771 ** invokes for each row of a query result.
773 static int shell_callback(
775 int nArg
, /* Number of result columns */
776 char **azArg
, /* Text of each result column */
777 char **azCol
, /* Column names */
778 int *aiType
/* Column types */
781 ShellState
*p
= (ShellState
*)pArg
;
786 if( azArg
==0 ) break;
787 for(i
=0; i
<nArg
; i
++){
788 int len
= strlen30(azCol
[i
] ? azCol
[i
] : "");
791 if( p
->cnt
++>0 ) fprintf(p
->out
, "%s", p
->rowSeparator
);
792 for(i
=0; i
<nArg
; i
++){
793 fprintf(p
->out
,"%*s = %s%s", w
, azCol
[i
],
794 azArg
[i
] ? azArg
[i
] : p
->nullValue
, p
->rowSeparator
);
801 for(i
=0; i
<nArg
; i
++){
803 if( i
<ArraySize(p
->colWidth
) ){
809 w
= strlen30(azCol
[i
] ? azCol
[i
] : "");
811 n
= strlen30(azArg
&& azArg
[i
] ? azArg
[i
] : p
->nullValue
);
814 if( i
<ArraySize(p
->actualWidth
) ){
815 p
->actualWidth
[i
] = w
;
819 fprintf(p
->out
,"%*.*s%s",-w
,-w
,azCol
[i
],
820 i
==nArg
-1 ? p
->rowSeparator
: " ");
822 fprintf(p
->out
,"%-*.*s%s",w
,w
,azCol
[i
],
823 i
==nArg
-1 ? p
->rowSeparator
: " ");
828 for(i
=0; i
<nArg
; i
++){
830 if( i
<ArraySize(p
->actualWidth
) ){
831 w
= p
->actualWidth
[i
];
836 fprintf(p
->out
,"%-*.*s%s",w
,w
,"-----------------------------------"
837 "----------------------------------------------------------",
838 i
==nArg
-1 ? p
->rowSeparator
: " ");
842 if( azArg
==0 ) break;
843 for(i
=0; i
<nArg
; i
++){
845 if( i
<ArraySize(p
->actualWidth
) ){
846 w
= p
->actualWidth
[i
];
850 if( p
->mode
==MODE_Explain
&& azArg
[i
] && strlen30(azArg
[i
])>w
){
851 w
= strlen30(azArg
[i
]);
853 if( i
==1 && p
->aiIndent
&& p
->pStmt
){
854 if( p
->iIndent
<p
->nIndent
){
855 fprintf(p
->out
, "%*.s", p
->aiIndent
[p
->iIndent
], "");
860 fprintf(p
->out
,"%*.*s%s",-w
,-w
,
861 azArg
[i
] ? azArg
[i
] : p
->nullValue
,
862 i
==nArg
-1 ? p
->rowSeparator
: " ");
864 fprintf(p
->out
,"%-*.*s%s",w
,w
,
865 azArg
[i
] ? azArg
[i
] : p
->nullValue
,
866 i
==nArg
-1 ? p
->rowSeparator
: " ");
873 if( p
->cnt
++==0 && p
->showHeader
){
874 for(i
=0; i
<nArg
; i
++){
875 fprintf(p
->out
,"%s%s",azCol
[i
],
876 i
==nArg
-1 ? p
->rowSeparator
: p
->colSeparator
);
879 if( azArg
==0 ) break;
880 for(i
=0; i
<nArg
; i
++){
882 if( z
==0 ) z
= p
->nullValue
;
883 fprintf(p
->out
, "%s", z
);
885 fprintf(p
->out
, "%s", p
->colSeparator
);
886 }else if( p
->mode
==MODE_Semi
){
887 fprintf(p
->out
, ";%s", p
->rowSeparator
);
889 fprintf(p
->out
, "%s", p
->rowSeparator
);
895 if( p
->cnt
++==0 && p
->showHeader
){
896 fprintf(p
->out
,"<TR>");
897 for(i
=0; i
<nArg
; i
++){
898 fprintf(p
->out
,"<TH>");
899 output_html_string(p
->out
, azCol
[i
]);
900 fprintf(p
->out
,"</TH>\n");
902 fprintf(p
->out
,"</TR>\n");
904 if( azArg
==0 ) break;
905 fprintf(p
->out
,"<TR>");
906 for(i
=0; i
<nArg
; i
++){
907 fprintf(p
->out
,"<TD>");
908 output_html_string(p
->out
, azArg
[i
] ? azArg
[i
] : p
->nullValue
);
909 fprintf(p
->out
,"</TD>\n");
911 fprintf(p
->out
,"</TR>\n");
915 if( p
->cnt
++==0 && p
->showHeader
){
916 for(i
=0; i
<nArg
; i
++){
917 output_c_string(p
->out
,azCol
[i
] ? azCol
[i
] : "");
918 if(i
<nArg
-1) fprintf(p
->out
, "%s", p
->colSeparator
);
920 fprintf(p
->out
, "%s", p
->rowSeparator
);
922 if( azArg
==0 ) break;
923 for(i
=0; i
<nArg
; i
++){
924 output_c_string(p
->out
, azArg
[i
] ? azArg
[i
] : p
->nullValue
);
925 if(i
<nArg
-1) fprintf(p
->out
, "%s", p
->colSeparator
);
927 fprintf(p
->out
, "%s", p
->rowSeparator
);
931 #if defined(WIN32) || defined(_WIN32)
933 _setmode(_fileno(p
->out
), _O_BINARY
);
935 if( p
->cnt
++==0 && p
->showHeader
){
936 for(i
=0; i
<nArg
; i
++){
937 output_csv(p
, azCol
[i
] ? azCol
[i
] : "", i
<nArg
-1);
939 fprintf(p
->out
, "%s", p
->rowSeparator
);
942 for(i
=0; i
<nArg
; i
++){
943 output_csv(p
, azArg
[i
], i
<nArg
-1);
945 fprintf(p
->out
, "%s", p
->rowSeparator
);
947 #if defined(WIN32) || defined(_WIN32)
949 _setmode(_fileno(p
->out
), _O_TEXT
);
955 if( azArg
==0 ) break;
956 fprintf(p
->out
,"INSERT INTO %s VALUES(",p
->zDestTable
);
957 for(i
=0; i
<nArg
; i
++){
958 char *zSep
= i
>0 ? ",": "";
959 if( (azArg
[i
]==0) || (aiType
&& aiType
[i
]==SQLITE_NULL
) ){
960 fprintf(p
->out
,"%sNULL",zSep
);
961 }else if( aiType
&& aiType
[i
]==SQLITE_TEXT
){
962 if( zSep
[0] ) fprintf(p
->out
,"%s",zSep
);
963 output_quoted_string(p
->out
, azArg
[i
]);
964 }else if( aiType
&& (aiType
[i
]==SQLITE_INTEGER
965 || aiType
[i
]==SQLITE_FLOAT
) ){
966 fprintf(p
->out
,"%s%s",zSep
, azArg
[i
]);
967 }else if( aiType
&& aiType
[i
]==SQLITE_BLOB
&& p
->pStmt
){
968 const void *pBlob
= sqlite3_column_blob(p
->pStmt
, i
);
969 int nBlob
= sqlite3_column_bytes(p
->pStmt
, i
);
970 if( zSep
[0] ) fprintf(p
->out
,"%s",zSep
);
971 output_hex_blob(p
->out
, pBlob
, nBlob
);
972 }else if( isNumber(azArg
[i
], 0) ){
973 fprintf(p
->out
,"%s%s",zSep
, azArg
[i
]);
975 if( zSep
[0] ) fprintf(p
->out
,"%s",zSep
);
976 output_quoted_string(p
->out
, azArg
[i
]);
979 fprintf(p
->out
,");\n");
983 if( p
->cnt
++==0 && p
->showHeader
){
984 for(i
=0; i
<nArg
; i
++){
985 if( i
>0 ) fprintf(p
->out
, "%s", p
->colSeparator
);
986 fprintf(p
->out
,"%s",azCol
[i
] ? azCol
[i
] : "");
988 fprintf(p
->out
, "%s", p
->rowSeparator
);
990 if( azArg
==0 ) break;
991 for(i
=0; i
<nArg
; i
++){
992 if( i
>0 ) fprintf(p
->out
, "%s", p
->colSeparator
);
993 fprintf(p
->out
,"%s",azArg
[i
] ? azArg
[i
] : p
->nullValue
);
995 fprintf(p
->out
, "%s", p
->rowSeparator
);
1003 ** This is the callback routine that the SQLite library
1004 ** invokes for each row of a query result.
1006 static int callback(void *pArg
, int nArg
, char **azArg
, char **azCol
){
1007 /* since we don't have type info, call the shell_callback with a NULL value */
1008 return shell_callback(pArg
, nArg
, azArg
, azCol
, NULL
);
1012 ** Set the destination table field of the ShellState structure to
1013 ** the name of the table given. Escape any quote characters in the
1016 static void set_table_name(ShellState
*p
, const char *zName
){
1021 if( p
->zDestTable
){
1022 free(p
->zDestTable
);
1025 if( zName
==0 ) return;
1026 needQuote
= !isalpha((unsigned char)*zName
) && *zName
!='_';
1027 for(i
=n
=0; zName
[i
]; i
++, n
++){
1028 if( !isalnum((unsigned char)zName
[i
]) && zName
[i
]!='_' ){
1030 if( zName
[i
]=='\'' ) n
++;
1033 if( needQuote
) n
+= 2;
1034 z
= p
->zDestTable
= malloc( n
+1 );
1036 fprintf(stderr
,"Error: out of memory\n");
1040 if( needQuote
) z
[n
++] = '\'';
1041 for(i
=0; zName
[i
]; i
++){
1043 if( zName
[i
]=='\'' ) z
[n
++] = '\'';
1045 if( needQuote
) z
[n
++] = '\'';
1049 /* zIn is either a pointer to a NULL-terminated string in memory obtained
1050 ** from malloc(), or a NULL pointer. The string pointed to by zAppend is
1051 ** added to zIn, and the result returned in memory obtained from malloc().
1052 ** zIn, if it was not NULL, is freed.
1054 ** If the third argument, quote, is not '\0', then it is used as a
1055 ** quote character for zAppend.
1057 static char *appendText(char *zIn
, char const *zAppend
, char quote
){
1060 int nAppend
= strlen30(zAppend
);
1061 int nIn
= (zIn
?strlen30(zIn
):0);
1063 len
= nAppend
+nIn
+1;
1066 for(i
=0; i
<nAppend
; i
++){
1067 if( zAppend
[i
]==quote
) len
++;
1071 zIn
= (char *)realloc(zIn
, len
);
1077 char *zCsr
= &zIn
[nIn
];
1079 for(i
=0; i
<nAppend
; i
++){
1080 *zCsr
++ = zAppend
[i
];
1081 if( zAppend
[i
]==quote
) *zCsr
++ = quote
;
1085 assert( (zCsr
-zIn
)==len
);
1087 memcpy(&zIn
[nIn
], zAppend
, nAppend
);
1096 ** Execute a query statement that will generate SQL output. Print
1097 ** the result columns, comma-separated, on a line and then add a
1098 ** semicolon terminator to the end of that line.
1100 ** If the number of columns is 1 and that column contains text "--"
1101 ** then write the semicolon on a separate line. That way, if a
1102 ** "--" comment occurs at the end of the statement, the comment
1103 ** won't consume the semicolon terminator.
1105 static int run_table_dump_query(
1106 ShellState
*p
, /* Query context */
1107 const char *zSelect
, /* SELECT statement to extract content */
1108 const char *zFirstRow
/* Print before first row, if not NULL */
1110 sqlite3_stmt
*pSelect
;
1115 rc
= sqlite3_prepare_v2(p
->db
, zSelect
, -1, &pSelect
, 0);
1116 if( rc
!=SQLITE_OK
|| !pSelect
){
1117 fprintf(p
->out
, "/**** ERROR: (%d) %s *****/\n", rc
, sqlite3_errmsg(p
->db
));
1118 if( (rc
&0xff)!=SQLITE_CORRUPT
) p
->nErr
++;
1121 rc
= sqlite3_step(pSelect
);
1122 nResult
= sqlite3_column_count(pSelect
);
1123 while( rc
==SQLITE_ROW
){
1125 fprintf(p
->out
, "%s", zFirstRow
);
1128 z
= (const char*)sqlite3_column_text(pSelect
, 0);
1129 fprintf(p
->out
, "%s", z
);
1130 for(i
=1; i
<nResult
; i
++){
1131 fprintf(p
->out
, ",%s", sqlite3_column_text(pSelect
, i
));
1134 while( z
[0] && (z
[0]!='-' || z
[1]!='-') ) z
++;
1136 fprintf(p
->out
, "\n;\n");
1138 fprintf(p
->out
, ";\n");
1140 rc
= sqlite3_step(pSelect
);
1142 rc
= sqlite3_finalize(pSelect
);
1143 if( rc
!=SQLITE_OK
){
1144 fprintf(p
->out
, "/**** ERROR: (%d) %s *****/\n", rc
, sqlite3_errmsg(p
->db
));
1145 if( (rc
&0xff)!=SQLITE_CORRUPT
) p
->nErr
++;
1151 ** Allocate space and save off current error string.
1153 static char *save_err_msg(
1154 sqlite3
*db
/* Database to query */
1156 int nErrMsg
= 1+strlen30(sqlite3_errmsg(db
));
1157 char *zErrMsg
= sqlite3_malloc(nErrMsg
);
1159 memcpy(zErrMsg
, sqlite3_errmsg(db
), nErrMsg
);
1165 ** Display memory stats.
1167 static int display_stats(
1168 sqlite3
*db
, /* Database to query */
1169 ShellState
*pArg
, /* Pointer to ShellState */
1170 int bReset
/* True to reset the stats */
1175 if( pArg
&& pArg
->out
){
1178 sqlite3_status(SQLITE_STATUS_MEMORY_USED
, &iCur
, &iHiwtr
, bReset
);
1180 "Memory Used: %d (max %d) bytes\n",
1183 sqlite3_status(SQLITE_STATUS_MALLOC_COUNT
, &iCur
, &iHiwtr
, bReset
);
1184 fprintf(pArg
->out
, "Number of Outstanding Allocations: %d (max %d)\n",
1186 if( pArg
->shellFlgs
& SHFLG_Pagecache
){
1188 sqlite3_status(SQLITE_STATUS_PAGECACHE_USED
, &iCur
, &iHiwtr
, bReset
);
1190 "Number of Pcache Pages Used: %d (max %d) pages\n",
1194 sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW
, &iCur
, &iHiwtr
, bReset
);
1196 "Number of Pcache Overflow Bytes: %d (max %d) bytes\n",
1198 if( pArg
->shellFlgs
& SHFLG_Scratch
){
1200 sqlite3_status(SQLITE_STATUS_SCRATCH_USED
, &iCur
, &iHiwtr
, bReset
);
1201 fprintf(pArg
->out
, "Number of Scratch Allocations Used: %d (max %d)\n",
1205 sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW
, &iCur
, &iHiwtr
, bReset
);
1207 "Number of Scratch Overflow Bytes: %d (max %d) bytes\n",
1210 sqlite3_status(SQLITE_STATUS_MALLOC_SIZE
, &iCur
, &iHiwtr
, bReset
);
1211 fprintf(pArg
->out
, "Largest Allocation: %d bytes\n",
1214 sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE
, &iCur
, &iHiwtr
, bReset
);
1215 fprintf(pArg
->out
, "Largest Pcache Allocation: %d bytes\n",
1218 sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE
, &iCur
, &iHiwtr
, bReset
);
1219 fprintf(pArg
->out
, "Largest Scratch Allocation: %d bytes\n",
1221 #ifdef YYTRACKMAXSTACKDEPTH
1223 sqlite3_status(SQLITE_STATUS_PARSER_STACK
, &iCur
, &iHiwtr
, bReset
);
1224 fprintf(pArg
->out
, "Deepest Parser Stack: %d (max %d)\n",
1229 if( pArg
&& pArg
->out
&& db
){
1230 if( pArg
->shellFlgs
& SHFLG_Lookaside
){
1232 sqlite3_db_status(db
, SQLITE_DBSTATUS_LOOKASIDE_USED
,
1233 &iCur
, &iHiwtr
, bReset
);
1234 fprintf(pArg
->out
, "Lookaside Slots Used: %d (max %d)\n",
1236 sqlite3_db_status(db
, SQLITE_DBSTATUS_LOOKASIDE_HIT
,
1237 &iCur
, &iHiwtr
, bReset
);
1238 fprintf(pArg
->out
, "Successful lookaside attempts: %d\n", iHiwtr
);
1239 sqlite3_db_status(db
, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE
,
1240 &iCur
, &iHiwtr
, bReset
);
1241 fprintf(pArg
->out
, "Lookaside failures due to size: %d\n", iHiwtr
);
1242 sqlite3_db_status(db
, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL
,
1243 &iCur
, &iHiwtr
, bReset
);
1244 fprintf(pArg
->out
, "Lookaside failures due to OOM: %d\n", iHiwtr
);
1247 sqlite3_db_status(db
, SQLITE_DBSTATUS_CACHE_USED
, &iCur
, &iHiwtr
, bReset
);
1248 fprintf(pArg
->out
, "Pager Heap Usage: %d bytes\n",iCur
);
1250 sqlite3_db_status(db
, SQLITE_DBSTATUS_CACHE_HIT
, &iCur
, &iHiwtr
, 1);
1251 fprintf(pArg
->out
, "Page cache hits: %d\n", iCur
);
1253 sqlite3_db_status(db
, SQLITE_DBSTATUS_CACHE_MISS
, &iCur
, &iHiwtr
, 1);
1254 fprintf(pArg
->out
, "Page cache misses: %d\n", iCur
);
1256 sqlite3_db_status(db
, SQLITE_DBSTATUS_CACHE_WRITE
, &iCur
, &iHiwtr
, 1);
1257 fprintf(pArg
->out
, "Page cache writes: %d\n", iCur
);
1259 sqlite3_db_status(db
, SQLITE_DBSTATUS_SCHEMA_USED
, &iCur
, &iHiwtr
, bReset
);
1260 fprintf(pArg
->out
, "Schema Heap Usage: %d bytes\n",iCur
);
1262 sqlite3_db_status(db
, SQLITE_DBSTATUS_STMT_USED
, &iCur
, &iHiwtr
, bReset
);
1263 fprintf(pArg
->out
, "Statement Heap/Lookaside Usage: %d bytes\n",iCur
);
1266 if( pArg
&& pArg
->out
&& db
&& pArg
->pStmt
){
1267 iCur
= sqlite3_stmt_status(pArg
->pStmt
, SQLITE_STMTSTATUS_FULLSCAN_STEP
,
1269 fprintf(pArg
->out
, "Fullscan Steps: %d\n", iCur
);
1270 iCur
= sqlite3_stmt_status(pArg
->pStmt
, SQLITE_STMTSTATUS_SORT
, bReset
);
1271 fprintf(pArg
->out
, "Sort Operations: %d\n", iCur
);
1272 iCur
= sqlite3_stmt_status(pArg
->pStmt
, SQLITE_STMTSTATUS_AUTOINDEX
,bReset
);
1273 fprintf(pArg
->out
, "Autoindex Inserts: %d\n", iCur
);
1274 iCur
= sqlite3_stmt_status(pArg
->pStmt
, SQLITE_STMTSTATUS_VM_STEP
, bReset
);
1275 fprintf(pArg
->out
, "Virtual Machine Steps: %d\n", iCur
);
1282 ** Display scan stats.
1284 static void display_scanstats(
1285 sqlite3
*db
, /* Database to query */
1286 ShellState
*pArg
/* Pointer to ShellState */
1288 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
1290 fprintf(pArg
->out
, "-------- scanstats --------\n");
1292 for(k
=0; k
<=mx
; k
++){
1293 double rEstLoop
= 1.0;
1295 sqlite3_stmt
*p
= pArg
->pStmt
;
1296 sqlite3_int64 nLoop
, nVisit
;
1299 const char *zExplain
;
1300 if( sqlite3_stmt_scanstatus(p
, i
, SQLITE_SCANSTAT_NLOOP
, (void*)&nLoop
) ){
1303 sqlite3_stmt_scanstatus(p
, i
, SQLITE_SCANSTAT_SELECTID
, (void*)&iSid
);
1304 if( iSid
>mx
) mx
= iSid
;
1305 if( iSid
!=k
) continue;
1307 rEstLoop
= (double)nLoop
;
1308 if( k
>0 ) fprintf(pArg
->out
, "-------- subquery %d -------\n", k
);
1311 sqlite3_stmt_scanstatus(p
, i
, SQLITE_SCANSTAT_NVISIT
, (void*)&nVisit
);
1312 sqlite3_stmt_scanstatus(p
, i
, SQLITE_SCANSTAT_EST
, (void*)&rEst
);
1313 sqlite3_stmt_scanstatus(p
, i
, SQLITE_SCANSTAT_EXPLAIN
, (void*)&zExplain
);
1314 fprintf(pArg
->out
, "Loop %2d: %s\n", n
, zExplain
);
1317 " nLoop=%-8lld nRow=%-8lld estRow=%-8lld estRow/Loop=%-8g\n",
1318 nLoop
, nVisit
, (sqlite3_int64
)(rEstLoop
+0.5), rEst
1322 fprintf(pArg
->out
, "---------------------------\n");
1327 ** Parameter azArray points to a zero-terminated array of strings. zStr
1328 ** points to a single nul-terminated string. Return non-zero if zStr
1329 ** is equal, according to strcmp(), to any of the strings in the array.
1330 ** Otherwise, return zero.
1332 static int str_in_array(const char *zStr
, const char **azArray
){
1334 for(i
=0; azArray
[i
]; i
++){
1335 if( 0==strcmp(zStr
, azArray
[i
]) ) return 1;
1341 ** If compiled statement pSql appears to be an EXPLAIN statement, allocate
1342 ** and populate the ShellState.aiIndent[] array with the number of
1343 ** spaces each opcode should be indented before it is output.
1345 ** The indenting rules are:
1347 ** * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent
1348 ** all opcodes that occur between the p2 jump destination and the opcode
1349 ** itself by 2 spaces.
1351 ** * For each "Goto", if the jump destination is earlier in the program
1352 ** and ends on one of:
1353 ** Yield SeekGt SeekLt RowSetRead Rewind
1354 ** or if the P1 parameter is one instead of zero,
1355 ** then indent all opcodes between the earlier instruction
1356 ** and "Goto" by 2 spaces.
1358 static void explain_data_prepare(ShellState
*p
, sqlite3_stmt
*pSql
){
1359 const char *zSql
; /* The text of the SQL statement */
1360 const char *z
; /* Used to check if this is an EXPLAIN */
1361 int *abYield
= 0; /* True if op is an OP_Yield */
1362 int nAlloc
= 0; /* Allocated size of p->aiIndent[], abYield */
1363 int iOp
; /* Index of operation in p->aiIndent[] */
1365 const char *azNext
[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext",
1366 "NextIfOpen", "PrevIfOpen", 0 };
1367 const char *azYield
[] = { "Yield", "SeekLT", "SeekGT", "RowSetRead",
1369 const char *azGoto
[] = { "Goto", 0 };
1371 /* Try to figure out if this is really an EXPLAIN statement. If this
1372 ** cannot be verified, return early. */
1373 zSql
= sqlite3_sql(pSql
);
1374 if( zSql
==0 ) return;
1375 for(z
=zSql
; *z
==' ' || *z
=='\t' || *z
=='\n' || *z
=='\f' || *z
=='\r'; z
++);
1376 if( sqlite3_strnicmp(z
, "explain", 7) ) return;
1378 for(iOp
=0; SQLITE_ROW
==sqlite3_step(pSql
); iOp
++){
1380 int iAddr
= sqlite3_column_int(pSql
, 0);
1381 const char *zOp
= (const char*)sqlite3_column_text(pSql
, 1);
1383 /* Set p2 to the P2 field of the current opcode. Then, assuming that
1384 ** p2 is an instruction address, set variable p2op to the index of that
1385 ** instruction in the aiIndent[] array. p2 and p2op may be different if
1386 ** the current instruction is part of a sub-program generated by an
1387 ** SQL trigger or foreign key. */
1388 int p2
= sqlite3_column_int(pSql
, 3);
1389 int p2op
= (p2
+ (iOp
-iAddr
));
1391 /* Grow the p->aiIndent array as required */
1394 p
->aiIndent
= (int*)sqlite3_realloc(p
->aiIndent
, nAlloc
*sizeof(int));
1395 abYield
= (int*)sqlite3_realloc(abYield
, nAlloc
*sizeof(int));
1397 abYield
[iOp
] = str_in_array(zOp
, azYield
);
1398 p
->aiIndent
[iOp
] = 0;
1401 if( str_in_array(zOp
, azNext
) ){
1402 for(i
=p2op
; i
<iOp
; i
++) p
->aiIndent
[i
] += 2;
1404 if( str_in_array(zOp
, azGoto
) && p2op
<p
->nIndent
1405 && (abYield
[p2op
] || sqlite3_column_int(pSql
, 2))
1407 for(i
=p2op
+1; i
<iOp
; i
++) p
->aiIndent
[i
] += 2;
1412 sqlite3_free(abYield
);
1413 sqlite3_reset(pSql
);
1417 ** Free the array allocated by explain_data_prepare().
1419 static void explain_data_delete(ShellState
*p
){
1420 sqlite3_free(p
->aiIndent
);
1427 ** Execute a statement or set of statements. Print
1428 ** any result rows/columns depending on the current mode
1429 ** set via the supplied callback.
1431 ** This is very similar to SQLite's built-in sqlite3_exec()
1432 ** function except it takes a slightly different callback
1433 ** and callback data argument.
1435 static int shell_exec(
1436 sqlite3
*db
, /* An open database */
1437 const char *zSql
, /* SQL to be evaluated */
1438 int (*xCallback
)(void*,int,char**,char**,int*), /* Callback function */
1439 /* (not the same as sqlite3_exec) */
1440 ShellState
*pArg
, /* Pointer to ShellState */
1441 char **pzErrMsg
/* Error msg written here */
1443 sqlite3_stmt
*pStmt
= NULL
; /* Statement to execute. */
1444 int rc
= SQLITE_OK
; /* Return Code */
1446 const char *zLeftover
; /* Tail of unprocessed SQL */
1452 while( zSql
[0] && (SQLITE_OK
== rc
) ){
1453 rc
= sqlite3_prepare_v2(db
, zSql
, -1, &pStmt
, &zLeftover
);
1454 if( SQLITE_OK
!= rc
){
1456 *pzErrMsg
= save_err_msg(db
);
1460 /* this happens for a comment or white-space */
1462 while( IsSpace(zSql
[0]) ) zSql
++;
1466 /* save off the prepared statment handle and reset row count */
1468 pArg
->pStmt
= pStmt
;
1472 /* echo the sql statement if echo on */
1473 if( pArg
&& pArg
->echoOn
){
1474 const char *zStmtSql
= sqlite3_sql(pStmt
);
1475 fprintf(pArg
->out
, "%s\n", zStmtSql
? zStmtSql
: zSql
);
1478 /* Show the EXPLAIN QUERY PLAN if .eqp is on */
1479 if( pArg
&& pArg
->autoEQP
){
1480 sqlite3_stmt
*pExplain
;
1481 char *zEQP
= sqlite3_mprintf("EXPLAIN QUERY PLAN %s",
1482 sqlite3_sql(pStmt
));
1483 rc
= sqlite3_prepare_v2(db
, zEQP
, -1, &pExplain
, 0);
1484 if( rc
==SQLITE_OK
){
1485 while( sqlite3_step(pExplain
)==SQLITE_ROW
){
1486 fprintf(pArg
->out
,"--EQP-- %d,", sqlite3_column_int(pExplain
, 0));
1487 fprintf(pArg
->out
,"%d,", sqlite3_column_int(pExplain
, 1));
1488 fprintf(pArg
->out
,"%d,", sqlite3_column_int(pExplain
, 2));
1489 fprintf(pArg
->out
,"%s\n", sqlite3_column_text(pExplain
, 3));
1492 sqlite3_finalize(pExplain
);
1496 /* If the shell is currently in ".explain" mode, gather the extra
1497 ** data required to add indents to the output.*/
1498 if( pArg
&& pArg
->mode
==MODE_Explain
){
1499 explain_data_prepare(pArg
, pStmt
);
1502 /* perform the first step. this will tell us if we
1503 ** have a result set or not and how wide it is.
1505 rc
= sqlite3_step(pStmt
);
1506 /* if we have a result set... */
1507 if( SQLITE_ROW
== rc
){
1508 /* if we have a callback... */
1510 /* allocate space for col name ptr, value ptr, and type */
1511 int nCol
= sqlite3_column_count(pStmt
);
1512 void *pData
= sqlite3_malloc(3*nCol
*sizeof(const char*) + 1);
1516 char **azCols
= (char **)pData
; /* Names of result columns */
1517 char **azVals
= &azCols
[nCol
]; /* Results */
1518 int *aiTypes
= (int *)&azVals
[nCol
]; /* Result types */
1520 assert(sizeof(int) <= sizeof(char *));
1521 /* save off ptrs to column names */
1522 for(i
=0; i
<nCol
; i
++){
1523 azCols
[i
] = (char *)sqlite3_column_name(pStmt
, i
);
1526 /* extract the data and data types */
1527 for(i
=0; i
<nCol
; i
++){
1528 aiTypes
[i
] = x
= sqlite3_column_type(pStmt
, i
);
1529 if( x
==SQLITE_BLOB
&& pArg
&& pArg
->mode
==MODE_Insert
){
1532 azVals
[i
] = (char*)sqlite3_column_text(pStmt
, i
);
1534 if( !azVals
[i
] && (aiTypes
[i
]!=SQLITE_NULL
) ){
1536 break; /* from for */
1540 /* if data and types extracted successfully... */
1541 if( SQLITE_ROW
== rc
){
1542 /* call the supplied callback with the result row data */
1543 if( xCallback(pArg
, nCol
, azVals
, azCols
, aiTypes
) ){
1546 rc
= sqlite3_step(pStmt
);
1549 } while( SQLITE_ROW
== rc
);
1550 sqlite3_free(pData
);
1554 rc
= sqlite3_step(pStmt
);
1555 } while( rc
== SQLITE_ROW
);
1559 explain_data_delete(pArg
);
1561 /* print usage stats if stats on */
1562 if( pArg
&& pArg
->statsOn
){
1563 display_stats(db
, pArg
, 0);
1566 /* print loop-counters if required */
1567 if( pArg
&& pArg
->scanstatsOn
){
1568 display_scanstats(db
, pArg
);
1571 /* Finalize the statement just executed. If this fails, save a
1572 ** copy of the error message. Otherwise, set zSql to point to the
1573 ** next statement to execute. */
1574 rc2
= sqlite3_finalize(pStmt
);
1575 if( rc
!=SQLITE_NOMEM
) rc
= rc2
;
1576 if( rc
==SQLITE_OK
){
1578 while( IsSpace(zSql
[0]) ) zSql
++;
1579 }else if( pzErrMsg
){
1580 *pzErrMsg
= save_err_msg(db
);
1583 /* clear saved stmt handle */
1595 ** This is a different callback routine used for dumping the database.
1596 ** Each row received by this callback consists of a table name,
1597 ** the table type ("index" or "table") and SQL to create the table.
1598 ** This routine should print text sufficient to recreate the table.
1600 static int dump_callback(void *pArg
, int nArg
, char **azArg
, char **azCol
){
1605 const char *zPrepStmt
= 0;
1606 ShellState
*p
= (ShellState
*)pArg
;
1608 UNUSED_PARAMETER(azCol
);
1609 if( nArg
!=3 ) return 1;
1614 if( strcmp(zTable
, "sqlite_sequence")==0 ){
1615 zPrepStmt
= "DELETE FROM sqlite_sequence;\n";
1616 }else if( sqlite3_strglob("sqlite_stat?", zTable
)==0 ){
1617 fprintf(p
->out
, "ANALYZE sqlite_master;\n");
1618 }else if( strncmp(zTable
, "sqlite_", 7)==0 ){
1620 }else if( strncmp(zSql
, "CREATE VIRTUAL TABLE", 20)==0 ){
1622 if( !p
->writableSchema
){
1623 fprintf(p
->out
, "PRAGMA writable_schema=ON;\n");
1624 p
->writableSchema
= 1;
1626 zIns
= sqlite3_mprintf(
1627 "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
1628 "VALUES('table','%q','%q',0,'%q');",
1629 zTable
, zTable
, zSql
);
1630 fprintf(p
->out
, "%s\n", zIns
);
1634 fprintf(p
->out
, "%s;\n", zSql
);
1637 if( strcmp(zType
, "table")==0 ){
1638 sqlite3_stmt
*pTableInfo
= 0;
1640 char *zTableInfo
= 0;
1644 zTableInfo
= appendText(zTableInfo
, "PRAGMA table_info(", 0);
1645 zTableInfo
= appendText(zTableInfo
, zTable
, '"');
1646 zTableInfo
= appendText(zTableInfo
, ");", 0);
1648 rc
= sqlite3_prepare_v2(p
->db
, zTableInfo
, -1, &pTableInfo
, 0);
1650 if( rc
!=SQLITE_OK
|| !pTableInfo
){
1654 zSelect
= appendText(zSelect
, "SELECT 'INSERT INTO ' || ", 0);
1655 /* Always quote the table name, even if it appears to be pure ascii,
1656 ** in case it is a keyword. Ex: INSERT INTO "table" ... */
1657 zTmp
= appendText(zTmp
, zTable
, '"');
1659 zSelect
= appendText(zSelect
, zTmp
, '\'');
1662 zSelect
= appendText(zSelect
, " || ' VALUES(' || ", 0);
1663 rc
= sqlite3_step(pTableInfo
);
1664 while( rc
==SQLITE_ROW
){
1665 const char *zText
= (const char *)sqlite3_column_text(pTableInfo
, 1);
1666 zSelect
= appendText(zSelect
, "quote(", 0);
1667 zSelect
= appendText(zSelect
, zText
, '"');
1668 rc
= sqlite3_step(pTableInfo
);
1669 if( rc
==SQLITE_ROW
){
1670 zSelect
= appendText(zSelect
, "), ", 0);
1672 zSelect
= appendText(zSelect
, ") ", 0);
1676 rc
= sqlite3_finalize(pTableInfo
);
1677 if( rc
!=SQLITE_OK
|| nRow
==0 ){
1681 zSelect
= appendText(zSelect
, "|| ')' FROM ", 0);
1682 zSelect
= appendText(zSelect
, zTable
, '"');
1684 rc
= run_table_dump_query(p
, zSelect
, zPrepStmt
);
1685 if( rc
==SQLITE_CORRUPT
){
1686 zSelect
= appendText(zSelect
, " ORDER BY rowid DESC", 0);
1687 run_table_dump_query(p
, zSelect
, 0);
1695 ** Run zQuery. Use dump_callback() as the callback routine so that
1696 ** the contents of the query are output as SQL statements.
1698 ** If we get a SQLITE_CORRUPT error, rerun the query after appending
1699 ** "ORDER BY rowid DESC" to the end.
1701 static int run_schema_dump_query(
1707 rc
= sqlite3_exec(p
->db
, zQuery
, dump_callback
, p
, &zErr
);
1708 if( rc
==SQLITE_CORRUPT
){
1710 int len
= strlen30(zQuery
);
1711 fprintf(p
->out
, "/****** CORRUPTION ERROR *******/\n");
1713 fprintf(p
->out
, "/****** %s ******/\n", zErr
);
1717 zQ2
= malloc( len
+100 );
1718 if( zQ2
==0 ) return rc
;
1719 sqlite3_snprintf(len
+100, zQ2
, "%s ORDER BY rowid DESC", zQuery
);
1720 rc
= sqlite3_exec(p
->db
, zQ2
, dump_callback
, p
, &zErr
);
1722 fprintf(p
->out
, "/****** ERROR: %s ******/\n", zErr
);
1724 rc
= SQLITE_CORRUPT
;
1733 ** Text of a help message
1735 static char zHelp
[] =
1736 ".backup ?DB? FILE Backup DB (default \"main\") to FILE\n"
1737 ".bail on|off Stop after hitting an error. Default OFF\n"
1738 ".clone NEWDB Clone data into NEWDB from the existing database\n"
1739 ".databases List names and files of attached databases\n"
1740 ".dump ?TABLE? ... Dump the database in an SQL text format\n"
1741 " If TABLE specified, only dump tables matching\n"
1742 " LIKE pattern TABLE.\n"
1743 ".echo on|off Turn command echo on or off\n"
1744 ".eqp on|off Enable or disable automatic EXPLAIN QUERY PLAN\n"
1745 ".exit Exit this program\n"
1746 ".explain ?on|off? Turn output mode suitable for EXPLAIN on or off.\n"
1747 " With no args, it turns EXPLAIN on.\n"
1748 ".fullschema Show schema and the content of sqlite_stat tables\n"
1749 ".headers on|off Turn display of headers on or off\n"
1750 ".help Show this message\n"
1751 ".import FILE TABLE Import data from FILE into TABLE\n"
1752 ".indices ?TABLE? Show names of all indices\n"
1753 " If TABLE specified, only show indices for tables\n"
1754 " matching LIKE pattern TABLE.\n"
1755 #ifdef SQLITE_ENABLE_IOTRACE
1756 ".iotrace FILE Enable I/O diagnostic logging to FILE\n"
1758 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1759 ".load FILE ?ENTRY? Load an extension library\n"
1761 ".log FILE|off Turn logging on or off. FILE can be stderr/stdout\n"
1762 ".mode MODE ?TABLE? Set output mode where MODE is one of:\n"
1763 " ascii Columns/rows delimited by 0x1F and 0x1E\n"
1764 " csv Comma-separated values\n"
1765 " column Left-aligned columns. (See .width)\n"
1766 " html HTML <table> code\n"
1767 " insert SQL insert statements for TABLE\n"
1768 " line One value per line\n"
1769 " list Values delimited by .separator strings\n"
1770 " tabs Tab-separated values\n"
1771 " tcl TCL list elements\n"
1772 ".nullvalue STRING Use STRING in place of NULL values\n"
1773 ".once FILENAME Output for the next SQL command only to FILENAME\n"
1774 ".open ?FILENAME? Close existing database and reopen FILENAME\n"
1775 ".output ?FILENAME? Send output to FILENAME or stdout\n"
1776 ".print STRING... Print literal STRING\n"
1777 ".prompt MAIN CONTINUE Replace the standard prompts\n"
1778 ".quit Exit this program\n"
1779 ".read FILENAME Execute SQL in FILENAME\n"
1780 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n"
1781 ".save FILE Write in-memory database into FILE\n"
1782 ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off\n"
1783 ".schema ?TABLE? Show the CREATE statements\n"
1784 " If TABLE specified, only show tables matching\n"
1785 " LIKE pattern TABLE.\n"
1786 ".separator COL ?ROW? Change the column separator and optionally the row\n"
1787 " separator for both the output mode and .import\n"
1788 ".shell CMD ARGS... Run CMD ARGS... in a system shell\n"
1789 ".show Show the current values for various settings\n"
1790 ".stats on|off Turn stats on or off\n"
1791 ".system CMD ARGS... Run CMD ARGS... in a system shell\n"
1792 ".tables ?TABLE? List names of tables\n"
1793 " If TABLE specified, only list tables matching\n"
1794 " LIKE pattern TABLE.\n"
1795 ".timeout MS Try opening locked tables for MS milliseconds\n"
1796 ".timer on|off Turn SQL timer on or off\n"
1797 ".trace FILE|off Output each SQL statement as it is run\n"
1798 ".vfsname ?AUX? Print the name of the VFS stack\n"
1799 ".width NUM1 NUM2 ... Set column widths for \"column\" mode\n"
1800 " Negative values right-justify\n"
1803 /* Forward reference */
1804 static int process_input(ShellState
*p
, FILE *in
);
1806 ** Implementation of the "readfile(X)" SQL function. The entire content
1807 ** of the file named X is read and returned as a BLOB. NULL is returned
1808 ** if the file does not exist or is unreadable.
1810 static void readfileFunc(
1811 sqlite3_context
*context
,
1813 sqlite3_value
**argv
1820 zName
= (const char*)sqlite3_value_text(argv
[0]);
1821 if( zName
==0 ) return;
1822 in
= fopen(zName
, "rb");
1824 fseek(in
, 0, SEEK_END
);
1827 pBuf
= sqlite3_malloc( nIn
);
1828 if( pBuf
&& 1==fread(pBuf
, nIn
, 1, in
) ){
1829 sqlite3_result_blob(context
, pBuf
, nIn
, sqlite3_free
);
1837 ** Implementation of the "writefile(X,Y)" SQL function. The argument Y
1838 ** is written into file X. The number of bytes written is returned. Or
1839 ** NULL is returned if something goes wrong, such as being unable to open
1840 ** file X for writing.
1842 static void writefileFunc(
1843 sqlite3_context
*context
,
1845 sqlite3_value
**argv
1852 zFile
= (const char*)sqlite3_value_text(argv
[0]);
1853 if( zFile
==0 ) return;
1854 out
= fopen(zFile
, "wb");
1855 if( out
==0 ) return;
1856 z
= (const char*)sqlite3_value_blob(argv
[1]);
1860 rc
= fwrite(z
, 1, sqlite3_value_bytes(argv
[1]), out
);
1863 sqlite3_result_int64(context
, rc
);
1867 ** Make sure the database is open. If it is not, then open it. If
1868 ** the database fails to open, print an error message and exit.
1870 static void open_db(ShellState
*p
, int keepAlive
){
1872 sqlite3_initialize();
1873 sqlite3_open(p
->zDbFilename
, &p
->db
);
1875 if( db
&& sqlite3_errcode(db
)==SQLITE_OK
){
1876 sqlite3_create_function(db
, "shellstatic", 0, SQLITE_UTF8
, 0,
1877 shellstaticFunc
, 0, 0);
1879 if( db
==0 || SQLITE_OK
!=sqlite3_errcode(db
) ){
1880 fprintf(stderr
,"Error: unable to open database \"%s\": %s\n",
1881 p
->zDbFilename
, sqlite3_errmsg(db
));
1882 if( keepAlive
) return;
1885 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1886 sqlite3_enable_load_extension(p
->db
, 1);
1888 sqlite3_create_function(db
, "readfile", 1, SQLITE_UTF8
, 0,
1889 readfileFunc
, 0, 0);
1890 sqlite3_create_function(db
, "writefile", 2, SQLITE_UTF8
, 0,
1891 writefileFunc
, 0, 0);
1896 ** Do C-language style dequoting.
1900 ** \r -> carriage return
1902 ** \NNN -> ascii character NNN in octal
1905 static void resolve_backslashes(char *z
){
1908 while( *z
&& *z
!='\\' ) z
++;
1909 for(i
=j
=0; (c
= z
[i
])!=0; i
++, j
++){
1918 }else if( c
=='\\' ){
1920 }else if( c
>='0' && c
<='7' ){
1922 if( z
[i
+1]>='0' && z
[i
+1]<='7' ){
1924 c
= (c
<<3) + z
[i
] - '0';
1925 if( z
[i
+1]>='0' && z
[i
+1]<='7' ){
1927 c
= (c
<<3) + z
[i
] - '0';
1938 ** Return the value of a hexadecimal digit. Return -1 if the input
1939 ** is not a hex digit.
1941 static int hexDigitValue(char c
){
1942 if( c
>='0' && c
<='9' ) return c
- '0';
1943 if( c
>='a' && c
<='f' ) return c
- 'a' + 10;
1944 if( c
>='A' && c
<='F' ) return c
- 'A' + 10;
1949 ** Interpret zArg as an integer value, possibly with suffixes.
1951 static sqlite3_int64
integerValue(const char *zArg
){
1952 sqlite3_int64 v
= 0;
1953 static const struct { char *zSuffix
; int iMult
; } aMult
[] = {
1955 { "MiB", 1024*1024 },
1956 { "GiB", 1024*1024*1024 },
1959 { "GB", 1000000000 },
1962 { "G", 1000000000 },
1969 }else if( zArg
[0]=='+' ){
1972 if( zArg
[0]=='0' && zArg
[1]=='x' ){
1975 while( (x
= hexDigitValue(zArg
[0]))>=0 ){
1980 while( IsDigit(zArg
[0]) ){
1981 v
= v
*10 + zArg
[0] - '0';
1985 for(i
=0; i
<ArraySize(aMult
); i
++){
1986 if( sqlite3_stricmp(aMult
[i
].zSuffix
, zArg
)==0 ){
1987 v
*= aMult
[i
].iMult
;
1991 return isNeg
? -v
: v
;
1995 ** Interpret zArg as either an integer or a boolean value. Return 1 or 0
1996 ** for TRUE and FALSE. Return the integer value if appropriate.
1998 static int booleanValue(char *zArg
){
2000 if( zArg
[0]=='0' && zArg
[1]=='x' ){
2001 for(i
=2; hexDigitValue(zArg
[i
])>=0; i
++){}
2003 for(i
=0; zArg
[i
]>='0' && zArg
[i
]<='9'; i
++){}
2005 if( i
>0 && zArg
[i
]==0 ) return (int)(integerValue(zArg
) & 0xffffffff);
2006 if( sqlite3_stricmp(zArg
, "on")==0 || sqlite3_stricmp(zArg
,"yes")==0 ){
2009 if( sqlite3_stricmp(zArg
, "off")==0 || sqlite3_stricmp(zArg
,"no")==0 ){
2012 fprintf(stderr
, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
2018 ** Close an output file, assuming it is not stderr or stdout
2020 static void output_file_close(FILE *f
){
2021 if( f
&& f
!=stdout
&& f
!=stderr
) fclose(f
);
2025 ** Try to open an output file. The names "stdout" and "stderr" are
2026 ** recognized and do the right thing. NULL is returned if the output
2027 ** filename is "off".
2029 static FILE *output_file_open(const char *zFile
){
2031 if( strcmp(zFile
,"stdout")==0 ){
2033 }else if( strcmp(zFile
, "stderr")==0 ){
2035 }else if( strcmp(zFile
, "off")==0 ){
2038 f
= fopen(zFile
, "wb");
2040 fprintf(stderr
, "Error: cannot open \"%s\"\n", zFile
);
2047 ** A routine for handling output from sqlite3_trace().
2049 static void sql_trace_callback(void *pArg
, const char *z
){
2050 FILE *f
= (FILE*)pArg
;
2052 int i
= (int)strlen(z
);
2053 while( i
>0 && z
[i
-1]==';' ){ i
--; }
2054 fprintf(f
, "%.*s;\n", i
, z
);
2059 ** A no-op routine that runs with the ".breakpoint" doc-command. This is
2060 ** a useful spot to set a debugger breakpoint.
2062 static void test_breakpoint(void){
2063 static int nCall
= 0;
2068 ** An object used to read a CSV and other files for import.
2070 typedef struct ImportCtx ImportCtx
;
2072 const char *zFile
; /* Name of the input file */
2073 FILE *in
; /* Read the CSV text from this input stream */
2074 char *z
; /* Accumulated text for a field */
2075 int n
; /* Number of bytes in z */
2076 int nAlloc
; /* Space allocated for z[] */
2077 int nLine
; /* Current line number */
2078 int cTerm
; /* Character that terminated the most recent field */
2079 int cColSep
; /* The column separator character. (Usually ",") */
2080 int cRowSep
; /* The row separator character. (Usually "\n") */
2083 /* Append a single byte to z[] */
2084 static void import_append_char(ImportCtx
*p
, int c
){
2085 if( p
->n
+1>=p
->nAlloc
){
2086 p
->nAlloc
+= p
->nAlloc
+ 100;
2087 p
->z
= sqlite3_realloc(p
->z
, p
->nAlloc
);
2089 fprintf(stderr
, "out of memory\n");
2093 p
->z
[p
->n
++] = (char)c
;
2096 /* Read a single field of CSV text. Compatible with rfc4180 and extended
2097 ** with the option of having a separator other than ",".
2099 ** + Input comes from p->in.
2100 ** + Store results in p->z of length p->n. Space to hold p->z comes
2101 ** from sqlite3_malloc().
2102 ** + Use p->cSep as the column separator. The default is ",".
2103 ** + Use p->rSep as the row separator. The default is "\n".
2104 ** + Keep track of the line number in p->nLine.
2105 ** + Store the character that terminates the field in p->cTerm. Store
2106 ** EOF on end-of-file.
2107 ** + Report syntax errors on stderr
2109 static char *csv_read_one_field(ImportCtx
*p
){
2111 int cSep
= p
->cColSep
;
2112 int rSep
= p
->cRowSep
;
2115 if( c
==EOF
|| seenInterrupt
){
2121 int startLine
= p
->nLine
;
2126 if( c
==rSep
) p
->nLine
++;
2133 if( (c
==cSep
&& pc
==cQuote
)
2134 || (c
==rSep
&& pc
==cQuote
)
2135 || (c
==rSep
&& pc
=='\r' && ppc
==cQuote
)
2136 || (c
==EOF
&& pc
==cQuote
)
2138 do{ p
->n
--; }while( p
->z
[p
->n
]!=cQuote
);
2142 if( pc
==cQuote
&& c
!='\r' ){
2143 fprintf(stderr
, "%s:%d: unescaped %c character\n",
2144 p
->zFile
, p
->nLine
, cQuote
);
2147 fprintf(stderr
, "%s:%d: unterminated %c-quoted field\n",
2148 p
->zFile
, startLine
, cQuote
);
2152 import_append_char(p
, c
);
2157 while( c
!=EOF
&& c
!=cSep
&& c
!=rSep
){
2158 import_append_char(p
, c
);
2163 if( p
->n
>0 && p
->z
[p
->n
-1]=='\r' ) p
->n
--;
2167 if( p
->z
) p
->z
[p
->n
] = 0;
2171 /* Read a single field of ASCII delimited text.
2173 ** + Input comes from p->in.
2174 ** + Store results in p->z of length p->n. Space to hold p->z comes
2175 ** from sqlite3_malloc().
2176 ** + Use p->cSep as the column separator. The default is "\x1F".
2177 ** + Use p->rSep as the row separator. The default is "\x1E".
2178 ** + Keep track of the row number in p->nLine.
2179 ** + Store the character that terminates the field in p->cTerm. Store
2180 ** EOF on end-of-file.
2181 ** + Report syntax errors on stderr
2183 static char *ascii_read_one_field(ImportCtx
*p
){
2185 int cSep
= p
->cColSep
;
2186 int rSep
= p
->cRowSep
;
2189 if( c
==EOF
|| seenInterrupt
){
2193 while( c
!=EOF
&& c
!=cSep
&& c
!=rSep
){
2194 import_append_char(p
, c
);
2201 if( p
->z
) p
->z
[p
->n
] = 0;
2206 ** Try to transfer data for table zTable. If an error is seen while
2207 ** moving forward, try to go backwards. The backwards movement won't
2208 ** work for WITHOUT ROWID tables.
2210 static void tryToCloneData(
2215 sqlite3_stmt
*pQuery
= 0;
2216 sqlite3_stmt
*pInsert
= 0;
2221 int nTable
= (int)strlen(zTable
);
2224 const int spinRate
= 10000;
2226 zQuery
= sqlite3_mprintf("SELECT * FROM \"%w\"", zTable
);
2227 rc
= sqlite3_prepare_v2(p
->db
, zQuery
, -1, &pQuery
, 0);
2229 fprintf(stderr
, "Error %d: %s on [%s]\n",
2230 sqlite3_extended_errcode(p
->db
), sqlite3_errmsg(p
->db
),
2234 n
= sqlite3_column_count(pQuery
);
2235 zInsert
= sqlite3_malloc(200 + nTable
+ n
*3);
2237 fprintf(stderr
, "out of memory\n");
2240 sqlite3_snprintf(200+nTable
,zInsert
,
2241 "INSERT OR IGNORE INTO \"%s\" VALUES(?", zTable
);
2242 i
= (int)strlen(zInsert
);
2244 memcpy(zInsert
+i
, ",?", 2);
2247 memcpy(zInsert
+i
, ");", 3);
2248 rc
= sqlite3_prepare_v2(newDb
, zInsert
, -1, &pInsert
, 0);
2250 fprintf(stderr
, "Error %d: %s on [%s]\n",
2251 sqlite3_extended_errcode(newDb
), sqlite3_errmsg(newDb
),
2256 while( (rc
= sqlite3_step(pQuery
))==SQLITE_ROW
){
2258 switch( sqlite3_column_type(pQuery
, i
) ){
2260 sqlite3_bind_null(pInsert
, i
+1);
2263 case SQLITE_INTEGER
: {
2264 sqlite3_bind_int64(pInsert
, i
+1, sqlite3_column_int64(pQuery
,i
));
2267 case SQLITE_FLOAT
: {
2268 sqlite3_bind_double(pInsert
, i
+1, sqlite3_column_double(pQuery
,i
));
2272 sqlite3_bind_text(pInsert
, i
+1,
2273 (const char*)sqlite3_column_text(pQuery
,i
),
2278 sqlite3_bind_blob(pInsert
, i
+1, sqlite3_column_blob(pQuery
,i
),
2279 sqlite3_column_bytes(pQuery
,i
),
2285 rc
= sqlite3_step(pInsert
);
2286 if( rc
!=SQLITE_OK
&& rc
!=SQLITE_ROW
&& rc
!=SQLITE_DONE
){
2287 fprintf(stderr
, "Error %d: %s\n", sqlite3_extended_errcode(newDb
),
2288 sqlite3_errmsg(newDb
));
2290 sqlite3_reset(pInsert
);
2292 if( (cnt
%spinRate
)==0 ){
2293 printf("%c\b", "|/-\\"[(cnt
/spinRate
)%4]);
2297 if( rc
==SQLITE_DONE
) break;
2298 sqlite3_finalize(pQuery
);
2299 sqlite3_free(zQuery
);
2300 zQuery
= sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;",
2302 rc
= sqlite3_prepare_v2(p
->db
, zQuery
, -1, &pQuery
, 0);
2304 fprintf(stderr
, "Warning: cannot step \"%s\" backwards", zTable
);
2307 } /* End for(k=0...) */
2310 sqlite3_finalize(pQuery
);
2311 sqlite3_finalize(pInsert
);
2312 sqlite3_free(zQuery
);
2313 sqlite3_free(zInsert
);
2318 ** Try to transfer all rows of the schema that match zWhere. For
2319 ** each row, invoke xForEach() on the object defined by that row.
2320 ** If an error is encountered while moving forward through the
2321 ** sqlite_master table, try again moving backwards.
2323 static void tryToCloneSchema(
2327 void (*xForEach
)(ShellState
*,sqlite3
*,const char*)
2329 sqlite3_stmt
*pQuery
= 0;
2332 const unsigned char *zName
;
2333 const unsigned char *zSql
;
2336 zQuery
= sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
2337 " WHERE %s", zWhere
);
2338 rc
= sqlite3_prepare_v2(p
->db
, zQuery
, -1, &pQuery
, 0);
2340 fprintf(stderr
, "Error: (%d) %s on [%s]\n",
2341 sqlite3_extended_errcode(p
->db
), sqlite3_errmsg(p
->db
),
2343 goto end_schema_xfer
;
2345 while( (rc
= sqlite3_step(pQuery
))==SQLITE_ROW
){
2346 zName
= sqlite3_column_text(pQuery
, 0);
2347 zSql
= sqlite3_column_text(pQuery
, 1);
2348 printf("%s... ", zName
); fflush(stdout
);
2349 sqlite3_exec(newDb
, (const char*)zSql
, 0, 0, &zErrMsg
);
2351 fprintf(stderr
, "Error: %s\nSQL: [%s]\n", zErrMsg
, zSql
);
2352 sqlite3_free(zErrMsg
);
2356 xForEach(p
, newDb
, (const char*)zName
);
2360 if( rc
!=SQLITE_DONE
){
2361 sqlite3_finalize(pQuery
);
2362 sqlite3_free(zQuery
);
2363 zQuery
= sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
2364 " WHERE %s ORDER BY rowid DESC", zWhere
);
2365 rc
= sqlite3_prepare_v2(p
->db
, zQuery
, -1, &pQuery
, 0);
2367 fprintf(stderr
, "Error: (%d) %s on [%s]\n",
2368 sqlite3_extended_errcode(p
->db
), sqlite3_errmsg(p
->db
),
2370 goto end_schema_xfer
;
2372 while( (rc
= sqlite3_step(pQuery
))==SQLITE_ROW
){
2373 zName
= sqlite3_column_text(pQuery
, 0);
2374 zSql
= sqlite3_column_text(pQuery
, 1);
2375 printf("%s... ", zName
); fflush(stdout
);
2376 sqlite3_exec(newDb
, (const char*)zSql
, 0, 0, &zErrMsg
);
2378 fprintf(stderr
, "Error: %s\nSQL: [%s]\n", zErrMsg
, zSql
);
2379 sqlite3_free(zErrMsg
);
2383 xForEach(p
, newDb
, (const char*)zName
);
2389 sqlite3_finalize(pQuery
);
2390 sqlite3_free(zQuery
);
2394 ** Open a new database file named "zNewDb". Try to recover as much information
2395 ** as possible out of the main database (which might be corrupt) and write it
2398 static void tryToClone(ShellState
*p
, const char *zNewDb
){
2401 if( access(zNewDb
,0)==0 ){
2402 fprintf(stderr
, "File \"%s\" already exists.\n", zNewDb
);
2405 rc
= sqlite3_open(zNewDb
, &newDb
);
2407 fprintf(stderr
, "Cannot create output database: %s\n",
2408 sqlite3_errmsg(newDb
));
2410 sqlite3_exec(p
->db
, "PRAGMA writable_schema=ON;", 0, 0, 0);
2411 sqlite3_exec(newDb
, "BEGIN EXCLUSIVE;", 0, 0, 0);
2412 tryToCloneSchema(p
, newDb
, "type='table'", tryToCloneData
);
2413 tryToCloneSchema(p
, newDb
, "type!='table'", 0);
2414 sqlite3_exec(newDb
, "COMMIT;", 0, 0, 0);
2415 sqlite3_exec(p
->db
, "PRAGMA writable_schema=OFF;", 0, 0, 0);
2417 sqlite3_close(newDb
);
2421 ** Change the output file back to stdout
2423 static void output_reset(ShellState
*p
){
2424 if( p
->outfile
[0]=='|' ){
2427 output_file_close(p
->out
);
2434 ** If an input line begins with "." then invoke this routine to
2435 ** process that line.
2437 ** Return 1 on error, 2 to exit, and 0 otherwise.
2439 static int do_meta_command(char *zLine
, ShellState
*p
){
2446 /* Parse the input line into tokens.
2448 while( zLine
[i
] && nArg
<ArraySize(azArg
) ){
2449 while( IsSpace(zLine
[i
]) ){ i
++; }
2450 if( zLine
[i
]==0 ) break;
2451 if( zLine
[i
]=='\'' || zLine
[i
]=='"' ){
2452 int delim
= zLine
[i
++];
2453 azArg
[nArg
++] = &zLine
[i
];
2454 while( zLine
[i
] && zLine
[i
]!=delim
){
2455 if( zLine
[i
]=='\\' && delim
=='"' && zLine
[i
+1]!=0 ) i
++;
2458 if( zLine
[i
]==delim
){
2461 if( delim
=='"' ) resolve_backslashes(azArg
[nArg
-1]);
2463 azArg
[nArg
++] = &zLine
[i
];
2464 while( zLine
[i
] && !IsSpace(zLine
[i
]) ){ i
++; }
2465 if( zLine
[i
] ) zLine
[i
++] = 0;
2466 resolve_backslashes(azArg
[nArg
-1]);
2470 /* Process the input line.
2472 if( nArg
==0 ) return 0; /* no tokens, no error */
2473 n
= strlen30(azArg
[0]);
2475 if( (c
=='b' && n
>=3 && strncmp(azArg
[0], "backup", n
)==0)
2476 || (c
=='s' && n
>=3 && strncmp(azArg
[0], "save", n
)==0)
2478 const char *zDestFile
= 0;
2479 const char *zDb
= 0;
2481 sqlite3_backup
*pBackup
;
2483 for(j
=1; j
<nArg
; j
++){
2484 const char *z
= azArg
[j
];
2486 while( z
[0]=='-' ) z
++;
2487 /* No options to process at this time */
2489 fprintf(stderr
, "unknown option: %s\n", azArg
[j
]);
2492 }else if( zDestFile
==0 ){
2493 zDestFile
= azArg
[j
];
2496 zDestFile
= azArg
[j
];
2498 fprintf(stderr
, "too many arguments to .backup\n");
2503 fprintf(stderr
, "missing FILENAME argument on .backup\n");
2506 if( zDb
==0 ) zDb
= "main";
2507 rc
= sqlite3_open(zDestFile
, &pDest
);
2508 if( rc
!=SQLITE_OK
){
2509 fprintf(stderr
, "Error: cannot open \"%s\"\n", zDestFile
);
2510 sqlite3_close(pDest
);
2514 pBackup
= sqlite3_backup_init(pDest
, "main", p
->db
, zDb
);
2516 fprintf(stderr
, "Error: %s\n", sqlite3_errmsg(pDest
));
2517 sqlite3_close(pDest
);
2520 while( (rc
= sqlite3_backup_step(pBackup
,100))==SQLITE_OK
){}
2521 sqlite3_backup_finish(pBackup
);
2522 if( rc
==SQLITE_DONE
){
2525 fprintf(stderr
, "Error: %s\n", sqlite3_errmsg(pDest
));
2528 sqlite3_close(pDest
);
2531 if( c
=='b' && n
>=3 && strncmp(azArg
[0], "bail", n
)==0 ){
2533 bail_on_error
= booleanValue(azArg
[1]);
2535 fprintf(stderr
, "Usage: .bail on|off\n");
2540 /* The undocumented ".breakpoint" command causes a call to the no-op
2541 ** routine named test_breakpoint().
2543 if( c
=='b' && n
>=3 && strncmp(azArg
[0], "breakpoint", n
)==0 ){
2547 if( c
=='c' && strncmp(azArg
[0], "clone", n
)==0 ){
2549 tryToClone(p
, azArg
[1]);
2551 fprintf(stderr
, "Usage: .clone FILENAME\n");
2556 if( c
=='d' && n
>1 && strncmp(azArg
[0], "databases", n
)==0 ){
2560 memcpy(&data
, p
, sizeof(data
));
2561 data
.showHeader
= 1;
2562 data
.mode
= MODE_Column
;
2563 data
.colWidth
[0] = 3;
2564 data
.colWidth
[1] = 15;
2565 data
.colWidth
[2] = 58;
2567 sqlite3_exec(p
->db
, "PRAGMA database_list; ", callback
, &data
, &zErrMsg
);
2569 fprintf(stderr
,"Error: %s\n", zErrMsg
);
2570 sqlite3_free(zErrMsg
);
2575 if( c
=='d' && strncmp(azArg
[0], "dump", n
)==0 ){
2577 /* When playing back a "dump", the content might appear in an order
2578 ** which causes immediate foreign key constraints to be violated.
2579 ** So disable foreign-key constraint enforcement to prevent problems. */
2580 if( nArg
!=1 && nArg
!=2 ){
2581 fprintf(stderr
, "Usage: .dump ?LIKE-PATTERN?\n");
2583 goto meta_command_exit
;
2585 fprintf(p
->out
, "PRAGMA foreign_keys=OFF;\n");
2586 fprintf(p
->out
, "BEGIN TRANSACTION;\n");
2587 p
->writableSchema
= 0;
2588 sqlite3_exec(p
->db
, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
2591 run_schema_dump_query(p
,
2592 "SELECT name, type, sql FROM sqlite_master "
2593 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
2595 run_schema_dump_query(p
,
2596 "SELECT name, type, sql FROM sqlite_master "
2597 "WHERE name=='sqlite_sequence'"
2599 run_table_dump_query(p
,
2600 "SELECT sql FROM sqlite_master "
2601 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
2605 for(i
=1; i
<nArg
; i
++){
2606 zShellStatic
= azArg
[i
];
2607 run_schema_dump_query(p
,
2608 "SELECT name, type, sql FROM sqlite_master "
2609 "WHERE tbl_name LIKE shellstatic() AND type=='table'"
2610 " AND sql NOT NULL");
2611 run_table_dump_query(p
,
2612 "SELECT sql FROM sqlite_master "
2613 "WHERE sql NOT NULL"
2614 " AND type IN ('index','trigger','view')"
2615 " AND tbl_name LIKE shellstatic()", 0
2620 if( p
->writableSchema
){
2621 fprintf(p
->out
, "PRAGMA writable_schema=OFF;\n");
2622 p
->writableSchema
= 0;
2624 sqlite3_exec(p
->db
, "PRAGMA writable_schema=OFF;", 0, 0, 0);
2625 sqlite3_exec(p
->db
, "RELEASE dump;", 0, 0, 0);
2626 fprintf(p
->out
, p
->nErr
? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
2629 if( c
=='e' && strncmp(azArg
[0], "echo", n
)==0 ){
2631 p
->echoOn
= booleanValue(azArg
[1]);
2633 fprintf(stderr
, "Usage: .echo on|off\n");
2638 if( c
=='e' && strncmp(azArg
[0], "eqp", n
)==0 ){
2640 p
->autoEQP
= booleanValue(azArg
[1]);
2642 fprintf(stderr
, "Usage: .eqp on|off\n");
2647 if( c
=='e' && strncmp(azArg
[0], "exit", n
)==0 ){
2648 if( nArg
>1 && (rc
= (int)integerValue(azArg
[1]))!=0 ) exit(rc
);
2652 if( c
=='e' && strncmp(azArg
[0], "explain", n
)==0 ){
2653 int val
= nArg
>=2 ? booleanValue(azArg
[1]) : 1;
2655 if(!p
->normalMode
.valid
) {
2656 p
->normalMode
.valid
= 1;
2657 p
->normalMode
.mode
= p
->mode
;
2658 p
->normalMode
.showHeader
= p
->showHeader
;
2659 memcpy(p
->normalMode
.colWidth
,p
->colWidth
,sizeof(p
->colWidth
));
2661 /* We could put this code under the !p->explainValid
2662 ** condition so that it does not execute if we are already in
2663 ** explain mode. However, always executing it allows us an easy
2664 ** was to reset to explain mode in case the user previously
2665 ** did an .explain followed by a .width, .mode or .header
2668 p
->mode
= MODE_Explain
;
2670 memset(p
->colWidth
,0,sizeof(p
->colWidth
));
2671 p
->colWidth
[0] = 4; /* addr */
2672 p
->colWidth
[1] = 13; /* opcode */
2673 p
->colWidth
[2] = 4; /* P1 */
2674 p
->colWidth
[3] = 4; /* P2 */
2675 p
->colWidth
[4] = 4; /* P3 */
2676 p
->colWidth
[5] = 13; /* P4 */
2677 p
->colWidth
[6] = 2; /* P5 */
2678 p
->colWidth
[7] = 13; /* Comment */
2679 }else if (p
->normalMode
.valid
) {
2680 p
->normalMode
.valid
= 0;
2681 p
->mode
= p
->normalMode
.mode
;
2682 p
->showHeader
= p
->normalMode
.showHeader
;
2683 memcpy(p
->colWidth
,p
->normalMode
.colWidth
,sizeof(p
->colWidth
));
2687 if( c
=='f' && strncmp(azArg
[0], "fullschema", n
)==0 ){
2692 fprintf(stderr
, "Usage: .fullschema\n");
2694 goto meta_command_exit
;
2697 memcpy(&data
, p
, sizeof(data
));
2698 data
.showHeader
= 0;
2699 data
.mode
= MODE_Semi
;
2700 rc
= sqlite3_exec(p
->db
,
2702 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
2703 " FROM sqlite_master UNION ALL"
2704 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
2705 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
2707 callback
, &data
, &zErrMsg
2709 if( rc
==SQLITE_OK
){
2710 sqlite3_stmt
*pStmt
;
2711 rc
= sqlite3_prepare_v2(p
->db
,
2712 "SELECT rowid FROM sqlite_master"
2713 " WHERE name GLOB 'sqlite_stat[134]'",
2715 doStats
= sqlite3_step(pStmt
)==SQLITE_ROW
;
2716 sqlite3_finalize(pStmt
);
2719 fprintf(p
->out
, "/* No STAT tables available */\n");
2721 fprintf(p
->out
, "ANALYZE sqlite_master;\n");
2722 sqlite3_exec(p
->db
, "SELECT 'ANALYZE sqlite_master'",
2723 callback
, &data
, &zErrMsg
);
2724 data
.mode
= MODE_Insert
;
2725 data
.zDestTable
= "sqlite_stat1";
2726 shell_exec(p
->db
, "SELECT * FROM sqlite_stat1",
2727 shell_callback
, &data
,&zErrMsg
);
2728 data
.zDestTable
= "sqlite_stat3";
2729 shell_exec(p
->db
, "SELECT * FROM sqlite_stat3",
2730 shell_callback
, &data
,&zErrMsg
);
2731 data
.zDestTable
= "sqlite_stat4";
2732 shell_exec(p
->db
, "SELECT * FROM sqlite_stat4",
2733 shell_callback
, &data
, &zErrMsg
);
2734 fprintf(p
->out
, "ANALYZE sqlite_master;\n");
2738 if( c
=='h' && strncmp(azArg
[0], "headers", n
)==0 ){
2740 p
->showHeader
= booleanValue(azArg
[1]);
2742 fprintf(stderr
, "Usage: .headers on|off\n");
2747 if( c
=='h' && strncmp(azArg
[0], "help", n
)==0 ){
2748 fprintf(p
->out
, "%s", zHelp
);
2751 if( c
=='i' && strncmp(azArg
[0], "import", n
)==0 ){
2752 char *zTable
; /* Insert data into this table */
2753 char *zFile
; /* Name of file to extra content from */
2754 sqlite3_stmt
*pStmt
= NULL
; /* A statement */
2755 int nCol
; /* Number of columns in the table */
2756 int nByte
; /* Number of bytes in an SQL string */
2757 int i
, j
; /* Loop counters */
2758 int needCommit
; /* True to COMMIT or ROLLBACK at end */
2759 int nSep
; /* Number of bytes in p->colSeparator[] */
2760 char *zSql
; /* An SQL statement */
2761 ImportCtx sCtx
; /* Reader context */
2762 char *(*xRead
)(ImportCtx
*); /* Procedure to read one value */
2763 int (*xCloser
)(FILE*); /* Procedure to close th3 connection */
2766 fprintf(stderr
, "Usage: .import FILE TABLE\n");
2767 goto meta_command_exit
;
2772 memset(&sCtx
, 0, sizeof(sCtx
));
2774 nSep
= strlen30(p
->colSeparator
);
2776 fprintf(stderr
, "Error: non-null column separator required for import\n");
2780 fprintf(stderr
, "Error: multi-character column separators not allowed"
2784 nSep
= strlen30(p
->rowSeparator
);
2786 fprintf(stderr
, "Error: non-null row separator required for import\n");
2789 if( nSep
==2 && p
->mode
==MODE_Csv
&& strcmp(p
->rowSeparator
, SEP_CrLf
)==0 ){
2790 /* When importing CSV (only), if the row separator is set to the
2791 ** default output row separator, change it to the default input
2792 ** row separator. This avoids having to maintain different input
2793 ** and output row separators. */
2794 sqlite3_snprintf(sizeof(p
->rowSeparator
), p
->rowSeparator
, SEP_Row
);
2795 nSep
= strlen30(p
->rowSeparator
);
2798 fprintf(stderr
, "Error: multi-character row separators not allowed"
2804 if( sCtx
.zFile
[0]=='|' ){
2805 sCtx
.in
= popen(sCtx
.zFile
+1, "r");
2806 sCtx
.zFile
= "<pipe>";
2809 sCtx
.in
= fopen(sCtx
.zFile
, "rb");
2812 if( p
->mode
==MODE_Ascii
){
2813 xRead
= ascii_read_one_field
;
2815 xRead
= csv_read_one_field
;
2818 fprintf(stderr
, "Error: cannot open \"%s\"\n", zFile
);
2821 sCtx
.cColSep
= p
->colSeparator
[0];
2822 sCtx
.cRowSep
= p
->rowSeparator
[0];
2823 zSql
= sqlite3_mprintf("SELECT * FROM %s", zTable
);
2825 fprintf(stderr
, "Error: out of memory\n");
2829 nByte
= strlen30(zSql
);
2830 rc
= sqlite3_prepare_v2(p
->db
, zSql
, -1, &pStmt
, 0);
2831 import_append_char(&sCtx
, 0); /* To ensure sCtx.z is allocated */
2832 if( rc
&& sqlite3_strglob("no such table: *", sqlite3_errmsg(db
))==0 ){
2833 char *zCreate
= sqlite3_mprintf("CREATE TABLE %s", zTable
);
2835 while( xRead(&sCtx
) ){
2836 zCreate
= sqlite3_mprintf("%z%c\n \"%s\" TEXT", zCreate
, cSep
, sCtx
.z
);
2838 if( sCtx
.cTerm
!=sCtx
.cColSep
) break;
2841 sqlite3_free(zCreate
);
2842 sqlite3_free(sCtx
.z
);
2844 fprintf(stderr
,"%s: empty file\n", sCtx
.zFile
);
2847 zCreate
= sqlite3_mprintf("%z\n)", zCreate
);
2848 rc
= sqlite3_exec(p
->db
, zCreate
, 0, 0, 0);
2849 sqlite3_free(zCreate
);
2851 fprintf(stderr
, "CREATE TABLE %s(...) failed: %s\n", zTable
,
2852 sqlite3_errmsg(db
));
2853 sqlite3_free(sCtx
.z
);
2857 rc
= sqlite3_prepare_v2(p
->db
, zSql
, -1, &pStmt
, 0);
2861 if (pStmt
) sqlite3_finalize(pStmt
);
2862 fprintf(stderr
,"Error: %s\n", sqlite3_errmsg(db
));
2866 nCol
= sqlite3_column_count(pStmt
);
2867 sqlite3_finalize(pStmt
);
2869 if( nCol
==0 ) return 0; /* no columns, no error */
2870 zSql
= sqlite3_malloc( nByte
*2 + 20 + nCol
*2 );
2872 fprintf(stderr
, "Error: out of memory\n");
2876 sqlite3_snprintf(nByte
+20, zSql
, "INSERT INTO \"%w\" VALUES(?", zTable
);
2878 for(i
=1; i
<nCol
; i
++){
2884 rc
= sqlite3_prepare_v2(p
->db
, zSql
, -1, &pStmt
, 0);
2887 fprintf(stderr
, "Error: %s\n", sqlite3_errmsg(db
));
2888 if (pStmt
) sqlite3_finalize(pStmt
);
2892 needCommit
= sqlite3_get_autocommit(db
);
2893 if( needCommit
) sqlite3_exec(db
, "BEGIN", 0, 0, 0);
2895 int startLine
= sCtx
.nLine
;
2896 for(i
=0; i
<nCol
; i
++){
2897 char *z
= xRead(&sCtx
);
2899 ** Did we reach end-of-file before finding any columns?
2900 ** If so, stop instead of NULL filling the remaining columns.
2902 if( z
==0 && i
==0 ) break;
2904 ** Did we reach end-of-file OR end-of-line before finding any
2905 ** columns in ASCII mode? If so, stop instead of NULL filling
2906 ** the remaining columns.
2908 if( p
->mode
==MODE_Ascii
&& (z
==0 || z
[0]==0) && i
==0 ) break;
2909 sqlite3_bind_text(pStmt
, i
+1, z
, -1, SQLITE_TRANSIENT
);
2910 if( i
<nCol
-1 && sCtx
.cTerm
!=sCtx
.cColSep
){
2911 fprintf(stderr
, "%s:%d: expected %d columns but found %d - "
2912 "filling the rest with NULL\n",
2913 sCtx
.zFile
, startLine
, nCol
, i
+1);
2915 while( i
<=nCol
){ sqlite3_bind_null(pStmt
, i
); i
++; }
2918 if( sCtx
.cTerm
==sCtx
.cColSep
){
2922 }while( sCtx
.cTerm
==sCtx
.cColSep
);
2923 fprintf(stderr
, "%s:%d: expected %d columns but found %d - "
2925 sCtx
.zFile
, startLine
, nCol
, i
);
2928 sqlite3_step(pStmt
);
2929 rc
= sqlite3_reset(pStmt
);
2930 if( rc
!=SQLITE_OK
){
2931 fprintf(stderr
, "%s:%d: INSERT failed: %s\n", sCtx
.zFile
, startLine
,
2932 sqlite3_errmsg(db
));
2935 }while( sCtx
.cTerm
!=EOF
);
2938 sqlite3_free(sCtx
.z
);
2939 sqlite3_finalize(pStmt
);
2940 if( needCommit
) sqlite3_exec(db
, "COMMIT", 0, 0, 0);
2943 if( c
=='i' && strncmp(azArg
[0], "indices", n
)==0 ){
2947 memcpy(&data
, p
, sizeof(data
));
2948 data
.showHeader
= 0;
2949 data
.mode
= MODE_List
;
2951 rc
= sqlite3_exec(p
->db
,
2952 "SELECT name FROM sqlite_master "
2953 "WHERE type='index' AND name NOT LIKE 'sqlite_%' "
2955 "SELECT name FROM sqlite_temp_master "
2956 "WHERE type='index' "
2958 callback
, &data
, &zErrMsg
2960 }else if( nArg
==2 ){
2961 zShellStatic
= azArg
[1];
2962 rc
= sqlite3_exec(p
->db
,
2963 "SELECT name FROM sqlite_master "
2964 "WHERE type='index' AND tbl_name LIKE shellstatic() "
2966 "SELECT name FROM sqlite_temp_master "
2967 "WHERE type='index' AND tbl_name LIKE shellstatic() "
2969 callback
, &data
, &zErrMsg
2973 fprintf(stderr
, "Usage: .indices ?LIKE-PATTERN?\n");
2975 goto meta_command_exit
;
2978 fprintf(stderr
,"Error: %s\n", zErrMsg
);
2979 sqlite3_free(zErrMsg
);
2981 }else if( rc
!= SQLITE_OK
){
2982 fprintf(stderr
,"Error: querying sqlite_master and sqlite_temp_master\n");
2987 #ifdef SQLITE_ENABLE_IOTRACE
2988 if( c
=='i' && strncmp(azArg
[0], "iotrace", n
)==0 ){
2989 extern void (*sqlite3IoTrace
)(const char*, ...);
2990 if( iotrace
&& iotrace
!=stdout
) fclose(iotrace
);
2994 }else if( strcmp(azArg
[1], "-")==0 ){
2995 sqlite3IoTrace
= iotracePrintf
;
2998 iotrace
= fopen(azArg
[1], "w");
3000 fprintf(stderr
, "Error: cannot open \"%s\"\n", azArg
[1]);
3004 sqlite3IoTrace
= iotracePrintf
;
3010 #ifndef SQLITE_OMIT_LOAD_EXTENSION
3011 if( c
=='l' && strncmp(azArg
[0], "load", n
)==0 ){
3012 const char *zFile
, *zProc
;
3015 fprintf(stderr
, "Usage: .load FILE ?ENTRYPOINT?\n");
3017 goto meta_command_exit
;
3020 zProc
= nArg
>=3 ? azArg
[2] : 0;
3022 rc
= sqlite3_load_extension(p
->db
, zFile
, zProc
, &zErrMsg
);
3023 if( rc
!=SQLITE_OK
){
3024 fprintf(stderr
, "Error: %s\n", zErrMsg
);
3025 sqlite3_free(zErrMsg
);
3031 if( c
=='l' && strncmp(azArg
[0], "log", n
)==0 ){
3033 fprintf(stderr
, "Usage: .log FILENAME\n");
3036 const char *zFile
= azArg
[1];
3037 output_file_close(p
->pLog
);
3038 p
->pLog
= output_file_open(zFile
);
3042 if( c
=='m' && strncmp(azArg
[0], "mode", n
)==0 ){
3043 const char *zMode
= nArg
>=2 ? azArg
[1] : "";
3044 int n2
= (int)strlen(zMode
);
3046 if( c2
=='l' && n2
>2 && strncmp(azArg
[1],"lines",n2
)==0 ){
3047 p
->mode
= MODE_Line
;
3048 }else if( c2
=='c' && strncmp(azArg
[1],"columns",n2
)==0 ){
3049 p
->mode
= MODE_Column
;
3050 }else if( c2
=='l' && n2
>2 && strncmp(azArg
[1],"list",n2
)==0 ){
3051 p
->mode
= MODE_List
;
3052 }else if( c2
=='h' && strncmp(azArg
[1],"html",n2
)==0 ){
3053 p
->mode
= MODE_Html
;
3054 }else if( c2
=='t' && strncmp(azArg
[1],"tcl",n2
)==0 ){
3056 sqlite3_snprintf(sizeof(p
->colSeparator
), p
->colSeparator
, SEP_Space
);
3057 }else if( c2
=='c' && strncmp(azArg
[1],"csv",n2
)==0 ){
3059 sqlite3_snprintf(sizeof(p
->colSeparator
), p
->colSeparator
, SEP_Comma
);
3060 sqlite3_snprintf(sizeof(p
->rowSeparator
), p
->rowSeparator
, SEP_CrLf
);
3061 }else if( c2
=='t' && strncmp(azArg
[1],"tabs",n2
)==0 ){
3062 p
->mode
= MODE_List
;
3063 sqlite3_snprintf(sizeof(p
->colSeparator
), p
->colSeparator
, SEP_Tab
);
3064 }else if( c2
=='i' && strncmp(azArg
[1],"insert",n2
)==0 ){
3065 p
->mode
= MODE_Insert
;
3066 set_table_name(p
, nArg
>=3 ? azArg
[2] : "table");
3067 }else if( c2
=='a' && strncmp(azArg
[1],"ascii",n2
)==0 ){
3068 p
->mode
= MODE_Ascii
;
3069 sqlite3_snprintf(sizeof(p
->colSeparator
), p
->colSeparator
, SEP_Unit
);
3070 sqlite3_snprintf(sizeof(p
->rowSeparator
), p
->rowSeparator
, SEP_Record
);
3072 fprintf(stderr
,"Error: mode should be one of: "
3073 "ascii column csv html insert line list tabs tcl\n");
3078 if( c
=='n' && strncmp(azArg
[0], "nullvalue", n
)==0 ){
3080 sqlite3_snprintf(sizeof(p
->nullValue
), p
->nullValue
,
3081 "%.*s", (int)ArraySize(p
->nullValue
)-1, azArg
[1]);
3083 fprintf(stderr
, "Usage: .nullvalue STRING\n");
3088 if( c
=='o' && strncmp(azArg
[0], "open", n
)==0 && n
>=2 ){
3089 sqlite3
*savedDb
= p
->db
;
3090 const char *zSavedFilename
= p
->zDbFilename
;
3091 char *zNewFilename
= 0;
3094 p
->zDbFilename
= zNewFilename
= sqlite3_mprintf("%s", azArg
[1]);
3098 sqlite3_close(savedDb
);
3099 sqlite3_free(p
->zFreeOnClose
);
3100 p
->zFreeOnClose
= zNewFilename
;
3102 sqlite3_free(zNewFilename
);
3104 p
->zDbFilename
= zSavedFilename
;
3109 && (strncmp(azArg
[0], "output", n
)==0 || strncmp(azArg
[0], "once", n
)==0)
3111 const char *zFile
= nArg
>=2 ? azArg
[1] : "stdout";
3113 fprintf(stderr
, "Usage: .%s FILE\n", azArg
[0]);
3115 goto meta_command_exit
;
3117 if( n
>1 && strncmp(azArg
[0], "once", n
)==0 ){
3119 fprintf(stderr
, "Usage: .once FILE\n");
3121 goto meta_command_exit
;
3128 if( zFile
[0]=='|' ){
3129 p
->out
= popen(zFile
+ 1, "w");
3131 fprintf(stderr
,"Error: cannot open pipe \"%s\"\n", zFile
+ 1);
3135 sqlite3_snprintf(sizeof(p
->outfile
), p
->outfile
, "%s", zFile
);
3138 p
->out
= output_file_open(zFile
);
3140 if( strcmp(zFile
,"off")!=0 ){
3141 fprintf(stderr
,"Error: cannot write to \"%s\"\n", zFile
);
3146 sqlite3_snprintf(sizeof(p
->outfile
), p
->outfile
, "%s", zFile
);
3151 if( c
=='p' && n
>=3 && strncmp(azArg
[0], "print", n
)==0 ){
3153 for(i
=1; i
<nArg
; i
++){
3154 if( i
>1 ) fprintf(p
->out
, " ");
3155 fprintf(p
->out
, "%s", azArg
[i
]);
3157 fprintf(p
->out
, "\n");
3160 if( c
=='p' && strncmp(azArg
[0], "prompt", n
)==0 ){
3162 strncpy(mainPrompt
,azArg
[1],(int)ArraySize(mainPrompt
)-1);
3165 strncpy(continuePrompt
,azArg
[2],(int)ArraySize(continuePrompt
)-1);
3169 if( c
=='q' && strncmp(azArg
[0], "quit", n
)==0 ){
3173 if( c
=='r' && n
>=3 && strncmp(azArg
[0], "read", n
)==0 ){
3176 fprintf(stderr
, "Usage: .read FILE\n");
3178 goto meta_command_exit
;
3180 alt
= fopen(azArg
[1], "rb");
3182 fprintf(stderr
,"Error: cannot open \"%s\"\n", azArg
[1]);
3185 rc
= process_input(p
, alt
);
3190 if( c
=='r' && n
>=3 && strncmp(azArg
[0], "restore", n
)==0 ){
3191 const char *zSrcFile
;
3194 sqlite3_backup
*pBackup
;
3198 zSrcFile
= azArg
[1];
3200 }else if( nArg
==3 ){
3201 zSrcFile
= azArg
[2];
3204 fprintf(stderr
, "Usage: .restore ?DB? FILE\n");
3206 goto meta_command_exit
;
3208 rc
= sqlite3_open(zSrcFile
, &pSrc
);
3209 if( rc
!=SQLITE_OK
){
3210 fprintf(stderr
, "Error: cannot open \"%s\"\n", zSrcFile
);
3211 sqlite3_close(pSrc
);
3215 pBackup
= sqlite3_backup_init(p
->db
, zDb
, pSrc
, "main");
3217 fprintf(stderr
, "Error: %s\n", sqlite3_errmsg(p
->db
));
3218 sqlite3_close(pSrc
);
3221 while( (rc
= sqlite3_backup_step(pBackup
,100))==SQLITE_OK
3222 || rc
==SQLITE_BUSY
){
3223 if( rc
==SQLITE_BUSY
){
3224 if( nTimeout
++ >= 3 ) break;
3228 sqlite3_backup_finish(pBackup
);
3229 if( rc
==SQLITE_DONE
){
3231 }else if( rc
==SQLITE_BUSY
|| rc
==SQLITE_LOCKED
){
3232 fprintf(stderr
, "Error: source database is busy\n");
3235 fprintf(stderr
, "Error: %s\n", sqlite3_errmsg(p
->db
));
3238 sqlite3_close(pSrc
);
3242 if( c
=='s' && strncmp(azArg
[0], "scanstats", n
)==0 ){
3244 p
->scanstatsOn
= booleanValue(azArg
[1]);
3245 #ifndef SQLITE_ENABLE_STMT_SCANSTATUS
3246 fprintf(stderr
, "Warning: .scanstats not available in this build.\n");
3249 fprintf(stderr
, "Usage: .scanstats on|off\n");
3254 if( c
=='s' && strncmp(azArg
[0], "schema", n
)==0 ){
3258 memcpy(&data
, p
, sizeof(data
));
3259 data
.showHeader
= 0;
3260 data
.mode
= MODE_Semi
;
3263 for(i
=0; azArg
[1][i
]; i
++) azArg
[1][i
] = ToLower(azArg
[1][i
]);
3264 if( strcmp(azArg
[1],"sqlite_master")==0 ){
3265 char *new_argv
[2], *new_colv
[2];
3266 new_argv
[0] = "CREATE TABLE sqlite_master (\n"
3270 " rootpage integer,\n"
3274 new_colv
[0] = "sql";
3276 callback(&data
, 1, new_argv
, new_colv
);
3278 }else if( strcmp(azArg
[1],"sqlite_temp_master")==0 ){
3279 char *new_argv
[2], *new_colv
[2];
3280 new_argv
[0] = "CREATE TEMP TABLE sqlite_temp_master (\n"
3284 " rootpage integer,\n"
3288 new_colv
[0] = "sql";
3290 callback(&data
, 1, new_argv
, new_colv
);
3293 zShellStatic
= azArg
[1];
3294 rc
= sqlite3_exec(p
->db
,
3296 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
3297 " FROM sqlite_master UNION ALL"
3298 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
3299 "WHERE lower(tbl_name) LIKE shellstatic()"
3300 " AND type!='meta' AND sql NOTNULL "
3302 callback
, &data
, &zErrMsg
);
3305 }else if( nArg
==1 ){
3306 rc
= sqlite3_exec(p
->db
,
3308 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
3309 " FROM sqlite_master UNION ALL"
3310 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
3311 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
3313 callback
, &data
, &zErrMsg
3316 fprintf(stderr
, "Usage: .schema ?LIKE-PATTERN?\n");
3318 goto meta_command_exit
;
3321 fprintf(stderr
,"Error: %s\n", zErrMsg
);
3322 sqlite3_free(zErrMsg
);
3324 }else if( rc
!= SQLITE_OK
){
3325 fprintf(stderr
,"Error: querying schema information\n");
3333 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
3334 if( c
=='s' && n
==11 && strncmp(azArg
[0], "selecttrace", n
)==0 ){
3335 extern int sqlite3SelectTrace
;
3336 sqlite3SelectTrace
= nArg
>=2 ? booleanValue(azArg
[1]) : 0xff;
3342 /* Undocumented commands for internal testing. Subject to change
3343 ** without notice. */
3344 if( c
=='s' && n
>=10 && strncmp(azArg
[0], "selftest-", 9)==0 ){
3345 if( strncmp(azArg
[0]+9, "boolean", n
-9)==0 ){
3347 for(i
=1; i
<nArg
; i
++){
3348 v
= booleanValue(azArg
[i
]);
3349 fprintf(p
->out
, "%s: %d 0x%x\n", azArg
[i
], v
, v
);
3352 if( strncmp(azArg
[0]+9, "integer", n
-9)==0 ){
3353 int i
; sqlite3_int64 v
;
3354 for(i
=1; i
<nArg
; i
++){
3356 v
= integerValue(azArg
[i
]);
3357 sqlite3_snprintf(sizeof(zBuf
),zBuf
,"%s: %lld 0x%llx\n", azArg
[i
],v
,v
);
3358 fprintf(p
->out
, "%s", zBuf
);
3364 if( c
=='s' && strncmp(azArg
[0], "separator", n
)==0 ){
3365 if( nArg
<2 || nArg
>3 ){
3366 fprintf(stderr
, "Usage: .separator COL ?ROW?\n");
3370 sqlite3_snprintf(sizeof(p
->colSeparator
), p
->colSeparator
,
3371 "%.*s", (int)ArraySize(p
->colSeparator
)-1, azArg
[1]);
3374 sqlite3_snprintf(sizeof(p
->rowSeparator
), p
->rowSeparator
,
3375 "%.*s", (int)ArraySize(p
->rowSeparator
)-1, azArg
[2]);
3380 && (strncmp(azArg
[0], "shell", n
)==0 || strncmp(azArg
[0],"system",n
)==0)
3385 fprintf(stderr
, "Usage: .system COMMAND\n");
3387 goto meta_command_exit
;
3389 zCmd
= sqlite3_mprintf(strchr(azArg
[1],' ')==0?"%s":"\"%s\"", azArg
[1]);
3390 for(i
=2; i
<nArg
; i
++){
3391 zCmd
= sqlite3_mprintf(strchr(azArg
[i
],' ')==0?"%z %s":"%z \"%s\"",
3396 if( x
) fprintf(stderr
, "System command returns %d\n", x
);
3399 if( c
=='s' && strncmp(azArg
[0], "show", n
)==0 ){
3402 fprintf(stderr
, "Usage: .show\n");
3404 goto meta_command_exit
;
3406 fprintf(p
->out
,"%12.12s: %s\n","echo", p
->echoOn
? "on" : "off");
3407 fprintf(p
->out
,"%12.12s: %s\n","eqp", p
->autoEQP
? "on" : "off");
3408 fprintf(p
->out
,"%9.9s: %s\n","explain", p
->normalMode
.valid
? "on" :"off");
3409 fprintf(p
->out
,"%12.12s: %s\n","headers", p
->showHeader
? "on" : "off");
3410 fprintf(p
->out
,"%12.12s: %s\n","mode", modeDescr
[p
->mode
]);
3411 fprintf(p
->out
,"%12.12s: ", "nullvalue");
3412 output_c_string(p
->out
, p
->nullValue
);
3413 fprintf(p
->out
, "\n");
3414 fprintf(p
->out
,"%12.12s: %s\n","output",
3415 strlen30(p
->outfile
) ? p
->outfile
: "stdout");
3416 fprintf(p
->out
,"%12.12s: ", "colseparator");
3417 output_c_string(p
->out
, p
->colSeparator
);
3418 fprintf(p
->out
, "\n");
3419 fprintf(p
->out
,"%12.12s: ", "rowseparator");
3420 output_c_string(p
->out
, p
->rowSeparator
);
3421 fprintf(p
->out
, "\n");
3422 fprintf(p
->out
,"%12.12s: %s\n","stats", p
->statsOn
? "on" : "off");
3423 fprintf(p
->out
,"%12.12s: ","width");
3424 for (i
=0;i
<(int)ArraySize(p
->colWidth
) && p
->colWidth
[i
] != 0;i
++) {
3425 fprintf(p
->out
,"%d ",p
->colWidth
[i
]);
3427 fprintf(p
->out
,"\n");
3430 if( c
=='s' && strncmp(azArg
[0], "stats", n
)==0 ){
3432 p
->statsOn
= booleanValue(azArg
[1]);
3434 fprintf(stderr
, "Usage: .stats on|off\n");
3439 if( c
=='t' && n
>1 && strncmp(azArg
[0], "tables", n
)==0 ){
3440 sqlite3_stmt
*pStmt
;
3446 rc
= sqlite3_prepare_v2(p
->db
, "PRAGMA database_list", -1, &pStmt
, 0);
3448 zSql
= sqlite3_mprintf(
3449 "SELECT name FROM sqlite_master"
3450 " WHERE type IN ('table','view')"
3451 " AND name NOT LIKE 'sqlite_%%'"
3452 " AND name LIKE ?1");
3453 while( sqlite3_step(pStmt
)==SQLITE_ROW
){
3454 const char *zDbName
= (const char*)sqlite3_column_text(pStmt
, 1);
3455 if( zDbName
==0 || strcmp(zDbName
,"main")==0 ) continue;
3456 if( strcmp(zDbName
,"temp")==0 ){
3457 zSql
= sqlite3_mprintf(
3459 "SELECT 'temp.' || name FROM sqlite_temp_master"
3460 " WHERE type IN ('table','view')"
3461 " AND name NOT LIKE 'sqlite_%%'"
3462 " AND name LIKE ?1", zSql
);
3464 zSql
= sqlite3_mprintf(
3466 "SELECT '%q.' || name FROM \"%w\".sqlite_master"
3467 " WHERE type IN ('table','view')"
3468 " AND name NOT LIKE 'sqlite_%%'"
3469 " AND name LIKE ?1", zSql
, zDbName
, zDbName
);
3472 sqlite3_finalize(pStmt
);
3473 zSql
= sqlite3_mprintf("%z ORDER BY 1", zSql
);
3474 rc
= sqlite3_prepare_v2(p
->db
, zSql
, -1, &pStmt
, 0);
3480 sqlite3_bind_text(pStmt
, 1, azArg
[1], -1, SQLITE_TRANSIENT
);
3482 sqlite3_bind_text(pStmt
, 1, "%", -1, SQLITE_STATIC
);
3484 while( sqlite3_step(pStmt
)==SQLITE_ROW
){
3487 int n
= nAlloc
*2 + 10;
3488 azNew
= sqlite3_realloc(azResult
, sizeof(azResult
[0])*n
);
3490 fprintf(stderr
, "Error: out of memory\n");
3496 azResult
[nRow
] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt
, 0));
3497 if( azResult
[nRow
] ) nRow
++;
3499 sqlite3_finalize(pStmt
);
3501 int len
, maxlen
= 0;
3503 int nPrintCol
, nPrintRow
;
3504 for(i
=0; i
<nRow
; i
++){
3505 len
= strlen30(azResult
[i
]);
3506 if( len
>maxlen
) maxlen
= len
;
3508 nPrintCol
= 80/(maxlen
+2);
3509 if( nPrintCol
<1 ) nPrintCol
= 1;
3510 nPrintRow
= (nRow
+ nPrintCol
- 1)/nPrintCol
;
3511 for(i
=0; i
<nPrintRow
; i
++){
3512 for(j
=i
; j
<nRow
; j
+=nPrintRow
){
3513 char *zSp
= j
<nPrintRow
? "" : " ";
3514 fprintf(p
->out
, "%s%-*s", zSp
, maxlen
, azResult
[j
] ? azResult
[j
]:"");
3516 fprintf(p
->out
, "\n");
3519 for(ii
=0; ii
<nRow
; ii
++) sqlite3_free(azResult
[ii
]);
3520 sqlite3_free(azResult
);
3523 if( c
=='t' && n
>=8 && strncmp(azArg
[0], "testctrl", n
)==0 && nArg
>=2 ){
3524 static const struct {
3525 const char *zCtrlName
; /* Name of a test-control option */
3526 int ctrlCode
; /* Integer code for that option */
3528 { "prng_save", SQLITE_TESTCTRL_PRNG_SAVE
},
3529 { "prng_restore", SQLITE_TESTCTRL_PRNG_RESTORE
},
3530 { "prng_reset", SQLITE_TESTCTRL_PRNG_RESET
},
3531 { "bitvec_test", SQLITE_TESTCTRL_BITVEC_TEST
},
3532 { "fault_install", SQLITE_TESTCTRL_FAULT_INSTALL
},
3533 { "benign_malloc_hooks", SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS
},
3534 { "pending_byte", SQLITE_TESTCTRL_PENDING_BYTE
},
3535 { "assert", SQLITE_TESTCTRL_ASSERT
},
3536 { "always", SQLITE_TESTCTRL_ALWAYS
},
3537 { "reserve", SQLITE_TESTCTRL_RESERVE
},
3538 { "optimizations", SQLITE_TESTCTRL_OPTIMIZATIONS
},
3539 { "iskeyword", SQLITE_TESTCTRL_ISKEYWORD
},
3540 { "scratchmalloc", SQLITE_TESTCTRL_SCRATCHMALLOC
},
3541 { "byteorder", SQLITE_TESTCTRL_BYTEORDER
},
3548 /* convert testctrl text option to value. allow any unique prefix
3549 ** of the option name, or a numerical value. */
3550 n
= strlen30(azArg
[1]);
3551 for(i
=0; i
<(int)(sizeof(aCtrl
)/sizeof(aCtrl
[0])); i
++){
3552 if( strncmp(azArg
[1], aCtrl
[i
].zCtrlName
, n
)==0 ){
3554 testctrl
= aCtrl
[i
].ctrlCode
;
3556 fprintf(stderr
, "ambiguous option name: \"%s\"\n", azArg
[1]);
3562 if( testctrl
<0 ) testctrl
= (int)integerValue(azArg
[1]);
3563 if( (testctrl
<SQLITE_TESTCTRL_FIRST
) || (testctrl
>SQLITE_TESTCTRL_LAST
) ){
3564 fprintf(stderr
,"Error: invalid testctrl option: %s\n", azArg
[1]);
3568 /* sqlite3_test_control(int, db, int) */
3569 case SQLITE_TESTCTRL_OPTIMIZATIONS
:
3570 case SQLITE_TESTCTRL_RESERVE
:
3572 int opt
= (int)strtol(azArg
[2], 0, 0);
3573 rc
= sqlite3_test_control(testctrl
, p
->db
, opt
);
3574 fprintf(p
->out
, "%d (0x%08x)\n", rc
, rc
);
3576 fprintf(stderr
,"Error: testctrl %s takes a single int option\n",
3581 /* sqlite3_test_control(int) */
3582 case SQLITE_TESTCTRL_PRNG_SAVE
:
3583 case SQLITE_TESTCTRL_PRNG_RESTORE
:
3584 case SQLITE_TESTCTRL_PRNG_RESET
:
3585 case SQLITE_TESTCTRL_BYTEORDER
:
3587 rc
= sqlite3_test_control(testctrl
);
3588 fprintf(p
->out
, "%d (0x%08x)\n", rc
, rc
);
3590 fprintf(stderr
,"Error: testctrl %s takes no options\n", azArg
[1]);
3594 /* sqlite3_test_control(int, uint) */
3595 case SQLITE_TESTCTRL_PENDING_BYTE
:
3597 unsigned int opt
= (unsigned int)integerValue(azArg
[2]);
3598 rc
= sqlite3_test_control(testctrl
, opt
);
3599 fprintf(p
->out
, "%d (0x%08x)\n", rc
, rc
);
3601 fprintf(stderr
,"Error: testctrl %s takes a single unsigned"
3602 " int option\n", azArg
[1]);
3606 /* sqlite3_test_control(int, int) */
3607 case SQLITE_TESTCTRL_ASSERT
:
3608 case SQLITE_TESTCTRL_ALWAYS
:
3610 int opt
= booleanValue(azArg
[2]);
3611 rc
= sqlite3_test_control(testctrl
, opt
);
3612 fprintf(p
->out
, "%d (0x%08x)\n", rc
, rc
);
3614 fprintf(stderr
,"Error: testctrl %s takes a single int option\n",
3619 /* sqlite3_test_control(int, char *) */
3620 #ifdef SQLITE_N_KEYWORD
3621 case SQLITE_TESTCTRL_ISKEYWORD
:
3623 const char *opt
= azArg
[2];
3624 rc
= sqlite3_test_control(testctrl
, opt
);
3625 fprintf(p
->out
, "%d (0x%08x)\n", rc
, rc
);
3627 fprintf(stderr
,"Error: testctrl %s takes a single char * option\n",
3633 case SQLITE_TESTCTRL_BITVEC_TEST
:
3634 case SQLITE_TESTCTRL_FAULT_INSTALL
:
3635 case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS
:
3636 case SQLITE_TESTCTRL_SCRATCHMALLOC
:
3638 fprintf(stderr
,"Error: CLI support for testctrl %s not implemented\n",
3645 if( c
=='t' && n
>4 && strncmp(azArg
[0], "timeout", n
)==0 ){
3647 sqlite3_busy_timeout(p
->db
, nArg
>=2 ? (int)integerValue(azArg
[1]) : 0);
3650 if( c
=='t' && n
>=5 && strncmp(azArg
[0], "timer", n
)==0 ){
3652 enableTimer
= booleanValue(azArg
[1]);
3653 if( enableTimer
&& !HAS_TIMER
){
3654 fprintf(stderr
, "Error: timer not available on this system.\n");
3658 fprintf(stderr
, "Usage: .timer on|off\n");
3663 if( c
=='t' && strncmp(azArg
[0], "trace", n
)==0 ){
3665 output_file_close(p
->traceOut
);
3667 fprintf(stderr
, "Usage: .trace FILE|off\n");
3669 goto meta_command_exit
;
3671 p
->traceOut
= output_file_open(azArg
[1]);
3672 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)
3673 if( p
->traceOut
==0 ){
3674 sqlite3_trace(p
->db
, 0, 0);
3676 sqlite3_trace(p
->db
, sql_trace_callback
, p
->traceOut
);
3681 #if SQLITE_USER_AUTHENTICATION
3682 if( c
=='u' && strncmp(azArg
[0], "user", n
)==0 ){
3684 fprintf(stderr
, "Usage: .user SUBCOMMAND ...\n");
3686 goto meta_command_exit
;
3689 if( strcmp(azArg
[1],"login")==0 ){
3691 fprintf(stderr
, "Usage: .user login USER PASSWORD\n");
3693 goto meta_command_exit
;
3695 rc
= sqlite3_user_authenticate(p
->db
, azArg
[2], azArg
[3],
3696 (int)strlen(azArg
[3]));
3698 fprintf(stderr
, "Authentication failed for user %s\n", azArg
[2]);
3701 }else if( strcmp(azArg
[1],"add")==0 ){
3703 fprintf(stderr
, "Usage: .user add USER PASSWORD ISADMIN\n");
3705 goto meta_command_exit
;
3707 rc
= sqlite3_user_add(p
->db
, azArg
[2],
3708 azArg
[3], (int)strlen(azArg
[3]),
3709 booleanValue(azArg
[4]));
3711 fprintf(stderr
, "User-Add failed: %d\n", rc
);
3714 }else if( strcmp(azArg
[1],"edit")==0 ){
3716 fprintf(stderr
, "Usage: .user edit USER PASSWORD ISADMIN\n");
3718 goto meta_command_exit
;
3720 rc
= sqlite3_user_change(p
->db
, azArg
[2],
3721 azArg
[3], (int)strlen(azArg
[3]),
3722 booleanValue(azArg
[4]));
3724 fprintf(stderr
, "User-Edit failed: %d\n", rc
);
3727 }else if( strcmp(azArg
[1],"delete")==0 ){
3729 fprintf(stderr
, "Usage: .user delete USER\n");
3731 goto meta_command_exit
;
3733 rc
= sqlite3_user_delete(p
->db
, azArg
[2]);
3735 fprintf(stderr
, "User-Delete failed: %d\n", rc
);
3739 fprintf(stderr
, "Usage: .user login|add|edit|delete ...\n");
3741 goto meta_command_exit
;
3744 #endif /* SQLITE_USER_AUTHENTICATION */
3746 if( c
=='v' && strncmp(azArg
[0], "version", n
)==0 ){
3747 fprintf(p
->out
, "SQLite %s %s\n" /*extra-version-info*/,
3748 sqlite3_libversion(), sqlite3_sourceid());
3751 if( c
=='v' && strncmp(azArg
[0], "vfsname", n
)==0 ){
3752 const char *zDbName
= nArg
==2 ? azArg
[1] : "main";
3755 sqlite3_file_control(p
->db
, zDbName
, SQLITE_FCNTL_VFSNAME
, &zVfsName
);
3757 fprintf(p
->out
, "%s\n", zVfsName
);
3758 sqlite3_free(zVfsName
);
3763 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
3764 if( c
=='w' && strncmp(azArg
[0], "wheretrace", n
)==0 ){
3765 extern int sqlite3WhereTrace
;
3766 sqlite3WhereTrace
= nArg
>=2 ? booleanValue(azArg
[1]) : 0xff;
3770 if( c
=='w' && strncmp(azArg
[0], "width", n
)==0 ){
3772 assert( nArg
<=ArraySize(azArg
) );
3773 for(j
=1; j
<nArg
&& j
<ArraySize(p
->colWidth
); j
++){
3774 p
->colWidth
[j
-1] = (int)integerValue(azArg
[j
]);
3779 fprintf(stderr
, "Error: unknown command or invalid arguments: "
3780 " \"%s\". Enter \".help\" for help\n", azArg
[0]);
3787 if( p
->outCount
==0 ) output_reset(p
);
3793 ** Return TRUE if a semicolon occurs anywhere in the first N characters
3796 static int line_contains_semicolon(const char *z
, int N
){
3798 for(i
=0; i
<N
; i
++){ if( z
[i
]==';' ) return 1; }
3803 ** Test to see if a line consists entirely of whitespace.
3805 static int _all_whitespace(const char *z
){
3807 if( IsSpace(z
[0]) ) continue;
3808 if( *z
=='/' && z
[1]=='*' ){
3810 while( *z
&& (*z
!='*' || z
[1]!='/') ){ z
++; }
3811 if( *z
==0 ) return 0;
3815 if( *z
=='-' && z
[1]=='-' ){
3817 while( *z
&& *z
!='\n' ){ z
++; }
3818 if( *z
==0 ) return 1;
3827 ** Return TRUE if the line typed in is an SQL command terminator other
3828 ** than a semi-colon. The SQL Server style "go" command is understood
3829 ** as is the Oracle "/".
3831 static int line_is_command_terminator(const char *zLine
){
3832 while( IsSpace(zLine
[0]) ){ zLine
++; };
3833 if( zLine
[0]=='/' && _all_whitespace(&zLine
[1]) ){
3834 return 1; /* Oracle */
3836 if( ToLower(zLine
[0])=='g' && ToLower(zLine
[1])=='o'
3837 && _all_whitespace(&zLine
[2]) ){
3838 return 1; /* SQL Server */
3844 ** Return true if zSql is a complete SQL statement. Return false if it
3845 ** ends in the middle of a string literal or C-style comment.
3847 static int line_is_complete(char *zSql
, int nSql
){
3849 if( zSql
==0 ) return 1;
3852 rc
= sqlite3_complete(zSql
);
3858 ** Read input from *in and process it. If *in==0 then input
3859 ** is interactive - the user is typing it it. Otherwise, input
3860 ** is coming from a file or device. A prompt is issued and history
3861 ** is saved only if input is interactive. An interrupt signal will
3862 ** cause this routine to exit immediately, unless input is interactive.
3864 ** Return the number of errors.
3866 static int process_input(ShellState
*p
, FILE *in
){
3867 char *zLine
= 0; /* A single input line */
3868 char *zSql
= 0; /* Accumulated SQL text */
3869 int nLine
; /* Length of current line */
3870 int nSql
= 0; /* Bytes of zSql[] used */
3871 int nAlloc
= 0; /* Allocated zSql[] space */
3872 int nSqlPrior
= 0; /* Bytes of zSql[] used by prior line */
3873 char *zErrMsg
; /* Error message returned */
3874 int rc
; /* Error code */
3875 int errCnt
= 0; /* Number of errors seen */
3876 int lineno
= 0; /* Current line number */
3877 int startline
= 0; /* Line number for start of current input */
3879 while( errCnt
==0 || !bail_on_error
|| (in
==0 && stdin_is_interactive
) ){
3881 zLine
= one_input_line(in
, zLine
, nSql
>0);
3884 if( stdin_is_interactive
) printf("\n");
3887 if( seenInterrupt
){
3892 if( nSql
==0 && _all_whitespace(zLine
) ){
3893 if( p
->echoOn
) printf("%s\n", zLine
);
3896 if( zLine
&& zLine
[0]=='.' && nSql
==0 ){
3897 if( p
->echoOn
) printf("%s\n", zLine
);
3898 rc
= do_meta_command(zLine
, p
);
3899 if( rc
==2 ){ /* exit requested */
3906 if( line_is_command_terminator(zLine
) && line_is_complete(zSql
, nSql
) ){
3907 memcpy(zLine
,";",2);
3909 nLine
= strlen30(zLine
);
3910 if( nSql
+nLine
+2>=nAlloc
){
3911 nAlloc
= nSql
+nLine
+100;
3912 zSql
= realloc(zSql
, nAlloc
);
3914 fprintf(stderr
, "Error: out of memory\n");
3921 for(i
=0; zLine
[i
] && IsSpace(zLine
[i
]); i
++){}
3922 assert( nAlloc
>0 && zSql
!=0 );
3923 memcpy(zSql
, zLine
+i
, nLine
+1-i
);
3927 zSql
[nSql
++] = '\n';
3928 memcpy(zSql
+nSql
, zLine
, nLine
+1);
3931 if( nSql
&& line_contains_semicolon(&zSql
[nSqlPrior
], nSql
-nSqlPrior
)
3932 && sqlite3_complete(zSql
) ){
3936 rc
= shell_exec(p
->db
, zSql
, shell_callback
, p
, &zErrMsg
);
3938 if( rc
|| zErrMsg
){
3940 if( in
!=0 || !stdin_is_interactive
){
3941 sqlite3_snprintf(sizeof(zPrefix
), zPrefix
,
3942 "Error: near line %d:", startline
);
3944 sqlite3_snprintf(sizeof(zPrefix
), zPrefix
, "Error:");
3947 fprintf(stderr
, "%s %s\n", zPrefix
, zErrMsg
);
3948 sqlite3_free(zErrMsg
);
3951 fprintf(stderr
, "%s %s\n", zPrefix
, sqlite3_errmsg(p
->db
));
3960 }else if( nSql
&& _all_whitespace(zSql
) ){
3961 if( p
->echoOn
) printf("%s\n", zSql
);
3966 if( !_all_whitespace(zSql
) ){
3967 fprintf(stderr
, "Error: incomplete SQL: %s\n", zSql
);
3977 ** Return a pathname which is the user's home directory. A
3978 ** 0 return indicates an error of some kind.
3980 static char *find_home_dir(void){
3981 static char *home_dir
= NULL
;
3982 if( home_dir
) return home_dir
;
3984 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) \
3985 && !defined(__RTP__) && !defined(_WRS_KERNEL)
3987 struct passwd
*pwent
;
3988 uid_t uid
= getuid();
3989 if( (pwent
=getpwuid(uid
)) != NULL
) {
3990 home_dir
= pwent
->pw_dir
;
3995 #if defined(_WIN32_WCE)
3996 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
4001 #if defined(_WIN32) || defined(WIN32)
4003 home_dir
= getenv("USERPROFILE");
4008 home_dir
= getenv("HOME");
4011 #if defined(_WIN32) || defined(WIN32)
4013 char *zDrive
, *zPath
;
4015 zDrive
= getenv("HOMEDRIVE");
4016 zPath
= getenv("HOMEPATH");
4017 if( zDrive
&& zPath
){
4018 n
= strlen30(zDrive
) + strlen30(zPath
) + 1;
4019 home_dir
= malloc( n
);
4020 if( home_dir
==0 ) return 0;
4021 sqlite3_snprintf(n
, home_dir
, "%s%s", zDrive
, zPath
);
4028 #endif /* !_WIN32_WCE */
4031 int n
= strlen30(home_dir
) + 1;
4032 char *z
= malloc( n
);
4033 if( z
) memcpy(z
, home_dir
, n
);
4041 ** Read input from the file given by sqliterc_override. Or if that
4042 ** parameter is NULL, take input from ~/.sqliterc
4044 ** Returns the number of errors.
4046 static int process_sqliterc(
4047 ShellState
*p
, /* Configuration data */
4048 const char *sqliterc_override
/* Name of config file. NULL to use default */
4050 char *home_dir
= NULL
;
4051 const char *sqliterc
= sqliterc_override
;
4056 if (sqliterc
== NULL
) {
4057 home_dir
= find_home_dir();
4059 #if !defined(__RTP__) && !defined(_WRS_KERNEL)
4060 fprintf(stderr
,"%s: Error: cannot locate your home directory\n", Argv0
);
4064 sqlite3_initialize();
4065 zBuf
= sqlite3_mprintf("%s/.sqliterc",home_dir
);
4068 in
= fopen(sqliterc
,"rb");
4070 if( stdin_is_interactive
){
4071 fprintf(stderr
,"-- Loading resources from %s\n",sqliterc
);
4073 rc
= process_input(p
,in
);
4081 ** Show available command line options
4083 static const char zOptions
[] =
4084 " -ascii set output mode to 'ascii'\n"
4085 " -bail stop after hitting an error\n"
4086 " -batch force batch I/O\n"
4087 " -column set output mode to 'column'\n"
4088 " -cmd COMMAND run \"COMMAND\" before reading stdin\n"
4089 " -csv set output mode to 'csv'\n"
4090 " -echo print commands before execution\n"
4091 " -init FILENAME read/process named file\n"
4092 " -[no]header turn headers on or off\n"
4093 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
4094 " -heap SIZE Size of heap for memsys3 or memsys5\n"
4096 " -help show this message\n"
4097 " -html set output mode to HTML\n"
4098 " -interactive force interactive I/O\n"
4099 " -line set output mode to 'line'\n"
4100 " -list set output mode to 'list'\n"
4101 " -lookaside SIZE N use N entries of SZ bytes for lookaside memory\n"
4102 " -mmap N default mmap size set to N\n"
4103 #ifdef SQLITE_ENABLE_MULTIPLEX
4104 " -multiplex enable the multiplexor VFS\n"
4106 " -newline SEP set output row separator. Default: '\\n'\n"
4107 " -nullvalue TEXT set text string for NULL values. Default ''\n"
4108 " -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n"
4109 " -scratch SIZE N use N slots of SZ bytes each for scratch memory\n"
4110 " -separator SEP set output column separator. Default: '|'\n"
4111 " -stats print memory stats before each finalize\n"
4112 " -version show SQLite version\n"
4113 " -vfs NAME use NAME as the default VFS\n"
4114 #ifdef SQLITE_ENABLE_VFSTRACE
4115 " -vfstrace enable tracing of all VFS calls\n"
4118 static void usage(int showDetail
){
4120 "Usage: %s [OPTIONS] FILENAME [SQL]\n"
4121 "FILENAME is the name of an SQLite database. A new database is created\n"
4122 "if the file does not previously exist.\n", Argv0
);
4124 fprintf(stderr
, "OPTIONS include:\n%s", zOptions
);
4126 fprintf(stderr
, "Use the -help option for additional information\n");
4132 ** Initialize the state information in data
4134 static void main_init(ShellState
*data
) {
4135 memset(data
, 0, sizeof(*data
));
4136 data
->mode
= MODE_List
;
4137 memcpy(data
->colSeparator
,SEP_Column
, 2);
4138 memcpy(data
->rowSeparator
,SEP_Row
, 2);
4139 data
->showHeader
= 0;
4140 data
->shellFlgs
= SHFLG_Lookaside
;
4141 sqlite3_config(SQLITE_CONFIG_URI
, 1);
4142 sqlite3_config(SQLITE_CONFIG_LOG
, shellLog
, data
);
4143 sqlite3_config(SQLITE_CONFIG_MULTITHREAD
);
4144 sqlite3_snprintf(sizeof(mainPrompt
), mainPrompt
,"sqlite> ");
4145 sqlite3_snprintf(sizeof(continuePrompt
), continuePrompt
," ...> ");
4149 ** Output text to the console in a font that attracts extra attention.
4152 static void printBold(const char *zText
){
4153 HANDLE out
= GetStdHandle(STD_OUTPUT_HANDLE
);
4154 CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo
;
4155 GetConsoleScreenBufferInfo(out
, &defaultScreenInfo
);
4156 SetConsoleTextAttribute(out
,
4157 FOREGROUND_RED
|FOREGROUND_INTENSITY
4159 printf("%s", zText
);
4160 SetConsoleTextAttribute(out
, defaultScreenInfo
.wAttributes
);
4163 static void printBold(const char *zText
){
4164 printf("\033[1m%s\033[0m", zText
);
4169 ** Get the argument to an --option. Throw an error and die if no argument
4172 static char *cmdline_option_value(int argc
, char **argv
, int i
){
4174 fprintf(stderr
, "%s: Error: missing argument to %s\n",
4175 argv
[0], argv
[argc
-1]);
4181 int main(int argc
, char **argv
){
4184 const char *zInitFile
= 0;
4187 int warnInmemoryDb
= 0;
4192 #if USE_SYSTEM_SQLITE+0!=1
4193 if( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID
)!=0 ){
4194 fprintf(stderr
, "SQLite header and source version mismatch\n%s\n%s\n",
4195 sqlite3_sourceid(), SQLITE_SOURCE_ID
);
4201 stdin_is_interactive
= isatty(0);
4203 /* Make sure we have a valid signal handler early, before anything
4207 signal(SIGINT
, interrupt_handler
);
4210 #ifdef SQLITE_SHELL_DBNAME_PROC
4212 /* If the SQLITE_SHELL_DBNAME_PROC macro is defined, then it is the name
4213 ** of a C-function that will provide the name of the database file. Use
4214 ** this compile-time option to embed this shell program in larger
4216 extern void SQLITE_SHELL_DBNAME_PROC(const char**);
4217 SQLITE_SHELL_DBNAME_PROC(&data
.zDbFilename
);
4222 /* Do an initial pass through the command-line argument to locate
4223 ** the name of the database file, the name of the initialization file,
4224 ** the size of the alternative malloc heap,
4225 ** and the first command to execute.
4227 for(i
=1; i
<argc
; i
++){
4231 if( data
.zDbFilename
==0 ){
4232 data
.zDbFilename
= z
;
4234 /* Excesss arguments are interpreted as SQL (or dot-commands) and
4235 ** mean that nothing is read from stdin */
4238 azCmd
= realloc(azCmd
, sizeof(azCmd
[0])*nCmd
);
4240 fprintf(stderr
, "out of memory\n");
4246 if( z
[1]=='-' ) z
++;
4247 if( strcmp(z
,"-separator")==0
4248 || strcmp(z
,"-nullvalue")==0
4249 || strcmp(z
,"-newline")==0
4250 || strcmp(z
,"-cmd")==0
4252 (void)cmdline_option_value(argc
, argv
, ++i
);
4253 }else if( strcmp(z
,"-init")==0 ){
4254 zInitFile
= cmdline_option_value(argc
, argv
, ++i
);
4255 }else if( strcmp(z
,"-batch")==0 ){
4256 /* Need to check for batch mode here to so we can avoid printing
4257 ** informational messages (like from process_sqliterc) before
4258 ** we do the actual processing of arguments later in a second pass.
4260 stdin_is_interactive
= 0;
4261 }else if( strcmp(z
,"-heap")==0 ){
4262 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
4264 sqlite3_int64 szHeap
;
4266 zSize
= cmdline_option_value(argc
, argv
, ++i
);
4267 szHeap
= integerValue(zSize
);
4268 if( szHeap
>0x7fff0000 ) szHeap
= 0x7fff0000;
4269 sqlite3_config(SQLITE_CONFIG_HEAP
, malloc((int)szHeap
), (int)szHeap
, 64);
4271 }else if( strcmp(z
,"-scratch")==0 ){
4273 sz
= (int)integerValue(cmdline_option_value(argc
,argv
,++i
));
4274 if( sz
>400000 ) sz
= 400000;
4275 if( sz
<2500 ) sz
= 2500;
4276 n
= (int)integerValue(cmdline_option_value(argc
,argv
,++i
));
4279 sqlite3_config(SQLITE_CONFIG_SCRATCH
, malloc(n
*sz
+1), sz
, n
);
4280 data
.shellFlgs
|= SHFLG_Scratch
;
4281 }else if( strcmp(z
,"-pagecache")==0 ){
4283 sz
= (int)integerValue(cmdline_option_value(argc
,argv
,++i
));
4284 if( sz
>70000 ) sz
= 70000;
4285 if( sz
<800 ) sz
= 800;
4286 n
= (int)integerValue(cmdline_option_value(argc
,argv
,++i
));
4288 sqlite3_config(SQLITE_CONFIG_PAGECACHE
, malloc(n
*sz
+1), sz
, n
);
4289 data
.shellFlgs
|= SHFLG_Pagecache
;
4290 }else if( strcmp(z
,"-lookaside")==0 ){
4292 sz
= (int)integerValue(cmdline_option_value(argc
,argv
,++i
));
4294 n
= (int)integerValue(cmdline_option_value(argc
,argv
,++i
));
4296 sqlite3_config(SQLITE_CONFIG_LOOKASIDE
, sz
, n
);
4297 if( sz
*n
==0 ) data
.shellFlgs
&= ~SHFLG_Lookaside
;
4298 #ifdef SQLITE_ENABLE_VFSTRACE
4299 }else if( strcmp(z
,"-vfstrace")==0 ){
4300 extern int vfstrace_register(
4301 const char *zTraceName
,
4302 const char *zOldVfsName
,
4303 int (*xOut
)(const char*,void*),
4307 vfstrace_register("trace",0,(int(*)(const char*,void*))fputs
,stderr
,1);
4309 #ifdef SQLITE_ENABLE_MULTIPLEX
4310 }else if( strcmp(z
,"-multiplex")==0 ){
4311 extern int sqlite3_multiple_initialize(const char*,int);
4312 sqlite3_multiplex_initialize(0, 1);
4314 }else if( strcmp(z
,"-mmap")==0 ){
4315 sqlite3_int64 sz
= integerValue(cmdline_option_value(argc
,argv
,++i
));
4316 sqlite3_config(SQLITE_CONFIG_MMAP_SIZE
, sz
, sz
);
4317 }else if( strcmp(z
,"-vfs")==0 ){
4318 sqlite3_vfs
*pVfs
= sqlite3_vfs_find(cmdline_option_value(argc
,argv
,++i
));
4320 sqlite3_vfs_register(pVfs
, 1);
4322 fprintf(stderr
, "no such VFS: \"%s\"\n", argv
[i
]);
4327 if( data
.zDbFilename
==0 ){
4328 #ifndef SQLITE_OMIT_MEMORYDB
4329 data
.zDbFilename
= ":memory:";
4330 warnInmemoryDb
= argc
==1;
4332 fprintf(stderr
,"%s: Error: no database filename specified\n", Argv0
);
4338 /* Go ahead and open the database file if it already exists. If the
4339 ** file does not exist, delay opening it. This prevents empty database
4340 ** files from being created if a user mistypes the database name argument
4341 ** to the sqlite command-line tool.
4343 if( access(data
.zDbFilename
, 0)==0 ){
4347 /* Process the initialization file if there is one. If no -init option
4348 ** is given on the command line, look for a file named ~/.sqliterc and
4349 ** try to process it.
4351 rc
= process_sqliterc(&data
,zInitFile
);
4356 /* Make a second pass through the command-line argument and set
4357 ** options. This second pass is delayed until after the initialization
4358 ** file is processed so that the command-line arguments will override
4359 ** settings in the initialization file.
4361 for(i
=1; i
<argc
; i
++){
4363 if( z
[0]!='-' ) continue;
4364 if( z
[1]=='-' ){ z
++; }
4365 if( strcmp(z
,"-init")==0 ){
4367 }else if( strcmp(z
,"-html")==0 ){
4368 data
.mode
= MODE_Html
;
4369 }else if( strcmp(z
,"-list")==0 ){
4370 data
.mode
= MODE_List
;
4371 }else if( strcmp(z
,"-line")==0 ){
4372 data
.mode
= MODE_Line
;
4373 }else if( strcmp(z
,"-column")==0 ){
4374 data
.mode
= MODE_Column
;
4375 }else if( strcmp(z
,"-csv")==0 ){
4376 data
.mode
= MODE_Csv
;
4377 memcpy(data
.colSeparator
,",",2);
4378 }else if( strcmp(z
,"-ascii")==0 ){
4379 data
.mode
= MODE_Ascii
;
4380 sqlite3_snprintf(sizeof(data
.colSeparator
), data
.colSeparator
,
4382 sqlite3_snprintf(sizeof(data
.rowSeparator
), data
.rowSeparator
,
4384 }else if( strcmp(z
,"-separator")==0 ){
4385 sqlite3_snprintf(sizeof(data
.colSeparator
), data
.colSeparator
,
4386 "%s",cmdline_option_value(argc
,argv
,++i
));
4387 }else if( strcmp(z
,"-newline")==0 ){
4388 sqlite3_snprintf(sizeof(data
.rowSeparator
), data
.rowSeparator
,
4389 "%s",cmdline_option_value(argc
,argv
,++i
));
4390 }else if( strcmp(z
,"-nullvalue")==0 ){
4391 sqlite3_snprintf(sizeof(data
.nullValue
), data
.nullValue
,
4392 "%s",cmdline_option_value(argc
,argv
,++i
));
4393 }else if( strcmp(z
,"-header")==0 ){
4394 data
.showHeader
= 1;
4395 }else if( strcmp(z
,"-noheader")==0 ){
4396 data
.showHeader
= 0;
4397 }else if( strcmp(z
,"-echo")==0 ){
4399 }else if( strcmp(z
,"-eqp")==0 ){
4401 }else if( strcmp(z
,"-stats")==0 ){
4403 }else if( strcmp(z
,"-scanstats")==0 ){
4404 data
.scanstatsOn
= 1;
4405 }else if( strcmp(z
,"-bail")==0 ){
4407 }else if( strcmp(z
,"-version")==0 ){
4408 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
4410 }else if( strcmp(z
,"-interactive")==0 ){
4411 stdin_is_interactive
= 1;
4412 }else if( strcmp(z
,"-batch")==0 ){
4413 stdin_is_interactive
= 0;
4414 }else if( strcmp(z
,"-heap")==0 ){
4416 }else if( strcmp(z
,"-scratch")==0 ){
4418 }else if( strcmp(z
,"-pagecache")==0 ){
4420 }else if( strcmp(z
,"-lookaside")==0 ){
4422 }else if( strcmp(z
,"-mmap")==0 ){
4424 }else if( strcmp(z
,"-vfs")==0 ){
4426 #ifdef SQLITE_ENABLE_VFSTRACE
4427 }else if( strcmp(z
,"-vfstrace")==0 ){
4430 #ifdef SQLITE_ENABLE_MULTIPLEX
4431 }else if( strcmp(z
,"-multiplex")==0 ){
4434 }else if( strcmp(z
,"-help")==0 ){
4436 }else if( strcmp(z
,"-cmd")==0 ){
4437 /* Run commands that follow -cmd first and separately from commands
4438 ** that simply appear on the command-line. This seems goofy. It would
4439 ** be better if all commands ran in the order that they appear. But
4440 ** we retain the goofy behavior for historical compatibility. */
4441 if( i
==argc
-1 ) break;
4442 z
= cmdline_option_value(argc
,argv
,++i
);
4444 rc
= do_meta_command(z
, &data
);
4445 if( rc
&& bail_on_error
) return rc
==2 ? 0 : rc
;
4448 rc
= shell_exec(data
.db
, z
, shell_callback
, &data
, &zErrMsg
);
4450 fprintf(stderr
,"Error: %s\n", zErrMsg
);
4451 if( bail_on_error
) return rc
!=0 ? rc
: 1;
4453 fprintf(stderr
,"Error: unable to process SQL \"%s\"\n", z
);
4454 if( bail_on_error
) return rc
;
4458 fprintf(stderr
,"%s: Error: unknown option: %s\n", Argv0
, z
);
4459 fprintf(stderr
,"Use -help for a list of options.\n");
4465 /* Run all arguments that do not begin with '-' as if they were separate
4466 ** command-line inputs, except for the argToSkip argument which contains
4467 ** the database filename.
4469 for(i
=0; i
<nCmd
; i
++){
4470 if( azCmd
[i
][0]=='.' ){
4471 rc
= do_meta_command(azCmd
[i
], &data
);
4472 if( rc
) return rc
==2 ? 0 : rc
;
4475 rc
= shell_exec(data
.db
, azCmd
[i
], shell_callback
, &data
, &zErrMsg
);
4477 fprintf(stderr
,"Error: %s\n", zErrMsg
);
4478 return rc
!=0 ? rc
: 1;
4480 fprintf(stderr
,"Error: unable to process SQL: %s\n", azCmd
[i
]);
4487 /* Run commands received from standard input
4489 if( stdin_is_interactive
){
4494 "SQLite version %s %.19s\n" /*extra-version-info*/
4495 "Enter \".help\" for usage hints.\n",
4496 sqlite3_libversion(), sqlite3_sourceid()
4498 if( warnInmemoryDb
){
4499 printf("Connected to a ");
4500 printBold("transient in-memory database");
4501 printf(".\nUse \".open FILENAME\" to reopen on a "
4502 "persistent database.\n");
4504 zHome
= find_home_dir();
4506 nHistory
= strlen30(zHome
) + 20;
4507 if( (zHistory
= malloc(nHistory
))!=0 ){
4508 sqlite3_snprintf(nHistory
, zHistory
,"%s/.sqlite_history", zHome
);
4511 if( zHistory
) shell_read_history(zHistory
);
4512 rc
= process_input(&data
, 0);
4514 shell_stifle_history(100);
4515 shell_write_history(zHistory
);
4519 rc
= process_input(&data
, stdin
);
4522 set_table_name(&data
, 0);
4524 sqlite3_close(data
.db
);
4526 sqlite3_free(data
.zFreeOnClose
);