blob: 8341d828c1fef80a660a5cedf50a1b4fd771263c [file] [log] [blame]
drh75897232000-05-29 14:26:00 +00001/*
drhb19a2bc2001-09-16 00:13:26 +00002** 2001 September 15
drh75897232000-05-29 14:26:00 +00003**
drhb19a2bc2001-09-16 00:13:26 +00004** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
drh75897232000-05-29 14:26:00 +00006**
drhb19a2bc2001-09-16 00:13:26 +00007** 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.
drh75897232000-05-29 14:26:00 +000010**
11*************************************************************************
12** This file contains code to implement the "sqlite" command line
13** utility for accessing SQLite databases.
drh75897232000-05-29 14:26:00 +000014*/
mistachkina3b2ff52011-09-16 20:16:36 +000015#if (defined(_WIN32) || defined(WIN32)) && !defined(_CRT_SECURE_NO_WARNINGS)
shane18e526c2008-12-10 22:30:24 +000016/* This needs to come before any includes for MSVC compiler */
17#define _CRT_SECURE_NO_WARNINGS
18#endif
19
drh36f7dd32011-10-13 16:02:17 +000020/*
mistachkin2318d332015-01-12 18:02:52 +000021** If requested, include the SQLite compiler options file for MSVC.
22*/
23#if defined(INCLUDE_MSVC_H)
24#include "msvc.h"
25#endif
26
27/*
drh8cd5b252015-03-02 22:06:43 +000028** No support for loadable extensions in VxWorks.
29*/
drhada3f2b2015-03-23 21:32:50 +000030#if (defined(__RTP__) || defined(_WRS_KERNEL)) && !SQLITE_OMIT_LOAD_EXTENSION
drh8cd5b252015-03-02 22:06:43 +000031# define SQLITE_OMIT_LOAD_EXTENSION 1
32#endif
33
34/*
drh36f7dd32011-10-13 16:02:17 +000035** Enable large-file support for fopen() and friends on unix.
36*/
37#ifndef SQLITE_DISABLE_LFS
38# define _LARGE_FILE 1
39# ifndef _FILE_OFFSET_BITS
40# define _FILE_OFFSET_BITS 64
41# endif
42# define _LARGEFILE_SOURCE 1
43#endif
44
drh75897232000-05-29 14:26:00 +000045#include <stdlib.h>
46#include <string.h>
47#include <stdio.h>
danielk19772a02e332004-06-05 08:04:36 +000048#include <assert.h>
drh1d482dd2004-05-31 18:23:07 +000049#include "sqlite3.h"
drhf442e332014-09-10 19:01:14 +000050#if SQLITE_USER_AUTHENTICATION
51# include "sqlite3userauth.h"
52#endif
drh75897232000-05-29 14:26:00 +000053#include <ctype.h>
drhb0603412007-02-28 04:47:26 +000054#include <stdarg.h>
persicom7e2dfdd2002-04-18 02:46:52 +000055
drh83905c92012-06-21 13:00:37 +000056#if !defined(_WIN32) && !defined(WIN32)
drh4c504392000-10-16 22:06:40 +000057# include <signal.h>
chw97185482008-11-17 08:05:31 +000058# if !defined(__RTP__) && !defined(_WRS_KERNEL)
59# include <pwd.h>
60# endif
drhdd45df82002-04-18 12:39:03 +000061# include <unistd.h>
62# include <sys/types.h>
drh4c504392000-10-16 22:06:40 +000063#endif
drh75897232000-05-29 14:26:00 +000064
drh0ede9eb2015-01-10 16:49:23 +000065#if HAVE_READLINE
drh8e7e7a22000-05-30 18:45:23 +000066# include <readline/readline.h>
67# include <readline/history.h>
drh81d7fd12010-12-08 00:02:26 +000068#endif
danfd34d6d2015-02-25 10:54:53 +000069
drh0ede9eb2015-01-10 16:49:23 +000070#if HAVE_EDITLINE
drhaaa21b42014-02-11 14:37:51 +000071# include <editline/readline.h>
72#endif
danfd34d6d2015-02-25 10:54:53 +000073
74#if HAVE_EDITLINE || HAVE_READLINE
75
76# define shell_add_history(X) add_history(X)
77# define shell_read_history(X) read_history(X)
78# define shell_write_history(X) write_history(X)
79# define shell_stifle_history(X) stifle_history(X)
80# define shell_readline(X) readline(X)
81
82#elif HAVE_LINENOISE
83
84# include "linenoise.h"
85# define shell_add_history(X) linenoiseHistoryAdd(X)
86# define shell_read_history(X) linenoiseHistoryLoad(X)
87# define shell_write_history(X) linenoiseHistorySave(X)
88# define shell_stifle_history(X) linenoiseHistorySetMaxLen(X)
89# define shell_readline(X) linenoise(X)
90
91#else
92
mistachkin1fe36bb2016-04-04 02:16:44 +000093# define shell_read_history(X)
danfd34d6d2015-02-25 10:54:53 +000094# define shell_write_history(X)
95# define shell_stifle_history(X)
96
97# define SHELL_USE_LOCAL_GETLINE 1
drh75897232000-05-29 14:26:00 +000098#endif
99
danfd34d6d2015-02-25 10:54:53 +0000100
adamd2e8464a2006-09-06 21:39:40 +0000101#if defined(_WIN32) || defined(WIN32)
102# include <io.h>
drh6976c212014-07-24 12:09:47 +0000103# include <fcntl.h>
mistachkin073664d2015-06-17 18:57:37 +0000104# define isatty(h) _isatty(h)
105# ifndef access
106# define access(f,m) _access((f),(m))
107# endif
108# undef popen
109# define popen _popen
110# undef pclose
111# define pclose _pclose
adamd2e8464a2006-09-06 21:39:40 +0000112#else
mistachkin073664d2015-06-17 18:57:37 +0000113 /* Make sure isatty() has a prototype. */
114 extern int isatty(int);
drh4328c8b2003-04-26 02:50:11 +0000115
mistachkin073664d2015-06-17 18:57:37 +0000116# if !defined(__RTP__) && !defined(_WRS_KERNEL)
117 /* popen and pclose are not C89 functions and so are
118 ** sometimes omitted from the <stdio.h> header */
119 extern FILE *popen(const char*,const char*);
120 extern int pclose(FILE*);
121# else
122# define SQLITE_OMIT_POPEN 1
123# endif
mistachkinf6418892013-08-28 01:54:12 +0000124#endif
drh53371f92013-07-25 17:07:03 +0000125
chw65d3c132007-11-12 21:09:10 +0000126#if defined(_WIN32_WCE)
127/* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty()
128 * thus we always assume that we have a console. That can be
129 * overridden with the -batch command line option.
130 */
131#define isatty(x) 1
132#endif
133
drhf0693c82011-10-11 20:41:54 +0000134/* ctype macros that work with signed characters */
135#define IsSpace(X) isspace((unsigned char)X)
136#define IsDigit(X) isdigit((unsigned char)X)
137#define ToLower(X) (char)tolower((unsigned char)X)
138
mistachkin1fe36bb2016-04-04 02:16:44 +0000139#if defined(_WIN32) || defined(WIN32)
140#include <windows.h>
141
142/* string conversion routines only needed on Win32 */
143extern char *sqlite3_win32_unicode_to_utf8(LPCWSTR);
144extern char *sqlite3_win32_mbcs_to_utf8_v2(const char *, int);
145extern char *sqlite3_win32_utf8_to_mbcs_v2(const char *, int);
mistachkin8145fc62016-09-16 20:39:21 +0000146extern LPWSTR sqlite3_win32_utf8_to_unicode(const char *zText);
mistachkin1fe36bb2016-04-04 02:16:44 +0000147#endif
148
drh047d4532015-01-18 20:30:23 +0000149/* On Windows, we normally run with output mode of TEXT so that \n characters
150** are automatically translated into \r\n. However, this behavior needs
151** to be disabled in some cases (ex: when generating CSV output and when
152** rendering quoted strings that contain \n characters). The following
153** routines take care of that.
154*/
155#if defined(_WIN32) || defined(WIN32)
mistachkin1fe36bb2016-04-04 02:16:44 +0000156static void setBinaryMode(FILE *file, int isOutput){
157 if( isOutput ) fflush(file);
158 _setmode(_fileno(file), _O_BINARY);
drh047d4532015-01-18 20:30:23 +0000159}
mistachkin1fe36bb2016-04-04 02:16:44 +0000160static void setTextMode(FILE *file, int isOutput){
161 if( isOutput ) fflush(file);
162 _setmode(_fileno(file), _O_TEXT);
drh047d4532015-01-18 20:30:23 +0000163}
164#else
mistachkin1fe36bb2016-04-04 02:16:44 +0000165# define setBinaryMode(X,Y)
166# define setTextMode(X,Y)
drh047d4532015-01-18 20:30:23 +0000167#endif
168
drh43408312013-10-30 12:43:36 +0000169
170/* True if the timer is enabled */
171static int enableTimer = 0;
172
173/* Return the current wall-clock time */
174static sqlite3_int64 timeOfDay(void){
175 static sqlite3_vfs *clockVfs = 0;
176 sqlite3_int64 t;
177 if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0);
dan3fd415b2015-11-16 08:54:10 +0000178 if( clockVfs->iVersion>=2 && clockVfs->xCurrentTimeInt64!=0 ){
drh43408312013-10-30 12:43:36 +0000179 clockVfs->xCurrentTimeInt64(clockVfs, &t);
180 }else{
181 double r;
182 clockVfs->xCurrentTime(clockVfs, &r);
183 t = (sqlite3_int64)(r*86400000.0);
184 }
185 return t;
186}
187
drh91eb93c2015-03-03 19:56:20 +0000188#if !defined(_WIN32) && !defined(WIN32) && !defined(__minux)
drh3b1a9882007-11-02 12:53:03 +0000189#include <sys/time.h>
190#include <sys/resource.h>
191
drh91eb93c2015-03-03 19:56:20 +0000192/* VxWorks does not support getrusage() as far as we can determine */
193#if defined(_WRS_KERNEL) || defined(__RTP__)
194struct rusage {
195 struct timeval ru_utime; /* user CPU time used */
196 struct timeval ru_stime; /* system CPU time used */
197};
198#define getrusage(A,B) memset(B,0,sizeof(*B))
199#endif
200
drhda108222009-02-25 19:07:24 +0000201/* Saved resource information for the beginning of an operation */
drh43408312013-10-30 12:43:36 +0000202static struct rusage sBegin; /* CPU time at start */
203static sqlite3_int64 iBegin; /* Wall-clock time at start */
drhda108222009-02-25 19:07:24 +0000204
drhda108222009-02-25 19:07:24 +0000205/*
206** Begin timing an operation
207*/
208static void beginTimer(void){
209 if( enableTimer ){
210 getrusage(RUSAGE_SELF, &sBegin);
drh43408312013-10-30 12:43:36 +0000211 iBegin = timeOfDay();
drhda108222009-02-25 19:07:24 +0000212 }
213}
214
215/* Return the difference of two time_structs in seconds */
216static double timeDiff(struct timeval *pStart, struct timeval *pEnd){
mistachkin1fe36bb2016-04-04 02:16:44 +0000217 return (pEnd->tv_usec - pStart->tv_usec)*0.000001 +
drhda108222009-02-25 19:07:24 +0000218 (double)(pEnd->tv_sec - pStart->tv_sec);
219}
220
221/*
222** Print the timing results.
223*/
224static void endTimer(void){
225 if( enableTimer ){
drh43408312013-10-30 12:43:36 +0000226 sqlite3_int64 iEnd = timeOfDay();
drh91eb93c2015-03-03 19:56:20 +0000227 struct rusage sEnd;
drhda108222009-02-25 19:07:24 +0000228 getrusage(RUSAGE_SELF, &sEnd);
drh43408312013-10-30 12:43:36 +0000229 printf("Run Time: real %.3f user %f sys %f\n",
230 (iEnd - iBegin)*0.001,
drhda108222009-02-25 19:07:24 +0000231 timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
232 timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
233 }
234}
shaneb320ccd2009-10-21 03:42:58 +0000235
drhda108222009-02-25 19:07:24 +0000236#define BEGIN_TIMER beginTimer()
237#define END_TIMER endTimer()
238#define HAS_TIMER 1
shaneb320ccd2009-10-21 03:42:58 +0000239
240#elif (defined(_WIN32) || defined(WIN32))
241
shaneb320ccd2009-10-21 03:42:58 +0000242/* Saved resource information for the beginning of an operation */
243static HANDLE hProcess;
244static FILETIME ftKernelBegin;
245static FILETIME ftUserBegin;
drh43408312013-10-30 12:43:36 +0000246static sqlite3_int64 ftWallBegin;
drh4ace5362014-11-10 14:42:28 +0000247typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME,
248 LPFILETIME, LPFILETIME);
shaneb320ccd2009-10-21 03:42:58 +0000249static GETPROCTIMES getProcessTimesAddr = NULL;
250
shaneb320ccd2009-10-21 03:42:58 +0000251/*
252** Check to see if we have timer support. Return 1 if necessary
253** support found (or found previously).
254*/
255static int hasTimer(void){
256 if( getProcessTimesAddr ){
257 return 1;
258 } else {
drh4ace5362014-11-10 14:42:28 +0000259 /* GetProcessTimes() isn't supported in WIN95 and some other Windows
260 ** versions. See if the version we are running on has it, and if it
261 ** does, save off a pointer to it and the current process handle.
shaneb320ccd2009-10-21 03:42:58 +0000262 */
263 hProcess = GetCurrentProcess();
264 if( hProcess ){
265 HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll"));
266 if( NULL != hinstLib ){
drh4ace5362014-11-10 14:42:28 +0000267 getProcessTimesAddr =
268 (GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes");
shaneb320ccd2009-10-21 03:42:58 +0000269 if( NULL != getProcessTimesAddr ){
270 return 1;
271 }
mistachkin1fe36bb2016-04-04 02:16:44 +0000272 FreeLibrary(hinstLib);
shaneb320ccd2009-10-21 03:42:58 +0000273 }
274 }
275 }
276 return 0;
277}
278
279/*
280** Begin timing an operation
281*/
282static void beginTimer(void){
283 if( enableTimer && getProcessTimesAddr ){
284 FILETIME ftCreation, ftExit;
drh4ace5362014-11-10 14:42:28 +0000285 getProcessTimesAddr(hProcess,&ftCreation,&ftExit,
286 &ftKernelBegin,&ftUserBegin);
drh43408312013-10-30 12:43:36 +0000287 ftWallBegin = timeOfDay();
shaneb320ccd2009-10-21 03:42:58 +0000288 }
289}
290
291/* Return the difference of two FILETIME structs in seconds */
292static double timeDiff(FILETIME *pStart, FILETIME *pEnd){
293 sqlite_int64 i64Start = *((sqlite_int64 *) pStart);
294 sqlite_int64 i64End = *((sqlite_int64 *) pEnd);
295 return (double) ((i64End - i64Start) / 10000000.0);
296}
297
298/*
299** Print the timing results.
300*/
301static void endTimer(void){
302 if( enableTimer && getProcessTimesAddr){
303 FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd;
drh43408312013-10-30 12:43:36 +0000304 sqlite3_int64 ftWallEnd = timeOfDay();
drh4ace5362014-11-10 14:42:28 +0000305 getProcessTimesAddr(hProcess,&ftCreation,&ftExit,&ftKernelEnd,&ftUserEnd);
drh43408312013-10-30 12:43:36 +0000306 printf("Run Time: real %.3f user %f sys %f\n",
307 (ftWallEnd - ftWallBegin)*0.001,
shaneb320ccd2009-10-21 03:42:58 +0000308 timeDiff(&ftUserBegin, &ftUserEnd),
309 timeDiff(&ftKernelBegin, &ftKernelEnd));
310 }
311}
312
313#define BEGIN_TIMER beginTimer()
314#define END_TIMER endTimer()
315#define HAS_TIMER hasTimer()
316
drhda108222009-02-25 19:07:24 +0000317#else
mistachkin1fe36bb2016-04-04 02:16:44 +0000318#define BEGIN_TIMER
drhda108222009-02-25 19:07:24 +0000319#define END_TIMER
320#define HAS_TIMER 0
321#endif
322
shanec0688ea2009-03-05 03:48:06 +0000323/*
324** Used to prevent warnings about unused parameters
325*/
326#define UNUSED_PARAMETER(x) (void)(x)
327
drhe91d16b2008-12-08 18:27:31 +0000328/*
drhc49f44e2006-10-26 18:15:42 +0000329** If the following flag is set, then command execution stops
330** at an error if we are not interactive.
331*/
332static int bail_on_error = 0;
333
334/*
drhc28490c2006-10-26 14:25:58 +0000335** Threat stdin as an interactive input if the following variable
336** is true. Otherwise, assume stdin is connected to a file or pipe.
337*/
338static int stdin_is_interactive = 1;
339
340/*
drhe05461c2015-12-30 13:36:57 +0000341** On Windows systems we have to know if standard output is a console
342** in order to translate UTF-8 into MBCS. The following variable is
343** true if translation is required.
344*/
345static int stdout_is_console = 1;
346
347/*
drh4c504392000-10-16 22:06:40 +0000348** The following is the open SQLite database. We make a pointer
349** to this database a static variable so that it can be accessed
350** by the SIGINT handler to interrupt database processing.
351*/
mistachkin8e189222015-04-19 21:43:16 +0000352static sqlite3 *globalDb = 0;
drh4c504392000-10-16 22:06:40 +0000353
354/*
drh67505e72002-04-19 12:34:06 +0000355** True if an interrupt (Control-C) has been received.
356*/
drh43617e92006-03-06 20:55:46 +0000357static volatile int seenInterrupt = 0;
drh67505e72002-04-19 12:34:06 +0000358
359/*
persicom7e2dfdd2002-04-18 02:46:52 +0000360** This is the name of our program. It is set in main(), used
361** in a number of other places, mostly for error messages.
362*/
363static char *Argv0;
364
365/*
366** Prompt strings. Initialized in main. Settable with
367** .prompt main continue
368*/
369static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/
370static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */
371
drhb0603412007-02-28 04:47:26 +0000372/*
mistachkin710b33b2016-01-03 18:59:28 +0000373** Render output like fprintf(). Except, if the output is going to the
374** console and if this is running on a Windows machine, translate the
375** output from UTF-8 into MBCS.
376*/
377#if defined(_WIN32) || defined(WIN32)
378void utf8_printf(FILE *out, const char *zFormat, ...){
379 va_list ap;
380 va_start(ap, zFormat);
381 if( stdout_is_console && (out==stdout || out==stderr) ){
mistachkin710b33b2016-01-03 18:59:28 +0000382 char *z1 = sqlite3_vmprintf(zFormat, ap);
mistachkin1fe36bb2016-04-04 02:16:44 +0000383 char *z2 = sqlite3_win32_utf8_to_mbcs_v2(z1, 0);
mistachkin710b33b2016-01-03 18:59:28 +0000384 sqlite3_free(z1);
385 fputs(z2, out);
386 sqlite3_free(z2);
387 }else{
388 vfprintf(out, zFormat, ap);
389 }
390 va_end(ap);
391}
392#elif !defined(utf8_printf)
393# define utf8_printf fprintf
394#endif
395
396/*
397** Render output like fprintf(). This should not be used on anything that
398** includes string formatting (e.g. "%s").
399*/
400#if !defined(raw_printf)
401# define raw_printf fprintf
402#endif
403
404/*
drhb0603412007-02-28 04:47:26 +0000405** Write I/O traces to the following stream.
406*/
rsebe0a9092007-07-30 18:24:38 +0000407#ifdef SQLITE_ENABLE_IOTRACE
drhb0603412007-02-28 04:47:26 +0000408static FILE *iotrace = 0;
rsebe0a9092007-07-30 18:24:38 +0000409#endif
drhb0603412007-02-28 04:47:26 +0000410
411/*
412** This routine works like printf in that its first argument is a
413** format string and subsequent arguments are values to be substituted
414** in place of % fields. The result of formatting this string
415** is written to iotrace.
416*/
rsebe0a9092007-07-30 18:24:38 +0000417#ifdef SQLITE_ENABLE_IOTRACE
mistachkin9871a932015-03-27 00:21:52 +0000418static void SQLITE_CDECL iotracePrintf(const char *zFormat, ...){
drhb0603412007-02-28 04:47:26 +0000419 va_list ap;
drhf075cd02007-02-28 06:14:25 +0000420 char *z;
drhb0603412007-02-28 04:47:26 +0000421 if( iotrace==0 ) return;
422 va_start(ap, zFormat);
drhf075cd02007-02-28 06:14:25 +0000423 z = sqlite3_vmprintf(zFormat, ap);
drhb0603412007-02-28 04:47:26 +0000424 va_end(ap);
mistachkin710b33b2016-01-03 18:59:28 +0000425 utf8_printf(iotrace, "%s", z);
drhf075cd02007-02-28 06:14:25 +0000426 sqlite3_free(z);
drhb0603412007-02-28 04:47:26 +0000427}
rsebe0a9092007-07-30 18:24:38 +0000428#endif
drhb0603412007-02-28 04:47:26 +0000429
drh44c2eb12003-04-30 11:38:26 +0000430
persicom7e2dfdd2002-04-18 02:46:52 +0000431/*
drh83965662003-04-17 02:54:13 +0000432** Determines if a string is a number of not.
433*/
danielk19772e588c72005-12-09 14:25:08 +0000434static int isNumber(const char *z, int *realnum){
drhc8d74412004-08-31 23:41:26 +0000435 if( *z=='-' || *z=='+' ) z++;
drhf0693c82011-10-11 20:41:54 +0000436 if( !IsDigit(*z) ){
drhc8d74412004-08-31 23:41:26 +0000437 return 0;
438 }
439 z++;
440 if( realnum ) *realnum = 0;
drhf0693c82011-10-11 20:41:54 +0000441 while( IsDigit(*z) ){ z++; }
drhc8d74412004-08-31 23:41:26 +0000442 if( *z=='.' ){
443 z++;
drhf0693c82011-10-11 20:41:54 +0000444 if( !IsDigit(*z) ) return 0;
445 while( IsDigit(*z) ){ z++; }
drhc8d74412004-08-31 23:41:26 +0000446 if( realnum ) *realnum = 1;
447 }
448 if( *z=='e' || *z=='E' ){
449 z++;
450 if( *z=='+' || *z=='-' ) z++;
drhf0693c82011-10-11 20:41:54 +0000451 if( !IsDigit(*z) ) return 0;
452 while( IsDigit(*z) ){ z++; }
drhc8d74412004-08-31 23:41:26 +0000453 if( realnum ) *realnum = 1;
454 }
455 return *z==0;
456}
drh83965662003-04-17 02:54:13 +0000457
458/*
drhe05461c2015-12-30 13:36:57 +0000459** Compute a string length that is limited to what can be stored in
460** lower 30 bits of a 32-bit signed integer.
461*/
462static int strlen30(const char *z){
463 const char *z2 = z;
464 while( *z2 ){ z2++; }
465 return 0x3fffffff & (int)(z2 - z);
466}
467
468/*
drhfeac5f82004-08-01 00:10:45 +0000469** This routine reads a line of text from FILE in, stores
drh8e7e7a22000-05-30 18:45:23 +0000470** the text in memory obtained from malloc() and returns a pointer
471** to the text. NULL is returned at end of file, or if malloc()
472** fails.
473**
drh9f099fd2013-08-06 14:01:46 +0000474** If zLine is not NULL then it is a malloced buffer returned from
475** a previous call to this routine that may be reused.
drh8e7e7a22000-05-30 18:45:23 +0000476*/
drh9f099fd2013-08-06 14:01:46 +0000477static char *local_getline(char *zLine, FILE *in){
478 int nLine = zLine==0 ? 0 : 100;
479 int n = 0;
drh8e7e7a22000-05-30 18:45:23 +0000480
drhb07028f2011-10-14 21:49:18 +0000481 while( 1 ){
drh8e7e7a22000-05-30 18:45:23 +0000482 if( n+100>nLine ){
483 nLine = nLine*2 + 100;
484 zLine = realloc(zLine, nLine);
485 if( zLine==0 ) return 0;
486 }
drhdaffd0e2001-04-11 14:28:42 +0000487 if( fgets(&zLine[n], nLine - n, in)==0 ){
drh8e7e7a22000-05-30 18:45:23 +0000488 if( n==0 ){
489 free(zLine);
490 return 0;
491 }
492 zLine[n] = 0;
drh8e7e7a22000-05-30 18:45:23 +0000493 break;
494 }
drh9f099fd2013-08-06 14:01:46 +0000495 while( zLine[n] ) n++;
496 if( n>0 && zLine[n-1]=='\n' ){
drh8e7e7a22000-05-30 18:45:23 +0000497 n--;
shaneh13b36022009-12-17 21:07:15 +0000498 if( n>0 && zLine[n-1]=='\r' ) n--;
drh8e7e7a22000-05-30 18:45:23 +0000499 zLine[n] = 0;
drhb07028f2011-10-14 21:49:18 +0000500 break;
drh8e7e7a22000-05-30 18:45:23 +0000501 }
502 }
drhe05461c2015-12-30 13:36:57 +0000503#if defined(_WIN32) || defined(WIN32)
mistachkin1fe36bb2016-04-04 02:16:44 +0000504 /* For interactive input on Windows systems, translate the
drhe05461c2015-12-30 13:36:57 +0000505 ** multi-byte characterset characters into UTF-8. */
drhfc8b40f2016-09-07 10:10:18 +0000506 if( stdin_is_interactive && in==stdin ){
mistachkin1fe36bb2016-04-04 02:16:44 +0000507 char *zTrans = sqlite3_win32_mbcs_to_utf8_v2(zLine, 0);
drhe05461c2015-12-30 13:36:57 +0000508 if( zTrans ){
509 int nTrans = strlen30(zTrans)+1;
510 if( nTrans>nLine ){
511 zLine = realloc(zLine, nTrans);
512 if( zLine==0 ){
513 sqlite3_free(zTrans);
514 return 0;
515 }
516 }
517 memcpy(zLine, zTrans, nTrans);
518 sqlite3_free(zTrans);
519 }
520 }
521#endif /* defined(_WIN32) || defined(WIN32) */
drh8e7e7a22000-05-30 18:45:23 +0000522 return zLine;
523}
524
525/*
drhc28490c2006-10-26 14:25:58 +0000526** Retrieve a single line of input text.
drh8e7e7a22000-05-30 18:45:23 +0000527**
drh9f099fd2013-08-06 14:01:46 +0000528** If in==0 then read from standard input and prompt before each line.
529** If isContinuation is true, then a continuation prompt is appropriate.
530** If isContinuation is zero, then the main prompt should be used.
531**
532** If zPrior is not NULL then it is a buffer from a prior call to this
533** routine that can be reused.
534**
535** The result is stored in space obtained from malloc() and must either
536** be freed by the caller or else passed back into this routine via the
537** zPrior argument for reuse.
drh8e7e7a22000-05-30 18:45:23 +0000538*/
drh9f099fd2013-08-06 14:01:46 +0000539static char *one_input_line(FILE *in, char *zPrior, int isContinuation){
drh8e7e7a22000-05-30 18:45:23 +0000540 char *zPrompt;
541 char *zResult;
drhdaffd0e2001-04-11 14:28:42 +0000542 if( in!=0 ){
drh9f099fd2013-08-06 14:01:46 +0000543 zResult = local_getline(zPrior, in);
drh8e7e7a22000-05-30 18:45:23 +0000544 }else{
drh9f099fd2013-08-06 14:01:46 +0000545 zPrompt = isContinuation ? continuePrompt : mainPrompt;
danfd34d6d2015-02-25 10:54:53 +0000546#if SHELL_USE_LOCAL_GETLINE
drh9f099fd2013-08-06 14:01:46 +0000547 printf("%s", zPrompt);
548 fflush(stdout);
549 zResult = local_getline(zPrior, stdin);
danfd34d6d2015-02-25 10:54:53 +0000550#else
551 free(zPrior);
552 zResult = shell_readline(zPrompt);
553 if( zResult && *zResult ) shell_add_history(zResult);
danielk19774af00c62005-01-23 23:43:21 +0000554#endif
drh9f099fd2013-08-06 14:01:46 +0000555 }
drh8e7e7a22000-05-30 18:45:23 +0000556 return zResult;
557}
drhf42d3182017-03-08 12:25:18 +0000558/*
559** A variable length string to which one can append text.
560*/
561typedef struct ShellText ShellText;
562struct ShellText {
563 char *z;
564 int n;
565 int nAlloc;
566};
567
568/*
569** Initialize and destroy a ShellText object
570*/
571static void initText(ShellText *p){
572 memset(p, 0, sizeof(*p));
573}
574static void freeText(ShellText *p){
575 free(p->z);
576 initText(p);
577}
578
579/* zIn is either a pointer to a NULL-terminated string in memory obtained
580** from malloc(), or a NULL pointer. The string pointed to by zAppend is
581** added to zIn, and the result returned in memory obtained from malloc().
582** zIn, if it was not NULL, is freed.
583**
584** If the third argument, quote, is not '\0', then it is used as a
585** quote character for zAppend.
586*/
587static void appendText(ShellText *p, char const *zAppend, char quote){
588 int len;
589 int i;
590 int nAppend = strlen30(zAppend);
591
592 len = nAppend+p->n+1;
593 if( quote ){
594 len += 2;
595 for(i=0; i<nAppend; i++){
596 if( zAppend[i]==quote ) len++;
597 }
598 }
599
600 if( p->n+len>=p->nAlloc ){
601 p->nAlloc = p->nAlloc*2 + len + 20;
602 p->z = realloc(p->z, p->nAlloc);
603 if( p->z==0 ){
604 memset(p, 0, sizeof(*p));
605 return;
606 }
607 }
608
609 if( quote ){
610 char *zCsr = p->z+p->n;
611 *zCsr++ = quote;
612 for(i=0; i<nAppend; i++){
613 *zCsr++ = zAppend[i];
614 if( zAppend[i]==quote ) *zCsr++ = quote;
615 }
616 *zCsr++ = quote;
617 p->n = (int)(zCsr - p->z);
618 *zCsr = '\0';
619 }else{
620 memcpy(p->z+p->n, zAppend, nAppend);
621 p->n += nAppend;
622 p->z[p->n] = '\0';
623 }
624}
625
626/*
627** Attempt to determine if identifier zName needs to be quoted, either
628** because it contains non-alphanumeric characters, or because it is an
629** SQLite keyword. Be conservative in this estimate: When in doubt assume
630** that quoting is required.
631**
632** Return '"' if quoting is required. Return 0 if no quoting is required.
633*/
634static char quoteChar(const char *zName){
635 /* All SQLite keywords, in alphabetical order */
636 static const char *azKeywords[] = {
637 "ABORT", "ACTION", "ADD", "AFTER", "ALL", "ALTER", "ANALYZE", "AND", "AS",
638 "ASC", "ATTACH", "AUTOINCREMENT", "BEFORE", "BEGIN", "BETWEEN", "BY",
639 "CASCADE", "CASE", "CAST", "CHECK", "COLLATE", "COLUMN", "COMMIT",
640 "CONFLICT", "CONSTRAINT", "CREATE", "CROSS", "CURRENT_DATE",
641 "CURRENT_TIME", "CURRENT_TIMESTAMP", "DATABASE", "DEFAULT", "DEFERRABLE",
642 "DEFERRED", "DELETE", "DESC", "DETACH", "DISTINCT", "DROP", "EACH",
643 "ELSE", "END", "ESCAPE", "EXCEPT", "EXCLUSIVE", "EXISTS", "EXPLAIN",
644 "FAIL", "FOR", "FOREIGN", "FROM", "FULL", "GLOB", "GROUP", "HAVING", "IF",
645 "IGNORE", "IMMEDIATE", "IN", "INDEX", "INDEXED", "INITIALLY", "INNER",
646 "INSERT", "INSTEAD", "INTERSECT", "INTO", "IS", "ISNULL", "JOIN", "KEY",
647 "LEFT", "LIKE", "LIMIT", "MATCH", "NATURAL", "NO", "NOT", "NOTNULL",
648 "NULL", "OF", "OFFSET", "ON", "OR", "ORDER", "OUTER", "PLAN", "PRAGMA",
649 "PRIMARY", "QUERY", "RAISE", "RECURSIVE", "REFERENCES", "REGEXP",
650 "REINDEX", "RELEASE", "RENAME", "REPLACE", "RESTRICT", "RIGHT",
651 "ROLLBACK", "ROW", "SAVEPOINT", "SELECT", "SET", "TABLE", "TEMP",
652 "TEMPORARY", "THEN", "TO", "TRANSACTION", "TRIGGER", "UNION", "UNIQUE",
653 "UPDATE", "USING", "VACUUM", "VALUES", "VIEW", "VIRTUAL", "WHEN", "WHERE",
654 "WITH", "WITHOUT",
655 };
656 int i, lwr, upr, mid, c;
657 if( !isalpha((unsigned char)zName[0]) && zName[0]!='_' ) return '"';
658 for(i=0; zName[i]; i++){
659 if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ) return '"';
660 }
661 lwr = 0;
662 upr = sizeof(azKeywords)/sizeof(azKeywords[0]) - 1;
663 while( lwr<=upr ){
664 mid = (lwr+upr)/2;
665 c = sqlite3_stricmp(azKeywords[mid], zName);
666 if( c==0 ) return '"';
667 if( c<0 ){
668 lwr = mid+1;
669 }else{
670 upr = mid-1;
671 }
672 }
673 return 0;
674}
drh8e7e7a22000-05-30 18:45:23 +0000675
drh1554bc82017-03-08 16:10:34 +0000676/******************************************************************************
677** SHA3 hash implementation copied from ../ext/misc/shathree.c
678*/
679typedef sqlite3_uint64 u64;
680/*
681** Macros to determine whether the machine is big or little endian,
682** and whether or not that determination is run-time or compile-time.
683**
684** For best performance, an attempt is made to guess at the byte-order
685** using C-preprocessor macros. If that is unsuccessful, or if
686** -DSHA3_BYTEORDER=0 is set, then byte-order is determined
687** at run-time.
688*/
689#ifndef SHA3_BYTEORDER
690# if defined(i386) || defined(__i386__) || defined(_M_IX86) || \
691 defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \
692 defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \
693 defined(__arm__)
694# define SHA3_BYTEORDER 1234
695# elif defined(sparc) || defined(__ppc__)
696# define SHA3_BYTEORDER 4321
697# else
698# define SHA3_BYTEORDER 0
699# endif
700#endif
701
702
703/*
704** State structure for a SHA3 hash in progress
705*/
706typedef struct SHA3Context SHA3Context;
707struct SHA3Context {
708 union {
709 u64 s[25]; /* Keccak state. 5x5 lines of 64 bits each */
710 unsigned char x[1600]; /* ... or 1600 bytes */
711 } u;
712 unsigned nRate; /* Bytes of input accepted per Keccak iteration */
713 unsigned nLoaded; /* Input bytes loaded into u.x[] so far this cycle */
714 unsigned ixMask; /* Insert next input into u.x[nLoaded^ixMask]. */
715};
716
717/*
718** A single step of the Keccak mixing function for a 1600-bit state
719*/
720static void KeccakF1600Step(SHA3Context *p){
721 int i;
722 u64 B0, B1, B2, B3, B4;
723 u64 C0, C1, C2, C3, C4;
724 u64 D0, D1, D2, D3, D4;
725 static const u64 RC[] = {
726 0x0000000000000001ULL, 0x0000000000008082ULL,
727 0x800000000000808aULL, 0x8000000080008000ULL,
728 0x000000000000808bULL, 0x0000000080000001ULL,
729 0x8000000080008081ULL, 0x8000000000008009ULL,
730 0x000000000000008aULL, 0x0000000000000088ULL,
731 0x0000000080008009ULL, 0x000000008000000aULL,
732 0x000000008000808bULL, 0x800000000000008bULL,
733 0x8000000000008089ULL, 0x8000000000008003ULL,
734 0x8000000000008002ULL, 0x8000000000000080ULL,
735 0x000000000000800aULL, 0x800000008000000aULL,
736 0x8000000080008081ULL, 0x8000000000008080ULL,
737 0x0000000080000001ULL, 0x8000000080008008ULL
738 };
739# define A00 (p->u.s[0])
740# define A01 (p->u.s[1])
741# define A02 (p->u.s[2])
742# define A03 (p->u.s[3])
743# define A04 (p->u.s[4])
744# define A10 (p->u.s[5])
745# define A11 (p->u.s[6])
746# define A12 (p->u.s[7])
747# define A13 (p->u.s[8])
748# define A14 (p->u.s[9])
749# define A20 (p->u.s[10])
750# define A21 (p->u.s[11])
751# define A22 (p->u.s[12])
752# define A23 (p->u.s[13])
753# define A24 (p->u.s[14])
754# define A30 (p->u.s[15])
755# define A31 (p->u.s[16])
756# define A32 (p->u.s[17])
757# define A33 (p->u.s[18])
758# define A34 (p->u.s[19])
759# define A40 (p->u.s[20])
760# define A41 (p->u.s[21])
761# define A42 (p->u.s[22])
762# define A43 (p->u.s[23])
763# define A44 (p->u.s[24])
764# define ROL64(a,x) ((a<<x)|(a>>(64-x)))
765
766 for(i=0; i<24; i+=4){
767 C0 = A00^A10^A20^A30^A40;
768 C1 = A01^A11^A21^A31^A41;
769 C2 = A02^A12^A22^A32^A42;
770 C3 = A03^A13^A23^A33^A43;
771 C4 = A04^A14^A24^A34^A44;
772 D0 = C4^ROL64(C1, 1);
773 D1 = C0^ROL64(C2, 1);
774 D2 = C1^ROL64(C3, 1);
775 D3 = C2^ROL64(C4, 1);
776 D4 = C3^ROL64(C0, 1);
777
778 B0 = (A00^D0);
779 B1 = ROL64((A11^D1), 44);
780 B2 = ROL64((A22^D2), 43);
781 B3 = ROL64((A33^D3), 21);
782 B4 = ROL64((A44^D4), 14);
783 A00 = B0 ^((~B1)& B2 );
784 A00 ^= RC[i];
785 A11 = B1 ^((~B2)& B3 );
786 A22 = B2 ^((~B3)& B4 );
787 A33 = B3 ^((~B4)& B0 );
788 A44 = B4 ^((~B0)& B1 );
789
790 B2 = ROL64((A20^D0), 3);
791 B3 = ROL64((A31^D1), 45);
792 B4 = ROL64((A42^D2), 61);
793 B0 = ROL64((A03^D3), 28);
794 B1 = ROL64((A14^D4), 20);
795 A20 = B0 ^((~B1)& B2 );
796 A31 = B1 ^((~B2)& B3 );
797 A42 = B2 ^((~B3)& B4 );
798 A03 = B3 ^((~B4)& B0 );
799 A14 = B4 ^((~B0)& B1 );
800
801 B4 = ROL64((A40^D0), 18);
802 B0 = ROL64((A01^D1), 1);
803 B1 = ROL64((A12^D2), 6);
804 B2 = ROL64((A23^D3), 25);
805 B3 = ROL64((A34^D4), 8);
806 A40 = B0 ^((~B1)& B2 );
807 A01 = B1 ^((~B2)& B3 );
808 A12 = B2 ^((~B3)& B4 );
809 A23 = B3 ^((~B4)& B0 );
810 A34 = B4 ^((~B0)& B1 );
811
812 B1 = ROL64((A10^D0), 36);
813 B2 = ROL64((A21^D1), 10);
814 B3 = ROL64((A32^D2), 15);
815 B4 = ROL64((A43^D3), 56);
816 B0 = ROL64((A04^D4), 27);
817 A10 = B0 ^((~B1)& B2 );
818 A21 = B1 ^((~B2)& B3 );
819 A32 = B2 ^((~B3)& B4 );
820 A43 = B3 ^((~B4)& B0 );
821 A04 = B4 ^((~B0)& B1 );
822
823 B3 = ROL64((A30^D0), 41);
824 B4 = ROL64((A41^D1), 2);
825 B0 = ROL64((A02^D2), 62);
826 B1 = ROL64((A13^D3), 55);
827 B2 = ROL64((A24^D4), 39);
828 A30 = B0 ^((~B1)& B2 );
829 A41 = B1 ^((~B2)& B3 );
830 A02 = B2 ^((~B3)& B4 );
831 A13 = B3 ^((~B4)& B0 );
832 A24 = B4 ^((~B0)& B1 );
833
834 C0 = A00^A20^A40^A10^A30;
835 C1 = A11^A31^A01^A21^A41;
836 C2 = A22^A42^A12^A32^A02;
837 C3 = A33^A03^A23^A43^A13;
838 C4 = A44^A14^A34^A04^A24;
839 D0 = C4^ROL64(C1, 1);
840 D1 = C0^ROL64(C2, 1);
841 D2 = C1^ROL64(C3, 1);
842 D3 = C2^ROL64(C4, 1);
843 D4 = C3^ROL64(C0, 1);
844
845 B0 = (A00^D0);
846 B1 = ROL64((A31^D1), 44);
847 B2 = ROL64((A12^D2), 43);
848 B3 = ROL64((A43^D3), 21);
849 B4 = ROL64((A24^D4), 14);
850 A00 = B0 ^((~B1)& B2 );
851 A00 ^= RC[i+1];
852 A31 = B1 ^((~B2)& B3 );
853 A12 = B2 ^((~B3)& B4 );
854 A43 = B3 ^((~B4)& B0 );
855 A24 = B4 ^((~B0)& B1 );
856
857 B2 = ROL64((A40^D0), 3);
858 B3 = ROL64((A21^D1), 45);
859 B4 = ROL64((A02^D2), 61);
860 B0 = ROL64((A33^D3), 28);
861 B1 = ROL64((A14^D4), 20);
862 A40 = B0 ^((~B1)& B2 );
863 A21 = B1 ^((~B2)& B3 );
864 A02 = B2 ^((~B3)& B4 );
865 A33 = B3 ^((~B4)& B0 );
866 A14 = B4 ^((~B0)& B1 );
867
868 B4 = ROL64((A30^D0), 18);
869 B0 = ROL64((A11^D1), 1);
870 B1 = ROL64((A42^D2), 6);
871 B2 = ROL64((A23^D3), 25);
872 B3 = ROL64((A04^D4), 8);
873 A30 = B0 ^((~B1)& B2 );
874 A11 = B1 ^((~B2)& B3 );
875 A42 = B2 ^((~B3)& B4 );
876 A23 = B3 ^((~B4)& B0 );
877 A04 = B4 ^((~B0)& B1 );
878
879 B1 = ROL64((A20^D0), 36);
880 B2 = ROL64((A01^D1), 10);
881 B3 = ROL64((A32^D2), 15);
882 B4 = ROL64((A13^D3), 56);
883 B0 = ROL64((A44^D4), 27);
884 A20 = B0 ^((~B1)& B2 );
885 A01 = B1 ^((~B2)& B3 );
886 A32 = B2 ^((~B3)& B4 );
887 A13 = B3 ^((~B4)& B0 );
888 A44 = B4 ^((~B0)& B1 );
889
890 B3 = ROL64((A10^D0), 41);
891 B4 = ROL64((A41^D1), 2);
892 B0 = ROL64((A22^D2), 62);
893 B1 = ROL64((A03^D3), 55);
894 B2 = ROL64((A34^D4), 39);
895 A10 = B0 ^((~B1)& B2 );
896 A41 = B1 ^((~B2)& B3 );
897 A22 = B2 ^((~B3)& B4 );
898 A03 = B3 ^((~B4)& B0 );
899 A34 = B4 ^((~B0)& B1 );
900
901 C0 = A00^A40^A30^A20^A10;
902 C1 = A31^A21^A11^A01^A41;
903 C2 = A12^A02^A42^A32^A22;
904 C3 = A43^A33^A23^A13^A03;
905 C4 = A24^A14^A04^A44^A34;
906 D0 = C4^ROL64(C1, 1);
907 D1 = C0^ROL64(C2, 1);
908 D2 = C1^ROL64(C3, 1);
909 D3 = C2^ROL64(C4, 1);
910 D4 = C3^ROL64(C0, 1);
911
912 B0 = (A00^D0);
913 B1 = ROL64((A21^D1), 44);
914 B2 = ROL64((A42^D2), 43);
915 B3 = ROL64((A13^D3), 21);
916 B4 = ROL64((A34^D4), 14);
917 A00 = B0 ^((~B1)& B2 );
918 A00 ^= RC[i+2];
919 A21 = B1 ^((~B2)& B3 );
920 A42 = B2 ^((~B3)& B4 );
921 A13 = B3 ^((~B4)& B0 );
922 A34 = B4 ^((~B0)& B1 );
923
924 B2 = ROL64((A30^D0), 3);
925 B3 = ROL64((A01^D1), 45);
926 B4 = ROL64((A22^D2), 61);
927 B0 = ROL64((A43^D3), 28);
928 B1 = ROL64((A14^D4), 20);
929 A30 = B0 ^((~B1)& B2 );
930 A01 = B1 ^((~B2)& B3 );
931 A22 = B2 ^((~B3)& B4 );
932 A43 = B3 ^((~B4)& B0 );
933 A14 = B4 ^((~B0)& B1 );
934
935 B4 = ROL64((A10^D0), 18);
936 B0 = ROL64((A31^D1), 1);
937 B1 = ROL64((A02^D2), 6);
938 B2 = ROL64((A23^D3), 25);
939 B3 = ROL64((A44^D4), 8);
940 A10 = B0 ^((~B1)& B2 );
941 A31 = B1 ^((~B2)& B3 );
942 A02 = B2 ^((~B3)& B4 );
943 A23 = B3 ^((~B4)& B0 );
944 A44 = B4 ^((~B0)& B1 );
945
946 B1 = ROL64((A40^D0), 36);
947 B2 = ROL64((A11^D1), 10);
948 B3 = ROL64((A32^D2), 15);
949 B4 = ROL64((A03^D3), 56);
950 B0 = ROL64((A24^D4), 27);
951 A40 = B0 ^((~B1)& B2 );
952 A11 = B1 ^((~B2)& B3 );
953 A32 = B2 ^((~B3)& B4 );
954 A03 = B3 ^((~B4)& B0 );
955 A24 = B4 ^((~B0)& B1 );
956
957 B3 = ROL64((A20^D0), 41);
958 B4 = ROL64((A41^D1), 2);
959 B0 = ROL64((A12^D2), 62);
960 B1 = ROL64((A33^D3), 55);
961 B2 = ROL64((A04^D4), 39);
962 A20 = B0 ^((~B1)& B2 );
963 A41 = B1 ^((~B2)& B3 );
964 A12 = B2 ^((~B3)& B4 );
965 A33 = B3 ^((~B4)& B0 );
966 A04 = B4 ^((~B0)& B1 );
967
968 C0 = A00^A30^A10^A40^A20;
969 C1 = A21^A01^A31^A11^A41;
970 C2 = A42^A22^A02^A32^A12;
971 C3 = A13^A43^A23^A03^A33;
972 C4 = A34^A14^A44^A24^A04;
973 D0 = C4^ROL64(C1, 1);
974 D1 = C0^ROL64(C2, 1);
975 D2 = C1^ROL64(C3, 1);
976 D3 = C2^ROL64(C4, 1);
977 D4 = C3^ROL64(C0, 1);
978
979 B0 = (A00^D0);
980 B1 = ROL64((A01^D1), 44);
981 B2 = ROL64((A02^D2), 43);
982 B3 = ROL64((A03^D3), 21);
983 B4 = ROL64((A04^D4), 14);
984 A00 = B0 ^((~B1)& B2 );
985 A00 ^= RC[i+3];
986 A01 = B1 ^((~B2)& B3 );
987 A02 = B2 ^((~B3)& B4 );
988 A03 = B3 ^((~B4)& B0 );
989 A04 = B4 ^((~B0)& B1 );
990
991 B2 = ROL64((A10^D0), 3);
992 B3 = ROL64((A11^D1), 45);
993 B4 = ROL64((A12^D2), 61);
994 B0 = ROL64((A13^D3), 28);
995 B1 = ROL64((A14^D4), 20);
996 A10 = B0 ^((~B1)& B2 );
997 A11 = B1 ^((~B2)& B3 );
998 A12 = B2 ^((~B3)& B4 );
999 A13 = B3 ^((~B4)& B0 );
1000 A14 = B4 ^((~B0)& B1 );
1001
1002 B4 = ROL64((A20^D0), 18);
1003 B0 = ROL64((A21^D1), 1);
1004 B1 = ROL64((A22^D2), 6);
1005 B2 = ROL64((A23^D3), 25);
1006 B3 = ROL64((A24^D4), 8);
1007 A20 = B0 ^((~B1)& B2 );
1008 A21 = B1 ^((~B2)& B3 );
1009 A22 = B2 ^((~B3)& B4 );
1010 A23 = B3 ^((~B4)& B0 );
1011 A24 = B4 ^((~B0)& B1 );
1012
1013 B1 = ROL64((A30^D0), 36);
1014 B2 = ROL64((A31^D1), 10);
1015 B3 = ROL64((A32^D2), 15);
1016 B4 = ROL64((A33^D3), 56);
1017 B0 = ROL64((A34^D4), 27);
1018 A30 = B0 ^((~B1)& B2 );
1019 A31 = B1 ^((~B2)& B3 );
1020 A32 = B2 ^((~B3)& B4 );
1021 A33 = B3 ^((~B4)& B0 );
1022 A34 = B4 ^((~B0)& B1 );
1023
1024 B3 = ROL64((A40^D0), 41);
1025 B4 = ROL64((A41^D1), 2);
1026 B0 = ROL64((A42^D2), 62);
1027 B1 = ROL64((A43^D3), 55);
1028 B2 = ROL64((A44^D4), 39);
1029 A40 = B0 ^((~B1)& B2 );
1030 A41 = B1 ^((~B2)& B3 );
1031 A42 = B2 ^((~B3)& B4 );
1032 A43 = B3 ^((~B4)& B0 );
1033 A44 = B4 ^((~B0)& B1 );
1034 }
1035}
1036
1037/*
1038** Initialize a new hash. iSize determines the size of the hash
1039** in bits and should be one of 224, 256, 384, or 512. Or iSize
1040** can be zero to use the default hash size of 256 bits.
1041*/
1042static void SHA3Init(SHA3Context *p, int iSize){
1043 memset(p, 0, sizeof(*p));
1044 if( iSize>=128 && iSize<=512 ){
1045 p->nRate = (1600 - ((iSize + 31)&~31)*2)/8;
1046 }else{
1047 p->nRate = (1600 - 2*256)/8;
1048 }
1049#if SHA3_BYTEORDER==1234
1050 /* Known to be little-endian at compile-time. No-op */
1051#elif SHA3_BYTEORDER==4321
1052 p->ixMask = 7; /* Big-endian */
1053#else
1054 {
1055 static unsigned int one = 1;
1056 if( 1==*(unsigned char*)&one ){
1057 /* Little endian. No byte swapping. */
1058 p->ixMask = 0;
1059 }else{
1060 /* Big endian. Byte swap. */
1061 p->ixMask = 7;
1062 }
1063 }
1064#endif
1065}
1066
1067/*
1068** Make consecutive calls to the SHA3Update function to add new content
1069** to the hash
1070*/
1071static void SHA3Update(
1072 SHA3Context *p,
1073 const unsigned char *aData,
1074 unsigned int nData
1075){
1076 unsigned int i = 0;
1077#if SHA3_BYTEORDER==1234
1078 if( (p->nLoaded % 8)==0 && ((aData - (const unsigned char*)0)&7)==0 ){
1079 for(; i+7<nData; i+=8){
1080 p->u.s[p->nLoaded/8] ^= *(u64*)&aData[i];
1081 p->nLoaded += 8;
1082 if( p->nLoaded>=p->nRate ){
1083 KeccakF1600Step(p);
1084 p->nLoaded = 0;
1085 }
1086 }
1087 }
1088#endif
1089 for(; i<nData; i++){
1090#if SHA3_BYTEORDER==1234
1091 p->u.x[p->nLoaded] ^= aData[i];
1092#elif SHA3_BYTEORDER==4321
1093 p->u.x[p->nLoaded^0x07] ^= aData[i];
1094#else
1095 p->u.x[p->nLoaded^p->ixMask] ^= aData[i];
1096#endif
1097 p->nLoaded++;
1098 if( p->nLoaded==p->nRate ){
1099 KeccakF1600Step(p);
1100 p->nLoaded = 0;
1101 }
1102 }
1103}
1104
1105/*
1106** After all content has been added, invoke SHA3Final() to compute
1107** the final hash. The function returns a pointer to the binary
1108** hash value.
1109*/
1110static unsigned char *SHA3Final(SHA3Context *p){
1111 unsigned int i;
1112 if( p->nLoaded==p->nRate-1 ){
1113 const unsigned char c1 = 0x86;
1114 SHA3Update(p, &c1, 1);
1115 }else{
1116 const unsigned char c2 = 0x06;
1117 const unsigned char c3 = 0x80;
1118 SHA3Update(p, &c2, 1);
1119 p->nLoaded = p->nRate - 1;
1120 SHA3Update(p, &c3, 1);
1121 }
1122 for(i=0; i<p->nRate; i++){
1123 p->u.x[i+p->nRate] = p->u.x[i^p->ixMask];
1124 }
1125 return &p->u.x[p->nRate];
1126}
1127
1128/*
1129** Implementation of the sha3(X,SIZE) function.
1130**
1131** Return a BLOB which is the SIZE-bit SHA3 hash of X. The default
1132** size is 256. If X is a BLOB, it is hashed as is.
1133** For all other non-NULL types of input, X is converted into a UTF-8 string
1134** and the string is hashed without the trailing 0x00 terminator. The hash
1135** of a NULL value is NULL.
1136*/
1137static void sha3Func(
1138 sqlite3_context *context,
1139 int argc,
1140 sqlite3_value **argv
1141){
1142 SHA3Context cx;
1143 int eType = sqlite3_value_type(argv[0]);
1144 int nByte = sqlite3_value_bytes(argv[0]);
1145 int iSize;
1146 if( argc==1 ){
1147 iSize = 256;
1148 }else{
1149 iSize = sqlite3_value_int(argv[1]);
1150 if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){
1151 sqlite3_result_error(context, "SHA3 size should be one of: 224 256 "
1152 "384 512", -1);
1153 return;
1154 }
1155 }
1156 if( eType==SQLITE_NULL ) return;
1157 SHA3Init(&cx, iSize);
1158 if( eType==SQLITE_BLOB ){
1159 SHA3Update(&cx, sqlite3_value_blob(argv[0]), nByte);
1160 }else{
1161 SHA3Update(&cx, sqlite3_value_text(argv[0]), nByte);
1162 }
1163 sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT);
1164}
1165
1166/* Compute a string using sqlite3_vsnprintf() with a maximum length
1167** of 50 bytes and add it to the hash.
1168*/
1169static void hash_step_vformat(
1170 SHA3Context *p, /* Add content to this context */
1171 const char *zFormat,
1172 ...
1173){
1174 va_list ap;
1175 int n;
1176 char zBuf[50];
1177 va_start(ap, zFormat);
1178 sqlite3_vsnprintf(sizeof(zBuf),zBuf,zFormat,ap);
1179 va_end(ap);
1180 n = (int)strlen(zBuf);
1181 SHA3Update(p, (unsigned char*)zBuf, n);
1182}
1183
1184/*
1185** Implementation of the sha3_query(SQL,SIZE) function.
1186**
1187** This function compiles and runs the SQL statement(s) given in the
1188** argument. The results are hashed using a SIZE-bit SHA3. The default
1189** size is 256.
1190**
1191** The format of the byte stream that is hashed is summarized as follows:
1192**
1193** S<n>:<sql>
1194** R
1195** N
1196** I<int>
1197** F<ieee-float>
1198** B<size>:<bytes>
1199** T<size>:<text>
1200**
1201** <sql> is the original SQL text for each statement run and <n> is
1202** the size of that text. The SQL text is UTF-8. A single R character
1203** occurs before the start of each row. N means a NULL value.
1204** I mean an 8-byte little-endian integer <int>. F is a floating point
1205** number with an 8-byte little-endian IEEE floating point value <ieee-float>.
1206** B means blobs of <size> bytes. T means text rendered as <size>
1207** bytes of UTF-8. The <n> and <size> values are expressed as an ASCII
1208** text integers.
1209**
1210** For each SQL statement in the X input, there is one S segment. Each
1211** S segment is followed by zero or more R segments, one for each row in the
1212** result set. After each R, there are one or more N, I, F, B, or T segments,
1213** one for each column in the result set. Segments are concatentated directly
1214** with no delimiters of any kind.
1215*/
1216static void sha3QueryFunc(
1217 sqlite3_context *context,
1218 int argc,
1219 sqlite3_value **argv
1220){
1221 sqlite3 *db = sqlite3_context_db_handle(context);
1222 const char *zSql = (const char*)sqlite3_value_text(argv[0]);
1223 sqlite3_stmt *pStmt = 0;
1224 int nCol; /* Number of columns in the result set */
1225 int i; /* Loop counter */
1226 int rc;
1227 int n;
1228 const char *z;
1229 SHA3Context cx;
1230 int iSize;
1231
1232 if( argc==1 ){
1233 iSize = 256;
1234 }else{
1235 iSize = sqlite3_value_int(argv[1]);
1236 if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){
1237 sqlite3_result_error(context, "SHA3 size should be one of: 224 256 "
1238 "384 512", -1);
1239 return;
1240 }
1241 }
1242 if( zSql==0 ) return;
1243 SHA3Init(&cx, iSize);
1244 while( zSql[0] ){
1245 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zSql);
1246 if( rc ){
1247 char *zMsg = sqlite3_mprintf("error SQL statement [%s]: %s",
1248 zSql, sqlite3_errmsg(db));
1249 sqlite3_finalize(pStmt);
1250 sqlite3_result_error(context, zMsg, -1);
1251 sqlite3_free(zMsg);
1252 return;
1253 }
1254 if( !sqlite3_stmt_readonly(pStmt) ){
1255 char *zMsg = sqlite3_mprintf("non-query: [%s]", sqlite3_sql(pStmt));
1256 sqlite3_finalize(pStmt);
1257 sqlite3_result_error(context, zMsg, -1);
1258 sqlite3_free(zMsg);
1259 return;
1260 }
1261 nCol = sqlite3_column_count(pStmt);
1262 z = sqlite3_sql(pStmt);
drh3ee83ef2017-03-08 17:56:54 +00001263 if( z==0 ){
1264 sqlite3_finalize(pStmt);
1265 continue;
1266 }
drh1554bc82017-03-08 16:10:34 +00001267 n = (int)strlen(z);
1268 hash_step_vformat(&cx,"S%d:",n);
1269 SHA3Update(&cx,(unsigned char*)z,n);
1270
1271 /* Compute a hash over the result of the query */
1272 while( SQLITE_ROW==sqlite3_step(pStmt) ){
1273 SHA3Update(&cx,(const unsigned char*)"R",1);
1274 for(i=0; i<nCol; i++){
1275 switch( sqlite3_column_type(pStmt,i) ){
1276 case SQLITE_NULL: {
1277 SHA3Update(&cx, (const unsigned char*)"N",1);
1278 break;
1279 }
1280 case SQLITE_INTEGER: {
1281 sqlite3_uint64 u;
1282 int j;
1283 unsigned char x[9];
1284 sqlite3_int64 v = sqlite3_column_int64(pStmt,i);
1285 memcpy(&u, &v, 8);
1286 for(j=8; j>=1; j--){
1287 x[j] = u & 0xff;
1288 u >>= 8;
1289 }
1290 x[0] = 'I';
1291 SHA3Update(&cx, x, 9);
1292 break;
1293 }
1294 case SQLITE_FLOAT: {
1295 sqlite3_uint64 u;
1296 int j;
1297 unsigned char x[9];
1298 double r = sqlite3_column_double(pStmt,i);
1299 memcpy(&u, &r, 8);
1300 for(j=8; j>=1; j--){
1301 x[j] = u & 0xff;
1302 u >>= 8;
1303 }
1304 x[0] = 'F';
1305 SHA3Update(&cx,x,9);
1306 break;
1307 }
1308 case SQLITE_TEXT: {
1309 int n2 = sqlite3_column_bytes(pStmt, i);
1310 const unsigned char *z2 = sqlite3_column_text(pStmt, i);
1311 hash_step_vformat(&cx,"T%d:",n2);
1312 SHA3Update(&cx, z2, n2);
1313 break;
1314 }
1315 case SQLITE_BLOB: {
1316 int n2 = sqlite3_column_bytes(pStmt, i);
1317 const unsigned char *z2 = sqlite3_column_blob(pStmt, i);
1318 hash_step_vformat(&cx,"B%d:",n2);
1319 SHA3Update(&cx, z2, n2);
1320 break;
1321 }
1322 }
1323 }
1324 }
1325 sqlite3_finalize(pStmt);
1326 }
1327 sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT);
1328}
1329/* End of SHA3 hashing logic copy/pasted from ../ext/misc/shathree.c
1330********************************************************************************/
1331
drhe6229612014-08-18 15:08:26 +00001332#if defined(SQLITE_ENABLE_SESSION)
1333/*
1334** State information for a single open session
1335*/
1336typedef struct OpenSession OpenSession;
1337struct OpenSession {
1338 char *zName; /* Symbolic name for this session */
1339 int nFilter; /* Number of xFilter rejection GLOB patterns */
1340 char **azFilter; /* Array of xFilter rejection GLOB patterns */
1341 sqlite3_session *p; /* The open session */
1342};
1343#endif
1344
drhdcd87a92014-08-18 13:45:42 +00001345/*
mistachkin1fe36bb2016-04-04 02:16:44 +00001346** Shell output mode information from before ".explain on",
drhdcd87a92014-08-18 13:45:42 +00001347** saved so that it can be restored by ".explain off"
1348*/
1349typedef struct SavedModeInfo SavedModeInfo;
1350struct SavedModeInfo {
1351 int valid; /* Is there legit data in here? */
1352 int mode; /* Mode prior to ".explain on" */
1353 int showHeader; /* The ".header" setting prior to ".explain on" */
1354 int colWidth[100]; /* Column widths prior to ".explain on" */
persicom7e2dfdd2002-04-18 02:46:52 +00001355};
drh45e29d82006-11-20 16:21:10 +00001356
drh8e7e7a22000-05-30 18:45:23 +00001357/*
drhdcd87a92014-08-18 13:45:42 +00001358** State information about the database connection is contained in an
1359** instance of the following structure.
drh75897232000-05-29 14:26:00 +00001360*/
drhdcd87a92014-08-18 13:45:42 +00001361typedef struct ShellState ShellState;
1362struct ShellState {
shane626a6e42009-10-22 17:30:15 +00001363 sqlite3 *db; /* The database */
drh700c2522016-02-09 18:39:25 +00001364 int autoExplain; /* Automatically turn on .explain mode */
drhc2ce0be2014-05-29 12:36:14 +00001365 int autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
shaneh642d8b82010-07-28 16:05:34 +00001366 int statsOn; /* True to display memory stats before each finalize */
dan8d1edb92014-11-05 09:07:28 +00001367 int scanstatsOn; /* True to display scan stats before each finalize */
drhc2ce0be2014-05-29 12:36:14 +00001368 int outCount; /* Revert to stdout when reaching zero */
drh28bd4bc2000-06-15 15:57:22 +00001369 int cnt; /* Number of records displayed so far */
1370 FILE *out; /* Write results here */
drh42f64e52012-04-04 16:56:23 +00001371 FILE *traceOut; /* Output for sqlite3_trace() */
drh2f464a02011-10-13 00:41:49 +00001372 int nErr; /* Number of errors seen */
drh28bd4bc2000-06-15 15:57:22 +00001373 int mode; /* An output mode setting */
drh700c2522016-02-09 18:39:25 +00001374 int cMode; /* temporary output mode for the current query */
1375 int normalMode; /* Output mode before ".explain on" */
drh45e29d82006-11-20 16:21:10 +00001376 int writableSchema; /* True if PRAGMA writable_schema=ON */
drh28bd4bc2000-06-15 15:57:22 +00001377 int showHeader; /* True to show column names in List or Column mode */
drh760c8162016-09-16 02:52:22 +00001378 int nCheck; /* Number of ".check" commands run */
drh44dec872014-08-30 15:49:25 +00001379 unsigned shellFlgs; /* Various flags */
drh33048c02001-10-01 14:29:22 +00001380 char *zDestTable; /* Name of destination table when MODE_Insert */
drh760c8162016-09-16 02:52:22 +00001381 char zTestcase[30]; /* Name of current test case */
mistachkin636bf9f2014-07-19 20:15:16 +00001382 char colSeparator[20]; /* Column separator character for several modes */
1383 char rowSeparator[20]; /* Row separator character for MODE_Ascii */
drha0c66f52000-07-29 13:20:21 +00001384 int colWidth[100]; /* Requested width of each column when in column mode*/
1385 int actualWidth[100]; /* Actual width of each column */
mistachkin44b99f72014-12-11 03:29:14 +00001386 char nullValue[20]; /* The text to print when a NULL comes back from
drh83965662003-04-17 02:54:13 +00001387 ** the database */
drh44c2eb12003-04-30 11:38:26 +00001388 char outfile[FILENAME_MAX]; /* Filename for *out */
1389 const char *zDbFilename; /* name of the database file */
drh05782482013-10-24 15:20:20 +00001390 char *zFreeOnClose; /* Filename to free when closing */
drha7e61d82011-03-12 17:02:57 +00001391 const char *zVfs; /* Name of VFS to use */
shane626a6e42009-10-22 17:30:15 +00001392 sqlite3_stmt *pStmt; /* Current statement if any. */
drh127f9d72010-02-23 01:47:00 +00001393 FILE *pLog; /* Write log output here */
dana98bf362013-11-13 18:35:01 +00001394 int *aiIndent; /* Array of indents used in MODE_Explain */
1395 int nIndent; /* Size of array aiIndent[] */
danc4650bb2013-11-18 08:41:06 +00001396 int iIndent; /* Index of current op in aiIndent[] */
drhe6229612014-08-18 15:08:26 +00001397#if defined(SQLITE_ENABLE_SESSION)
1398 int nSession; /* Number of active sessions */
1399 OpenSession aSession[4]; /* Array of sessions. [0] is in focus. */
1400#endif
drh75897232000-05-29 14:26:00 +00001401};
1402
1403/*
drh44dec872014-08-30 15:49:25 +00001404** These are the allowed shellFlgs values
1405*/
drhe6e1d122017-03-09 13:50:49 +00001406#define SHFLG_Scratch 0x00000001 /* The --scratch option is used */
1407#define SHFLG_Pagecache 0x00000002 /* The --pagecache option is used */
1408#define SHFLG_Lookaside 0x00000004 /* Lookaside memory is used */
1409#define SHFLG_Backslash 0x00000008 /* The --backslash option is used */
1410#define SHFLG_PreserveRowid 0x00000010 /* .dump preserves rowid values */
1411#define SHFLG_CountChanges 0x00000020 /* .changes setting */
1412#define SHFLG_Echo 0x00000040 /* .echo or --echo setting */
1413
1414/*
1415** Macros for testing and setting shellFlgs
1416*/
1417#define ShellHasFlag(P,X) (((P)->shellFlgs & (X))!=0)
1418#define ShellSetFlag(P,X) ((P)->shellFlgs|=(X))
1419#define ShellClearFlag(P,X) ((P)->shellFlgs&=(~(X)))
drh44dec872014-08-30 15:49:25 +00001420
1421/*
drh75897232000-05-29 14:26:00 +00001422** These are the allowed modes.
1423*/
drh967e8b72000-06-21 13:59:10 +00001424#define MODE_Line 0 /* One column per line. Blank line between records */
drh75897232000-05-29 14:26:00 +00001425#define MODE_Column 1 /* One record per line in neat columns */
1426#define MODE_List 2 /* One record per line with a separator */
drhe3710332000-09-29 13:30:53 +00001427#define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */
1428#define MODE_Html 4 /* Generate an XHTML table */
1429#define MODE_Insert 5 /* Generate SQL "insert" statements */
drh41f5f6e2016-10-21 17:39:30 +00001430#define MODE_Quote 6 /* Quote values as for SQL */
1431#define MODE_Tcl 7 /* Generate ANSI-C or TCL quoted elements */
1432#define MODE_Csv 8 /* Quote strings, numbers are plain */
1433#define MODE_Explain 9 /* Like MODE_Column, but do not truncate data */
1434#define MODE_Ascii 10 /* Use ASCII unit and record separators (0x1F/0x1E) */
1435#define MODE_Pretty 11 /* Pretty-print schemas */
persicom7e2dfdd2002-04-18 02:46:52 +00001436
drh66ce4d02008-02-15 17:38:06 +00001437static const char *modeDescr[] = {
persicom7e2dfdd2002-04-18 02:46:52 +00001438 "line",
1439 "column",
1440 "list",
1441 "semi",
1442 "html",
drhfeac5f82004-08-01 00:10:45 +00001443 "insert",
drh41f5f6e2016-10-21 17:39:30 +00001444 "quote",
drhfeac5f82004-08-01 00:10:45 +00001445 "tcl",
drh8e64d1c2004-10-07 00:32:39 +00001446 "csv",
drh66ce4d02008-02-15 17:38:06 +00001447 "explain",
mistachkin636bf9f2014-07-19 20:15:16 +00001448 "ascii",
drh4926fec2016-04-13 15:33:42 +00001449 "prettyprint",
persicom7e2dfdd2002-04-18 02:46:52 +00001450};
drh75897232000-05-29 14:26:00 +00001451
1452/*
mistachkinfad42082014-07-24 22:13:12 +00001453** These are the column/row/line separators used by the various
1454** import/export modes.
mistachkin636bf9f2014-07-19 20:15:16 +00001455*/
mistachkinfad42082014-07-24 22:13:12 +00001456#define SEP_Column "|"
1457#define SEP_Row "\n"
1458#define SEP_Tab "\t"
1459#define SEP_Space " "
1460#define SEP_Comma ","
1461#define SEP_CrLf "\r\n"
1462#define SEP_Unit "\x1F"
1463#define SEP_Record "\x1E"
mistachkin636bf9f2014-07-19 20:15:16 +00001464
1465/*
drh75897232000-05-29 14:26:00 +00001466** Number of elements in an array
1467*/
drh902b9ee2008-12-05 17:17:07 +00001468#define ArraySize(X) (int)(sizeof(X)/sizeof(X[0]))
drh75897232000-05-29 14:26:00 +00001469
1470/*
drh127f9d72010-02-23 01:47:00 +00001471** A callback for the sqlite3_log() interface.
1472*/
1473static void shellLog(void *pArg, int iErrCode, const char *zMsg){
drhdcd87a92014-08-18 13:45:42 +00001474 ShellState *p = (ShellState*)pArg;
drh127f9d72010-02-23 01:47:00 +00001475 if( p->pLog==0 ) return;
mistachkinaae280e2015-12-31 19:06:24 +00001476 utf8_printf(p->pLog, "(%d) %s\n", iErrCode, zMsg);
drh127f9d72010-02-23 01:47:00 +00001477 fflush(p->pLog);
1478}
1479
1480/*
shane626a6e42009-10-22 17:30:15 +00001481** Output the given string as a hex-encoded blob (eg. X'1234' )
1482*/
1483static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){
1484 int i;
1485 char *zBlob = (char *)pBlob;
mistachkinaae280e2015-12-31 19:06:24 +00001486 raw_printf(out,"X'");
1487 for(i=0; i<nBlob; i++){ raw_printf(out,"%02x",zBlob[i]&0xff); }
1488 raw_printf(out,"'");
shane626a6e42009-10-22 17:30:15 +00001489}
1490
1491/*
drh6193d492017-04-07 11:45:58 +00001492** Find a string that is not found anywhere in z[]. Return a pointer
1493** to that string.
1494**
1495** Try to use zA and zB first. If both of those are already found in z[]
1496** then make up some string and store it in the buffer zBuf.
1497*/
1498static const char *unused_string(
1499 const char *z, /* Result must not appear anywhere in z */
1500 const char *zA, const char *zB, /* Try these first */
1501 char *zBuf /* Space to store a generated string */
1502){
1503 unsigned i = 0;
1504 if( strstr(z, zA)==0 ) return zA;
1505 if( strstr(z, zB)==0 ) return zB;
1506 do{
1507 sqlite3_snprintf(20,zBuf,"(%s%u)", zA, i++);
1508 }while( strstr(z,zBuf)!=0 );
1509 return zBuf;
1510}
1511
1512/*
drh28bd4bc2000-06-15 15:57:22 +00001513** Output the given string as a quoted string using SQL quoting conventions.
drh708b22b2017-03-11 01:56:41 +00001514**
drh13fe1382017-04-08 13:42:55 +00001515** See also: output_quoted_escaped_string()
drh28bd4bc2000-06-15 15:57:22 +00001516*/
1517static void output_quoted_string(FILE *out, const char *z){
1518 int i;
drh708b22b2017-03-11 01:56:41 +00001519 char c;
mistachkin1fe36bb2016-04-04 02:16:44 +00001520 setBinaryMode(out, 1);
drh13fe1382017-04-08 13:42:55 +00001521 for(i=0; (c = z[i])!=0 && c!='\''; i++){}
1522 if( c==0 ){
1523 utf8_printf(out,"'%s'",z);
1524 }else{
1525 raw_printf(out, "'");
1526 while( *z ){
1527 for(i=0; (c = z[i])!=0 && c!='\''; i++){}
1528 if( c=='\'' ) i++;
1529 if( i ){
1530 utf8_printf(out, "%.*s", i, z);
1531 z += i;
1532 }
1533 if( c=='\'' ){
1534 raw_printf(out, "'");
1535 continue;
1536 }
1537 if( c==0 ){
1538 break;
1539 }
1540 z++;
1541 }
1542 raw_printf(out, "'");
1543 }
1544 setTextMode(out, 1);
1545}
1546
1547/*
1548** Output the given string as a quoted string using SQL quoting conventions.
1549** Additionallly , escape the "\n" and "\r" characters so that they do not
1550** get corrupted by end-of-line translation facilities in some operating
1551** systems.
1552**
1553** This is like output_quoted_string() but with the addition of the \r\n
1554** escape mechanism.
1555*/
1556static void output_quoted_escaped_string(FILE *out, const char *z){
1557 int i;
1558 char c;
1559 setBinaryMode(out, 1);
drh708b22b2017-03-11 01:56:41 +00001560 for(i=0; (c = z[i])!=0 && c!='\'' && c!='\n' && c!='\r'; i++){}
1561 if( c==0 ){
drhe05461c2015-12-30 13:36:57 +00001562 utf8_printf(out,"'%s'",z);
drh28bd4bc2000-06-15 15:57:22 +00001563 }else{
drh6193d492017-04-07 11:45:58 +00001564 const char *zNL = 0;
1565 const char *zCR = 0;
1566 int nNL = 0;
1567 int nCR = 0;
1568 char zBuf1[20], zBuf2[20];
1569 for(i=0; z[i]; i++){
1570 if( z[i]=='\n' ) nNL++;
1571 if( z[i]=='\r' ) nCR++;
1572 }
1573 if( nNL ){
1574 raw_printf(out, "replace(");
1575 zNL = unused_string(z, "\\n", "\\012", zBuf1);
1576 }
1577 if( nCR ){
1578 raw_printf(out, "replace(");
1579 zCR = unused_string(z, "\\r", "\\015", zBuf2);
1580 }
1581 raw_printf(out, "'");
drh28bd4bc2000-06-15 15:57:22 +00001582 while( *z ){
drh708b22b2017-03-11 01:56:41 +00001583 for(i=0; (c = z[i])!=0 && c!='\n' && c!='\r' && c!='\''; i++){}
1584 if( c=='\'' ) i++;
1585 if( i ){
drh708b22b2017-03-11 01:56:41 +00001586 utf8_printf(out, "%.*s", i, z);
1587 z += i;
drh708b22b2017-03-11 01:56:41 +00001588 }
1589 if( c=='\'' ){
1590 raw_printf(out, "'");
1591 continue;
1592 }
drh708b22b2017-03-11 01:56:41 +00001593 if( c==0 ){
drh28bd4bc2000-06-15 15:57:22 +00001594 break;
1595 }
drh6193d492017-04-07 11:45:58 +00001596 z++;
1597 if( c=='\n' ){
1598 raw_printf(out, "%s", zNL);
1599 continue;
drh708b22b2017-03-11 01:56:41 +00001600 }
drh6193d492017-04-07 11:45:58 +00001601 raw_printf(out, "%s", zCR);
drh28bd4bc2000-06-15 15:57:22 +00001602 }
drh6193d492017-04-07 11:45:58 +00001603 raw_printf(out, "'");
1604 if( nCR ){
1605 raw_printf(out, ",'%s',char(13))", zCR);
1606 }
1607 if( nNL ){
1608 raw_printf(out, ",'%s',char(10))", zNL);
1609 }
drh28bd4bc2000-06-15 15:57:22 +00001610 }
mistachkin1fe36bb2016-04-04 02:16:44 +00001611 setTextMode(out, 1);
drh28bd4bc2000-06-15 15:57:22 +00001612}
1613
1614/*
drhfeac5f82004-08-01 00:10:45 +00001615** Output the given string as a quoted according to C or TCL quoting rules.
1616*/
1617static void output_c_string(FILE *out, const char *z){
1618 unsigned int c;
1619 fputc('"', out);
1620 while( (c = *(z++))!=0 ){
1621 if( c=='\\' ){
1622 fputc(c, out);
1623 fputc(c, out);
mistachkin585dcb22012-12-04 00:23:43 +00001624 }else if( c=='"' ){
1625 fputc('\\', out);
1626 fputc('"', out);
drhfeac5f82004-08-01 00:10:45 +00001627 }else if( c=='\t' ){
1628 fputc('\\', out);
1629 fputc('t', out);
1630 }else if( c=='\n' ){
1631 fputc('\\', out);
1632 fputc('n', out);
1633 }else if( c=='\r' ){
1634 fputc('\\', out);
1635 fputc('r', out);
mistachkinf6418892013-08-28 01:54:12 +00001636 }else if( !isprint(c&0xff) ){
mistachkinaae280e2015-12-31 19:06:24 +00001637 raw_printf(out, "\\%03o", c&0xff);
drhfeac5f82004-08-01 00:10:45 +00001638 }else{
1639 fputc(c, out);
1640 }
1641 }
1642 fputc('"', out);
1643}
1644
1645/*
drhc08a4f12000-06-15 16:49:48 +00001646** Output the given string with characters that are special to
1647** HTML escaped.
1648*/
1649static void output_html_string(FILE *out, const char *z){
1650 int i;
drhc3d6ba42014-01-13 20:38:35 +00001651 if( z==0 ) z = "";
drhc08a4f12000-06-15 16:49:48 +00001652 while( *z ){
mistachkin1fe36bb2016-04-04 02:16:44 +00001653 for(i=0; z[i]
1654 && z[i]!='<'
1655 && z[i]!='&'
1656 && z[i]!='>'
1657 && z[i]!='\"'
shane43d9cb22009-10-21 14:11:48 +00001658 && z[i]!='\'';
1659 i++){}
drhc08a4f12000-06-15 16:49:48 +00001660 if( i>0 ){
drhe05461c2015-12-30 13:36:57 +00001661 utf8_printf(out,"%.*s",i,z);
drhc08a4f12000-06-15 16:49:48 +00001662 }
1663 if( z[i]=='<' ){
mistachkinaae280e2015-12-31 19:06:24 +00001664 raw_printf(out,"&lt;");
drhc08a4f12000-06-15 16:49:48 +00001665 }else if( z[i]=='&' ){
mistachkinaae280e2015-12-31 19:06:24 +00001666 raw_printf(out,"&amp;");
shane43d9cb22009-10-21 14:11:48 +00001667 }else if( z[i]=='>' ){
mistachkinaae280e2015-12-31 19:06:24 +00001668 raw_printf(out,"&gt;");
shane43d9cb22009-10-21 14:11:48 +00001669 }else if( z[i]=='\"' ){
mistachkinaae280e2015-12-31 19:06:24 +00001670 raw_printf(out,"&quot;");
shane43d9cb22009-10-21 14:11:48 +00001671 }else if( z[i]=='\'' ){
mistachkinaae280e2015-12-31 19:06:24 +00001672 raw_printf(out,"&#39;");
drhc08a4f12000-06-15 16:49:48 +00001673 }else{
1674 break;
1675 }
1676 z += i + 1;
1677 }
1678}
1679
1680/*
drhc49f44e2006-10-26 18:15:42 +00001681** If a field contains any character identified by a 1 in the following
1682** array, then the string must be quoted for CSV.
1683*/
1684static const char needCsvQuote[] = {
mistachkin1fe36bb2016-04-04 02:16:44 +00001685 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1686 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1687 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
1688 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1689 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1690 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1691 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1692 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
1693 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1694 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1695 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1696 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1697 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1698 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1699 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1700 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
drhc49f44e2006-10-26 18:15:42 +00001701};
1702
1703/*
mistachkindd11f2d2014-12-11 04:49:46 +00001704** Output a single term of CSV. Actually, p->colSeparator is used for
mistachkin44b99f72014-12-11 03:29:14 +00001705** the separator, which may or may not be a comma. p->nullValue is
drh6976c212014-07-24 12:09:47 +00001706** the null value. Strings are quoted if necessary. The separator
1707** is only issued if bSep is true.
drh8e64d1c2004-10-07 00:32:39 +00001708*/
drhdcd87a92014-08-18 13:45:42 +00001709static void output_csv(ShellState *p, const char *z, int bSep){
drhc49f44e2006-10-26 18:15:42 +00001710 FILE *out = p->out;
drh8e64d1c2004-10-07 00:32:39 +00001711 if( z==0 ){
drhe05461c2015-12-30 13:36:57 +00001712 utf8_printf(out,"%s",p->nullValue);
drh8e64d1c2004-10-07 00:32:39 +00001713 }else{
drhc49f44e2006-10-26 18:15:42 +00001714 int i;
mistachkin636bf9f2014-07-19 20:15:16 +00001715 int nSep = strlen30(p->colSeparator);
drhc49f44e2006-10-26 18:15:42 +00001716 for(i=0; z[i]; i++){
mistachkin1fe36bb2016-04-04 02:16:44 +00001717 if( needCsvQuote[((unsigned char*)z)[i]]
1718 || (z[i]==p->colSeparator[0] &&
mistachkin636bf9f2014-07-19 20:15:16 +00001719 (nSep==1 || memcmp(z, p->colSeparator, nSep)==0)) ){
drhc49f44e2006-10-26 18:15:42 +00001720 i = 0;
1721 break;
1722 }
1723 }
1724 if( i==0 ){
1725 putc('"', out);
1726 for(i=0; z[i]; i++){
1727 if( z[i]=='"' ) putc('"', out);
1728 putc(z[i], out);
1729 }
1730 putc('"', out);
1731 }else{
drhe05461c2015-12-30 13:36:57 +00001732 utf8_printf(out, "%s", z);
drhc49f44e2006-10-26 18:15:42 +00001733 }
drh8e64d1c2004-10-07 00:32:39 +00001734 }
1735 if( bSep ){
drhe05461c2015-12-30 13:36:57 +00001736 utf8_printf(p->out, "%s", p->colSeparator);
drh8e64d1c2004-10-07 00:32:39 +00001737 }
1738}
1739
danielk19774af00c62005-01-23 23:43:21 +00001740#ifdef SIGINT
drh8e64d1c2004-10-07 00:32:39 +00001741/*
drh4c504392000-10-16 22:06:40 +00001742** This routine runs when the user presses Ctrl-C
1743*/
1744static void interrupt_handler(int NotUsed){
drh902b9ee2008-12-05 17:17:07 +00001745 UNUSED_PARAMETER(NotUsed);
drh43ae8f62014-05-23 12:03:47 +00001746 seenInterrupt++;
1747 if( seenInterrupt>2 ) exit(1);
mistachkin8e189222015-04-19 21:43:16 +00001748 if( globalDb ) sqlite3_interrupt(globalDb);
drh4c504392000-10-16 22:06:40 +00001749}
danielk19774af00c62005-01-23 23:43:21 +00001750#endif
drh4c504392000-10-16 22:06:40 +00001751
drha0daa752016-09-16 11:53:10 +00001752#ifndef SQLITE_OMIT_AUTHORIZATION
drh4c504392000-10-16 22:06:40 +00001753/*
drhde613c62016-04-04 17:23:10 +00001754** When the ".auth ON" is set, the following authorizer callback is
1755** invoked. It always returns SQLITE_OK.
1756*/
1757static int shellAuth(
1758 void *pClientData,
1759 int op,
1760 const char *zA1,
1761 const char *zA2,
1762 const char *zA3,
1763 const char *zA4
1764){
1765 ShellState *p = (ShellState*)pClientData;
1766 static const char *azAction[] = { 0,
1767 "CREATE_INDEX", "CREATE_TABLE", "CREATE_TEMP_INDEX",
1768 "CREATE_TEMP_TABLE", "CREATE_TEMP_TRIGGER", "CREATE_TEMP_VIEW",
1769 "CREATE_TRIGGER", "CREATE_VIEW", "DELETE",
1770 "DROP_INDEX", "DROP_TABLE", "DROP_TEMP_INDEX",
1771 "DROP_TEMP_TABLE", "DROP_TEMP_TRIGGER", "DROP_TEMP_VIEW",
1772 "DROP_TRIGGER", "DROP_VIEW", "INSERT",
1773 "PRAGMA", "READ", "SELECT",
1774 "TRANSACTION", "UPDATE", "ATTACH",
1775 "DETACH", "ALTER_TABLE", "REINDEX",
1776 "ANALYZE", "CREATE_VTABLE", "DROP_VTABLE",
1777 "FUNCTION", "SAVEPOINT", "RECURSIVE"
1778 };
1779 int i;
1780 const char *az[4];
1781 az[0] = zA1;
1782 az[1] = zA2;
1783 az[2] = zA3;
1784 az[3] = zA4;
mistachkin8145fc62016-09-16 20:39:21 +00001785 utf8_printf(p->out, "authorizer: %s", azAction[op]);
drhde613c62016-04-04 17:23:10 +00001786 for(i=0; i<4; i++){
1787 raw_printf(p->out, " ");
1788 if( az[i] ){
1789 output_c_string(p->out, az[i]);
1790 }else{
1791 raw_printf(p->out, "NULL");
1792 }
1793 }
1794 raw_printf(p->out, "\n");
1795 return SQLITE_OK;
1796}
drha0daa752016-09-16 11:53:10 +00001797#endif
mistachkin8145fc62016-09-16 20:39:21 +00001798
drh79f20e92016-12-13 23:22:39 +00001799/*
1800** Print a schema statement. Part of MODE_Semi and MODE_Pretty output.
1801**
1802** This routine converts some CREATE TABLE statements for shadow tables
1803** in FTS3/4/5 into CREATE TABLE IF NOT EXISTS statements.
1804*/
1805static void printSchemaLine(FILE *out, const char *z, const char *zTail){
1806 if( sqlite3_strglob("CREATE TABLE ['\"]*", z)==0 ){
1807 utf8_printf(out, "CREATE TABLE IF NOT EXISTS %s%s", z+13, zTail);
1808 }else{
1809 utf8_printf(out, "%s%s", z, zTail);
1810 }
1811}
1812static void printSchemaLineN(FILE *out, char *z, int n, const char *zTail){
1813 char c = z[n];
1814 z[n] = 0;
1815 printSchemaLine(out, z, zTail);
1816 z[n] = c;
1817}
drhde613c62016-04-04 17:23:10 +00001818
1819/*
shane626a6e42009-10-22 17:30:15 +00001820** This is the callback routine that the shell
drh75897232000-05-29 14:26:00 +00001821** invokes for each row of a query result.
1822*/
drh4ace5362014-11-10 14:42:28 +00001823static int shell_callback(
1824 void *pArg,
1825 int nArg, /* Number of result columns */
1826 char **azArg, /* Text of each result column */
1827 char **azCol, /* Column names */
1828 int *aiType /* Column types */
1829){
drh75897232000-05-29 14:26:00 +00001830 int i;
drhdcd87a92014-08-18 13:45:42 +00001831 ShellState *p = (ShellState*)pArg;
shaneb9fc17d2009-10-22 21:23:35 +00001832
drh700c2522016-02-09 18:39:25 +00001833 switch( p->cMode ){
drh75897232000-05-29 14:26:00 +00001834 case MODE_Line: {
drhe3710332000-09-29 13:30:53 +00001835 int w = 5;
drh6a535342001-10-19 16:44:56 +00001836 if( azArg==0 ) break;
drhe3710332000-09-29 13:30:53 +00001837 for(i=0; i<nArg; i++){
drh4f21c4a2008-12-10 22:15:00 +00001838 int len = strlen30(azCol[i] ? azCol[i] : "");
drhe3710332000-09-29 13:30:53 +00001839 if( len>w ) w = len;
1840 }
drhe05461c2015-12-30 13:36:57 +00001841 if( p->cnt++>0 ) utf8_printf(p->out, "%s", p->rowSeparator);
drh75897232000-05-29 14:26:00 +00001842 for(i=0; i<nArg; i++){
drhe05461c2015-12-30 13:36:57 +00001843 utf8_printf(p->out,"%*s = %s%s", w, azCol[i],
mistachkin44b99f72014-12-11 03:29:14 +00001844 azArg[i] ? azArg[i] : p->nullValue, p->rowSeparator);
drh75897232000-05-29 14:26:00 +00001845 }
1846 break;
1847 }
danielk19770d78bae2008-01-03 07:09:48 +00001848 case MODE_Explain:
drh75897232000-05-29 14:26:00 +00001849 case MODE_Column: {
drh700c2522016-02-09 18:39:25 +00001850 static const int aExplainWidths[] = {4, 13, 4, 4, 4, 13, 2, 13};
1851 const int *colWidth;
1852 int showHdr;
1853 char *rowSep;
1854 if( p->cMode==MODE_Column ){
1855 colWidth = p->colWidth;
1856 showHdr = p->showHeader;
1857 rowSep = p->rowSeparator;
1858 }else{
1859 colWidth = aExplainWidths;
1860 showHdr = 1;
mistachkin6d945552016-02-09 20:31:50 +00001861 rowSep = SEP_Row;
drh700c2522016-02-09 18:39:25 +00001862 }
drha0c66f52000-07-29 13:20:21 +00001863 if( p->cnt++==0 ){
drh75897232000-05-29 14:26:00 +00001864 for(i=0; i<nArg; i++){
drha0c66f52000-07-29 13:20:21 +00001865 int w, n;
1866 if( i<ArraySize(p->colWidth) ){
drh700c2522016-02-09 18:39:25 +00001867 w = colWidth[i];
drh75897232000-05-29 14:26:00 +00001868 }else{
danielk19770d78bae2008-01-03 07:09:48 +00001869 w = 0;
drh75897232000-05-29 14:26:00 +00001870 }
drh078b1fd2012-09-21 13:40:02 +00001871 if( w==0 ){
drh4f21c4a2008-12-10 22:15:00 +00001872 w = strlen30(azCol[i] ? azCol[i] : "");
drha0c66f52000-07-29 13:20:21 +00001873 if( w<10 ) w = 10;
mistachkin44b99f72014-12-11 03:29:14 +00001874 n = strlen30(azArg && azArg[i] ? azArg[i] : p->nullValue);
drha0c66f52000-07-29 13:20:21 +00001875 if( w<n ) w = n;
1876 }
1877 if( i<ArraySize(p->actualWidth) ){
persicom1d0b8722002-04-18 02:53:04 +00001878 p->actualWidth[i] = w;
drha0c66f52000-07-29 13:20:21 +00001879 }
drh700c2522016-02-09 18:39:25 +00001880 if( showHdr ){
drh078b1fd2012-09-21 13:40:02 +00001881 if( w<0 ){
drhe05461c2015-12-30 13:36:57 +00001882 utf8_printf(p->out,"%*.*s%s",-w,-w,azCol[i],
drh700c2522016-02-09 18:39:25 +00001883 i==nArg-1 ? rowSep : " ");
drh078b1fd2012-09-21 13:40:02 +00001884 }else{
drhe05461c2015-12-30 13:36:57 +00001885 utf8_printf(p->out,"%-*.*s%s",w,w,azCol[i],
drh700c2522016-02-09 18:39:25 +00001886 i==nArg-1 ? rowSep : " ");
drh078b1fd2012-09-21 13:40:02 +00001887 }
drha0c66f52000-07-29 13:20:21 +00001888 }
1889 }
drh700c2522016-02-09 18:39:25 +00001890 if( showHdr ){
drha0c66f52000-07-29 13:20:21 +00001891 for(i=0; i<nArg; i++){
1892 int w;
1893 if( i<ArraySize(p->actualWidth) ){
1894 w = p->actualWidth[i];
drh078b1fd2012-09-21 13:40:02 +00001895 if( w<0 ) w = -w;
drha0c66f52000-07-29 13:20:21 +00001896 }else{
1897 w = 10;
1898 }
mistachkinaae280e2015-12-31 19:06:24 +00001899 utf8_printf(p->out,"%-*.*s%s",w,w,
drhe05461c2015-12-30 13:36:57 +00001900 "----------------------------------------------------------"
drha0c66f52000-07-29 13:20:21 +00001901 "----------------------------------------------------------",
drh700c2522016-02-09 18:39:25 +00001902 i==nArg-1 ? rowSep : " ");
drha0c66f52000-07-29 13:20:21 +00001903 }
drh75897232000-05-29 14:26:00 +00001904 }
1905 }
drh6a535342001-10-19 16:44:56 +00001906 if( azArg==0 ) break;
drh75897232000-05-29 14:26:00 +00001907 for(i=0; i<nArg; i++){
1908 int w;
drha0c66f52000-07-29 13:20:21 +00001909 if( i<ArraySize(p->actualWidth) ){
1910 w = p->actualWidth[i];
drh75897232000-05-29 14:26:00 +00001911 }else{
1912 w = 10;
1913 }
drh700c2522016-02-09 18:39:25 +00001914 if( p->cMode==MODE_Explain && azArg[i] && strlen30(azArg[i])>w ){
drh4f21c4a2008-12-10 22:15:00 +00001915 w = strlen30(azArg[i]);
danielk19770d78bae2008-01-03 07:09:48 +00001916 }
dana98bf362013-11-13 18:35:01 +00001917 if( i==1 && p->aiIndent && p->pStmt ){
danc4650bb2013-11-18 08:41:06 +00001918 if( p->iIndent<p->nIndent ){
mistachkinaae280e2015-12-31 19:06:24 +00001919 utf8_printf(p->out, "%*.s", p->aiIndent[p->iIndent], "");
dana98bf362013-11-13 18:35:01 +00001920 }
danc4650bb2013-11-18 08:41:06 +00001921 p->iIndent++;
dana98bf362013-11-13 18:35:01 +00001922 }
drh078b1fd2012-09-21 13:40:02 +00001923 if( w<0 ){
drhe05461c2015-12-30 13:36:57 +00001924 utf8_printf(p->out,"%*.*s%s",-w,-w,
mistachkin44b99f72014-12-11 03:29:14 +00001925 azArg[i] ? azArg[i] : p->nullValue,
drh700c2522016-02-09 18:39:25 +00001926 i==nArg-1 ? rowSep : " ");
drh078b1fd2012-09-21 13:40:02 +00001927 }else{
drhe05461c2015-12-30 13:36:57 +00001928 utf8_printf(p->out,"%-*.*s%s",w,w,
mistachkin44b99f72014-12-11 03:29:14 +00001929 azArg[i] ? azArg[i] : p->nullValue,
drh700c2522016-02-09 18:39:25 +00001930 i==nArg-1 ? rowSep : " ");
drh078b1fd2012-09-21 13:40:02 +00001931 }
drh75897232000-05-29 14:26:00 +00001932 }
1933 break;
1934 }
drh4926fec2016-04-13 15:33:42 +00001935 case MODE_Semi: { /* .schema and .fullschema output */
drh79f20e92016-12-13 23:22:39 +00001936 printSchemaLine(p->out, azArg[0], ";\n");
drh4926fec2016-04-13 15:33:42 +00001937 break;
1938 }
1939 case MODE_Pretty: { /* .schema and .fullschema with --indent */
1940 char *z;
drh07d683f2016-04-13 21:00:36 +00001941 int j;
drh4926fec2016-04-13 15:33:42 +00001942 int nParen = 0;
1943 char cEnd = 0;
1944 char c;
1945 int nLine = 0;
1946 assert( nArg==1 );
1947 if( azArg[0]==0 ) break;
1948 if( sqlite3_strlike("CREATE VIEW%", azArg[0], 0)==0
1949 || sqlite3_strlike("CREATE TRIG%", azArg[0], 0)==0
1950 ){
1951 utf8_printf(p->out, "%s;\n", azArg[0]);
1952 break;
1953 }
1954 z = sqlite3_mprintf("%s", azArg[0]);
1955 j = 0;
1956 for(i=0; IsSpace(z[i]); i++){}
1957 for(; (c = z[i])!=0; i++){
1958 if( IsSpace(c) ){
1959 if( IsSpace(z[j-1]) || z[j-1]=='(' ) continue;
1960 }else if( (c=='(' || c==')') && j>0 && IsSpace(z[j-1]) ){
1961 j--;
1962 }
1963 z[j++] = c;
1964 }
1965 while( j>0 && IsSpace(z[j-1]) ){ j--; }
1966 z[j] = 0;
1967 if( strlen30(z)>=79 ){
drh07d683f2016-04-13 21:00:36 +00001968 for(i=j=0; (c = z[i])!=0; i++){
drh4926fec2016-04-13 15:33:42 +00001969 if( c==cEnd ){
1970 cEnd = 0;
1971 }else if( c=='"' || c=='\'' || c=='`' ){
1972 cEnd = c;
1973 }else if( c=='[' ){
1974 cEnd = ']';
1975 }else if( c=='(' ){
1976 nParen++;
1977 }else if( c==')' ){
1978 nParen--;
1979 if( nLine>0 && nParen==0 && j>0 ){
drh79f20e92016-12-13 23:22:39 +00001980 printSchemaLineN(p->out, z, j, "\n");
drh4926fec2016-04-13 15:33:42 +00001981 j = 0;
1982 }
1983 }
1984 z[j++] = c;
1985 if( nParen==1 && (c=='(' || c==',' || c=='\n') ){
1986 if( c=='\n' ) j--;
drh79f20e92016-12-13 23:22:39 +00001987 printSchemaLineN(p->out, z, j, "\n ");
drh4926fec2016-04-13 15:33:42 +00001988 j = 0;
1989 nLine++;
1990 while( IsSpace(z[i+1]) ){ i++; }
1991 }
1992 }
1993 z[j] = 0;
1994 }
drh79f20e92016-12-13 23:22:39 +00001995 printSchemaLine(p->out, z, ";\n");
drh4926fec2016-04-13 15:33:42 +00001996 sqlite3_free(z);
1997 break;
1998 }
drh75897232000-05-29 14:26:00 +00001999 case MODE_List: {
2000 if( p->cnt++==0 && p->showHeader ){
2001 for(i=0; i<nArg; i++){
drhe05461c2015-12-30 13:36:57 +00002002 utf8_printf(p->out,"%s%s",azCol[i],
mistachkin636bf9f2014-07-19 20:15:16 +00002003 i==nArg-1 ? p->rowSeparator : p->colSeparator);
drh75897232000-05-29 14:26:00 +00002004 }
2005 }
drh6a535342001-10-19 16:44:56 +00002006 if( azArg==0 ) break;
drh75897232000-05-29 14:26:00 +00002007 for(i=0; i<nArg; i++){
drh4c653a02000-06-07 01:27:47 +00002008 char *z = azArg[i];
mistachkin44b99f72014-12-11 03:29:14 +00002009 if( z==0 ) z = p->nullValue;
drhe05461c2015-12-30 13:36:57 +00002010 utf8_printf(p->out, "%s", z);
drhe3710332000-09-29 13:30:53 +00002011 if( i<nArg-1 ){
drhe05461c2015-12-30 13:36:57 +00002012 utf8_printf(p->out, "%s", p->colSeparator);
drhe3710332000-09-29 13:30:53 +00002013 }else{
drhe05461c2015-12-30 13:36:57 +00002014 utf8_printf(p->out, "%s", p->rowSeparator);
drhe3710332000-09-29 13:30:53 +00002015 }
drh75897232000-05-29 14:26:00 +00002016 }
2017 break;
2018 }
drh1e5d0e92000-05-31 23:33:17 +00002019 case MODE_Html: {
2020 if( p->cnt++==0 && p->showHeader ){
mistachkinaae280e2015-12-31 19:06:24 +00002021 raw_printf(p->out,"<TR>");
drh1e5d0e92000-05-31 23:33:17 +00002022 for(i=0; i<nArg; i++){
mistachkinaae280e2015-12-31 19:06:24 +00002023 raw_printf(p->out,"<TH>");
shane43d9cb22009-10-21 14:11:48 +00002024 output_html_string(p->out, azCol[i]);
mistachkinaae280e2015-12-31 19:06:24 +00002025 raw_printf(p->out,"</TH>\n");
drh1e5d0e92000-05-31 23:33:17 +00002026 }
mistachkinaae280e2015-12-31 19:06:24 +00002027 raw_printf(p->out,"</TR>\n");
drh1e5d0e92000-05-31 23:33:17 +00002028 }
drh6a535342001-10-19 16:44:56 +00002029 if( azArg==0 ) break;
mistachkinaae280e2015-12-31 19:06:24 +00002030 raw_printf(p->out,"<TR>");
drh1e5d0e92000-05-31 23:33:17 +00002031 for(i=0; i<nArg; i++){
mistachkinaae280e2015-12-31 19:06:24 +00002032 raw_printf(p->out,"<TD>");
mistachkin44b99f72014-12-11 03:29:14 +00002033 output_html_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
mistachkinaae280e2015-12-31 19:06:24 +00002034 raw_printf(p->out,"</TD>\n");
drh1e5d0e92000-05-31 23:33:17 +00002035 }
mistachkinaae280e2015-12-31 19:06:24 +00002036 raw_printf(p->out,"</TR>\n");
drh1e5d0e92000-05-31 23:33:17 +00002037 break;
2038 }
drhfeac5f82004-08-01 00:10:45 +00002039 case MODE_Tcl: {
2040 if( p->cnt++==0 && p->showHeader ){
2041 for(i=0; i<nArg; i++){
drh2cc55692006-06-27 20:39:04 +00002042 output_c_string(p->out,azCol[i] ? azCol[i] : "");
drhe05461c2015-12-30 13:36:57 +00002043 if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator);
drhfeac5f82004-08-01 00:10:45 +00002044 }
drhe05461c2015-12-30 13:36:57 +00002045 utf8_printf(p->out, "%s", p->rowSeparator);
drhfeac5f82004-08-01 00:10:45 +00002046 }
2047 if( azArg==0 ) break;
2048 for(i=0; i<nArg; i++){
mistachkin44b99f72014-12-11 03:29:14 +00002049 output_c_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
drhe05461c2015-12-30 13:36:57 +00002050 if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator);
drhfeac5f82004-08-01 00:10:45 +00002051 }
drhe05461c2015-12-30 13:36:57 +00002052 utf8_printf(p->out, "%s", p->rowSeparator);
drhfeac5f82004-08-01 00:10:45 +00002053 break;
2054 }
drh8e64d1c2004-10-07 00:32:39 +00002055 case MODE_Csv: {
mistachkin1fe36bb2016-04-04 02:16:44 +00002056 setBinaryMode(p->out, 1);
drh8e64d1c2004-10-07 00:32:39 +00002057 if( p->cnt++==0 && p->showHeader ){
2058 for(i=0; i<nArg; i++){
drh2cc55692006-06-27 20:39:04 +00002059 output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
drh8e64d1c2004-10-07 00:32:39 +00002060 }
drhe05461c2015-12-30 13:36:57 +00002061 utf8_printf(p->out, "%s", p->rowSeparator);
drh8e64d1c2004-10-07 00:32:39 +00002062 }
drh40253262014-10-17 21:35:05 +00002063 if( nArg>0 ){
drh6976c212014-07-24 12:09:47 +00002064 for(i=0; i<nArg; i++){
2065 output_csv(p, azArg[i], i<nArg-1);
2066 }
drhe05461c2015-12-30 13:36:57 +00002067 utf8_printf(p->out, "%s", p->rowSeparator);
drh8e64d1c2004-10-07 00:32:39 +00002068 }
mistachkin1fe36bb2016-04-04 02:16:44 +00002069 setTextMode(p->out, 1);
drh8e64d1c2004-10-07 00:32:39 +00002070 break;
2071 }
drh28bd4bc2000-06-15 15:57:22 +00002072 case MODE_Insert: {
drh6a535342001-10-19 16:44:56 +00002073 if( azArg==0 ) break;
drh13fe1382017-04-08 13:42:55 +00002074 utf8_printf(p->out,"INSERT INTO %s",p->zDestTable);
2075 if( p->showHeader ){
2076 raw_printf(p->out,"(");
2077 for(i=0; i<nArg; i++){
2078 if( i>0 ) raw_printf(p->out, ",");
2079 if( quoteChar(azCol[i]) ){
2080 char *z = sqlite3_mprintf("\"%w\"", azCol[i]);
2081 utf8_printf(p->out, "%s", z);
2082 sqlite3_free(z);
2083 }else{
2084 raw_printf(p->out, "%s", azCol[i]);
drh41f5f6e2016-10-21 17:39:30 +00002085 }
mistachkin151c75a2015-04-07 21:16:40 +00002086 }
drh13fe1382017-04-08 13:42:55 +00002087 raw_printf(p->out,")");
2088 }
2089 p->cnt++;
2090 for(i=0; i<nArg; i++){
2091 raw_printf(p->out, i>0 ? "," : " VALUES(");
2092 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
2093 utf8_printf(p->out,"NULL");
2094 }else if( aiType && aiType[i]==SQLITE_TEXT ){
2095 output_quoted_escaped_string(p->out, azArg[i]);
2096 }else if( aiType && aiType[i]==SQLITE_INTEGER ){
2097 utf8_printf(p->out,"%s", azArg[i]);
2098 }else if( aiType && aiType[i]==SQLITE_FLOAT ){
2099 char z[50];
2100 double r = sqlite3_column_double(p->pStmt, i);
2101 sqlite3_snprintf(50,z,"%!.20g", r);
2102 raw_printf(p->out, "%s", z);
2103 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
2104 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
2105 int nBlob = sqlite3_column_bytes(p->pStmt, i);
2106 output_hex_blob(p->out, pBlob, nBlob);
2107 }else if( isNumber(azArg[i], 0) ){
2108 utf8_printf(p->out,"%s", azArg[i]);
2109 }else{
2110 output_quoted_escaped_string(p->out, azArg[i]);
2111 }
2112 }
2113 raw_printf(p->out,");\n");
2114 break;
2115 }
2116 case MODE_Quote: {
2117 if( azArg==0 ) break;
2118 if( p->cnt==0 && p->showHeader ){
drh59ce2c42016-11-03 13:12:28 +00002119 for(i=0; i<nArg; i++){
mistachkin2f9a6132016-11-11 05:19:45 +00002120 if( i>0 ) raw_printf(p->out, ",");
drh59ce2c42016-11-03 13:12:28 +00002121 output_quoted_string(p->out, azCol[i]);
2122 }
mistachkin2f9a6132016-11-11 05:19:45 +00002123 raw_printf(p->out,"\n");
mistachkin151c75a2015-04-07 21:16:40 +00002124 }
drh59ce2c42016-11-03 13:12:28 +00002125 p->cnt++;
drh28bd4bc2000-06-15 15:57:22 +00002126 for(i=0; i<nArg; i++){
drh13fe1382017-04-08 13:42:55 +00002127 if( i>0 ) raw_printf(p->out, ",");
shanead6b8d02009-10-22 18:12:58 +00002128 if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
drh13fe1382017-04-08 13:42:55 +00002129 utf8_printf(p->out,"NULL");
shanead6b8d02009-10-22 18:12:58 +00002130 }else if( aiType && aiType[i]==SQLITE_TEXT ){
shanead6b8d02009-10-22 18:12:58 +00002131 output_quoted_string(p->out, azArg[i]);
drh891d6b42017-03-11 00:46:57 +00002132 }else if( aiType && aiType[i]==SQLITE_INTEGER ){
drh13fe1382017-04-08 13:42:55 +00002133 utf8_printf(p->out,"%s", azArg[i]);
drh891d6b42017-03-11 00:46:57 +00002134 }else if( aiType && aiType[i]==SQLITE_FLOAT ){
2135 char z[50];
2136 double r = sqlite3_column_double(p->pStmt, i);
2137 sqlite3_snprintf(50,z,"%!.20g", r);
drh13fe1382017-04-08 13:42:55 +00002138 raw_printf(p->out, "%s", z);
shane626a6e42009-10-22 17:30:15 +00002139 }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
2140 const void *pBlob = sqlite3_column_blob(p->pStmt, i);
2141 int nBlob = sqlite3_column_bytes(p->pStmt, i);
shane626a6e42009-10-22 17:30:15 +00002142 output_hex_blob(p->out, pBlob, nBlob);
drhc8d74412004-08-31 23:41:26 +00002143 }else if( isNumber(azArg[i], 0) ){
drh13fe1382017-04-08 13:42:55 +00002144 utf8_printf(p->out,"%s", azArg[i]);
drh28bd4bc2000-06-15 15:57:22 +00002145 }else{
drh28bd4bc2000-06-15 15:57:22 +00002146 output_quoted_string(p->out, azArg[i]);
2147 }
2148 }
drh13fe1382017-04-08 13:42:55 +00002149 raw_printf(p->out,"\n");
drh6a535342001-10-19 16:44:56 +00002150 break;
drh28bd4bc2000-06-15 15:57:22 +00002151 }
mistachkin636bf9f2014-07-19 20:15:16 +00002152 case MODE_Ascii: {
2153 if( p->cnt++==0 && p->showHeader ){
2154 for(i=0; i<nArg; i++){
drhe05461c2015-12-30 13:36:57 +00002155 if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator);
2156 utf8_printf(p->out,"%s",azCol[i] ? azCol[i] : "");
mistachkin636bf9f2014-07-19 20:15:16 +00002157 }
drhe05461c2015-12-30 13:36:57 +00002158 utf8_printf(p->out, "%s", p->rowSeparator);
mistachkin636bf9f2014-07-19 20:15:16 +00002159 }
2160 if( azArg==0 ) break;
2161 for(i=0; i<nArg; i++){
drhe05461c2015-12-30 13:36:57 +00002162 if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator);
2163 utf8_printf(p->out,"%s",azArg[i] ? azArg[i] : p->nullValue);
mistachkin636bf9f2014-07-19 20:15:16 +00002164 }
drhe05461c2015-12-30 13:36:57 +00002165 utf8_printf(p->out, "%s", p->rowSeparator);
mistachkin636bf9f2014-07-19 20:15:16 +00002166 break;
2167 }
persicom1d0b8722002-04-18 02:53:04 +00002168 }
drh75897232000-05-29 14:26:00 +00002169 return 0;
2170}
2171
2172/*
shane626a6e42009-10-22 17:30:15 +00002173** This is the callback routine that the SQLite library
2174** invokes for each row of a query result.
2175*/
2176static int callback(void *pArg, int nArg, char **azArg, char **azCol){
2177 /* since we don't have type info, call the shell_callback with a NULL value */
2178 return shell_callback(pArg, nArg, azArg, azCol, NULL);
2179}
2180
drhfb546af2017-03-09 22:00:33 +00002181/*
2182** This is the callback routine from sqlite3_exec() that appends all
2183** output onto the end of a ShellText object.
2184*/
2185static int captureOutputCallback(void *pArg, int nArg, char **azArg, char **az){
2186 ShellText *p = (ShellText*)pArg;
2187 int i;
drh2fb79e92017-03-25 12:08:11 +00002188 UNUSED_PARAMETER(az);
drhfb546af2017-03-09 22:00:33 +00002189 if( p->n ) appendText(p, "|", 0);
2190 for(i=0; i<nArg; i++){
2191 if( i ) appendText(p, ",", 0);
2192 if( azArg[i] ) appendText(p, azArg[i], 0);
2193 }
2194 return 0;
2195}
2196
2197/*
2198** Generate an appropriate SELFTEST table in the main database.
2199*/
2200static void createSelftestTable(ShellState *p){
drhf157d102017-03-10 01:05:38 +00002201 char *zErrMsg = 0;
drhfb546af2017-03-09 22:00:33 +00002202 sqlite3_exec(p->db,
drhf157d102017-03-10 01:05:38 +00002203 "SAVEPOINT selftest_init;\n"
2204 "CREATE TABLE IF NOT EXISTS selftest(\n"
drhfb546af2017-03-09 22:00:33 +00002205 " tno INTEGER PRIMARY KEY,\n" /* Test number */
2206 " op TEXT,\n" /* Operator: memo run */
2207 " cmd TEXT,\n" /* Command text */
2208 " ans TEXT\n" /* Desired answer */
2209 ");"
drhf157d102017-03-10 01:05:38 +00002210 "CREATE TEMP TABLE [_shell$self](op,cmd,ans);\n"
2211 "INSERT INTO [_shell$self](rowid,op,cmd)\n"
2212 " VALUES(coalesce((SELECT (max(tno)+100)/10 FROM selftest),10),\n"
2213 " 'memo','Tests generated by --init');\n"
2214 "INSERT INTO [_shell$self]\n"
2215 " SELECT 'run',\n"
2216 " 'SELECT hex(sha3_query(''SELECT type,name,tbl_name,sql "
2217 "FROM sqlite_master ORDER BY 2'',224))',\n"
2218 " hex(sha3_query('SELECT type,name,tbl_name,sql "
2219 "FROM sqlite_master ORDER BY 2',224));\n"
2220 "INSERT INTO [_shell$self]\n"
drhfb546af2017-03-09 22:00:33 +00002221 " SELECT 'run',"
2222 " 'SELECT hex(sha3_query(''SELECT * FROM \"' ||"
2223 " printf('%w',name) || '\" NOT INDEXED'',224))',\n"
2224 " hex(sha3_query(printf('SELECT * FROM \"%w\" NOT INDEXED',name),224))\n"
2225 " FROM (\n"
2226 " SELECT name FROM sqlite_master\n"
2227 " WHERE type='table'\n"
2228 " AND name<>'selftest'\n"
2229 " AND coalesce(rootpage,0)>0\n"
2230 " )\n"
2231 " ORDER BY name;\n"
drhf157d102017-03-10 01:05:38 +00002232 "INSERT INTO [_shell$self]\n"
drhfb546af2017-03-09 22:00:33 +00002233 " VALUES('run','PRAGMA integrity_check','ok');\n"
drhf157d102017-03-10 01:05:38 +00002234 "INSERT INTO selftest(tno,op,cmd,ans)"
2235 " SELECT rowid*10,op,cmd,ans FROM [_shell$self];\n"
2236 "DROP TABLE [_shell$self];"
2237 ,0,0,&zErrMsg);
2238 if( zErrMsg ){
2239 utf8_printf(stderr, "SELFTEST initialization failure: %s\n", zErrMsg);
2240 sqlite3_free(zErrMsg);
2241 }
2242 sqlite3_exec(p->db, "RELEASE selftest_init",0,0,0);
drhfb546af2017-03-09 22:00:33 +00002243}
2244
drhf42d3182017-03-08 12:25:18 +00002245
shane626a6e42009-10-22 17:30:15 +00002246/*
drhdcd87a92014-08-18 13:45:42 +00002247** Set the destination table field of the ShellState structure to
drh33048c02001-10-01 14:29:22 +00002248** the name of the table given. Escape any quote characters in the
2249** table name.
2250*/
drhdcd87a92014-08-18 13:45:42 +00002251static void set_table_name(ShellState *p, const char *zName){
drh33048c02001-10-01 14:29:22 +00002252 int i, n;
drhf42d3182017-03-08 12:25:18 +00002253 int cQuote;
drh33048c02001-10-01 14:29:22 +00002254 char *z;
2255
2256 if( p->zDestTable ){
2257 free(p->zDestTable);
2258 p->zDestTable = 0;
2259 }
2260 if( zName==0 ) return;
drhf42d3182017-03-08 12:25:18 +00002261 cQuote = quoteChar(zName);
2262 n = strlen30(zName);
2263 if( cQuote ) n += 2;
drh33048c02001-10-01 14:29:22 +00002264 z = p->zDestTable = malloc( n+1 );
2265 if( z==0 ){
mistachkinaae280e2015-12-31 19:06:24 +00002266 raw_printf(stderr,"Error: out of memory\n");
drh33048c02001-10-01 14:29:22 +00002267 exit(1);
2268 }
2269 n = 0;
drhf42d3182017-03-08 12:25:18 +00002270 if( cQuote ) z[n++] = cQuote;
drh33048c02001-10-01 14:29:22 +00002271 for(i=0; zName[i]; i++){
2272 z[n++] = zName[i];
drhf42d3182017-03-08 12:25:18 +00002273 if( zName[i]==cQuote ) z[n++] = cQuote;
drh33048c02001-10-01 14:29:22 +00002274 }
drhf42d3182017-03-08 12:25:18 +00002275 if( cQuote ) z[n++] = cQuote;
drh33048c02001-10-01 14:29:22 +00002276 z[n] = 0;
2277}
2278
drhdd3d4592004-08-30 01:54:05 +00002279
2280/*
drhb21a8e42012-01-28 21:08:51 +00002281** Execute a query statement that will generate SQL output. Print
2282** the result columns, comma-separated, on a line and then add a
2283** semicolon terminator to the end of that line.
drh45e29d82006-11-20 16:21:10 +00002284**
drhb21a8e42012-01-28 21:08:51 +00002285** If the number of columns is 1 and that column contains text "--"
mistachkin1fe36bb2016-04-04 02:16:44 +00002286** then write the semicolon on a separate line. That way, if a
drhb21a8e42012-01-28 21:08:51 +00002287** "--" comment occurs at the end of the statement, the comment
2288** won't consume the semicolon terminator.
drhdd3d4592004-08-30 01:54:05 +00002289*/
drh157e29a2009-05-21 15:15:00 +00002290static int run_table_dump_query(
drhdcd87a92014-08-18 13:45:42 +00002291 ShellState *p, /* Query context */
drh2f464a02011-10-13 00:41:49 +00002292 const char *zSelect, /* SELECT statement to extract content */
2293 const char *zFirstRow /* Print before first row, if not NULL */
drh157e29a2009-05-21 15:15:00 +00002294){
drhdd3d4592004-08-30 01:54:05 +00002295 sqlite3_stmt *pSelect;
2296 int rc;
drhb21a8e42012-01-28 21:08:51 +00002297 int nResult;
2298 int i;
2299 const char *z;
drhc7181902014-02-27 15:04:13 +00002300 rc = sqlite3_prepare_v2(p->db, zSelect, -1, &pSelect, 0);
drhdd3d4592004-08-30 01:54:05 +00002301 if( rc!=SQLITE_OK || !pSelect ){
mistachkinaae280e2015-12-31 19:06:24 +00002302 utf8_printf(p->out, "/**** ERROR: (%d) %s *****/\n", rc,
2303 sqlite3_errmsg(p->db));
drh4384e982013-10-01 15:30:05 +00002304 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
drhdd3d4592004-08-30 01:54:05 +00002305 return rc;
2306 }
2307 rc = sqlite3_step(pSelect);
drhb21a8e42012-01-28 21:08:51 +00002308 nResult = sqlite3_column_count(pSelect);
drhdd3d4592004-08-30 01:54:05 +00002309 while( rc==SQLITE_ROW ){
drh157e29a2009-05-21 15:15:00 +00002310 if( zFirstRow ){
drhe05461c2015-12-30 13:36:57 +00002311 utf8_printf(p->out, "%s", zFirstRow);
drh157e29a2009-05-21 15:15:00 +00002312 zFirstRow = 0;
2313 }
drhb21a8e42012-01-28 21:08:51 +00002314 z = (const char*)sqlite3_column_text(pSelect, 0);
drhe05461c2015-12-30 13:36:57 +00002315 utf8_printf(p->out, "%s", z);
mistachkin1fe36bb2016-04-04 02:16:44 +00002316 for(i=1; i<nResult; i++){
drhe05461c2015-12-30 13:36:57 +00002317 utf8_printf(p->out, ",%s", sqlite3_column_text(pSelect, i));
drhb21a8e42012-01-28 21:08:51 +00002318 }
2319 if( z==0 ) z = "";
2320 while( z[0] && (z[0]!='-' || z[1]!='-') ) z++;
2321 if( z[0] ){
mistachkinaae280e2015-12-31 19:06:24 +00002322 raw_printf(p->out, "\n;\n");
drhb21a8e42012-01-28 21:08:51 +00002323 }else{
mistachkinaae280e2015-12-31 19:06:24 +00002324 raw_printf(p->out, ";\n");
mistachkin1fe36bb2016-04-04 02:16:44 +00002325 }
drhdd3d4592004-08-30 01:54:05 +00002326 rc = sqlite3_step(pSelect);
2327 }
drh2f464a02011-10-13 00:41:49 +00002328 rc = sqlite3_finalize(pSelect);
2329 if( rc!=SQLITE_OK ){
mistachkinaae280e2015-12-31 19:06:24 +00002330 utf8_printf(p->out, "/**** ERROR: (%d) %s *****/\n", rc,
2331 sqlite3_errmsg(p->db));
drh4384e982013-10-01 15:30:05 +00002332 if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
drh2f464a02011-10-13 00:41:49 +00002333 }
2334 return rc;
drhdd3d4592004-08-30 01:54:05 +00002335}
2336
shane626a6e42009-10-22 17:30:15 +00002337/*
2338** Allocate space and save off current error string.
2339*/
2340static char *save_err_msg(
2341 sqlite3 *db /* Database to query */
2342){
2343 int nErrMsg = 1+strlen30(sqlite3_errmsg(db));
drhf3cdcdc2015-04-29 16:50:28 +00002344 char *zErrMsg = sqlite3_malloc64(nErrMsg);
shane626a6e42009-10-22 17:30:15 +00002345 if( zErrMsg ){
2346 memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg);
2347 }
2348 return zErrMsg;
2349}
2350
drh34784902016-02-27 17:12:36 +00002351#ifdef __linux__
2352/*
2353** Attempt to display I/O stats on Linux using /proc/PID/io
2354*/
2355static void displayLinuxIoStats(FILE *out){
2356 FILE *in;
2357 char z[200];
2358 sqlite3_snprintf(sizeof(z), z, "/proc/%d/io", getpid());
2359 in = fopen(z, "rb");
2360 if( in==0 ) return;
2361 while( fgets(z, sizeof(z), in)!=0 ){
2362 static const struct {
2363 const char *zPattern;
2364 const char *zDesc;
2365 } aTrans[] = {
drhfc1a84c2016-02-27 19:19:22 +00002366 { "rchar: ", "Bytes received by read():" },
2367 { "wchar: ", "Bytes sent to write():" },
2368 { "syscr: ", "Read() system calls:" },
2369 { "syscw: ", "Write() system calls:" },
2370 { "read_bytes: ", "Bytes read from storage:" },
2371 { "write_bytes: ", "Bytes written to storage:" },
2372 { "cancelled_write_bytes: ", "Cancelled write bytes:" },
drh34784902016-02-27 17:12:36 +00002373 };
2374 int i;
2375 for(i=0; i<ArraySize(aTrans); i++){
2376 int n = (int)strlen(aTrans[i].zPattern);
2377 if( strncmp(aTrans[i].zPattern, z, n)==0 ){
mistachkin8145fc62016-09-16 20:39:21 +00002378 utf8_printf(out, "%-36s %s", aTrans[i].zDesc, &z[n]);
drh34784902016-02-27 17:12:36 +00002379 break;
2380 }
2381 }
2382 }
2383 fclose(in);
mistachkin1fe36bb2016-04-04 02:16:44 +00002384}
drh34784902016-02-27 17:12:36 +00002385#endif
2386
drha2df53b2017-03-10 14:36:10 +00002387/*
2388** Display a single line of status using 64-bit values.
2389*/
2390static void displayStatLine(
2391 ShellState *p, /* The shell context */
2392 char *zLabel, /* Label for this one line */
2393 char *zFormat, /* Format for the result */
2394 int iStatusCtrl, /* Which status to display */
2395 int bReset /* True to reset the stats */
2396){
2397 sqlite3_int64 iCur = -1;
2398 sqlite3_int64 iHiwtr = -1;
2399 int i, nPercent;
2400 char zLine[200];
2401 sqlite3_status64(iStatusCtrl, &iCur, &iHiwtr, bReset);
2402 for(i=0, nPercent=0; zFormat[i]; i++){
2403 if( zFormat[i]=='%' ) nPercent++;
2404 }
2405 if( nPercent>1 ){
2406 sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iCur, iHiwtr);
2407 }else{
2408 sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iHiwtr);
2409 }
2410 raw_printf(p->out, "%-36s %s\n", zLabel, zLine);
2411}
drh34784902016-02-27 17:12:36 +00002412
shane626a6e42009-10-22 17:30:15 +00002413/*
shaneh642d8b82010-07-28 16:05:34 +00002414** Display memory stats.
2415*/
2416static int display_stats(
2417 sqlite3 *db, /* Database to query */
drhdcd87a92014-08-18 13:45:42 +00002418 ShellState *pArg, /* Pointer to ShellState */
shaneh642d8b82010-07-28 16:05:34 +00002419 int bReset /* True to reset the stats */
2420){
2421 int iCur;
2422 int iHiwtr;
2423
2424 if( pArg && pArg->out ){
drha2df53b2017-03-10 14:36:10 +00002425 displayStatLine(pArg, "Memory Used:",
2426 "%lld (max %lld) bytes", SQLITE_STATUS_MEMORY_USED, bReset);
2427 displayStatLine(pArg, "Number of Outstanding Allocations:",
2428 "%lld (max %lld)", SQLITE_STATUS_MALLOC_COUNT, bReset);
drh44dec872014-08-30 15:49:25 +00002429 if( pArg->shellFlgs & SHFLG_Pagecache ){
drha2df53b2017-03-10 14:36:10 +00002430 displayStatLine(pArg, "Number of Pcache Pages Used:",
2431 "%lld (max %lld) pages", SQLITE_STATUS_PAGECACHE_USED, bReset);
drh44dec872014-08-30 15:49:25 +00002432 }
drha2df53b2017-03-10 14:36:10 +00002433 displayStatLine(pArg, "Number of Pcache Overflow Bytes:",
2434 "%lld (max %lld) bytes", SQLITE_STATUS_PAGECACHE_OVERFLOW, bReset);
drh44dec872014-08-30 15:49:25 +00002435 if( pArg->shellFlgs & SHFLG_Scratch ){
drha2df53b2017-03-10 14:36:10 +00002436 displayStatLine(pArg, "Number of Scratch Allocations Used:",
2437 "%lld (max %lld)", SQLITE_STATUS_SCRATCH_USED, bReset);
drh44dec872014-08-30 15:49:25 +00002438 }
drha2df53b2017-03-10 14:36:10 +00002439 displayStatLine(pArg, "Number of Scratch Overflow Bytes:",
2440 "%lld (max %lld) bytes", SQLITE_STATUS_SCRATCH_OVERFLOW, bReset);
2441 displayStatLine(pArg, "Largest Allocation:",
2442 "%lld bytes", SQLITE_STATUS_MALLOC_SIZE, bReset);
2443 displayStatLine(pArg, "Largest Pcache Allocation:",
2444 "%lld bytes", SQLITE_STATUS_PAGECACHE_SIZE, bReset);
2445 displayStatLine(pArg, "Largest Scratch Allocation:",
2446 "%lld bytes", SQLITE_STATUS_SCRATCH_SIZE, bReset);
shaneh642d8b82010-07-28 16:05:34 +00002447#ifdef YYTRACKMAXSTACKDEPTH
drha2df53b2017-03-10 14:36:10 +00002448 displayStatLine(pArg, "Deepest Parser Stack:",
2449 "%lld (max %lld)", SQLITE_STATUS_PARSER_STACK, bReset);
shaneh642d8b82010-07-28 16:05:34 +00002450#endif
2451 }
2452
2453 if( pArg && pArg->out && db ){
drh44dec872014-08-30 15:49:25 +00002454 if( pArg->shellFlgs & SHFLG_Lookaside ){
2455 iHiwtr = iCur = -1;
drh4ace5362014-11-10 14:42:28 +00002456 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED,
2457 &iCur, &iHiwtr, bReset);
mistachkinaae280e2015-12-31 19:06:24 +00002458 raw_printf(pArg->out,
2459 "Lookaside Slots Used: %d (max %d)\n",
drh4ace5362014-11-10 14:42:28 +00002460 iCur, iHiwtr);
2461 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT,
2462 &iCur, &iHiwtr, bReset);
mistachkinaae280e2015-12-31 19:06:24 +00002463 raw_printf(pArg->out, "Successful lookaside attempts: %d\n",
2464 iHiwtr);
drh4ace5362014-11-10 14:42:28 +00002465 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE,
2466 &iCur, &iHiwtr, bReset);
mistachkinaae280e2015-12-31 19:06:24 +00002467 raw_printf(pArg->out, "Lookaside failures due to size: %d\n",
2468 iHiwtr);
drh4ace5362014-11-10 14:42:28 +00002469 sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL,
2470 &iCur, &iHiwtr, bReset);
mistachkinaae280e2015-12-31 19:06:24 +00002471 raw_printf(pArg->out, "Lookaside failures due to OOM: %d\n",
2472 iHiwtr);
drh44dec872014-08-30 15:49:25 +00002473 }
shaneh642d8b82010-07-28 16:05:34 +00002474 iHiwtr = iCur = -1;
2475 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);
mistachkinaae280e2015-12-31 19:06:24 +00002476 raw_printf(pArg->out, "Pager Heap Usage: %d bytes\n",
2477 iCur);
drh4ace5362014-11-10 14:42:28 +00002478 iHiwtr = iCur = -1;
drhc78e6e42011-09-23 18:58:23 +00002479 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1);
mistachkinaae280e2015-12-31 19:06:24 +00002480 raw_printf(pArg->out, "Page cache hits: %d\n", iCur);
drhc78e6e42011-09-23 18:58:23 +00002481 iHiwtr = iCur = -1;
2482 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1);
mistachkin1fe36bb2016-04-04 02:16:44 +00002483 raw_printf(pArg->out, "Page cache misses: %d\n", iCur);
shaneh642d8b82010-07-28 16:05:34 +00002484 iHiwtr = iCur = -1;
drhfbbcd5d2012-03-24 20:09:33 +00002485 sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1);
mistachkin1fe36bb2016-04-04 02:16:44 +00002486 raw_printf(pArg->out, "Page cache writes: %d\n", iCur);
drhfbbcd5d2012-03-24 20:09:33 +00002487 iHiwtr = iCur = -1;
shaneh642d8b82010-07-28 16:05:34 +00002488 sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset);
mistachkinaae280e2015-12-31 19:06:24 +00002489 raw_printf(pArg->out, "Schema Heap Usage: %d bytes\n",
mistachkin1fe36bb2016-04-04 02:16:44 +00002490 iCur);
shaneh642d8b82010-07-28 16:05:34 +00002491 iHiwtr = iCur = -1;
2492 sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset);
mistachkinaae280e2015-12-31 19:06:24 +00002493 raw_printf(pArg->out, "Statement Heap/Lookaside Usage: %d bytes\n",
mistachkin1fe36bb2016-04-04 02:16:44 +00002494 iCur);
shaneh642d8b82010-07-28 16:05:34 +00002495 }
2496
2497 if( pArg && pArg->out && db && pArg->pStmt ){
drh4ace5362014-11-10 14:42:28 +00002498 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP,
2499 bReset);
mistachkinaae280e2015-12-31 19:06:24 +00002500 raw_printf(pArg->out, "Fullscan Steps: %d\n", iCur);
shaneh642d8b82010-07-28 16:05:34 +00002501 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset);
mistachkinaae280e2015-12-31 19:06:24 +00002502 raw_printf(pArg->out, "Sort Operations: %d\n", iCur);
drh4ace5362014-11-10 14:42:28 +00002503 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX,bReset);
mistachkinaae280e2015-12-31 19:06:24 +00002504 raw_printf(pArg->out, "Autoindex Inserts: %d\n", iCur);
drhbf159fa2013-06-25 22:01:22 +00002505 iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset);
mistachkinaae280e2015-12-31 19:06:24 +00002506 raw_printf(pArg->out, "Virtual Machine Steps: %d\n", iCur);
shaneh642d8b82010-07-28 16:05:34 +00002507 }
2508
drh34784902016-02-27 17:12:36 +00002509#ifdef __linux__
2510 displayLinuxIoStats(pArg->out);
2511#endif
2512
dan5a790282015-08-07 20:06:14 +00002513 /* Do not remove this machine readable comment: extra-stats-output-here */
2514
shaneh642d8b82010-07-28 16:05:34 +00002515 return 0;
2516}
2517
2518/*
dan8d1edb92014-11-05 09:07:28 +00002519** Display scan stats.
2520*/
2521static void display_scanstats(
2522 sqlite3 *db, /* Database to query */
2523 ShellState *pArg /* Pointer to ShellState */
2524){
drhf5ed7ad2015-06-15 14:43:25 +00002525#ifndef SQLITE_ENABLE_STMT_SCANSTATUS
2526 UNUSED_PARAMETER(db);
2527 UNUSED_PARAMETER(pArg);
2528#else
drh15f23c22014-11-06 12:46:16 +00002529 int i, k, n, mx;
mistachkinaae280e2015-12-31 19:06:24 +00002530 raw_printf(pArg->out, "-------- scanstats --------\n");
drh15f23c22014-11-06 12:46:16 +00002531 mx = 0;
2532 for(k=0; k<=mx; k++){
drh42f30bc2014-11-06 12:08:21 +00002533 double rEstLoop = 1.0;
2534 for(i=n=0; 1; i++){
2535 sqlite3_stmt *p = pArg->pStmt;
2536 sqlite3_int64 nLoop, nVisit;
2537 double rEst;
2538 int iSid;
2539 const char *zExplain;
2540 if( sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NLOOP, (void*)&nLoop) ){
2541 break;
2542 }
2543 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_SELECTID, (void*)&iSid);
drh15f23c22014-11-06 12:46:16 +00002544 if( iSid>mx ) mx = iSid;
drh42f30bc2014-11-06 12:08:21 +00002545 if( iSid!=k ) continue;
drh179bac32014-11-06 12:17:24 +00002546 if( n==0 ){
2547 rEstLoop = (double)nLoop;
mistachkinaae280e2015-12-31 19:06:24 +00002548 if( k>0 ) raw_printf(pArg->out, "-------- subquery %d -------\n", k);
drh179bac32014-11-06 12:17:24 +00002549 }
drh42f30bc2014-11-06 12:08:21 +00002550 n++;
2551 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NVISIT, (void*)&nVisit);
2552 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EST, (void*)&rEst);
2553 sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EXPLAIN, (void*)&zExplain);
drhe05461c2015-12-30 13:36:57 +00002554 utf8_printf(pArg->out, "Loop %2d: %s\n", n, zExplain);
drh42f30bc2014-11-06 12:08:21 +00002555 rEstLoop *= rEst;
mistachkin1fe36bb2016-04-04 02:16:44 +00002556 raw_printf(pArg->out,
drh4ace5362014-11-10 14:42:28 +00002557 " nLoop=%-8lld nRow=%-8lld estRow=%-8lld estRow/Loop=%-8g\n",
drh9a06d302014-11-07 13:52:44 +00002558 nLoop, nVisit, (sqlite3_int64)(rEstLoop+0.5), rEst
drh42f30bc2014-11-06 12:08:21 +00002559 );
dan8d1edb92014-11-05 09:07:28 +00002560 }
dan8d1edb92014-11-05 09:07:28 +00002561 }
mistachkinaae280e2015-12-31 19:06:24 +00002562 raw_printf(pArg->out, "---------------------------\n");
drh15f23c22014-11-06 12:46:16 +00002563#endif
dan8d1edb92014-11-05 09:07:28 +00002564}
2565
2566/*
dana98bf362013-11-13 18:35:01 +00002567** Parameter azArray points to a zero-terminated array of strings. zStr
2568** points to a single nul-terminated string. Return non-zero if zStr
2569** is equal, according to strcmp(), to any of the strings in the array.
2570** Otherwise, return zero.
2571*/
2572static int str_in_array(const char *zStr, const char **azArray){
2573 int i;
2574 for(i=0; azArray[i]; i++){
2575 if( 0==strcmp(zStr, azArray[i]) ) return 1;
2576 }
2577 return 0;
2578}
2579
2580/*
2581** If compiled statement pSql appears to be an EXPLAIN statement, allocate
drhdcd87a92014-08-18 13:45:42 +00002582** and populate the ShellState.aiIndent[] array with the number of
mistachkin1fe36bb2016-04-04 02:16:44 +00002583** spaces each opcode should be indented before it is output.
dana98bf362013-11-13 18:35:01 +00002584**
2585** The indenting rules are:
2586**
2587** * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent
2588** all opcodes that occur between the p2 jump destination and the opcode
2589** itself by 2 spaces.
2590**
drh01752bc2013-11-14 23:59:33 +00002591** * For each "Goto", if the jump destination is earlier in the program
2592** and ends on one of:
drhe73f0592014-01-21 22:25:45 +00002593** Yield SeekGt SeekLt RowSetRead Rewind
drhfe705102014-03-06 13:38:37 +00002594** or if the P1 parameter is one instead of zero,
drh01752bc2013-11-14 23:59:33 +00002595** then indent all opcodes between the earlier instruction
drhd2447442013-11-13 19:01:41 +00002596** and "Goto" by 2 spaces.
dana98bf362013-11-13 18:35:01 +00002597*/
drhdcd87a92014-08-18 13:45:42 +00002598static void explain_data_prepare(ShellState *p, sqlite3_stmt *pSql){
dana98bf362013-11-13 18:35:01 +00002599 const char *zSql; /* The text of the SQL statement */
2600 const char *z; /* Used to check if this is an EXPLAIN */
2601 int *abYield = 0; /* True if op is an OP_Yield */
2602 int nAlloc = 0; /* Allocated size of p->aiIndent[], abYield */
danc4650bb2013-11-18 08:41:06 +00002603 int iOp; /* Index of operation in p->aiIndent[] */
dana98bf362013-11-13 18:35:01 +00002604
drh8ad0de32014-03-20 18:45:27 +00002605 const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext",
2606 "NextIfOpen", "PrevIfOpen", 0 };
drh4ace5362014-11-10 14:42:28 +00002607 const char *azYield[] = { "Yield", "SeekLT", "SeekGT", "RowSetRead",
2608 "Rewind", 0 };
dana98bf362013-11-13 18:35:01 +00002609 const char *azGoto[] = { "Goto", 0 };
2610
2611 /* Try to figure out if this is really an EXPLAIN statement. If this
2612 ** cannot be verified, return early. */
drh87a24aa2016-02-09 20:04:07 +00002613 if( sqlite3_column_count(pSql)!=8 ){
2614 p->cMode = p->mode;
2615 return;
2616 }
dana98bf362013-11-13 18:35:01 +00002617 zSql = sqlite3_sql(pSql);
2618 if( zSql==0 ) return;
2619 for(z=zSql; *z==' ' || *z=='\t' || *z=='\n' || *z=='\f' || *z=='\r'; z++);
drh87a24aa2016-02-09 20:04:07 +00002620 if( sqlite3_strnicmp(z, "explain", 7) ){
2621 p->cMode = p->mode;
2622 return;
2623 }
dana98bf362013-11-13 18:35:01 +00002624
2625 for(iOp=0; SQLITE_ROW==sqlite3_step(pSql); iOp++){
2626 int i;
danc4650bb2013-11-18 08:41:06 +00002627 int iAddr = sqlite3_column_int(pSql, 0);
dana98bf362013-11-13 18:35:01 +00002628 const char *zOp = (const char*)sqlite3_column_text(pSql, 1);
danc4650bb2013-11-18 08:41:06 +00002629
2630 /* Set p2 to the P2 field of the current opcode. Then, assuming that
2631 ** p2 is an instruction address, set variable p2op to the index of that
2632 ** instruction in the aiIndent[] array. p2 and p2op may be different if
2633 ** the current instruction is part of a sub-program generated by an
2634 ** SQL trigger or foreign key. */
dana98bf362013-11-13 18:35:01 +00002635 int p2 = sqlite3_column_int(pSql, 3);
danc4650bb2013-11-18 08:41:06 +00002636 int p2op = (p2 + (iOp-iAddr));
dana98bf362013-11-13 18:35:01 +00002637
2638 /* Grow the p->aiIndent array as required */
2639 if( iOp>=nAlloc ){
drh87a24aa2016-02-09 20:04:07 +00002640 if( iOp==0 ){
2641 /* Do further verfication that this is explain output. Abort if
2642 ** it is not */
2643 static const char *explainCols[] = {
2644 "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment" };
2645 int jj;
2646 for(jj=0; jj<ArraySize(explainCols); jj++){
2647 if( strcmp(sqlite3_column_name(pSql,jj),explainCols[jj])!=0 ){
2648 p->cMode = p->mode;
2649 sqlite3_reset(pSql);
2650 return;
2651 }
2652 }
2653 }
dana98bf362013-11-13 18:35:01 +00002654 nAlloc += 100;
drhf3cdcdc2015-04-29 16:50:28 +00002655 p->aiIndent = (int*)sqlite3_realloc64(p->aiIndent, nAlloc*sizeof(int));
2656 abYield = (int*)sqlite3_realloc64(abYield, nAlloc*sizeof(int));
dana98bf362013-11-13 18:35:01 +00002657 }
2658 abYield[iOp] = str_in_array(zOp, azYield);
2659 p->aiIndent[iOp] = 0;
2660 p->nIndent = iOp+1;
2661
2662 if( str_in_array(zOp, azNext) ){
danc4650bb2013-11-18 08:41:06 +00002663 for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2;
dana98bf362013-11-13 18:35:01 +00002664 }
drhfe705102014-03-06 13:38:37 +00002665 if( str_in_array(zOp, azGoto) && p2op<p->nIndent
2666 && (abYield[p2op] || sqlite3_column_int(pSql, 2))
2667 ){
drheacd29d2016-04-15 15:03:27 +00002668 for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2;
dana98bf362013-11-13 18:35:01 +00002669 }
2670 }
2671
danc4650bb2013-11-18 08:41:06 +00002672 p->iIndent = 0;
dana98bf362013-11-13 18:35:01 +00002673 sqlite3_free(abYield);
2674 sqlite3_reset(pSql);
2675}
2676
2677/*
2678** Free the array allocated by explain_data_prepare().
2679*/
drhdcd87a92014-08-18 13:45:42 +00002680static void explain_data_delete(ShellState *p){
dana98bf362013-11-13 18:35:01 +00002681 sqlite3_free(p->aiIndent);
2682 p->aiIndent = 0;
2683 p->nIndent = 0;
danc4650bb2013-11-18 08:41:06 +00002684 p->iIndent = 0;
dana98bf362013-11-13 18:35:01 +00002685}
2686
2687/*
drheacd29d2016-04-15 15:03:27 +00002688** Disable and restore .wheretrace and .selecttrace settings.
2689*/
2690#if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
2691extern int sqlite3SelectTrace;
2692static int savedSelectTrace;
2693#endif
2694#if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
2695extern int sqlite3WhereTrace;
2696static int savedWhereTrace;
2697#endif
2698static void disable_debug_trace_modes(void){
2699#if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
2700 savedSelectTrace = sqlite3SelectTrace;
2701 sqlite3SelectTrace = 0;
2702#endif
2703#if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
2704 savedWhereTrace = sqlite3WhereTrace;
2705 sqlite3WhereTrace = 0;
2706#endif
2707}
2708static void restore_debug_trace_modes(void){
2709#if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
2710 sqlite3SelectTrace = savedSelectTrace;
2711#endif
2712#if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
2713 sqlite3WhereTrace = savedWhereTrace;
2714#endif
2715}
2716
2717/*
2718** Run a prepared statement
2719*/
2720static void exec_prepared_stmt(
2721 ShellState *pArg, /* Pointer to ShellState */
2722 sqlite3_stmt *pStmt, /* Statment to run */
2723 int (*xCallback)(void*,int,char**,char**,int*) /* Callback function */
2724){
2725 int rc;
2726
2727 /* perform the first step. this will tell us if we
2728 ** have a result set or not and how wide it is.
2729 */
2730 rc = sqlite3_step(pStmt);
2731 /* if we have a result set... */
2732 if( SQLITE_ROW == rc ){
2733 /* if we have a callback... */
2734 if( xCallback ){
2735 /* allocate space for col name ptr, value ptr, and type */
2736 int nCol = sqlite3_column_count(pStmt);
2737 void *pData = sqlite3_malloc64(3*nCol*sizeof(const char*) + 1);
2738 if( !pData ){
2739 rc = SQLITE_NOMEM;
2740 }else{
2741 char **azCols = (char **)pData; /* Names of result columns */
2742 char **azVals = &azCols[nCol]; /* Results */
2743 int *aiTypes = (int *)&azVals[nCol]; /* Result types */
2744 int i, x;
2745 assert(sizeof(int) <= sizeof(char *));
2746 /* save off ptrs to column names */
2747 for(i=0; i<nCol; i++){
2748 azCols[i] = (char *)sqlite3_column_name(pStmt, i);
2749 }
2750 do{
2751 /* extract the data and data types */
2752 for(i=0; i<nCol; i++){
2753 aiTypes[i] = x = sqlite3_column_type(pStmt, i);
2754 if( x==SQLITE_BLOB && pArg && pArg->cMode==MODE_Insert ){
2755 azVals[i] = "";
2756 }else{
2757 azVals[i] = (char*)sqlite3_column_text(pStmt, i);
2758 }
2759 if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){
2760 rc = SQLITE_NOMEM;
2761 break; /* from for */
2762 }
2763 } /* end for */
2764
2765 /* if data and types extracted successfully... */
2766 if( SQLITE_ROW == rc ){
2767 /* call the supplied callback with the result row data */
2768 if( xCallback(pArg, nCol, azVals, azCols, aiTypes) ){
2769 rc = SQLITE_ABORT;
2770 }else{
2771 rc = sqlite3_step(pStmt);
2772 }
2773 }
2774 } while( SQLITE_ROW == rc );
2775 sqlite3_free(pData);
2776 }
2777 }else{
2778 do{
2779 rc = sqlite3_step(pStmt);
2780 } while( rc == SQLITE_ROW );
2781 }
2782 }
2783}
2784
2785/*
mistachkin1fe36bb2016-04-04 02:16:44 +00002786** Execute a statement or set of statements. Print
2787** any result rows/columns depending on the current mode
shane626a6e42009-10-22 17:30:15 +00002788** set via the supplied callback.
2789**
mistachkin1fe36bb2016-04-04 02:16:44 +00002790** This is very similar to SQLite's built-in sqlite3_exec()
2791** function except it takes a slightly different callback
shane626a6e42009-10-22 17:30:15 +00002792** and callback data argument.
2793*/
2794static int shell_exec(
drhdcd87a92014-08-18 13:45:42 +00002795 sqlite3 *db, /* An open database */
2796 const char *zSql, /* SQL to be evaluated */
shane626a6e42009-10-22 17:30:15 +00002797 int (*xCallback)(void*,int,char**,char**,int*), /* Callback function */
drhdcd87a92014-08-18 13:45:42 +00002798 /* (not the same as sqlite3_exec) */
2799 ShellState *pArg, /* Pointer to ShellState */
2800 char **pzErrMsg /* Error msg written here */
shane626a6e42009-10-22 17:30:15 +00002801){
dan4564ced2010-01-05 04:59:56 +00002802 sqlite3_stmt *pStmt = NULL; /* Statement to execute. */
2803 int rc = SQLITE_OK; /* Return Code */
drhb07028f2011-10-14 21:49:18 +00002804 int rc2;
dan4564ced2010-01-05 04:59:56 +00002805 const char *zLeftover; /* Tail of unprocessed SQL */
shane626a6e42009-10-22 17:30:15 +00002806
2807 if( pzErrMsg ){
2808 *pzErrMsg = NULL;
2809 }
2810
shaneb9fc17d2009-10-22 21:23:35 +00002811 while( zSql[0] && (SQLITE_OK == rc) ){
drheacd29d2016-04-15 15:03:27 +00002812 static const char *zStmtSql;
shaneb9fc17d2009-10-22 21:23:35 +00002813 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
2814 if( SQLITE_OK != rc ){
shane626a6e42009-10-22 17:30:15 +00002815 if( pzErrMsg ){
2816 *pzErrMsg = save_err_msg(db);
2817 }
2818 }else{
shaneb9fc17d2009-10-22 21:23:35 +00002819 if( !pStmt ){
2820 /* this happens for a comment or white-space */
2821 zSql = zLeftover;
drhf0693c82011-10-11 20:41:54 +00002822 while( IsSpace(zSql[0]) ) zSql++;
shaneb9fc17d2009-10-22 21:23:35 +00002823 continue;
2824 }
drheacd29d2016-04-15 15:03:27 +00002825 zStmtSql = sqlite3_sql(pStmt);
drh60275612016-11-03 02:25:30 +00002826 if( zStmtSql==0 ) zStmtSql = "";
drheacd29d2016-04-15 15:03:27 +00002827 while( IsSpace(zStmtSql[0]) ) zStmtSql++;
shane626a6e42009-10-22 17:30:15 +00002828
shaneh642d8b82010-07-28 16:05:34 +00002829 /* save off the prepared statment handle and reset row count */
2830 if( pArg ){
2831 pArg->pStmt = pStmt;
2832 pArg->cnt = 0;
2833 }
2834
shanehb7977c52010-01-18 18:17:10 +00002835 /* echo the sql statement if echo on */
drhe6e1d122017-03-09 13:50:49 +00002836 if( pArg && ShellHasFlag(pArg, SHFLG_Echo) ){
drhe05461c2015-12-30 13:36:57 +00002837 utf8_printf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
drha8c62df2010-02-15 15:47:18 +00002838 }
shanehb7977c52010-01-18 18:17:10 +00002839
drhefbf3b12014-02-28 20:47:24 +00002840 /* Show the EXPLAIN QUERY PLAN if .eqp is on */
drheacd29d2016-04-15 15:03:27 +00002841 if( pArg && pArg->autoEQP && sqlite3_strlike("EXPLAIN%",zStmtSql,0)!=0 ){
drhefbf3b12014-02-28 20:47:24 +00002842 sqlite3_stmt *pExplain;
drheacd29d2016-04-15 15:03:27 +00002843 char *zEQP;
2844 disable_debug_trace_modes();
2845 zEQP = sqlite3_mprintf("EXPLAIN QUERY PLAN %s", zStmtSql);
drhefbf3b12014-02-28 20:47:24 +00002846 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
2847 if( rc==SQLITE_OK ){
2848 while( sqlite3_step(pExplain)==SQLITE_ROW ){
mistachkinaae280e2015-12-31 19:06:24 +00002849 raw_printf(pArg->out,"--EQP-- %d,",sqlite3_column_int(pExplain, 0));
2850 raw_printf(pArg->out,"%d,", sqlite3_column_int(pExplain, 1));
2851 raw_printf(pArg->out,"%d,", sqlite3_column_int(pExplain, 2));
drhe05461c2015-12-30 13:36:57 +00002852 utf8_printf(pArg->out,"%s\n", sqlite3_column_text(pExplain, 3));
drhefbf3b12014-02-28 20:47:24 +00002853 }
2854 }
2855 sqlite3_finalize(pExplain);
2856 sqlite3_free(zEQP);
drheacd29d2016-04-15 15:03:27 +00002857 if( pArg->autoEQP>=2 ){
2858 /* Also do an EXPLAIN for ".eqp full" mode */
2859 zEQP = sqlite3_mprintf("EXPLAIN %s", zStmtSql);
2860 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
2861 if( rc==SQLITE_OK ){
2862 pArg->cMode = MODE_Explain;
2863 explain_data_prepare(pArg, pExplain);
2864 exec_prepared_stmt(pArg, pExplain, xCallback);
2865 explain_data_delete(pArg);
2866 }
2867 sqlite3_finalize(pExplain);
2868 sqlite3_free(zEQP);
2869 }
2870 restore_debug_trace_modes();
drhefbf3b12014-02-28 20:47:24 +00002871 }
2872
drh700c2522016-02-09 18:39:25 +00002873 if( pArg ){
2874 pArg->cMode = pArg->mode;
drh87a24aa2016-02-09 20:04:07 +00002875 if( pArg->autoExplain
2876 && sqlite3_column_count(pStmt)==8
drheacd29d2016-04-15 15:03:27 +00002877 && sqlite3_strlike("EXPLAIN%", zStmtSql,0)==0
drh700c2522016-02-09 18:39:25 +00002878 ){
2879 pArg->cMode = MODE_Explain;
2880 }
mistachkin1fe36bb2016-04-04 02:16:44 +00002881
drh700c2522016-02-09 18:39:25 +00002882 /* If the shell is currently in ".explain" mode, gather the extra
2883 ** data required to add indents to the output.*/
2884 if( pArg->cMode==MODE_Explain ){
2885 explain_data_prepare(pArg, pStmt);
2886 }
dana98bf362013-11-13 18:35:01 +00002887 }
2888
drheacd29d2016-04-15 15:03:27 +00002889 exec_prepared_stmt(pArg, pStmt, xCallback);
dana98bf362013-11-13 18:35:01 +00002890 explain_data_delete(pArg);
2891
shaneh642d8b82010-07-28 16:05:34 +00002892 /* print usage stats if stats on */
2893 if( pArg && pArg->statsOn ){
2894 display_stats(db, pArg, 0);
2895 }
2896
dan8d1edb92014-11-05 09:07:28 +00002897 /* print loop-counters if required */
2898 if( pArg && pArg->scanstatsOn ){
2899 display_scanstats(db, pArg);
2900 }
2901
mistachkin1fe36bb2016-04-04 02:16:44 +00002902 /* Finalize the statement just executed. If this fails, save a
dan4564ced2010-01-05 04:59:56 +00002903 ** copy of the error message. Otherwise, set zSql to point to the
2904 ** next statement to execute. */
drhb07028f2011-10-14 21:49:18 +00002905 rc2 = sqlite3_finalize(pStmt);
2906 if( rc!=SQLITE_NOMEM ) rc = rc2;
dan4564ced2010-01-05 04:59:56 +00002907 if( rc==SQLITE_OK ){
shaneb9fc17d2009-10-22 21:23:35 +00002908 zSql = zLeftover;
drhf0693c82011-10-11 20:41:54 +00002909 while( IsSpace(zSql[0]) ) zSql++;
dan4564ced2010-01-05 04:59:56 +00002910 }else if( pzErrMsg ){
2911 *pzErrMsg = save_err_msg(db);
shane626a6e42009-10-22 17:30:15 +00002912 }
shaneh642d8b82010-07-28 16:05:34 +00002913
2914 /* clear saved stmt handle */
2915 if( pArg ){
2916 pArg->pStmt = NULL;
2917 }
shane626a6e42009-10-22 17:30:15 +00002918 }
shaneb9fc17d2009-10-22 21:23:35 +00002919 } /* end while */
shane626a6e42009-10-22 17:30:15 +00002920
2921 return rc;
2922}
2923
drhe611f142017-03-08 11:44:00 +00002924/*
2925** Release memory previously allocated by tableColumnList().
2926*/
2927static void freeColumnList(char **azCol){
2928 int i;
2929 for(i=1; azCol[i]; i++){
2930 sqlite3_free(azCol[i]);
2931 }
2932 /* azCol[0] is a static string */
2933 sqlite3_free(azCol);
2934}
2935
2936/*
2937** Return a list of pointers to strings which are the names of all
2938** columns in table zTab. The memory to hold the names is dynamically
2939** allocated and must be released by the caller using a subsequent call
2940** to freeColumnList().
2941**
2942** The azCol[0] entry is usually NULL. However, if zTab contains a rowid
2943** value that needs to be preserved, then azCol[0] is filled in with the
2944** name of the rowid column.
2945**
2946** The first regular column in the table is azCol[1]. The list is terminated
2947** by an entry with azCol[i]==0.
2948*/
2949static char **tableColumnList(ShellState *p, const char *zTab){
2950 char **azCol = 0;
2951 sqlite3_stmt *pStmt;
2952 char *zSql;
2953 int nCol = 0;
2954 int nAlloc = 0;
2955 int nPK = 0; /* Number of PRIMARY KEY columns seen */
2956 int isIPK = 0; /* True if one PRIMARY KEY column of type INTEGER */
drhe6e1d122017-03-09 13:50:49 +00002957 int preserveRowid = ShellHasFlag(p, SHFLG_PreserveRowid);
drhe611f142017-03-08 11:44:00 +00002958 int rc;
2959
2960 zSql = sqlite3_mprintf("PRAGMA table_info=%Q", zTab);
2961 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2962 sqlite3_free(zSql);
2963 if( rc ) return 0;
2964 while( sqlite3_step(pStmt)==SQLITE_ROW ){
2965 if( nCol>=nAlloc-2 ){
2966 nAlloc = nAlloc*2 + nCol + 10;
2967 azCol = sqlite3_realloc(azCol, nAlloc*sizeof(azCol[0]));
2968 if( azCol==0 ){
2969 raw_printf(stderr, "Error: out of memory\n");
2970 exit(1);
2971 }
2972 }
2973 azCol[++nCol] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 1));
2974 if( sqlite3_column_int(pStmt, 5) ){
2975 nPK++;
2976 if( nPK==1
2977 && sqlite3_stricmp((const char*)sqlite3_column_text(pStmt,2),
2978 "INTEGER")==0
2979 ){
2980 isIPK = 1;
2981 }else{
2982 isIPK = 0;
2983 }
2984 }
2985 }
2986 sqlite3_finalize(pStmt);
2987 azCol[0] = 0;
2988 azCol[nCol+1] = 0;
2989
2990 /* The decision of whether or not a rowid really needs to be preserved
2991 ** is tricky. We never need to preserve a rowid for a WITHOUT ROWID table
2992 ** or a table with an INTEGER PRIMARY KEY. We are unable to preserve
2993 ** rowids on tables where the rowid is inaccessible because there are other
2994 ** columns in the table named "rowid", "_rowid_", and "oid".
2995 */
2996 if( preserveRowid && isIPK ){
2997 /* If a single PRIMARY KEY column with type INTEGER was seen, then it
2998 ** might be an alise for the ROWID. But it might also be a WITHOUT ROWID
2999 ** table or a INTEGER PRIMARY KEY DESC column, neither of which are
3000 ** ROWID aliases. To distinguish these cases, check to see if
3001 ** there is a "pk" entry in "PRAGMA index_list". There will be
3002 ** no "pk" index if the PRIMARY KEY really is an alias for the ROWID.
3003 */
3004 zSql = sqlite3_mprintf("SELECT 1 FROM pragma_index_list(%Q)"
3005 " WHERE origin='pk'", zTab);
3006 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
3007 sqlite3_free(zSql);
3008 if( rc ){
3009 freeColumnList(azCol);
3010 return 0;
3011 }
3012 rc = sqlite3_step(pStmt);
3013 sqlite3_finalize(pStmt);
3014 preserveRowid = rc==SQLITE_ROW;
3015 }
3016 if( preserveRowid ){
3017 /* Only preserve the rowid if we can find a name to use for the
3018 ** rowid */
3019 static char *azRowid[] = { "rowid", "_rowid_", "oid" };
3020 int i, j;
3021 for(j=0; j<3; j++){
3022 for(i=1; i<=nCol; i++){
3023 if( sqlite3_stricmp(azRowid[j],azCol[i])==0 ) break;
3024 }
3025 if( i>nCol ){
3026 /* At this point, we know that azRowid[j] is not the name of any
3027 ** ordinary column in the table. Verify that azRowid[j] is a valid
3028 ** name for the rowid before adding it to azCol[0]. WITHOUT ROWID
3029 ** tables will fail this last check */
drhe611f142017-03-08 11:44:00 +00003030 rc = sqlite3_table_column_metadata(p->db,0,zTab,azRowid[j],0,0,0,0,0);
3031 if( rc==SQLITE_OK ) azCol[0] = azRowid[j];
3032 break;
3033 }
3034 }
3035 }
3036 return azCol;
3037}
3038
drh33048c02001-10-01 14:29:22 +00003039/*
drhf8563c02017-03-09 18:13:52 +00003040** Toggle the reverse_unordered_selects setting.
3041*/
3042static void toggleSelectOrder(sqlite3 *db){
3043 sqlite3_stmt *pStmt = 0;
3044 int iSetting = 0;
3045 char zStmt[100];
3046 sqlite3_prepare_v2(db, "PRAGMA reverse_unordered_selects", -1, &pStmt, 0);
3047 if( sqlite3_step(pStmt)==SQLITE_ROW ){
3048 iSetting = sqlite3_column_int(pStmt, 0);
3049 }
3050 sqlite3_finalize(pStmt);
3051 sqlite3_snprintf(sizeof(zStmt), zStmt,
3052 "PRAGMA reverse_unordered_selects(%d)", !iSetting);
3053 sqlite3_exec(db, zStmt, 0, 0, 0);
3054}
3055
3056/*
drh4c653a02000-06-07 01:27:47 +00003057** This is a different callback routine used for dumping the database.
3058** Each row received by this callback consists of a table name,
3059** the table type ("index" or "table") and SQL to create the table.
3060** This routine should print text sufficient to recreate the table.
3061*/
drh701ff6a2017-03-22 12:51:34 +00003062static int dump_callback(void *pArg, int nArg, char **azArg, char **azNotUsed){
danielk19772a02e332004-06-05 08:04:36 +00003063 int rc;
3064 const char *zTable;
3065 const char *zType;
3066 const char *zSql;
drhdcd87a92014-08-18 13:45:42 +00003067 ShellState *p = (ShellState *)pArg;
danielk19772a02e332004-06-05 08:04:36 +00003068
drh701ff6a2017-03-22 12:51:34 +00003069 UNUSED_PARAMETER(azNotUsed);
drh4c653a02000-06-07 01:27:47 +00003070 if( nArg!=3 ) return 1;
danielk19772a02e332004-06-05 08:04:36 +00003071 zTable = azArg[0];
3072 zType = azArg[1];
3073 zSql = azArg[2];
mistachkin1fe36bb2016-04-04 02:16:44 +00003074
drh00b950d2005-09-11 02:03:03 +00003075 if( strcmp(zTable, "sqlite_sequence")==0 ){
drhe611f142017-03-08 11:44:00 +00003076 raw_printf(p->out, "DELETE FROM sqlite_sequence;\n");
drh7ed10322013-08-07 16:04:27 +00003077 }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
mistachkinaae280e2015-12-31 19:06:24 +00003078 raw_printf(p->out, "ANALYZE sqlite_master;\n");
drh00b950d2005-09-11 02:03:03 +00003079 }else if( strncmp(zTable, "sqlite_", 7)==0 ){
3080 return 0;
drh45e29d82006-11-20 16:21:10 +00003081 }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
3082 char *zIns;
3083 if( !p->writableSchema ){
mistachkinaae280e2015-12-31 19:06:24 +00003084 raw_printf(p->out, "PRAGMA writable_schema=ON;\n");
drh45e29d82006-11-20 16:21:10 +00003085 p->writableSchema = 1;
3086 }
3087 zIns = sqlite3_mprintf(
3088 "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
3089 "VALUES('table','%q','%q',0,'%q');",
3090 zTable, zTable, zSql);
drhe05461c2015-12-30 13:36:57 +00003091 utf8_printf(p->out, "%s\n", zIns);
drh45e29d82006-11-20 16:21:10 +00003092 sqlite3_free(zIns);
3093 return 0;
drh00b950d2005-09-11 02:03:03 +00003094 }else{
drh79f20e92016-12-13 23:22:39 +00003095 printSchemaLine(p->out, zSql, ";\n");
drhf8eb96a2005-02-03 00:42:34 +00003096 }
danielk19772a02e332004-06-05 08:04:36 +00003097
3098 if( strcmp(zType, "table")==0 ){
drhf42d3182017-03-08 12:25:18 +00003099 ShellText sSelect;
3100 ShellText sTable;
drhe611f142017-03-08 11:44:00 +00003101 char **azCol;
3102 int i;
3103 char *savedDestTable;
3104 int savedMode;
mistachkin1fe36bb2016-04-04 02:16:44 +00003105
drhe611f142017-03-08 11:44:00 +00003106 azCol = tableColumnList(p, zTable);
3107 if( azCol==0 ){
3108 p->nErr++;
3109 return 0;
danielk19772a02e332004-06-05 08:04:36 +00003110 }
3111
drhbf92ec02012-03-22 12:50:34 +00003112 /* Always quote the table name, even if it appears to be pure ascii,
3113 ** in case it is a keyword. Ex: INSERT INTO "table" ... */
drhf42d3182017-03-08 12:25:18 +00003114 initText(&sTable);
3115 appendText(&sTable, zTable, quoteChar(zTable));
drhe611f142017-03-08 11:44:00 +00003116 /* If preserving the rowid, add a column list after the table name.
3117 ** In other words: "INSERT INTO tab(rowid,a,b,c,...) VALUES(...)"
3118 ** instead of the usual "INSERT INTO tab VALUES(...)".
3119 */
3120 if( azCol[0] ){
3121 appendText(&sTable, "(", 0);
3122 appendText(&sTable, azCol[0], 0);
3123 for(i=1; azCol[i]; i++){
3124 appendText(&sTable, ",", 0);
drhf42d3182017-03-08 12:25:18 +00003125 appendText(&sTable, azCol[i], quoteChar(azCol[i]));
danielk19772a02e332004-06-05 08:04:36 +00003126 }
drhe611f142017-03-08 11:44:00 +00003127 appendText(&sTable, ")", 0);
danielk19772a02e332004-06-05 08:04:36 +00003128 }
danielk19772a02e332004-06-05 08:04:36 +00003129
drhe611f142017-03-08 11:44:00 +00003130 /* Build an appropriate SELECT statement */
drhf42d3182017-03-08 12:25:18 +00003131 initText(&sSelect);
drhe611f142017-03-08 11:44:00 +00003132 appendText(&sSelect, "SELECT ", 0);
3133 if( azCol[0] ){
3134 appendText(&sSelect, azCol[0], 0);
3135 appendText(&sSelect, ",", 0);
drhdd3d4592004-08-30 01:54:05 +00003136 }
drhe611f142017-03-08 11:44:00 +00003137 for(i=1; azCol[i]; i++){
drhf42d3182017-03-08 12:25:18 +00003138 appendText(&sSelect, azCol[i], quoteChar(azCol[i]));
drhe611f142017-03-08 11:44:00 +00003139 if( azCol[i+1] ){
3140 appendText(&sSelect, ",", 0);
3141 }
3142 }
3143 freeColumnList(azCol);
3144 appendText(&sSelect, " FROM ", 0);
drhf42d3182017-03-08 12:25:18 +00003145 appendText(&sSelect, zTable, quoteChar(zTable));
drhe611f142017-03-08 11:44:00 +00003146
3147 savedDestTable = p->zDestTable;
3148 savedMode = p->mode;
3149 p->zDestTable = sTable.z;
3150 p->mode = p->cMode = MODE_Insert;
3151 rc = shell_exec(p->db, sSelect.z, shell_callback, p, 0);
drhf8563c02017-03-09 18:13:52 +00003152 if( (rc&0xff)==SQLITE_CORRUPT ){
3153 raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n");
3154 toggleSelectOrder(p->db);
3155 shell_exec(p->db, sSelect.z, shell_callback, p, 0);
3156 toggleSelectOrder(p->db);
3157 }
drhe611f142017-03-08 11:44:00 +00003158 p->zDestTable = savedDestTable;
3159 p->mode = savedMode;
drhf42d3182017-03-08 12:25:18 +00003160 freeText(&sTable);
3161 freeText(&sSelect);
drhe611f142017-03-08 11:44:00 +00003162 if( rc ) p->nErr++;
drh4c653a02000-06-07 01:27:47 +00003163 }
drh4c653a02000-06-07 01:27:47 +00003164 return 0;
3165}
3166
3167/*
drh45e29d82006-11-20 16:21:10 +00003168** Run zQuery. Use dump_callback() as the callback routine so that
3169** the contents of the query are output as SQL statements.
3170**
drhdd3d4592004-08-30 01:54:05 +00003171** If we get a SQLITE_CORRUPT error, rerun the query after appending
3172** "ORDER BY rowid DESC" to the end.
3173*/
3174static int run_schema_dump_query(
mistachkin1fe36bb2016-04-04 02:16:44 +00003175 ShellState *p,
drh2f464a02011-10-13 00:41:49 +00003176 const char *zQuery
drhdd3d4592004-08-30 01:54:05 +00003177){
3178 int rc;
drh2f464a02011-10-13 00:41:49 +00003179 char *zErr = 0;
3180 rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr);
drhdd3d4592004-08-30 01:54:05 +00003181 if( rc==SQLITE_CORRUPT ){
3182 char *zQ2;
drh4f21c4a2008-12-10 22:15:00 +00003183 int len = strlen30(zQuery);
mistachkinaae280e2015-12-31 19:06:24 +00003184 raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n");
drh2f464a02011-10-13 00:41:49 +00003185 if( zErr ){
mistachkinaae280e2015-12-31 19:06:24 +00003186 utf8_printf(p->out, "/****** %s ******/\n", zErr);
drh2f464a02011-10-13 00:41:49 +00003187 sqlite3_free(zErr);
3188 zErr = 0;
3189 }
drhdd3d4592004-08-30 01:54:05 +00003190 zQ2 = malloc( len+100 );
3191 if( zQ2==0 ) return rc;
drh8c5058b2012-04-16 17:22:30 +00003192 sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery);
drh2f464a02011-10-13 00:41:49 +00003193 rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr);
3194 if( rc ){
mistachkinaae280e2015-12-31 19:06:24 +00003195 utf8_printf(p->out, "/****** ERROR: %s ******/\n", zErr);
drh2f464a02011-10-13 00:41:49 +00003196 }else{
3197 rc = SQLITE_CORRUPT;
3198 }
3199 sqlite3_free(zErr);
drhdd3d4592004-08-30 01:54:05 +00003200 free(zQ2);
3201 }
3202 return rc;
3203}
3204
3205/*
drh75897232000-05-29 14:26:00 +00003206** Text of a help message
3207*/
persicom1d0b8722002-04-18 02:53:04 +00003208static char zHelp[] =
drha0daa752016-09-16 11:53:10 +00003209#ifndef SQLITE_OMIT_AUTHORIZATION
drhde613c62016-04-04 17:23:10 +00003210 ".auth ON|OFF Show authorizer callbacks\n"
drha0daa752016-09-16 11:53:10 +00003211#endif
drh9ff849f2009-02-04 20:55:57 +00003212 ".backup ?DB? FILE Backup DB (default \"main\") to FILE\n"
drhc2ce0be2014-05-29 12:36:14 +00003213 ".bail on|off Stop after hitting an error. Default OFF\n"
mistachkinf21979d2015-01-18 05:35:01 +00003214 ".binary on|off Turn binary output on or off. Default OFF\n"
drhdf12f1c2015-12-07 21:46:19 +00003215 ".changes on|off Show number of rows changed by SQL\n"
drh2db82112016-09-15 21:35:24 +00003216 ".check GLOB Fail if output since .testcase does not match\n"
drh4bbcf102014-02-06 02:46:08 +00003217 ".clone NEWDB Clone data into NEWDB from the existing database\n"
jplyon6a65bb32003-05-04 07:25:57 +00003218 ".databases List names and files of attached databases\n"
drh0e55db12015-02-06 14:51:13 +00003219 ".dbinfo ?DB? Show status information about the database\n"
drhb860bc92004-08-04 15:16:55 +00003220 ".dump ?TABLE? ... Dump the database in an SQL text format\n"
shane86f5bdb2009-10-24 02:00:07 +00003221 " If TABLE specified, only dump tables matching\n"
3222 " LIKE pattern TABLE.\n"
drhc2ce0be2014-05-29 12:36:14 +00003223 ".echo on|off Turn command echo on or off\n"
drheacd29d2016-04-15 15:03:27 +00003224 ".eqp on|off|full Enable or disable automatic EXPLAIN QUERY PLAN\n"
drh75897232000-05-29 14:26:00 +00003225 ".exit Exit this program\n"
drh700c2522016-02-09 18:39:25 +00003226 ".explain ?on|off|auto? Turn EXPLAIN output mode on or off or to automatic\n"
drh4926fec2016-04-13 15:33:42 +00003227 ".fullschema ?--indent? Show schema and the content of sqlite_stat tables\n"
drhc2ce0be2014-05-29 12:36:14 +00003228 ".headers on|off Turn display of headers on or off\n"
drh75897232000-05-29 14:26:00 +00003229 ".help Show this message\n"
drhb860bc92004-08-04 15:16:55 +00003230 ".import FILE TABLE Import data from FILE into TABLE\n"
drh16eb5942016-11-03 13:01:38 +00003231#ifndef SQLITE_OMIT_TEST_CONTROL
3232 ".imposter INDEX TABLE Create imposter table TABLE on index INDEX\n"
3233#endif
drh0e55db12015-02-06 14:51:13 +00003234 ".indexes ?TABLE? Show names of all indexes\n"
3235 " If TABLE specified, only show indexes for tables\n"
shane86f5bdb2009-10-24 02:00:07 +00003236 " matching LIKE pattern TABLE.\n"
drhae5e4452007-05-03 17:18:36 +00003237#ifdef SQLITE_ENABLE_IOTRACE
3238 ".iotrace FILE Enable I/O diagnostic logging to FILE\n"
3239#endif
drh1a513372015-05-02 17:40:23 +00003240 ".limit ?LIMIT? ?VAL? Display or change the value of an SQLITE_LIMIT\n"
drh3fd9f332016-12-16 18:41:11 +00003241 ".lint OPTIONS Report potential schema issues. Options:\n"
3242 " fkey-indexes Find missing foreign key indexes\n"
drh70df4fe2006-06-13 15:12:21 +00003243#ifndef SQLITE_OMIT_LOAD_EXTENSION
drh1e397f82006-06-08 15:28:43 +00003244 ".load FILE ?ENTRY? Load an extension library\n"
drh70df4fe2006-06-13 15:12:21 +00003245#endif
drh127f9d72010-02-23 01:47:00 +00003246 ".log FILE|off Turn logging on or off. FILE can be stderr/stdout\n"
danielk19776b77a362005-01-13 11:10:25 +00003247 ".mode MODE ?TABLE? Set output mode where MODE is one of:\n"
mistachkine0d68852014-12-11 03:12:33 +00003248 " ascii Columns/rows delimited by 0x1F and 0x1E\n"
drh3b584fa2004-09-24 12:50:03 +00003249 " csv Comma-separated values\n"
drhb860bc92004-08-04 15:16:55 +00003250 " column Left-aligned columns. (See .width)\n"
3251 " html HTML <table> code\n"
3252 " insert SQL insert statements for TABLE\n"
3253 " line One value per line\n"
drh0c5cd962017-02-14 21:47:46 +00003254 " list Values delimited by \"|\"\n"
drh41f5f6e2016-10-21 17:39:30 +00003255 " quote Escape answers as for SQL\n"
drhb860bc92004-08-04 15:16:55 +00003256 " tabs Tab-separated values\n"
3257 " tcl TCL list elements\n"
drh078b1fd2012-09-21 13:40:02 +00003258 ".nullvalue STRING Use STRING in place of NULL values\n"
drhc2ce0be2014-05-29 12:36:14 +00003259 ".once FILENAME Output for the next SQL command only to FILENAME\n"
mistachkin8145fc62016-09-16 20:39:21 +00003260 ".open ?--new? ?FILE? Close existing database and reopen FILE\n"
drhcd0509e2016-09-16 00:26:08 +00003261 " The --new starts with an empty file\n"
drhc2ce0be2014-05-29 12:36:14 +00003262 ".output ?FILENAME? Send output to FILENAME or stdout\n"
drh078b1fd2012-09-21 13:40:02 +00003263 ".print STRING... Print literal STRING\n"
persicom7e2dfdd2002-04-18 02:46:52 +00003264 ".prompt MAIN CONTINUE Replace the standard prompts\n"
persicom7e2dfdd2002-04-18 02:46:52 +00003265 ".quit Exit this program\n"
drhdaffd0e2001-04-11 14:28:42 +00003266 ".read FILENAME Execute SQL in FILENAME\n"
drh9ff849f2009-02-04 20:55:57 +00003267 ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n"
drh5c7976f2014-02-10 19:59:27 +00003268 ".save FILE Write in-memory database into FILE\n"
drh15f23c22014-11-06 12:46:16 +00003269 ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off\n"
drh4926fec2016-04-13 15:33:42 +00003270 ".schema ?PATTERN? Show the CREATE statements matching PATTERN\n"
3271 " Add --indent for pretty-printing\n"
drha5d75ba2017-03-15 14:20:34 +00003272 ".selftest ?--init? Run tests defined in the SELFTEST table\n"
mistachkine0d68852014-12-11 03:12:33 +00003273 ".separator COL ?ROW? Change the column separator and optionally the row\n"
3274 " separator for both the output mode and .import\n"
drhe6229612014-08-18 15:08:26 +00003275#if defined(SQLITE_ENABLE_SESSION)
3276 ".session CMD ... Create or control sessions\n"
3277#endif
drh1554bc82017-03-08 16:10:34 +00003278 ".sha3sum ?OPTIONS...? Compute a SHA3 hash of database content\n"
drh62cdde52014-05-28 20:22:28 +00003279 ".shell CMD ARGS... Run CMD ARGS... in a system shell\n"
drhdd45df82002-04-18 12:39:03 +00003280 ".show Show the current values for various settings\n"
drh34784902016-02-27 17:12:36 +00003281 ".stats ?on|off? Show stats or turn stats on or off\n"
drh62cdde52014-05-28 20:22:28 +00003282 ".system CMD ARGS... Run CMD ARGS... in a system shell\n"
shane86f5bdb2009-10-24 02:00:07 +00003283 ".tables ?TABLE? List names of tables\n"
3284 " If TABLE specified, only list tables matching\n"
3285 " LIKE pattern TABLE.\n"
drh760c8162016-09-16 02:52:22 +00003286 ".testcase NAME Begin redirecting output to 'testcase-out.txt'\n"
drh2dfbbca2000-07-28 14:32:48 +00003287 ".timeout MS Try opening locked tables for MS milliseconds\n"
drhc2ce0be2014-05-29 12:36:14 +00003288 ".timer on|off Turn SQL timer on or off\n"
drh42f64e52012-04-04 16:56:23 +00003289 ".trace FILE|off Output each SQL statement as it is run\n"
drh790f2872015-11-28 18:06:36 +00003290 ".vfsinfo ?AUX? Information about the top-level VFS\n"
drhb19e7352016-01-12 19:37:20 +00003291 ".vfslist List all available VFSes\n"
drhde60fc22011-12-14 17:53:36 +00003292 ".vfsname ?AUX? Print the name of the VFS stack\n"
shanehe2aa9d72009-11-06 17:20:17 +00003293 ".width NUM1 NUM2 ... Set column widths for \"column\" mode\n"
drh62cdde52014-05-28 20:22:28 +00003294 " Negative values right-justify\n"
drh75897232000-05-29 14:26:00 +00003295;
3296
drhe6229612014-08-18 15:08:26 +00003297#if defined(SQLITE_ENABLE_SESSION)
3298/*
3299** Print help information for the ".sessions" command
3300*/
3301void session_help(ShellState *p){
mistachkin899c5c92016-04-03 20:50:02 +00003302 raw_printf(p->out,
drhe6229612014-08-18 15:08:26 +00003303 ".session ?NAME? SUBCOMMAND ?ARGS...?\n"
3304 "If ?NAME? is omitted, the first defined session is used.\n"
3305 "Subcommands:\n"
3306 " attach TABLE Attach TABLE\n"
3307 " changeset FILE Write a changeset into FILE\n"
3308 " close Close one session\n"
3309 " enable ?BOOLEAN? Set or query the enable bit\n"
mistachkin1fe36bb2016-04-04 02:16:44 +00003310 " filter GLOB... Reject tables matching GLOBs\n"
drhe6229612014-08-18 15:08:26 +00003311 " indirect ?BOOLEAN? Mark or query the indirect status\n"
3312 " isempty Query whether the session is empty\n"
3313 " list List currently open session names\n"
3314 " open DB NAME Open a new session on DB\n"
3315 " patchset FILE Write a patchset into FILE\n"
3316 );
3317}
3318#endif
3319
3320
drhdaffd0e2001-04-11 14:28:42 +00003321/* Forward reference */
drhdcd87a92014-08-18 13:45:42 +00003322static int process_input(ShellState *p, FILE *in);
drh2db82112016-09-15 21:35:24 +00003323
drh2db82112016-09-15 21:35:24 +00003324/*
dan11da0022016-12-17 08:18:05 +00003325** Read the content of file zName into memory obtained from sqlite3_malloc64()
3326** and return a pointer to the buffer. The caller is responsible for freeing
3327** the memory.
drh2db82112016-09-15 21:35:24 +00003328**
dan11da0022016-12-17 08:18:05 +00003329** If parameter pnByte is not NULL, (*pnByte) is set to the number of bytes
3330** read.
3331**
3332** For convenience, a nul-terminator byte is always appended to the data read
3333** from the file before the buffer is returned. This byte is not included in
3334** the final value of (*pnByte), if applicable.
3335**
3336** NULL is returned if any error is encountered. The final value of *pnByte
3337** is undefined in this case.
drh2db82112016-09-15 21:35:24 +00003338*/
dan11da0022016-12-17 08:18:05 +00003339static char *readFile(const char *zName, int *pnByte){
drh2db82112016-09-15 21:35:24 +00003340 FILE *in = fopen(zName, "rb");
3341 long nIn;
drhd1459152016-09-16 19:11:03 +00003342 size_t nRead;
drh2db82112016-09-15 21:35:24 +00003343 char *pBuf;
3344 if( in==0 ) return 0;
3345 fseek(in, 0, SEEK_END);
3346 nIn = ftell(in);
3347 rewind(in);
drhd1459152016-09-16 19:11:03 +00003348 pBuf = sqlite3_malloc64( nIn+1 );
drh2db82112016-09-15 21:35:24 +00003349 if( pBuf==0 ) return 0;
drhd1459152016-09-16 19:11:03 +00003350 nRead = fread(pBuf, nIn, 1, in);
3351 fclose(in);
3352 if( nRead!=1 ){
drh2db82112016-09-15 21:35:24 +00003353 sqlite3_free(pBuf);
3354 return 0;
3355 }
drhd1459152016-09-16 19:11:03 +00003356 pBuf[nIn] = 0;
dan11da0022016-12-17 08:18:05 +00003357 if( pnByte ) *pnByte = nIn;
drh2db82112016-09-15 21:35:24 +00003358 return pBuf;
3359}
3360
drhba5b0932014-07-24 12:39:59 +00003361/*
3362** Implementation of the "readfile(X)" SQL function. The entire content
3363** of the file named X is read and returned as a BLOB. NULL is returned
3364** if the file does not exist or is unreadable.
3365*/
3366static void readfileFunc(
3367 sqlite3_context *context,
3368 int argc,
3369 sqlite3_value **argv
3370){
3371 const char *zName;
drhba5b0932014-07-24 12:39:59 +00003372 void *pBuf;
dan11da0022016-12-17 08:18:05 +00003373 int nBuf;
drhba5b0932014-07-24 12:39:59 +00003374
drhf5ed7ad2015-06-15 14:43:25 +00003375 UNUSED_PARAMETER(argc);
drhba5b0932014-07-24 12:39:59 +00003376 zName = (const char*)sqlite3_value_text(argv[0]);
3377 if( zName==0 ) return;
dan11da0022016-12-17 08:18:05 +00003378 pBuf = readFile(zName, &nBuf);
3379 if( pBuf ) sqlite3_result_blob(context, pBuf, nBuf, sqlite3_free);
drhba5b0932014-07-24 12:39:59 +00003380}
3381
3382/*
3383** Implementation of the "writefile(X,Y)" SQL function. The argument Y
3384** is written into file X. The number of bytes written is returned. Or
3385** NULL is returned if something goes wrong, such as being unable to open
3386** file X for writing.
3387*/
3388static void writefileFunc(
3389 sqlite3_context *context,
3390 int argc,
3391 sqlite3_value **argv
3392){
3393 FILE *out;
3394 const char *z;
drhba5b0932014-07-24 12:39:59 +00003395 sqlite3_int64 rc;
3396 const char *zFile;
3397
drhf5ed7ad2015-06-15 14:43:25 +00003398 UNUSED_PARAMETER(argc);
drhba5b0932014-07-24 12:39:59 +00003399 zFile = (const char*)sqlite3_value_text(argv[0]);
3400 if( zFile==0 ) return;
3401 out = fopen(zFile, "wb");
3402 if( out==0 ) return;
3403 z = (const char*)sqlite3_value_blob(argv[1]);
3404 if( z==0 ){
drhba5b0932014-07-24 12:39:59 +00003405 rc = 0;
3406 }else{
drh490fe862014-08-11 14:21:32 +00003407 rc = fwrite(z, 1, sqlite3_value_bytes(argv[1]), out);
drhba5b0932014-07-24 12:39:59 +00003408 }
3409 fclose(out);
3410 sqlite3_result_int64(context, rc);
3411}
drhdaffd0e2001-04-11 14:28:42 +00003412
drhe6229612014-08-18 15:08:26 +00003413#if defined(SQLITE_ENABLE_SESSION)
3414/*
3415** Close a single OpenSession object and release all of its associated
3416** resources.
3417*/
3418static void session_close(OpenSession *pSession){
3419 int i;
3420 sqlite3session_delete(pSession->p);
3421 sqlite3_free(pSession->zName);
3422 for(i=0; i<pSession->nFilter; i++){
3423 sqlite3_free(pSession->azFilter[i]);
3424 }
3425 sqlite3_free(pSession->azFilter);
3426 memset(pSession, 0, sizeof(OpenSession));
3427}
3428#endif
3429
3430/*
drh51b55a32016-04-04 12:38:05 +00003431** Close all OpenSession objects and release all associated resources.
drhe6229612014-08-18 15:08:26 +00003432*/
drhe6229612014-08-18 15:08:26 +00003433#if defined(SQLITE_ENABLE_SESSION)
drh51b55a32016-04-04 12:38:05 +00003434static void session_close_all(ShellState *p){
drhe6229612014-08-18 15:08:26 +00003435 int i;
3436 for(i=0; i<p->nSession; i++){
3437 session_close(&p->aSession[i]);
3438 }
3439 p->nSession = 0;
drhe6229612014-08-18 15:08:26 +00003440}
drh51b55a32016-04-04 12:38:05 +00003441#else
3442# define session_close_all(X)
3443#endif
drhe6229612014-08-18 15:08:26 +00003444
drh75897232000-05-29 14:26:00 +00003445/*
drh03168ca2014-08-18 20:01:31 +00003446** Implementation of the xFilter function for an open session. Omit
3447** any tables named by ".session filter" but let all other table through.
3448*/
3449#if defined(SQLITE_ENABLE_SESSION)
3450static int session_filter(void *pCtx, const char *zTab){
3451 OpenSession *pSession = (OpenSession*)pCtx;
3452 int i;
3453 for(i=0; i<pSession->nFilter; i++){
3454 if( sqlite3_strglob(pSession->azFilter[i], zTab)==0 ) return 0;
3455 }
3456 return 1;
3457}
3458#endif
3459
3460/*
drh44c2eb12003-04-30 11:38:26 +00003461** Make sure the database is open. If it is not, then open it. If
3462** the database fails to open, print an error message and exit.
3463*/
drhdcd87a92014-08-18 13:45:42 +00003464static void open_db(ShellState *p, int keepAlive){
drh44c2eb12003-04-30 11:38:26 +00003465 if( p->db==0 ){
drhbbb0be82012-06-27 16:12:27 +00003466 sqlite3_initialize();
danielk19774f057f92004-06-08 00:02:33 +00003467 sqlite3_open(p->zDbFilename, &p->db);
mistachkin8e189222015-04-19 21:43:16 +00003468 globalDb = p->db;
mistachkin8e189222015-04-19 21:43:16 +00003469 if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){
mistachkin1fe36bb2016-04-04 02:16:44 +00003470 utf8_printf(stderr,"Error: unable to open database \"%s\": %s\n",
mistachkin8e189222015-04-19 21:43:16 +00003471 p->zDbFilename, sqlite3_errmsg(p->db));
drh05782482013-10-24 15:20:20 +00003472 if( keepAlive ) return;
drh22fbcb82004-02-01 01:22:50 +00003473 exit(1);
drh44c2eb12003-04-30 11:38:26 +00003474 }
drhc2e87a32006-06-27 15:16:14 +00003475#ifndef SQLITE_OMIT_LOAD_EXTENSION
3476 sqlite3_enable_load_extension(p->db, 1);
3477#endif
mistachkin8e189222015-04-19 21:43:16 +00003478 sqlite3_create_function(p->db, "readfile", 1, SQLITE_UTF8, 0,
drhba5b0932014-07-24 12:39:59 +00003479 readfileFunc, 0, 0);
mistachkin8e189222015-04-19 21:43:16 +00003480 sqlite3_create_function(p->db, "writefile", 2, SQLITE_UTF8, 0,
drhba5b0932014-07-24 12:39:59 +00003481 writefileFunc, 0, 0);
drh1554bc82017-03-08 16:10:34 +00003482 sqlite3_create_function(p->db, "sha3", 1, SQLITE_UTF8, 0,
3483 sha3Func, 0, 0);
3484 sqlite3_create_function(p->db, "sha3", 2, SQLITE_UTF8, 0,
3485 sha3Func, 0, 0);
3486 sqlite3_create_function(p->db, "sha3_query", 1, SQLITE_UTF8, 0,
3487 sha3QueryFunc, 0, 0);
3488 sqlite3_create_function(p->db, "sha3_query", 2, SQLITE_UTF8, 0,
3489 sha3QueryFunc, 0, 0);
drh44c2eb12003-04-30 11:38:26 +00003490 }
3491}
3492
3493/*
drhfeac5f82004-08-01 00:10:45 +00003494** Do C-language style dequoting.
3495**
mistachkinf21979d2015-01-18 05:35:01 +00003496** \a -> alarm
3497** \b -> backspace
drhfeac5f82004-08-01 00:10:45 +00003498** \t -> tab
3499** \n -> newline
mistachkinf21979d2015-01-18 05:35:01 +00003500** \v -> vertical tab
3501** \f -> form feed
drhfeac5f82004-08-01 00:10:45 +00003502** \r -> carriage return
mistachkinf21979d2015-01-18 05:35:01 +00003503** \s -> space
drh4c56b992013-06-27 13:26:55 +00003504** \" -> "
mistachkinf21979d2015-01-18 05:35:01 +00003505** \' -> '
drhfeac5f82004-08-01 00:10:45 +00003506** \\ -> backslash
mistachkinf21979d2015-01-18 05:35:01 +00003507** \NNN -> ascii character NNN in octal
drhfeac5f82004-08-01 00:10:45 +00003508*/
3509static void resolve_backslashes(char *z){
shane7d3846a2008-12-11 02:58:26 +00003510 int i, j;
3511 char c;
drhc2ce0be2014-05-29 12:36:14 +00003512 while( *z && *z!='\\' ) z++;
drhfeac5f82004-08-01 00:10:45 +00003513 for(i=j=0; (c = z[i])!=0; i++, j++){
drh4b608032015-04-15 19:25:25 +00003514 if( c=='\\' && z[i+1]!=0 ){
drhfeac5f82004-08-01 00:10:45 +00003515 c = z[++i];
mistachkinf21979d2015-01-18 05:35:01 +00003516 if( c=='a' ){
3517 c = '\a';
3518 }else if( c=='b' ){
3519 c = '\b';
drhfeac5f82004-08-01 00:10:45 +00003520 }else if( c=='t' ){
3521 c = '\t';
mistachkinf21979d2015-01-18 05:35:01 +00003522 }else if( c=='n' ){
3523 c = '\n';
3524 }else if( c=='v' ){
3525 c = '\v';
3526 }else if( c=='f' ){
3527 c = '\f';
drhfeac5f82004-08-01 00:10:45 +00003528 }else if( c=='r' ){
3529 c = '\r';
mistachkinf21979d2015-01-18 05:35:01 +00003530 }else if( c=='"' ){
3531 c = '"';
3532 }else if( c=='\'' ){
3533 c = '\'';
drh4c56b992013-06-27 13:26:55 +00003534 }else if( c=='\\' ){
3535 c = '\\';
drhfeac5f82004-08-01 00:10:45 +00003536 }else if( c>='0' && c<='7' ){
drhaa816082005-12-29 12:53:09 +00003537 c -= '0';
drhfeac5f82004-08-01 00:10:45 +00003538 if( z[i+1]>='0' && z[i+1]<='7' ){
3539 i++;
3540 c = (c<<3) + z[i] - '0';
3541 if( z[i+1]>='0' && z[i+1]<='7' ){
3542 i++;
3543 c = (c<<3) + z[i] - '0';
3544 }
3545 }
3546 }
3547 }
3548 z[j] = c;
3549 }
drhc2ce0be2014-05-29 12:36:14 +00003550 if( j<i ) z[j] = 0;
drhfeac5f82004-08-01 00:10:45 +00003551}
3552
3553/*
drh348d19c2013-06-03 12:47:43 +00003554** Return the value of a hexadecimal digit. Return -1 if the input
3555** is not a hex digit.
drhc28490c2006-10-26 14:25:58 +00003556*/
drh348d19c2013-06-03 12:47:43 +00003557static int hexDigitValue(char c){
3558 if( c>='0' && c<='9' ) return c - '0';
3559 if( c>='a' && c<='f' ) return c - 'a' + 10;
3560 if( c>='A' && c<='F' ) return c - 'A' + 10;
3561 return -1;
drhc28490c2006-10-26 14:25:58 +00003562}
3563
3564/*
drh7d9f3942013-04-03 01:26:54 +00003565** Interpret zArg as an integer value, possibly with suffixes.
3566*/
3567static sqlite3_int64 integerValue(const char *zArg){
3568 sqlite3_int64 v = 0;
3569 static const struct { char *zSuffix; int iMult; } aMult[] = {
3570 { "KiB", 1024 },
3571 { "MiB", 1024*1024 },
3572 { "GiB", 1024*1024*1024 },
3573 { "KB", 1000 },
3574 { "MB", 1000000 },
3575 { "GB", 1000000000 },
3576 { "K", 1000 },
3577 { "M", 1000000 },
3578 { "G", 1000000000 },
3579 };
3580 int i;
3581 int isNeg = 0;
3582 if( zArg[0]=='-' ){
3583 isNeg = 1;
3584 zArg++;
3585 }else if( zArg[0]=='+' ){
3586 zArg++;
3587 }
drh348d19c2013-06-03 12:47:43 +00003588 if( zArg[0]=='0' && zArg[1]=='x' ){
3589 int x;
3590 zArg += 2;
3591 while( (x = hexDigitValue(zArg[0]))>=0 ){
3592 v = (v<<4) + x;
3593 zArg++;
3594 }
3595 }else{
3596 while( IsDigit(zArg[0]) ){
3597 v = v*10 + zArg[0] - '0';
3598 zArg++;
3599 }
drh7d9f3942013-04-03 01:26:54 +00003600 }
drhc2bed0a2013-05-24 11:57:50 +00003601 for(i=0; i<ArraySize(aMult); i++){
drh7d9f3942013-04-03 01:26:54 +00003602 if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){
3603 v *= aMult[i].iMult;
3604 break;
3605 }
3606 }
3607 return isNeg? -v : v;
3608}
3609
3610/*
drh348d19c2013-06-03 12:47:43 +00003611** Interpret zArg as either an integer or a boolean value. Return 1 or 0
3612** for TRUE and FALSE. Return the integer value if appropriate.
3613*/
drhe6e1d122017-03-09 13:50:49 +00003614static int booleanValue(const char *zArg){
drh348d19c2013-06-03 12:47:43 +00003615 int i;
3616 if( zArg[0]=='0' && zArg[1]=='x' ){
3617 for(i=2; hexDigitValue(zArg[i])>=0; i++){}
3618 }else{
3619 for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
3620 }
3621 if( i>0 && zArg[i]==0 ) return (int)(integerValue(zArg) & 0xffffffff);
3622 if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){
3623 return 1;
3624 }
3625 if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){
3626 return 0;
3627 }
mistachkinaae280e2015-12-31 19:06:24 +00003628 utf8_printf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
drh348d19c2013-06-03 12:47:43 +00003629 zArg);
3630 return 0;
3631}
3632
3633/*
drhe6e1d122017-03-09 13:50:49 +00003634** Set or clear a shell flag according to a boolean value.
3635*/
3636static void setOrClearFlag(ShellState *p, unsigned mFlag, const char *zArg){
3637 if( booleanValue(zArg) ){
3638 ShellSetFlag(p, mFlag);
3639 }else{
3640 ShellClearFlag(p, mFlag);
3641 }
3642}
3643
3644/*
drh42f64e52012-04-04 16:56:23 +00003645** Close an output file, assuming it is not stderr or stdout
3646*/
3647static void output_file_close(FILE *f){
3648 if( f && f!=stdout && f!=stderr ) fclose(f);
3649}
3650
3651/*
3652** Try to open an output file. The names "stdout" and "stderr" are
mistachkin1fe36bb2016-04-04 02:16:44 +00003653** recognized and do the right thing. NULL is returned if the output
drh42f64e52012-04-04 16:56:23 +00003654** filename is "off".
3655*/
3656static FILE *output_file_open(const char *zFile){
3657 FILE *f;
3658 if( strcmp(zFile,"stdout")==0 ){
3659 f = stdout;
3660 }else if( strcmp(zFile, "stderr")==0 ){
3661 f = stderr;
3662 }else if( strcmp(zFile, "off")==0 ){
3663 f = 0;
3664 }else{
3665 f = fopen(zFile, "wb");
3666 if( f==0 ){
mistachkinaae280e2015-12-31 19:06:24 +00003667 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile);
drh42f64e52012-04-04 16:56:23 +00003668 }
3669 }
3670 return f;
3671}
3672
drhd12602a2016-12-07 15:49:02 +00003673#if !defined(SQLITE_UNTESTABLE)
drhc10b9da2016-11-20 17:59:59 +00003674#if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)
drh42f64e52012-04-04 16:56:23 +00003675/*
3676** A routine for handling output from sqlite3_trace().
3677*/
drh4b363a52016-07-23 20:27:41 +00003678static int sql_trace_callback(
3679 unsigned mType,
3680 void *pArg,
3681 void *pP,
3682 void *pX
3683){
drh42f64e52012-04-04 16:56:23 +00003684 FILE *f = (FILE*)pArg;
drhb0df5402016-08-01 17:06:44 +00003685 UNUSED_PARAMETER(mType);
3686 UNUSED_PARAMETER(pP);
drh4b2590e2014-08-19 19:28:00 +00003687 if( f ){
drh4b363a52016-07-23 20:27:41 +00003688 const char *z = (const char*)pX;
drh4b2590e2014-08-19 19:28:00 +00003689 int i = (int)strlen(z);
3690 while( i>0 && z[i-1]==';' ){ i--; }
drhe05461c2015-12-30 13:36:57 +00003691 utf8_printf(f, "%.*s;\n", i, z);
drh4b2590e2014-08-19 19:28:00 +00003692 }
drh4b363a52016-07-23 20:27:41 +00003693 return 0;
drh42f64e52012-04-04 16:56:23 +00003694}
drhc10b9da2016-11-20 17:59:59 +00003695#endif
3696#endif
drh42f64e52012-04-04 16:56:23 +00003697
3698/*
drhd8621b92012-04-17 09:09:33 +00003699** A no-op routine that runs with the ".breakpoint" doc-command. This is
3700** a useful spot to set a debugger breakpoint.
3701*/
3702static void test_breakpoint(void){
3703 static int nCall = 0;
3704 nCall++;
3705}
3706
3707/*
mistachkin636bf9f2014-07-19 20:15:16 +00003708** An object used to read a CSV and other files for import.
drhdb95f682013-06-26 22:46:00 +00003709*/
mistachkin636bf9f2014-07-19 20:15:16 +00003710typedef struct ImportCtx ImportCtx;
3711struct ImportCtx {
drhdb95f682013-06-26 22:46:00 +00003712 const char *zFile; /* Name of the input file */
3713 FILE *in; /* Read the CSV text from this input stream */
3714 char *z; /* Accumulated text for a field */
3715 int n; /* Number of bytes in z */
3716 int nAlloc; /* Space allocated for z[] */
3717 int nLine; /* Current line number */
3718 int cTerm; /* Character that terminated the most recent field */
mistachkin636bf9f2014-07-19 20:15:16 +00003719 int cColSep; /* The column separator character. (Usually ",") */
3720 int cRowSep; /* The row separator character. (Usually "\n") */
drhdb95f682013-06-26 22:46:00 +00003721};
3722
3723/* Append a single byte to z[] */
mistachkin636bf9f2014-07-19 20:15:16 +00003724static void import_append_char(ImportCtx *p, int c){
drhdb95f682013-06-26 22:46:00 +00003725 if( p->n+1>=p->nAlloc ){
3726 p->nAlloc += p->nAlloc + 100;
drhf3cdcdc2015-04-29 16:50:28 +00003727 p->z = sqlite3_realloc64(p->z, p->nAlloc);
drhdb95f682013-06-26 22:46:00 +00003728 if( p->z==0 ){
mistachkinaae280e2015-12-31 19:06:24 +00003729 raw_printf(stderr, "out of memory\n");
drhdb95f682013-06-26 22:46:00 +00003730 exit(1);
3731 }
3732 }
3733 p->z[p->n++] = (char)c;
3734}
3735
3736/* Read a single field of CSV text. Compatible with rfc4180 and extended
3737** with the option of having a separator other than ",".
3738**
3739** + Input comes from p->in.
3740** + Store results in p->z of length p->n. Space to hold p->z comes
drhf3cdcdc2015-04-29 16:50:28 +00003741** from sqlite3_malloc64().
mistachkin636bf9f2014-07-19 20:15:16 +00003742** + Use p->cSep as the column separator. The default is ",".
3743** + Use p->rSep as the row separator. The default is "\n".
drhdb95f682013-06-26 22:46:00 +00003744** + Keep track of the line number in p->nLine.
3745** + Store the character that terminates the field in p->cTerm. Store
3746** EOF on end-of-file.
3747** + Report syntax errors on stderr
3748*/
mistachkin44723ce2015-03-21 02:22:37 +00003749static char *SQLITE_CDECL csv_read_one_field(ImportCtx *p){
mistachkin636bf9f2014-07-19 20:15:16 +00003750 int c;
3751 int cSep = p->cColSep;
3752 int rSep = p->cRowSep;
drhdb95f682013-06-26 22:46:00 +00003753 p->n = 0;
3754 c = fgetc(p->in);
3755 if( c==EOF || seenInterrupt ){
3756 p->cTerm = EOF;
3757 return 0;
3758 }
3759 if( c=='"' ){
mistachkin636bf9f2014-07-19 20:15:16 +00003760 int pc, ppc;
drhdb95f682013-06-26 22:46:00 +00003761 int startLine = p->nLine;
3762 int cQuote = c;
drha81ad172013-12-11 14:00:04 +00003763 pc = ppc = 0;
drhdb95f682013-06-26 22:46:00 +00003764 while( 1 ){
3765 c = fgetc(p->in);
mistachkin636bf9f2014-07-19 20:15:16 +00003766 if( c==rSep ) p->nLine++;
drhdb95f682013-06-26 22:46:00 +00003767 if( c==cQuote ){
3768 if( pc==cQuote ){
3769 pc = 0;
3770 continue;
3771 }
3772 }
3773 if( (c==cSep && pc==cQuote)
mistachkin636bf9f2014-07-19 20:15:16 +00003774 || (c==rSep && pc==cQuote)
3775 || (c==rSep && pc=='\r' && ppc==cQuote)
drhdb95f682013-06-26 22:46:00 +00003776 || (c==EOF && pc==cQuote)
3777 ){
3778 do{ p->n--; }while( p->z[p->n]!=cQuote );
drhdb95f682013-06-26 22:46:00 +00003779 p->cTerm = c;
3780 break;
3781 }
3782 if( pc==cQuote && c!='\r' ){
mistachkinaae280e2015-12-31 19:06:24 +00003783 utf8_printf(stderr, "%s:%d: unescaped %c character\n",
drhdb95f682013-06-26 22:46:00 +00003784 p->zFile, p->nLine, cQuote);
3785 }
3786 if( c==EOF ){
mistachkinaae280e2015-12-31 19:06:24 +00003787 utf8_printf(stderr, "%s:%d: unterminated %c-quoted field\n",
drhdb95f682013-06-26 22:46:00 +00003788 p->zFile, startLine, cQuote);
mistachkin636bf9f2014-07-19 20:15:16 +00003789 p->cTerm = c;
drhdb95f682013-06-26 22:46:00 +00003790 break;
3791 }
mistachkin636bf9f2014-07-19 20:15:16 +00003792 import_append_char(p, c);
drha81ad172013-12-11 14:00:04 +00003793 ppc = pc;
drhdb95f682013-06-26 22:46:00 +00003794 pc = c;
drhd0a64dc2013-06-30 20:24:26 +00003795 }
drhdb95f682013-06-26 22:46:00 +00003796 }else{
mistachkin636bf9f2014-07-19 20:15:16 +00003797 while( c!=EOF && c!=cSep && c!=rSep ){
3798 import_append_char(p, c);
drhd0a64dc2013-06-30 20:24:26 +00003799 c = fgetc(p->in);
drhdb95f682013-06-26 22:46:00 +00003800 }
mistachkin636bf9f2014-07-19 20:15:16 +00003801 if( c==rSep ){
drhdb95f682013-06-26 22:46:00 +00003802 p->nLine++;
drh3852b682014-02-26 13:53:34 +00003803 if( p->n>0 && p->z[p->n-1]=='\r' ) p->n--;
drhdb95f682013-06-26 22:46:00 +00003804 }
drhdb95f682013-06-26 22:46:00 +00003805 p->cTerm = c;
3806 }
drh8dd675e2013-07-12 21:09:24 +00003807 if( p->z ) p->z[p->n] = 0;
drhdb95f682013-06-26 22:46:00 +00003808 return p->z;
3809}
3810
mistachkin636bf9f2014-07-19 20:15:16 +00003811/* Read a single field of ASCII delimited text.
3812**
3813** + Input comes from p->in.
3814** + Store results in p->z of length p->n. Space to hold p->z comes
drhf3cdcdc2015-04-29 16:50:28 +00003815** from sqlite3_malloc64().
mistachkin636bf9f2014-07-19 20:15:16 +00003816** + Use p->cSep as the column separator. The default is "\x1F".
3817** + Use p->rSep as the row separator. The default is "\x1E".
3818** + Keep track of the row number in p->nLine.
3819** + Store the character that terminates the field in p->cTerm. Store
3820** EOF on end-of-file.
3821** + Report syntax errors on stderr
3822*/
mistachkin44723ce2015-03-21 02:22:37 +00003823static char *SQLITE_CDECL ascii_read_one_field(ImportCtx *p){
mistachkin636bf9f2014-07-19 20:15:16 +00003824 int c;
3825 int cSep = p->cColSep;
3826 int rSep = p->cRowSep;
3827 p->n = 0;
3828 c = fgetc(p->in);
3829 if( c==EOF || seenInterrupt ){
3830 p->cTerm = EOF;
3831 return 0;
3832 }
3833 while( c!=EOF && c!=cSep && c!=rSep ){
3834 import_append_char(p, c);
3835 c = fgetc(p->in);
3836 }
3837 if( c==rSep ){
3838 p->nLine++;
3839 }
3840 p->cTerm = c;
3841 if( p->z ) p->z[p->n] = 0;
3842 return p->z;
3843}
3844
drhdb95f682013-06-26 22:46:00 +00003845/*
drh4bbcf102014-02-06 02:46:08 +00003846** Try to transfer data for table zTable. If an error is seen while
3847** moving forward, try to go backwards. The backwards movement won't
3848** work for WITHOUT ROWID tables.
drh3350ce92014-02-06 00:49:12 +00003849*/
mistachkine31ae902014-02-06 01:15:29 +00003850static void tryToCloneData(
drhdcd87a92014-08-18 13:45:42 +00003851 ShellState *p,
drh3350ce92014-02-06 00:49:12 +00003852 sqlite3 *newDb,
3853 const char *zTable
3854){
mistachkin1fe36bb2016-04-04 02:16:44 +00003855 sqlite3_stmt *pQuery = 0;
drh3350ce92014-02-06 00:49:12 +00003856 sqlite3_stmt *pInsert = 0;
3857 char *zQuery = 0;
3858 char *zInsert = 0;
3859 int rc;
3860 int i, j, n;
3861 int nTable = (int)strlen(zTable);
3862 int k = 0;
drh4bbcf102014-02-06 02:46:08 +00003863 int cnt = 0;
3864 const int spinRate = 10000;
drh3350ce92014-02-06 00:49:12 +00003865
3866 zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable);
3867 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
3868 if( rc ){
mistachkinaae280e2015-12-31 19:06:24 +00003869 utf8_printf(stderr, "Error %d: %s on [%s]\n",
drh3350ce92014-02-06 00:49:12 +00003870 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
3871 zQuery);
3872 goto end_data_xfer;
3873 }
3874 n = sqlite3_column_count(pQuery);
drhf3cdcdc2015-04-29 16:50:28 +00003875 zInsert = sqlite3_malloc64(200 + nTable + n*3);
drh3350ce92014-02-06 00:49:12 +00003876 if( zInsert==0 ){
mistachkinaae280e2015-12-31 19:06:24 +00003877 raw_printf(stderr, "out of memory\n");
drh3350ce92014-02-06 00:49:12 +00003878 goto end_data_xfer;
3879 }
3880 sqlite3_snprintf(200+nTable,zInsert,
3881 "INSERT OR IGNORE INTO \"%s\" VALUES(?", zTable);
3882 i = (int)strlen(zInsert);
3883 for(j=1; j<n; j++){
3884 memcpy(zInsert+i, ",?", 2);
3885 i += 2;
3886 }
3887 memcpy(zInsert+i, ");", 3);
3888 rc = sqlite3_prepare_v2(newDb, zInsert, -1, &pInsert, 0);
3889 if( rc ){
mistachkinaae280e2015-12-31 19:06:24 +00003890 utf8_printf(stderr, "Error %d: %s on [%s]\n",
drh3350ce92014-02-06 00:49:12 +00003891 sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb),
3892 zQuery);
3893 goto end_data_xfer;
3894 }
3895 for(k=0; k<2; k++){
3896 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
3897 for(i=0; i<n; i++){
3898 switch( sqlite3_column_type(pQuery, i) ){
3899 case SQLITE_NULL: {
3900 sqlite3_bind_null(pInsert, i+1);
3901 break;
3902 }
3903 case SQLITE_INTEGER: {
3904 sqlite3_bind_int64(pInsert, i+1, sqlite3_column_int64(pQuery,i));
3905 break;
3906 }
3907 case SQLITE_FLOAT: {
3908 sqlite3_bind_double(pInsert, i+1, sqlite3_column_double(pQuery,i));
3909 break;
3910 }
3911 case SQLITE_TEXT: {
3912 sqlite3_bind_text(pInsert, i+1,
3913 (const char*)sqlite3_column_text(pQuery,i),
3914 -1, SQLITE_STATIC);
3915 break;
3916 }
3917 case SQLITE_BLOB: {
3918 sqlite3_bind_blob(pInsert, i+1, sqlite3_column_blob(pQuery,i),
3919 sqlite3_column_bytes(pQuery,i),
3920 SQLITE_STATIC);
3921 break;
3922 }
3923 }
3924 } /* End for */
drh4bbcf102014-02-06 02:46:08 +00003925 rc = sqlite3_step(pInsert);
3926 if( rc!=SQLITE_OK && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
mistachkinaae280e2015-12-31 19:06:24 +00003927 utf8_printf(stderr, "Error %d: %s\n", sqlite3_extended_errcode(newDb),
drh4bbcf102014-02-06 02:46:08 +00003928 sqlite3_errmsg(newDb));
3929 }
drh3350ce92014-02-06 00:49:12 +00003930 sqlite3_reset(pInsert);
drh4bbcf102014-02-06 02:46:08 +00003931 cnt++;
3932 if( (cnt%spinRate)==0 ){
3933 printf("%c\b", "|/-\\"[(cnt/spinRate)%4]);
3934 fflush(stdout);
3935 }
drh3350ce92014-02-06 00:49:12 +00003936 } /* End while */
3937 if( rc==SQLITE_DONE ) break;
3938 sqlite3_finalize(pQuery);
3939 sqlite3_free(zQuery);
3940 zQuery = sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;",
3941 zTable);
3942 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
3943 if( rc ){
mistachkinaae280e2015-12-31 19:06:24 +00003944 utf8_printf(stderr, "Warning: cannot step \"%s\" backwards", zTable);
drh4bbcf102014-02-06 02:46:08 +00003945 break;
drh3350ce92014-02-06 00:49:12 +00003946 }
3947 } /* End for(k=0...) */
3948
3949end_data_xfer:
3950 sqlite3_finalize(pQuery);
3951 sqlite3_finalize(pInsert);
3952 sqlite3_free(zQuery);
3953 sqlite3_free(zInsert);
3954}
3955
3956
3957/*
3958** Try to transfer all rows of the schema that match zWhere. For
3959** each row, invoke xForEach() on the object defined by that row.
drh4bbcf102014-02-06 02:46:08 +00003960** If an error is encountered while moving forward through the
3961** sqlite_master table, try again moving backwards.
drh3350ce92014-02-06 00:49:12 +00003962*/
mistachkine31ae902014-02-06 01:15:29 +00003963static void tryToCloneSchema(
drhdcd87a92014-08-18 13:45:42 +00003964 ShellState *p,
drh3350ce92014-02-06 00:49:12 +00003965 sqlite3 *newDb,
3966 const char *zWhere,
drhdcd87a92014-08-18 13:45:42 +00003967 void (*xForEach)(ShellState*,sqlite3*,const char*)
drh3350ce92014-02-06 00:49:12 +00003968){
3969 sqlite3_stmt *pQuery = 0;
3970 char *zQuery = 0;
3971 int rc;
3972 const unsigned char *zName;
3973 const unsigned char *zSql;
drh4bbcf102014-02-06 02:46:08 +00003974 char *zErrMsg = 0;
drh3350ce92014-02-06 00:49:12 +00003975
3976 zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
3977 " WHERE %s", zWhere);
3978 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
3979 if( rc ){
mistachkinaae280e2015-12-31 19:06:24 +00003980 utf8_printf(stderr, "Error: (%d) %s on [%s]\n",
drh3350ce92014-02-06 00:49:12 +00003981 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
3982 zQuery);
3983 goto end_schema_xfer;
3984 }
3985 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
3986 zName = sqlite3_column_text(pQuery, 0);
3987 zSql = sqlite3_column_text(pQuery, 1);
3988 printf("%s... ", zName); fflush(stdout);
drh4bbcf102014-02-06 02:46:08 +00003989 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
3990 if( zErrMsg ){
mistachkinaae280e2015-12-31 19:06:24 +00003991 utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
drh4bbcf102014-02-06 02:46:08 +00003992 sqlite3_free(zErrMsg);
3993 zErrMsg = 0;
3994 }
drh3350ce92014-02-06 00:49:12 +00003995 if( xForEach ){
3996 xForEach(p, newDb, (const char*)zName);
3997 }
3998 printf("done\n");
3999 }
4000 if( rc!=SQLITE_DONE ){
4001 sqlite3_finalize(pQuery);
4002 sqlite3_free(zQuery);
4003 zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
4004 " WHERE %s ORDER BY rowid DESC", zWhere);
4005 rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
4006 if( rc ){
mistachkinaae280e2015-12-31 19:06:24 +00004007 utf8_printf(stderr, "Error: (%d) %s on [%s]\n",
drh3350ce92014-02-06 00:49:12 +00004008 sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
4009 zQuery);
4010 goto end_schema_xfer;
4011 }
4012 while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
4013 zName = sqlite3_column_text(pQuery, 0);
4014 zSql = sqlite3_column_text(pQuery, 1);
4015 printf("%s... ", zName); fflush(stdout);
drh4bbcf102014-02-06 02:46:08 +00004016 sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
4017 if( zErrMsg ){
mistachkinaae280e2015-12-31 19:06:24 +00004018 utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
drh4bbcf102014-02-06 02:46:08 +00004019 sqlite3_free(zErrMsg);
4020 zErrMsg = 0;
4021 }
drh3350ce92014-02-06 00:49:12 +00004022 if( xForEach ){
4023 xForEach(p, newDb, (const char*)zName);
4024 }
4025 printf("done\n");
4026 }
4027 }
4028end_schema_xfer:
4029 sqlite3_finalize(pQuery);
4030 sqlite3_free(zQuery);
4031}
4032
4033/*
4034** Open a new database file named "zNewDb". Try to recover as much information
4035** as possible out of the main database (which might be corrupt) and write it
4036** into zNewDb.
4037*/
drhdcd87a92014-08-18 13:45:42 +00004038static void tryToClone(ShellState *p, const char *zNewDb){
drh3350ce92014-02-06 00:49:12 +00004039 int rc;
4040 sqlite3 *newDb = 0;
4041 if( access(zNewDb,0)==0 ){
mistachkinaae280e2015-12-31 19:06:24 +00004042 utf8_printf(stderr, "File \"%s\" already exists.\n", zNewDb);
drh3350ce92014-02-06 00:49:12 +00004043 return;
4044 }
4045 rc = sqlite3_open(zNewDb, &newDb);
4046 if( rc ){
mistachkinaae280e2015-12-31 19:06:24 +00004047 utf8_printf(stderr, "Cannot create output database: %s\n",
drh3350ce92014-02-06 00:49:12 +00004048 sqlite3_errmsg(newDb));
4049 }else{
drh54d0d2d2014-04-03 00:32:13 +00004050 sqlite3_exec(p->db, "PRAGMA writable_schema=ON;", 0, 0, 0);
drh3350ce92014-02-06 00:49:12 +00004051 sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0);
mistachkine31ae902014-02-06 01:15:29 +00004052 tryToCloneSchema(p, newDb, "type='table'", tryToCloneData);
4053 tryToCloneSchema(p, newDb, "type!='table'", 0);
drh3350ce92014-02-06 00:49:12 +00004054 sqlite3_exec(newDb, "COMMIT;", 0, 0, 0);
drh54d0d2d2014-04-03 00:32:13 +00004055 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
drh3350ce92014-02-06 00:49:12 +00004056 }
4057 sqlite3_close(newDb);
4058}
4059
4060/*
drhc2ce0be2014-05-29 12:36:14 +00004061** Change the output file back to stdout
4062*/
drhdcd87a92014-08-18 13:45:42 +00004063static void output_reset(ShellState *p){
drhc2ce0be2014-05-29 12:36:14 +00004064 if( p->outfile[0]=='|' ){
drh8cd5b252015-03-02 22:06:43 +00004065#ifndef SQLITE_OMIT_POPEN
drhc2ce0be2014-05-29 12:36:14 +00004066 pclose(p->out);
drh8cd5b252015-03-02 22:06:43 +00004067#endif
drhc2ce0be2014-05-29 12:36:14 +00004068 }else{
4069 output_file_close(p->out);
4070 }
4071 p->outfile[0] = 0;
4072 p->out = stdout;
4073}
4074
4075/*
drhf7502f02015-02-06 14:19:44 +00004076** Run an SQL command and return the single integer result.
4077*/
4078static int db_int(ShellState *p, const char *zSql){
4079 sqlite3_stmt *pStmt;
4080 int res = 0;
4081 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
4082 if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
4083 res = sqlite3_column_int(pStmt,0);
4084 }
4085 sqlite3_finalize(pStmt);
4086 return res;
4087}
4088
4089/*
4090** Convert a 2-byte or 4-byte big-endian integer into a native integer
4091*/
drha0620ac2016-07-13 13:05:13 +00004092static unsigned int get2byteInt(unsigned char *a){
drhf7502f02015-02-06 14:19:44 +00004093 return (a[0]<<8) + a[1];
4094}
drha0620ac2016-07-13 13:05:13 +00004095static unsigned int get4byteInt(unsigned char *a){
drhf7502f02015-02-06 14:19:44 +00004096 return (a[0]<<24) + (a[1]<<16) + (a[2]<<8) + a[3];
4097}
4098
4099/*
4100** Implementation of the ".info" command.
4101**
4102** Return 1 on error, 2 to exit, and 0 otherwise.
4103*/
drh0e55db12015-02-06 14:51:13 +00004104static int shell_dbinfo_command(ShellState *p, int nArg, char **azArg){
drhf7502f02015-02-06 14:19:44 +00004105 static const struct { const char *zName; int ofst; } aField[] = {
4106 { "file change counter:", 24 },
4107 { "database page count:", 28 },
4108 { "freelist page count:", 36 },
4109 { "schema cookie:", 40 },
4110 { "schema format:", 44 },
4111 { "default cache size:", 48 },
4112 { "autovacuum top root:", 52 },
4113 { "incremental vacuum:", 64 },
4114 { "text encoding:", 56 },
4115 { "user version:", 60 },
4116 { "application id:", 68 },
4117 { "software version:", 96 },
4118 };
drh0e55db12015-02-06 14:51:13 +00004119 static const struct { const char *zName; const char *zSql; } aQuery[] = {
4120 { "number of tables:",
4121 "SELECT count(*) FROM %s WHERE type='table'" },
4122 { "number of indexes:",
4123 "SELECT count(*) FROM %s WHERE type='index'" },
4124 { "number of triggers:",
4125 "SELECT count(*) FROM %s WHERE type='trigger'" },
4126 { "number of views:",
4127 "SELECT count(*) FROM %s WHERE type='view'" },
4128 { "schema size:",
4129 "SELECT total(length(sql)) FROM %s" },
4130 };
mistachkinbfe8bd52015-11-17 19:17:14 +00004131 sqlite3_file *pFile = 0;
drh0e55db12015-02-06 14:51:13 +00004132 int i;
4133 char *zSchemaTab;
4134 char *zDb = nArg>=2 ? azArg[1] : "main";
4135 unsigned char aHdr[100];
drhf7502f02015-02-06 14:19:44 +00004136 open_db(p, 0);
4137 if( p->db==0 ) return 1;
drh0e55db12015-02-06 14:51:13 +00004138 sqlite3_file_control(p->db, zDb, SQLITE_FCNTL_FILE_POINTER, &pFile);
drhf7502f02015-02-06 14:19:44 +00004139 if( pFile==0 || pFile->pMethods==0 || pFile->pMethods->xRead==0 ){
4140 return 1;
4141 }
4142 i = pFile->pMethods->xRead(pFile, aHdr, 100, 0);
4143 if( i!=SQLITE_OK ){
mistachkinaae280e2015-12-31 19:06:24 +00004144 raw_printf(stderr, "unable to read database header\n");
drhf7502f02015-02-06 14:19:44 +00004145 return 1;
4146 }
4147 i = get2byteInt(aHdr+16);
4148 if( i==1 ) i = 65536;
mistachkinaae280e2015-12-31 19:06:24 +00004149 utf8_printf(p->out, "%-20s %d\n", "database page size:", i);
4150 utf8_printf(p->out, "%-20s %d\n", "write format:", aHdr[18]);
4151 utf8_printf(p->out, "%-20s %d\n", "read format:", aHdr[19]);
4152 utf8_printf(p->out, "%-20s %d\n", "reserved bytes:", aHdr[20]);
drhf5ed7ad2015-06-15 14:43:25 +00004153 for(i=0; i<ArraySize(aField); i++){
drhf7502f02015-02-06 14:19:44 +00004154 int ofst = aField[i].ofst;
4155 unsigned int val = get4byteInt(aHdr + ofst);
mistachkinaae280e2015-12-31 19:06:24 +00004156 utf8_printf(p->out, "%-20s %u", aField[i].zName, val);
drhf7502f02015-02-06 14:19:44 +00004157 switch( ofst ){
4158 case 56: {
mistachkin1fe36bb2016-04-04 02:16:44 +00004159 if( val==1 ) raw_printf(p->out, " (utf8)");
4160 if( val==2 ) raw_printf(p->out, " (utf16le)");
4161 if( val==3 ) raw_printf(p->out, " (utf16be)");
drhf7502f02015-02-06 14:19:44 +00004162 }
4163 }
mistachkinaae280e2015-12-31 19:06:24 +00004164 raw_printf(p->out, "\n");
drhf7502f02015-02-06 14:19:44 +00004165 }
drh0e55db12015-02-06 14:51:13 +00004166 if( zDb==0 ){
4167 zSchemaTab = sqlite3_mprintf("main.sqlite_master");
4168 }else if( strcmp(zDb,"temp")==0 ){
4169 zSchemaTab = sqlite3_mprintf("%s", "sqlite_temp_master");
4170 }else{
4171 zSchemaTab = sqlite3_mprintf("\"%w\".sqlite_master", zDb);
4172 }
drhf5ed7ad2015-06-15 14:43:25 +00004173 for(i=0; i<ArraySize(aQuery); i++){
drh0e55db12015-02-06 14:51:13 +00004174 char *zSql = sqlite3_mprintf(aQuery[i].zSql, zSchemaTab);
4175 int val = db_int(p, zSql);
4176 sqlite3_free(zSql);
drhe05461c2015-12-30 13:36:57 +00004177 utf8_printf(p->out, "%-20s %d\n", aQuery[i].zName, val);
drh0e55db12015-02-06 14:51:13 +00004178 }
4179 sqlite3_free(zSchemaTab);
drhf7502f02015-02-06 14:19:44 +00004180 return 0;
4181}
4182
dand95bb392015-09-30 11:19:05 +00004183/*
4184** Print the current sqlite3_errmsg() value to stderr and return 1.
4185*/
4186static int shellDatabaseError(sqlite3 *db){
4187 const char *zErr = sqlite3_errmsg(db);
mistachkinaae280e2015-12-31 19:06:24 +00004188 utf8_printf(stderr, "Error: %s\n", zErr);
dand95bb392015-09-30 11:19:05 +00004189 return 1;
4190}
4191
4192/*
4193** Print an out-of-memory message to stderr and return 1.
4194*/
4195static int shellNomemError(void){
mistachkinaae280e2015-12-31 19:06:24 +00004196 raw_printf(stderr, "Error: out of memory\n");
dand95bb392015-09-30 11:19:05 +00004197 return 1;
4198}
drhf7502f02015-02-06 14:19:44 +00004199
drh2db82112016-09-15 21:35:24 +00004200/*
4201** Compare the pattern in zGlob[] against the text in z[]. Return TRUE
4202** if they match and FALSE (0) if they do not match.
4203**
4204** Globbing rules:
4205**
4206** '*' Matches any sequence of zero or more characters.
4207**
4208** '?' Matches exactly one character.
4209**
4210** [...] Matches one character from the enclosed list of
4211** characters.
4212**
4213** [^...] Matches one character not in the enclosed list.
4214**
4215** '#' Matches any sequence of one or more digits with an
4216** optional + or - sign in front
4217**
4218** ' ' Any span of whitespace matches any other span of
4219** whitespace.
4220**
4221** Extra whitespace at the end of z[] is ignored.
4222*/
4223static int testcase_glob(const char *zGlob, const char *z){
4224 int c, c2;
4225 int invert;
4226 int seen;
4227
4228 while( (c = (*(zGlob++)))!=0 ){
4229 if( IsSpace(c) ){
4230 if( !IsSpace(*z) ) return 0;
4231 while( IsSpace(*zGlob) ) zGlob++;
4232 while( IsSpace(*z) ) z++;
4233 }else if( c=='*' ){
4234 while( (c=(*(zGlob++))) == '*' || c=='?' ){
4235 if( c=='?' && (*(z++))==0 ) return 0;
4236 }
4237 if( c==0 ){
4238 return 1;
4239 }else if( c=='[' ){
4240 while( *z && testcase_glob(zGlob-1,z)==0 ){
4241 z++;
4242 }
4243 return (*z)!=0;
4244 }
4245 while( (c2 = (*(z++)))!=0 ){
4246 while( c2!=c ){
4247 c2 = *(z++);
4248 if( c2==0 ) return 0;
4249 }
4250 if( testcase_glob(zGlob,z) ) return 1;
4251 }
4252 return 0;
4253 }else if( c=='?' ){
4254 if( (*(z++))==0 ) return 0;
4255 }else if( c=='[' ){
4256 int prior_c = 0;
4257 seen = 0;
4258 invert = 0;
4259 c = *(z++);
4260 if( c==0 ) return 0;
4261 c2 = *(zGlob++);
4262 if( c2=='^' ){
4263 invert = 1;
4264 c2 = *(zGlob++);
4265 }
4266 if( c2==']' ){
4267 if( c==']' ) seen = 1;
4268 c2 = *(zGlob++);
4269 }
4270 while( c2 && c2!=']' ){
4271 if( c2=='-' && zGlob[0]!=']' && zGlob[0]!=0 && prior_c>0 ){
4272 c2 = *(zGlob++);
4273 if( c>=prior_c && c<=c2 ) seen = 1;
4274 prior_c = 0;
4275 }else{
4276 if( c==c2 ){
4277 seen = 1;
4278 }
4279 prior_c = c2;
4280 }
4281 c2 = *(zGlob++);
4282 }
4283 if( c2==0 || (seen ^ invert)==0 ) return 0;
4284 }else if( c=='#' ){
4285 if( (z[0]=='-' || z[0]=='+') && IsDigit(z[1]) ) z++;
4286 if( !IsDigit(z[0]) ) return 0;
4287 z++;
4288 while( IsDigit(z[0]) ){ z++; }
4289 }else{
4290 if( c!=(*(z++)) ) return 0;
4291 }
4292 }
4293 while( IsSpace(*z) ){ z++; }
4294 return *z==0;
4295}
drh2db82112016-09-15 21:35:24 +00004296
4297
drhf7502f02015-02-06 14:19:44 +00004298/*
drh4926fec2016-04-13 15:33:42 +00004299** Compare the string as a command-line option with either one or two
4300** initial "-" characters.
4301*/
4302static int optionMatch(const char *zStr, const char *zOpt){
4303 if( zStr[0]!='-' ) return 0;
4304 zStr++;
4305 if( zStr[0]=='-' ) zStr++;
4306 return strcmp(zStr, zOpt)==0;
4307}
4308
4309/*
drhcd0509e2016-09-16 00:26:08 +00004310** Delete a file.
4311*/
4312int shellDeleteFile(const char *zFilename){
4313 int rc;
4314#ifdef _WIN32
mistachkin8145fc62016-09-16 20:39:21 +00004315 wchar_t *z = sqlite3_win32_utf8_to_unicode(zFilename);
drhcd0509e2016-09-16 00:26:08 +00004316 rc = _wunlink(z);
4317 sqlite3_free(z);
4318#else
4319 rc = unlink(zFilename);
4320#endif
4321 return rc;
4322}
4323
dan35ac58e2016-12-14 19:28:27 +00004324
dan35ac58e2016-12-14 19:28:27 +00004325/*
dandd9e0be2016-12-16 16:44:27 +00004326** The implementation of SQL scalar function fkey_collate_clause(), used
dan3c7ebeb2016-12-16 17:28:56 +00004327** by the ".lint fkey-indexes" command. This scalar function is always
dandd9e0be2016-12-16 16:44:27 +00004328** called with four arguments - the parent table name, the parent column name,
4329** the child table name and the child column name.
dan35ac58e2016-12-14 19:28:27 +00004330**
4331** fkey_collate_clause('parent-tab', 'parent-col', 'child-tab', 'child-col')
4332**
4333** If either of the named tables or columns do not exist, this function
4334** returns an empty string. An empty string is also returned if both tables
4335** and columns exist but have the same default collation sequence. Or,
4336** if both exist but the default collation sequences are different, this
4337** function returns the string " COLLATE <parent-collation>", where
4338** <parent-collation> is the default collation sequence of the parent column.
4339*/
4340static void shellFkeyCollateClause(
4341 sqlite3_context *pCtx,
4342 int nVal,
4343 sqlite3_value **apVal
4344){
4345 sqlite3 *db = sqlite3_context_db_handle(pCtx);
4346 const char *zParent;
4347 const char *zParentCol;
4348 const char *zParentSeq;
4349 const char *zChild;
4350 const char *zChildCol;
drh96ada592016-12-29 19:48:46 +00004351 const char *zChildSeq = 0; /* Initialize to avoid false-positive warning */
dan35ac58e2016-12-14 19:28:27 +00004352 int rc;
4353
4354 assert( nVal==4 );
4355 zParent = (const char*)sqlite3_value_text(apVal[0]);
4356 zParentCol = (const char*)sqlite3_value_text(apVal[1]);
4357 zChild = (const char*)sqlite3_value_text(apVal[2]);
4358 zChildCol = (const char*)sqlite3_value_text(apVal[3]);
4359
4360 sqlite3_result_text(pCtx, "", -1, SQLITE_STATIC);
4361 rc = sqlite3_table_column_metadata(
4362 db, "main", zParent, zParentCol, 0, &zParentSeq, 0, 0, 0
4363 );
4364 if( rc==SQLITE_OK ){
4365 rc = sqlite3_table_column_metadata(
4366 db, "main", zChild, zChildCol, 0, &zChildSeq, 0, 0, 0
4367 );
4368 }
4369
4370 if( rc==SQLITE_OK && sqlite3_stricmp(zParentSeq, zChildSeq) ){
4371 char *z = sqlite3_mprintf(" COLLATE %s", zParentSeq);
4372 sqlite3_result_text(pCtx, z, -1, SQLITE_TRANSIENT);
4373 sqlite3_free(z);
4374 }
4375}
4376
4377
4378/*
dan3c7ebeb2016-12-16 17:28:56 +00004379** The implementation of dot-command ".lint fkey-indexes".
dan35ac58e2016-12-14 19:28:27 +00004380*/
dan3c7ebeb2016-12-16 17:28:56 +00004381static int lintFkeyIndexes(
dan35ac58e2016-12-14 19:28:27 +00004382 ShellState *pState, /* Current shell tool state */
4383 char **azArg, /* Array of arguments passed to dot command */
4384 int nArg /* Number of entries in azArg[] */
4385){
dandd9e0be2016-12-16 16:44:27 +00004386 sqlite3 *db = pState->db; /* Database handle to query "main" db of */
4387 FILE *out = pState->out; /* Stream to write non-error output to */
danf9647b62016-12-15 06:01:40 +00004388 int bVerbose = 0; /* If -verbose is present */
4389 int bGroupByParent = 0; /* If -groupbyparent is present */
dandd9e0be2016-12-16 16:44:27 +00004390 int i; /* To iterate through azArg[] */
4391 const char *zIndent = ""; /* How much to indent CREATE INDEX by */
4392 int rc; /* Return code */
4393 sqlite3_stmt *pSql = 0; /* Compiled version of SQL statement below */
dan35ac58e2016-12-14 19:28:27 +00004394
dandd9e0be2016-12-16 16:44:27 +00004395 /*
4396 ** This SELECT statement returns one row for each foreign key constraint
4397 ** in the schema of the main database. The column values are:
4398 **
4399 ** 0. The text of an SQL statement similar to:
4400 **
4401 ** "EXPLAIN QUERY PLAN SELECT rowid FROM child_table WHERE child_key=?"
4402 **
4403 ** This is the same SELECT that the foreign keys implementation needs
4404 ** to run internally on child tables. If there is an index that can
4405 ** be used to optimize this query, then it can also be used by the FK
4406 ** implementation to optimize DELETE or UPDATE statements on the parent
4407 ** table.
4408 **
4409 ** 1. A GLOB pattern suitable for sqlite3_strglob(). If the plan output by
4410 ** the EXPLAIN QUERY PLAN command matches this pattern, then the schema
4411 ** contains an index that can be used to optimize the query.
4412 **
4413 ** 2. Human readable text that describes the child table and columns. e.g.
4414 **
4415 ** "child_table(child_key1, child_key2)"
4416 **
4417 ** 3. Human readable text that describes the parent table and columns. e.g.
4418 **
4419 ** "parent_table(parent_key1, parent_key2)"
4420 **
4421 ** 4. A full CREATE INDEX statement for an index that could be used to
4422 ** optimize DELETE or UPDATE statements on the parent table. e.g.
4423 **
4424 ** "CREATE INDEX child_table_child_key ON child_table(child_key)"
4425 **
4426 ** 5. The name of the parent table.
4427 **
4428 ** These six values are used by the C logic below to generate the report.
4429 */
dan35ac58e2016-12-14 19:28:27 +00004430 const char *zSql =
dandd9e0be2016-12-16 16:44:27 +00004431 "SELECT "
4432 " 'EXPLAIN QUERY PLAN SELECT rowid FROM ' || quote(s.name) || ' WHERE '"
4433 " || group_concat(quote(s.name) || '.' || quote(f.[from]) || '=?' "
dan50da9382017-04-06 12:06:56 +00004434 " || fkey_collate_clause("
4435 " f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]),' AND ')"
dan35ac58e2016-12-14 19:28:27 +00004436 ", "
dandd9e0be2016-12-16 16:44:27 +00004437 " 'SEARCH TABLE ' || s.name || ' USING COVERING INDEX*('"
dan35ac58e2016-12-14 19:28:27 +00004438 " || group_concat('*=?', ' AND ') || ')'"
4439 ", "
dandd9e0be2016-12-16 16:44:27 +00004440 " s.name || '(' || group_concat(f.[from], ', ') || ')'"
dan35ac58e2016-12-14 19:28:27 +00004441 ", "
dan50da9382017-04-06 12:06:56 +00004442 " f.[table] || '(' || group_concat(COALESCE(f.[to], p.[name])) || ')'"
dan35ac58e2016-12-14 19:28:27 +00004443 ", "
dandd9e0be2016-12-16 16:44:27 +00004444 " 'CREATE INDEX ' || quote(s.name ||'_'|| group_concat(f.[from], '_'))"
4445 " || ' ON ' || quote(s.name) || '('"
4446 " || group_concat(quote(f.[from]) ||"
dan50da9382017-04-06 12:06:56 +00004447 " fkey_collate_clause("
4448 " f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]), ', ')"
dan35ac58e2016-12-14 19:28:27 +00004449 " || ');'"
danf9647b62016-12-15 06:01:40 +00004450 ", "
dandd9e0be2016-12-16 16:44:27 +00004451 " f.[table] "
dandd9e0be2016-12-16 16:44:27 +00004452 "FROM sqlite_master AS s, pragma_foreign_key_list(s.name) AS f "
dan50da9382017-04-06 12:06:56 +00004453 "LEFT JOIN pragma_table_info AS p ON (pk-1=seq AND p.arg=f.[table]) "
dandd9e0be2016-12-16 16:44:27 +00004454 "GROUP BY s.name, f.id "
4455 "ORDER BY (CASE WHEN ? THEN f.[table] ELSE s.name END)"
dan35ac58e2016-12-14 19:28:27 +00004456 ;
dan54e2efc2017-04-06 14:56:26 +00004457 const char *zGlobIPK = "SEARCH TABLE * USING INTEGER PRIMARY KEY (rowid=?)";
dan35ac58e2016-12-14 19:28:27 +00004458
dan3c7ebeb2016-12-16 17:28:56 +00004459 for(i=2; i<nArg; i++){
drh344a1bf2016-12-22 14:53:25 +00004460 int n = (int)strlen(azArg[i]);
danf9647b62016-12-15 06:01:40 +00004461 if( n>1 && sqlite3_strnicmp("-verbose", azArg[i], n)==0 ){
4462 bVerbose = 1;
4463 }
4464 else if( n>1 && sqlite3_strnicmp("-groupbyparent", azArg[i], n)==0 ){
4465 bGroupByParent = 1;
4466 zIndent = " ";
4467 }
4468 else{
dan3c7ebeb2016-12-16 17:28:56 +00004469 raw_printf(stderr, "Usage: %s %s ?-verbose? ?-groupbyparent?\n",
4470 azArg[0], azArg[1]
4471 );
danf9647b62016-12-15 06:01:40 +00004472 return SQLITE_ERROR;
4473 }
dan35ac58e2016-12-14 19:28:27 +00004474 }
dan35ac58e2016-12-14 19:28:27 +00004475
4476 /* Register the fkey_collate_clause() SQL function */
dandd9e0be2016-12-16 16:44:27 +00004477 rc = sqlite3_create_function(db, "fkey_collate_clause", 4, SQLITE_UTF8,
4478 0, shellFkeyCollateClause, 0, 0
4479 );
dan35ac58e2016-12-14 19:28:27 +00004480
4481
4482 if( rc==SQLITE_OK ){
4483 rc = sqlite3_prepare_v2(db, zSql, -1, &pSql, 0);
4484 }
danf9647b62016-12-15 06:01:40 +00004485 if( rc==SQLITE_OK ){
4486 sqlite3_bind_int(pSql, 1, bGroupByParent);
4487 }
dan35ac58e2016-12-14 19:28:27 +00004488
4489 if( rc==SQLITE_OK ){
4490 int rc2;
danf9647b62016-12-15 06:01:40 +00004491 char *zPrev = 0;
dan35ac58e2016-12-14 19:28:27 +00004492 while( SQLITE_ROW==sqlite3_step(pSql) ){
4493 int res = -1;
4494 sqlite3_stmt *pExplain = 0;
4495 const char *zEQP = (const char*)sqlite3_column_text(pSql, 0);
4496 const char *zGlob = (const char*)sqlite3_column_text(pSql, 1);
4497 const char *zFrom = (const char*)sqlite3_column_text(pSql, 2);
4498 const char *zTarget = (const char*)sqlite3_column_text(pSql, 3);
4499 const char *zCI = (const char*)sqlite3_column_text(pSql, 4);
danf9647b62016-12-15 06:01:40 +00004500 const char *zParent = (const char*)sqlite3_column_text(pSql, 5);
dan35ac58e2016-12-14 19:28:27 +00004501
4502 rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
4503 if( rc!=SQLITE_OK ) break;
4504 if( SQLITE_ROW==sqlite3_step(pExplain) ){
4505 const char *zPlan = (const char*)sqlite3_column_text(pExplain, 3);
dan54e2efc2017-04-06 14:56:26 +00004506 res = (
4507 0==sqlite3_strglob(zGlob, zPlan)
4508 || 0==sqlite3_strglob(zGlobIPK, zPlan)
4509 );
dan35ac58e2016-12-14 19:28:27 +00004510 }
4511 rc = sqlite3_finalize(pExplain);
4512 if( rc!=SQLITE_OK ) break;
4513
4514 if( res<0 ){
4515 raw_printf(stderr, "Error: internal error");
4516 break;
danf9647b62016-12-15 06:01:40 +00004517 }else{
4518 if( bGroupByParent
4519 && (bVerbose || res==0)
4520 && (zPrev==0 || sqlite3_stricmp(zParent, zPrev))
4521 ){
4522 raw_printf(out, "-- Parent table %s\n", zParent);
4523 sqlite3_free(zPrev);
4524 zPrev = sqlite3_mprintf("%s", zParent);
4525 }
4526
4527 if( res==0 ){
4528 raw_printf(out, "%s%s --> %s\n", zIndent, zCI, zTarget);
4529 }else if( bVerbose ){
4530 raw_printf(out, "%s/* no extra indexes required for %s -> %s */\n",
4531 zIndent, zFrom, zTarget
4532 );
4533 }
dan35ac58e2016-12-14 19:28:27 +00004534 }
4535 }
danf9647b62016-12-15 06:01:40 +00004536 sqlite3_free(zPrev);
dan35ac58e2016-12-14 19:28:27 +00004537
4538 if( rc!=SQLITE_OK ){
4539 raw_printf(stderr, "%s\n", sqlite3_errmsg(db));
4540 }
4541
4542 rc2 = sqlite3_finalize(pSql);
4543 if( rc==SQLITE_OK && rc2!=SQLITE_OK ){
4544 rc = rc2;
4545 raw_printf(stderr, "%s\n", sqlite3_errmsg(db));
4546 }
4547 }else{
4548 raw_printf(stderr, "%s\n", sqlite3_errmsg(db));
4549 }
4550
4551 return rc;
4552}
dan3c7ebeb2016-12-16 17:28:56 +00004553
dan35ac58e2016-12-14 19:28:27 +00004554/*
dan3c7ebeb2016-12-16 17:28:56 +00004555** Implementation of ".lint" dot command.
4556*/
4557static int lintDotCommand(
4558 ShellState *pState, /* Current shell tool state */
4559 char **azArg, /* Array of arguments passed to dot command */
4560 int nArg /* Number of entries in azArg[] */
4561){
4562 int n;
drh96ada592016-12-29 19:48:46 +00004563 n = (nArg>=2 ? (int)strlen(azArg[1]) : 0);
dan3c7ebeb2016-12-16 17:28:56 +00004564 if( n<1 || sqlite3_strnicmp(azArg[1], "fkey-indexes", n) ) goto usage;
4565 return lintFkeyIndexes(pState, azArg, nArg);
4566
4567 usage:
4568 raw_printf(stderr, "Usage %s sub-command ?switches...?\n", azArg[0]);
4569 raw_printf(stderr, "Where sub-commands are:\n");
4570 raw_printf(stderr, " fkey-indexes\n");
4571 return SQLITE_ERROR;
4572}
4573
dan35ac58e2016-12-14 19:28:27 +00004574
drhcd0509e2016-09-16 00:26:08 +00004575/*
drh75897232000-05-29 14:26:00 +00004576** If an input line begins with "." then invoke this routine to
4577** process that line.
drh67505e72002-04-19 12:34:06 +00004578**
drh47ad6842006-11-08 12:25:42 +00004579** Return 1 on error, 2 to exit, and 0 otherwise.
drh75897232000-05-29 14:26:00 +00004580*/
drhdcd87a92014-08-18 13:45:42 +00004581static int do_meta_command(char *zLine, ShellState *p){
mistachkin8e189222015-04-19 21:43:16 +00004582 int h = 1;
drh75897232000-05-29 14:26:00 +00004583 int nArg = 0;
4584 int n, c;
drh67505e72002-04-19 12:34:06 +00004585 int rc = 0;
drh75897232000-05-29 14:26:00 +00004586 char *azArg[50];
4587
4588 /* Parse the input line into tokens.
4589 */
mistachkin8e189222015-04-19 21:43:16 +00004590 while( zLine[h] && nArg<ArraySize(azArg) ){
4591 while( IsSpace(zLine[h]) ){ h++; }
4592 if( zLine[h]==0 ) break;
4593 if( zLine[h]=='\'' || zLine[h]=='"' ){
4594 int delim = zLine[h++];
4595 azArg[nArg++] = &zLine[h];
mistachkin1fe36bb2016-04-04 02:16:44 +00004596 while( zLine[h] && zLine[h]!=delim ){
mistachkin8e189222015-04-19 21:43:16 +00004597 if( zLine[h]=='\\' && delim=='"' && zLine[h+1]!=0 ) h++;
mistachkin1fe36bb2016-04-04 02:16:44 +00004598 h++;
drh4c56b992013-06-27 13:26:55 +00004599 }
mistachkin8e189222015-04-19 21:43:16 +00004600 if( zLine[h]==delim ){
4601 zLine[h++] = 0;
drh75897232000-05-29 14:26:00 +00004602 }
drhfeac5f82004-08-01 00:10:45 +00004603 if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
drh75897232000-05-29 14:26:00 +00004604 }else{
mistachkin8e189222015-04-19 21:43:16 +00004605 azArg[nArg++] = &zLine[h];
4606 while( zLine[h] && !IsSpace(zLine[h]) ){ h++; }
4607 if( zLine[h] ) zLine[h++] = 0;
drhfeac5f82004-08-01 00:10:45 +00004608 resolve_backslashes(azArg[nArg-1]);
drh75897232000-05-29 14:26:00 +00004609 }
4610 }
4611
4612 /* Process the input line.
4613 */
shane9bd1b442009-10-23 01:27:39 +00004614 if( nArg==0 ) return 0; /* no tokens, no error */
drh4f21c4a2008-12-10 22:15:00 +00004615 n = strlen30(azArg[0]);
drh75897232000-05-29 14:26:00 +00004616 c = azArg[0][0];
drhde613c62016-04-04 17:23:10 +00004617
drha0daa752016-09-16 11:53:10 +00004618#ifndef SQLITE_OMIT_AUTHORIZATION
drhde613c62016-04-04 17:23:10 +00004619 if( c=='a' && strncmp(azArg[0], "auth", n)==0 ){
4620 if( nArg!=2 ){
4621 raw_printf(stderr, "Usage: .auth ON|OFF\n");
4622 rc = 1;
4623 goto meta_command_exit;
4624 }
4625 open_db(p, 0);
4626 if( booleanValue(azArg[1]) ){
4627 sqlite3_set_authorizer(p->db, shellAuth, p);
4628 }else{
4629 sqlite3_set_authorizer(p->db, 0, 0);
4630 }
4631 }else
drha0daa752016-09-16 11:53:10 +00004632#endif
drhde613c62016-04-04 17:23:10 +00004633
drh5c7976f2014-02-10 19:59:27 +00004634 if( (c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0)
4635 || (c=='s' && n>=3 && strncmp(azArg[0], "save", n)==0)
4636 ){
drhbc46f022013-01-23 18:53:23 +00004637 const char *zDestFile = 0;
4638 const char *zDb = 0;
drh9ff849f2009-02-04 20:55:57 +00004639 sqlite3 *pDest;
4640 sqlite3_backup *pBackup;
drhbc46f022013-01-23 18:53:23 +00004641 int j;
4642 for(j=1; j<nArg; j++){
4643 const char *z = azArg[j];
4644 if( z[0]=='-' ){
4645 while( z[0]=='-' ) z++;
drhaf664332013-07-18 20:28:29 +00004646 /* No options to process at this time */
drhbc46f022013-01-23 18:53:23 +00004647 {
mistachkinaae280e2015-12-31 19:06:24 +00004648 utf8_printf(stderr, "unknown option: %s\n", azArg[j]);
drhbc46f022013-01-23 18:53:23 +00004649 return 1;
4650 }
4651 }else if( zDestFile==0 ){
4652 zDestFile = azArg[j];
4653 }else if( zDb==0 ){
4654 zDb = zDestFile;
4655 zDestFile = azArg[j];
4656 }else{
mistachkinaae280e2015-12-31 19:06:24 +00004657 raw_printf(stderr, "too many arguments to .backup\n");
drhbc46f022013-01-23 18:53:23 +00004658 return 1;
4659 }
drh9ff849f2009-02-04 20:55:57 +00004660 }
drhbc46f022013-01-23 18:53:23 +00004661 if( zDestFile==0 ){
mistachkinaae280e2015-12-31 19:06:24 +00004662 raw_printf(stderr, "missing FILENAME argument on .backup\n");
drhbc46f022013-01-23 18:53:23 +00004663 return 1;
4664 }
4665 if( zDb==0 ) zDb = "main";
drh9ff849f2009-02-04 20:55:57 +00004666 rc = sqlite3_open(zDestFile, &pDest);
4667 if( rc!=SQLITE_OK ){
mistachkinaae280e2015-12-31 19:06:24 +00004668 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zDestFile);
drh9ff849f2009-02-04 20:55:57 +00004669 sqlite3_close(pDest);
4670 return 1;
4671 }
drh05782482013-10-24 15:20:20 +00004672 open_db(p, 0);
drh9ff849f2009-02-04 20:55:57 +00004673 pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
4674 if( pBackup==0 ){
mistachkinaae280e2015-12-31 19:06:24 +00004675 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
drh9ff849f2009-02-04 20:55:57 +00004676 sqlite3_close(pDest);
4677 return 1;
4678 }
4679 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
4680 sqlite3_backup_finish(pBackup);
4681 if( rc==SQLITE_DONE ){
shane9bd1b442009-10-23 01:27:39 +00004682 rc = 0;
drh9ff849f2009-02-04 20:55:57 +00004683 }else{
mistachkinaae280e2015-12-31 19:06:24 +00004684 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
shane9bd1b442009-10-23 01:27:39 +00004685 rc = 1;
drh9ff849f2009-02-04 20:55:57 +00004686 }
4687 sqlite3_close(pDest);
4688 }else
4689
drhc2ce0be2014-05-29 12:36:14 +00004690 if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 ){
4691 if( nArg==2 ){
4692 bail_on_error = booleanValue(azArg[1]);
4693 }else{
mistachkinaae280e2015-12-31 19:06:24 +00004694 raw_printf(stderr, "Usage: .bail on|off\n");
drhc2ce0be2014-05-29 12:36:14 +00004695 rc = 1;
4696 }
drhc49f44e2006-10-26 18:15:42 +00004697 }else
4698
mistachkinf21979d2015-01-18 05:35:01 +00004699 if( c=='b' && n>=3 && strncmp(azArg[0], "binary", n)==0 ){
4700 if( nArg==2 ){
mistachkinbdffff92015-01-19 20:22:33 +00004701 if( booleanValue(azArg[1]) ){
mistachkin1fe36bb2016-04-04 02:16:44 +00004702 setBinaryMode(p->out, 1);
mistachkinbdffff92015-01-19 20:22:33 +00004703 }else{
mistachkin1fe36bb2016-04-04 02:16:44 +00004704 setTextMode(p->out, 1);
mistachkinbdffff92015-01-19 20:22:33 +00004705 }
mistachkinf21979d2015-01-18 05:35:01 +00004706 }else{
mistachkinaae280e2015-12-31 19:06:24 +00004707 raw_printf(stderr, "Usage: .binary on|off\n");
mistachkinf21979d2015-01-18 05:35:01 +00004708 rc = 1;
4709 }
4710 }else
4711
drhd8621b92012-04-17 09:09:33 +00004712 /* The undocumented ".breakpoint" command causes a call to the no-op
4713 ** routine named test_breakpoint().
4714 */
4715 if( c=='b' && n>=3 && strncmp(azArg[0], "breakpoint", n)==0 ){
4716 test_breakpoint();
4717 }else
4718
drhdf12f1c2015-12-07 21:46:19 +00004719 if( c=='c' && n>=3 && strncmp(azArg[0], "changes", n)==0 ){
4720 if( nArg==2 ){
drhe6e1d122017-03-09 13:50:49 +00004721 setOrClearFlag(p, SHFLG_CountChanges, azArg[1]);
drhdf12f1c2015-12-07 21:46:19 +00004722 }else{
mistachkinaae280e2015-12-31 19:06:24 +00004723 raw_printf(stderr, "Usage: .changes on|off\n");
drhdf12f1c2015-12-07 21:46:19 +00004724 rc = 1;
4725 }
4726 }else
4727
drh2db82112016-09-15 21:35:24 +00004728 /* Cancel output redirection, if it is currently set (by .testcase)
4729 ** Then read the content of the testcase-out.txt file and compare against
4730 ** azArg[1]. If there are differences, report an error and exit.
4731 */
4732 if( c=='c' && n>=3 && strncmp(azArg[0], "check", n)==0 ){
4733 char *zRes = 0;
4734 output_reset(p);
4735 if( nArg!=2 ){
4736 raw_printf(stderr, "Usage: .check GLOB-PATTERN\n");
drh760c8162016-09-16 02:52:22 +00004737 rc = 2;
dan11da0022016-12-17 08:18:05 +00004738 }else if( (zRes = readFile("testcase-out.txt", 0))==0 ){
drh2db82112016-09-15 21:35:24 +00004739 raw_printf(stderr, "Error: cannot read 'testcase-out.txt'\n");
4740 rc = 2;
4741 }else if( testcase_glob(azArg[1],zRes)==0 ){
mistachkin8145fc62016-09-16 20:39:21 +00004742 utf8_printf(stderr,
drh760c8162016-09-16 02:52:22 +00004743 "testcase-%s FAILED\n Expected: [%s]\n Got: [%s]\n",
4744 p->zTestcase, azArg[1], zRes);
drh2db82112016-09-15 21:35:24 +00004745 rc = 2;
drh760c8162016-09-16 02:52:22 +00004746 }else{
mistachkin8145fc62016-09-16 20:39:21 +00004747 utf8_printf(stdout, "testcase-%s ok\n", p->zTestcase);
drh760c8162016-09-16 02:52:22 +00004748 p->nCheck++;
drh2db82112016-09-15 21:35:24 +00004749 }
4750 sqlite3_free(zRes);
4751 }else
drh2db82112016-09-15 21:35:24 +00004752
drhc2ce0be2014-05-29 12:36:14 +00004753 if( c=='c' && strncmp(azArg[0], "clone", n)==0 ){
4754 if( nArg==2 ){
4755 tryToClone(p, azArg[1]);
4756 }else{
mistachkinaae280e2015-12-31 19:06:24 +00004757 raw_printf(stderr, "Usage: .clone FILENAME\n");
drhc2ce0be2014-05-29 12:36:14 +00004758 rc = 1;
4759 }
mistachkine31ae902014-02-06 01:15:29 +00004760 }else
4761
drhc2ce0be2014-05-29 12:36:14 +00004762 if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){
drhdcd87a92014-08-18 13:45:42 +00004763 ShellState data;
jplyon672a1ed2003-05-11 20:07:05 +00004764 char *zErrMsg = 0;
drh05782482013-10-24 15:20:20 +00004765 open_db(p, 0);
jplyon672a1ed2003-05-11 20:07:05 +00004766 memcpy(&data, p, sizeof(data));
drhb20a61b2016-12-24 18:18:58 +00004767 data.showHeader = 0;
4768 data.cMode = data.mode = MODE_List;
4769 sqlite3_snprintf(sizeof(data.colSeparator),data.colSeparator,": ");
drh0b2110c2004-10-26 00:08:10 +00004770 data.cnt = 0;
drhb20a61b2016-12-24 18:18:58 +00004771 sqlite3_exec(p->db, "SELECT name, file FROM pragma_database_list",
4772 callback, &data, &zErrMsg);
jplyon672a1ed2003-05-11 20:07:05 +00004773 if( zErrMsg ){
mistachkinaae280e2015-12-31 19:06:24 +00004774 utf8_printf(stderr,"Error: %s\n", zErrMsg);
drh3f4fedb2004-05-31 19:34:33 +00004775 sqlite3_free(zErrMsg);
shane9bd1b442009-10-23 01:27:39 +00004776 rc = 1;
jplyon6a65bb32003-05-04 07:25:57 +00004777 }
4778 }else
4779
drh0e55db12015-02-06 14:51:13 +00004780 if( c=='d' && strncmp(azArg[0], "dbinfo", n)==0 ){
4781 rc = shell_dbinfo_command(p, nArg, azArg);
4782 }else
4783
drhc2ce0be2014-05-29 12:36:14 +00004784 if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
drhe611f142017-03-08 11:44:00 +00004785 const char *zLike = 0;
4786 int i;
drh72507d42017-04-08 00:55:13 +00004787 int savedShowHeader = p->showHeader;
drhe6e1d122017-03-09 13:50:49 +00004788 ShellClearFlag(p, SHFLG_PreserveRowid);
drhe611f142017-03-08 11:44:00 +00004789 for(i=1; i<nArg; i++){
4790 if( azArg[i][0]=='-' ){
4791 const char *z = azArg[i]+1;
4792 if( z[0]=='-' ) z++;
4793 if( strcmp(z,"preserve-rowids")==0 ){
drh34ad36b2017-03-25 18:15:05 +00004794#ifdef SQLITE_OMIT_VIRTUALTABLE
4795 raw_printf(stderr, "The --preserve-rowids option is not compatible"
4796 " with SQLITE_OMIT_VIRTUALTABLE\n");
4797 rc = 1;
4798 goto meta_command_exit;
4799#else
drhe6e1d122017-03-09 13:50:49 +00004800 ShellSetFlag(p, SHFLG_PreserveRowid);
drh34ad36b2017-03-25 18:15:05 +00004801#endif
drhe611f142017-03-08 11:44:00 +00004802 }else
4803 {
4804 raw_printf(stderr, "Unknown option \"%s\" on \".dump\"\n", azArg[i]);
4805 rc = 1;
4806 goto meta_command_exit;
4807 }
4808 }else if( zLike ){
4809 raw_printf(stderr, "Usage: .dump ?--preserve-rowids? ?LIKE-PATTERN?\n");
4810 rc = 1;
4811 goto meta_command_exit;
4812 }else{
4813 zLike = azArg[i];
4814 }
4815 }
drh05782482013-10-24 15:20:20 +00004816 open_db(p, 0);
drhf1dfc4f2009-09-23 15:51:35 +00004817 /* When playing back a "dump", the content might appear in an order
4818 ** which causes immediate foreign key constraints to be violated.
4819 ** So disable foreign-key constraint enforcement to prevent problems. */
mistachkinaae280e2015-12-31 19:06:24 +00004820 raw_printf(p->out, "PRAGMA foreign_keys=OFF;\n");
4821 raw_printf(p->out, "BEGIN TRANSACTION;\n");
drh45e29d82006-11-20 16:21:10 +00004822 p->writableSchema = 0;
drh72507d42017-04-08 00:55:13 +00004823 p->showHeader = 0;
drhe611f142017-03-08 11:44:00 +00004824 /* Set writable_schema=ON since doing so forces SQLite to initialize
4825 ** as much of the schema as it can even if the sqlite_master table is
4826 ** corrupt. */
drh56197952011-10-13 16:30:13 +00004827 sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
drh2f464a02011-10-13 00:41:49 +00004828 p->nErr = 0;
drhe611f142017-03-08 11:44:00 +00004829 if( zLike==0 ){
mistachkin1fe36bb2016-04-04 02:16:44 +00004830 run_schema_dump_query(p,
drha18c5682000-10-08 22:20:57 +00004831 "SELECT name, type, sql FROM sqlite_master "
drh2f464a02011-10-13 00:41:49 +00004832 "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
drh4f324762009-05-21 14:51:03 +00004833 );
mistachkin1fe36bb2016-04-04 02:16:44 +00004834 run_schema_dump_query(p,
drh4f324762009-05-21 14:51:03 +00004835 "SELECT name, type, sql FROM sqlite_master "
drh2f464a02011-10-13 00:41:49 +00004836 "WHERE name=='sqlite_sequence'"
drh0b9a5942006-09-13 20:22:02 +00004837 );
drh2f464a02011-10-13 00:41:49 +00004838 run_table_dump_query(p,
drh0b9a5942006-09-13 20:22:02 +00004839 "SELECT sql FROM sqlite_master "
drh157e29a2009-05-21 15:15:00 +00004840 "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
drha18c5682000-10-08 22:20:57 +00004841 );
drh4c653a02000-06-07 01:27:47 +00004842 }else{
drhe611f142017-03-08 11:44:00 +00004843 char *zSql;
4844 zSql = sqlite3_mprintf(
4845 "SELECT name, type, sql FROM sqlite_master "
4846 "WHERE tbl_name LIKE %Q AND type=='table'"
4847 " AND sql NOT NULL", zLike);
4848 run_schema_dump_query(p,zSql);
4849 sqlite3_free(zSql);
4850 zSql = sqlite3_mprintf(
4851 "SELECT sql FROM sqlite_master "
4852 "WHERE sql NOT NULL"
4853 " AND type IN ('index','trigger','view')"
4854 " AND tbl_name LIKE %Q", zLike);
4855 run_table_dump_query(p, zSql, 0);
4856 sqlite3_free(zSql);
drh4c653a02000-06-07 01:27:47 +00004857 }
drh45e29d82006-11-20 16:21:10 +00004858 if( p->writableSchema ){
mistachkinaae280e2015-12-31 19:06:24 +00004859 raw_printf(p->out, "PRAGMA writable_schema=OFF;\n");
drh45e29d82006-11-20 16:21:10 +00004860 p->writableSchema = 0;
4861 }
drh56197952011-10-13 16:30:13 +00004862 sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
4863 sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0);
mistachkinaae280e2015-12-31 19:06:24 +00004864 raw_printf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
drh72507d42017-04-08 00:55:13 +00004865 p->showHeader = savedShowHeader;
drh4c653a02000-06-07 01:27:47 +00004866 }else
drh75897232000-05-29 14:26:00 +00004867
drhc2ce0be2014-05-29 12:36:14 +00004868 if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){
4869 if( nArg==2 ){
drhe6e1d122017-03-09 13:50:49 +00004870 setOrClearFlag(p, SHFLG_Echo, azArg[1]);
drhc2ce0be2014-05-29 12:36:14 +00004871 }else{
mistachkinaae280e2015-12-31 19:06:24 +00004872 raw_printf(stderr, "Usage: .echo on|off\n");
drhc2ce0be2014-05-29 12:36:14 +00004873 rc = 1;
4874 }
drhdaffd0e2001-04-11 14:28:42 +00004875 }else
4876
drhc2ce0be2014-05-29 12:36:14 +00004877 if( c=='e' && strncmp(azArg[0], "eqp", n)==0 ){
4878 if( nArg==2 ){
drheacd29d2016-04-15 15:03:27 +00004879 if( strcmp(azArg[1],"full")==0 ){
4880 p->autoEQP = 2;
4881 }else{
4882 p->autoEQP = booleanValue(azArg[1]);
4883 }
drhc2ce0be2014-05-29 12:36:14 +00004884 }else{
drheacd29d2016-04-15 15:03:27 +00004885 raw_printf(stderr, "Usage: .eqp on|off|full\n");
drhc2ce0be2014-05-29 12:36:14 +00004886 rc = 1;
mistachkin1fe36bb2016-04-04 02:16:44 +00004887 }
drhefbf3b12014-02-28 20:47:24 +00004888 }else
4889
drhd3ac7d92013-01-25 18:33:43 +00004890 if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){
drh348d19c2013-06-03 12:47:43 +00004891 if( nArg>1 && (rc = (int)integerValue(azArg[1]))!=0 ) exit(rc);
drh47ad6842006-11-08 12:25:42 +00004892 rc = 2;
drh75897232000-05-29 14:26:00 +00004893 }else
4894
drhc2ce0be2014-05-29 12:36:14 +00004895 if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){
drh700c2522016-02-09 18:39:25 +00004896 int val = 1;
4897 if( nArg>=2 ){
4898 if( strcmp(azArg[1],"auto")==0 ){
4899 val = 99;
4900 }else{
4901 val = booleanValue(azArg[1]);
persicom7e2dfdd2002-04-18 02:46:52 +00004902 }
drh700c2522016-02-09 18:39:25 +00004903 }
4904 if( val==1 && p->mode!=MODE_Explain ){
4905 p->normalMode = p->mode;
danielk19770d78bae2008-01-03 07:09:48 +00004906 p->mode = MODE_Explain;
drh700c2522016-02-09 18:39:25 +00004907 p->autoExplain = 0;
4908 }else if( val==0 ){
4909 if( p->mode==MODE_Explain ) p->mode = p->normalMode;
4910 p->autoExplain = 0;
4911 }else if( val==99 ){
4912 if( p->mode==MODE_Explain ) p->mode = p->normalMode;
4913 p->autoExplain = 1;
persicom7e2dfdd2002-04-18 02:46:52 +00004914 }
drh75897232000-05-29 14:26:00 +00004915 }else
4916
drhc1971542014-06-23 23:28:13 +00004917 if( c=='f' && strncmp(azArg[0], "fullschema", n)==0 ){
drhdcd87a92014-08-18 13:45:42 +00004918 ShellState data;
drhc1971542014-06-23 23:28:13 +00004919 char *zErrMsg = 0;
drh56f674c2014-07-18 14:43:29 +00004920 int doStats = 0;
drh4926fec2016-04-13 15:33:42 +00004921 memcpy(&data, p, sizeof(data));
4922 data.showHeader = 0;
4923 data.cMode = data.mode = MODE_Semi;
4924 if( nArg==2 && optionMatch(azArg[1], "indent") ){
4925 data.cMode = data.mode = MODE_Pretty;
4926 nArg = 1;
4927 }
drhc1971542014-06-23 23:28:13 +00004928 if( nArg!=1 ){
drh4926fec2016-04-13 15:33:42 +00004929 raw_printf(stderr, "Usage: .fullschema ?--indent?\n");
drhc1971542014-06-23 23:28:13 +00004930 rc = 1;
4931 goto meta_command_exit;
4932 }
4933 open_db(p, 0);
drhc1971542014-06-23 23:28:13 +00004934 rc = sqlite3_exec(p->db,
4935 "SELECT sql FROM"
4936 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
4937 " FROM sqlite_master UNION ALL"
4938 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
drh4b2590e2014-08-19 19:28:00 +00004939 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
drhc1971542014-06-23 23:28:13 +00004940 "ORDER BY rowid",
4941 callback, &data, &zErrMsg
4942 );
drh56f674c2014-07-18 14:43:29 +00004943 if( rc==SQLITE_OK ){
4944 sqlite3_stmt *pStmt;
4945 rc = sqlite3_prepare_v2(p->db,
4946 "SELECT rowid FROM sqlite_master"
4947 " WHERE name GLOB 'sqlite_stat[134]'",
4948 -1, &pStmt, 0);
4949 doStats = sqlite3_step(pStmt)==SQLITE_ROW;
4950 sqlite3_finalize(pStmt);
4951 }
4952 if( doStats==0 ){
mistachkinaae280e2015-12-31 19:06:24 +00004953 raw_printf(p->out, "/* No STAT tables available */\n");
drh56f674c2014-07-18 14:43:29 +00004954 }else{
mistachkinaae280e2015-12-31 19:06:24 +00004955 raw_printf(p->out, "ANALYZE sqlite_master;\n");
drh56f674c2014-07-18 14:43:29 +00004956 sqlite3_exec(p->db, "SELECT 'ANALYZE sqlite_master'",
4957 callback, &data, &zErrMsg);
drh700c2522016-02-09 18:39:25 +00004958 data.cMode = data.mode = MODE_Insert;
drh56f674c2014-07-18 14:43:29 +00004959 data.zDestTable = "sqlite_stat1";
4960 shell_exec(p->db, "SELECT * FROM sqlite_stat1",
4961 shell_callback, &data,&zErrMsg);
4962 data.zDestTable = "sqlite_stat3";
4963 shell_exec(p->db, "SELECT * FROM sqlite_stat3",
4964 shell_callback, &data,&zErrMsg);
4965 data.zDestTable = "sqlite_stat4";
4966 shell_exec(p->db, "SELECT * FROM sqlite_stat4",
4967 shell_callback, &data, &zErrMsg);
mistachkinaae280e2015-12-31 19:06:24 +00004968 raw_printf(p->out, "ANALYZE sqlite_master;\n");
drh56f674c2014-07-18 14:43:29 +00004969 }
drhc1971542014-06-23 23:28:13 +00004970 }else
4971
drhc2ce0be2014-05-29 12:36:14 +00004972 if( c=='h' && strncmp(azArg[0], "headers", n)==0 ){
4973 if( nArg==2 ){
4974 p->showHeader = booleanValue(azArg[1]);
4975 }else{
mistachkinaae280e2015-12-31 19:06:24 +00004976 raw_printf(stderr, "Usage: .headers on|off\n");
drhc2ce0be2014-05-29 12:36:14 +00004977 rc = 1;
shaneb320ccd2009-10-21 03:42:58 +00004978 }
drh75897232000-05-29 14:26:00 +00004979 }else
4980
drhc2ce0be2014-05-29 12:36:14 +00004981 if( c=='h' && strncmp(azArg[0], "help", n)==0 ){
mistachkinaae280e2015-12-31 19:06:24 +00004982 utf8_printf(p->out, "%s", zHelp);
drhc2ce0be2014-05-29 12:36:14 +00004983 }else
4984
4985 if( c=='i' && strncmp(azArg[0], "import", n)==0 ){
drh01f37542014-05-31 15:43:33 +00004986 char *zTable; /* Insert data into this table */
4987 char *zFile; /* Name of file to extra content from */
shane916f9612009-10-23 00:37:15 +00004988 sqlite3_stmt *pStmt = NULL; /* A statement */
drhfeac5f82004-08-01 00:10:45 +00004989 int nCol; /* Number of columns in the table */
4990 int nByte; /* Number of bytes in an SQL string */
4991 int i, j; /* Loop counters */
drh2d463112013-08-06 14:36:36 +00004992 int needCommit; /* True to COMMIT or ROLLBACK at end */
mistachkin636bf9f2014-07-19 20:15:16 +00004993 int nSep; /* Number of bytes in p->colSeparator[] */
drhfeac5f82004-08-01 00:10:45 +00004994 char *zSql; /* An SQL statement */
mistachkin636bf9f2014-07-19 20:15:16 +00004995 ImportCtx sCtx; /* Reader context */
mistachkin44723ce2015-03-21 02:22:37 +00004996 char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */
4997 int (SQLITE_CDECL *xCloser)(FILE*); /* Func to close file */
drhfeac5f82004-08-01 00:10:45 +00004998
drhc2ce0be2014-05-29 12:36:14 +00004999 if( nArg!=3 ){
mistachkinaae280e2015-12-31 19:06:24 +00005000 raw_printf(stderr, "Usage: .import FILE TABLE\n");
drhc2ce0be2014-05-29 12:36:14 +00005001 goto meta_command_exit;
5002 }
drh01f37542014-05-31 15:43:33 +00005003 zFile = azArg[1];
5004 zTable = azArg[2];
drhdb95f682013-06-26 22:46:00 +00005005 seenInterrupt = 0;
mistachkin636bf9f2014-07-19 20:15:16 +00005006 memset(&sCtx, 0, sizeof(sCtx));
drh05782482013-10-24 15:20:20 +00005007 open_db(p, 0);
mistachkin636bf9f2014-07-19 20:15:16 +00005008 nSep = strlen30(p->colSeparator);
drhfeac5f82004-08-01 00:10:45 +00005009 if( nSep==0 ){
mistachkinaae280e2015-12-31 19:06:24 +00005010 raw_printf(stderr,
5011 "Error: non-null column separator required for import\n");
shane916f9612009-10-23 00:37:15 +00005012 return 1;
drhfeac5f82004-08-01 00:10:45 +00005013 }
drhdb95f682013-06-26 22:46:00 +00005014 if( nSep>1 ){
mistachkinaae280e2015-12-31 19:06:24 +00005015 raw_printf(stderr, "Error: multi-character column separators not allowed"
drhdb95f682013-06-26 22:46:00 +00005016 " for import\n");
5017 return 1;
5018 }
mistachkin636bf9f2014-07-19 20:15:16 +00005019 nSep = strlen30(p->rowSeparator);
5020 if( nSep==0 ){
mistachkinaae280e2015-12-31 19:06:24 +00005021 raw_printf(stderr, "Error: non-null row separator required for import\n");
mistachkin636bf9f2014-07-19 20:15:16 +00005022 return 1;
5023 }
mistachkine0d68852014-12-11 03:12:33 +00005024 if( nSep==2 && p->mode==MODE_Csv && strcmp(p->rowSeparator, SEP_CrLf)==0 ){
5025 /* When importing CSV (only), if the row separator is set to the
5026 ** default output row separator, change it to the default input
5027 ** row separator. This avoids having to maintain different input
5028 ** and output row separators. */
5029 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
5030 nSep = strlen30(p->rowSeparator);
5031 }
mistachkin636bf9f2014-07-19 20:15:16 +00005032 if( nSep>1 ){
mistachkinaae280e2015-12-31 19:06:24 +00005033 raw_printf(stderr, "Error: multi-character row separators not allowed"
mistachkin636bf9f2014-07-19 20:15:16 +00005034 " for import\n");
5035 return 1;
5036 }
5037 sCtx.zFile = zFile;
5038 sCtx.nLine = 1;
5039 if( sCtx.zFile[0]=='|' ){
drh8cd5b252015-03-02 22:06:43 +00005040#ifdef SQLITE_OMIT_POPEN
mistachkinaae280e2015-12-31 19:06:24 +00005041 raw_printf(stderr, "Error: pipes are not supported in this OS\n");
drh8cd5b252015-03-02 22:06:43 +00005042 return 1;
5043#else
mistachkin636bf9f2014-07-19 20:15:16 +00005044 sCtx.in = popen(sCtx.zFile+1, "r");
5045 sCtx.zFile = "<pipe>";
drh5bde8162013-06-27 14:07:53 +00005046 xCloser = pclose;
drh8cd5b252015-03-02 22:06:43 +00005047#endif
drh5bde8162013-06-27 14:07:53 +00005048 }else{
mistachkin636bf9f2014-07-19 20:15:16 +00005049 sCtx.in = fopen(sCtx.zFile, "rb");
drh5bde8162013-06-27 14:07:53 +00005050 xCloser = fclose;
5051 }
mistachkin636bf9f2014-07-19 20:15:16 +00005052 if( p->mode==MODE_Ascii ){
5053 xRead = ascii_read_one_field;
5054 }else{
5055 xRead = csv_read_one_field;
5056 }
5057 if( sCtx.in==0 ){
mistachkinaae280e2015-12-31 19:06:24 +00005058 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile);
drhdb95f682013-06-26 22:46:00 +00005059 return 1;
5060 }
mistachkin636bf9f2014-07-19 20:15:16 +00005061 sCtx.cColSep = p->colSeparator[0];
5062 sCtx.cRowSep = p->rowSeparator[0];
drh7b075e32011-09-28 01:10:00 +00005063 zSql = sqlite3_mprintf("SELECT * FROM %s", zTable);
shane916f9612009-10-23 00:37:15 +00005064 if( zSql==0 ){
mistachkinaae280e2015-12-31 19:06:24 +00005065 raw_printf(stderr, "Error: out of memory\n");
mistachkin636bf9f2014-07-19 20:15:16 +00005066 xCloser(sCtx.in);
shane916f9612009-10-23 00:37:15 +00005067 return 1;
5068 }
drh4f21c4a2008-12-10 22:15:00 +00005069 nByte = strlen30(zSql);
drhc7181902014-02-27 15:04:13 +00005070 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
mistachkin636bf9f2014-07-19 20:15:16 +00005071 import_append_char(&sCtx, 0); /* To ensure sCtx.z is allocated */
mistachkin8e189222015-04-19 21:43:16 +00005072 if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(p->db))==0 ){
drhdb95f682013-06-26 22:46:00 +00005073 char *zCreate = sqlite3_mprintf("CREATE TABLE %s", zTable);
5074 char cSep = '(';
mistachkin636bf9f2014-07-19 20:15:16 +00005075 while( xRead(&sCtx) ){
drhd8c22ac2016-02-25 13:33:02 +00005076 zCreate = sqlite3_mprintf("%z%c\n \"%w\" TEXT", zCreate, cSep, sCtx.z);
drhdb95f682013-06-26 22:46:00 +00005077 cSep = ',';
mistachkin636bf9f2014-07-19 20:15:16 +00005078 if( sCtx.cTerm!=sCtx.cColSep ) break;
drhdb95f682013-06-26 22:46:00 +00005079 }
drh5bde8162013-06-27 14:07:53 +00005080 if( cSep=='(' ){
5081 sqlite3_free(zCreate);
mistachkin636bf9f2014-07-19 20:15:16 +00005082 sqlite3_free(sCtx.z);
5083 xCloser(sCtx.in);
mistachkinaae280e2015-12-31 19:06:24 +00005084 utf8_printf(stderr,"%s: empty file\n", sCtx.zFile);
drh5bde8162013-06-27 14:07:53 +00005085 return 1;
5086 }
drhdb95f682013-06-26 22:46:00 +00005087 zCreate = sqlite3_mprintf("%z\n)", zCreate);
5088 rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
5089 sqlite3_free(zCreate);
5090 if( rc ){
mistachkinaae280e2015-12-31 19:06:24 +00005091 utf8_printf(stderr, "CREATE TABLE %s(...) failed: %s\n", zTable,
mistachkin8e189222015-04-19 21:43:16 +00005092 sqlite3_errmsg(p->db));
mistachkin636bf9f2014-07-19 20:15:16 +00005093 sqlite3_free(sCtx.z);
5094 xCloser(sCtx.in);
drhdb95f682013-06-26 22:46:00 +00005095 return 1;
5096 }
drhc7181902014-02-27 15:04:13 +00005097 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
drhdb95f682013-06-26 22:46:00 +00005098 }
drhfeac5f82004-08-01 00:10:45 +00005099 sqlite3_free(zSql);
5100 if( rc ){
shane916f9612009-10-23 00:37:15 +00005101 if (pStmt) sqlite3_finalize(pStmt);
mistachkinaae280e2015-12-31 19:06:24 +00005102 utf8_printf(stderr,"Error: %s\n", sqlite3_errmsg(p->db));
mistachkin636bf9f2014-07-19 20:15:16 +00005103 xCloser(sCtx.in);
shane916f9612009-10-23 00:37:15 +00005104 return 1;
drhfeac5f82004-08-01 00:10:45 +00005105 }
shane916f9612009-10-23 00:37:15 +00005106 nCol = sqlite3_column_count(pStmt);
drhfeac5f82004-08-01 00:10:45 +00005107 sqlite3_finalize(pStmt);
shane916f9612009-10-23 00:37:15 +00005108 pStmt = 0;
shane9bd1b442009-10-23 01:27:39 +00005109 if( nCol==0 ) return 0; /* no columns, no error */
drhf3cdcdc2015-04-29 16:50:28 +00005110 zSql = sqlite3_malloc64( nByte*2 + 20 + nCol*2 );
shane916f9612009-10-23 00:37:15 +00005111 if( zSql==0 ){
mistachkinaae280e2015-12-31 19:06:24 +00005112 raw_printf(stderr, "Error: out of memory\n");
mistachkin636bf9f2014-07-19 20:15:16 +00005113 xCloser(sCtx.in);
shane916f9612009-10-23 00:37:15 +00005114 return 1;
5115 }
drhdb95f682013-06-26 22:46:00 +00005116 sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable);
drh4f21c4a2008-12-10 22:15:00 +00005117 j = strlen30(zSql);
drhfeac5f82004-08-01 00:10:45 +00005118 for(i=1; i<nCol; i++){
5119 zSql[j++] = ',';
5120 zSql[j++] = '?';
5121 }
5122 zSql[j++] = ')';
5123 zSql[j] = 0;
drhc7181902014-02-27 15:04:13 +00005124 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
drhdb95f682013-06-26 22:46:00 +00005125 sqlite3_free(zSql);
drhfeac5f82004-08-01 00:10:45 +00005126 if( rc ){
mistachkinaae280e2015-12-31 19:06:24 +00005127 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
shane916f9612009-10-23 00:37:15 +00005128 if (pStmt) sqlite3_finalize(pStmt);
mistachkin636bf9f2014-07-19 20:15:16 +00005129 xCloser(sCtx.in);
drh47ad6842006-11-08 12:25:42 +00005130 return 1;
drhfeac5f82004-08-01 00:10:45 +00005131 }
mistachkin8e189222015-04-19 21:43:16 +00005132 needCommit = sqlite3_get_autocommit(p->db);
5133 if( needCommit ) sqlite3_exec(p->db, "BEGIN", 0, 0, 0);
drhdb95f682013-06-26 22:46:00 +00005134 do{
mistachkin636bf9f2014-07-19 20:15:16 +00005135 int startLine = sCtx.nLine;
drhfeac5f82004-08-01 00:10:45 +00005136 for(i=0; i<nCol; i++){
mistachkin636bf9f2014-07-19 20:15:16 +00005137 char *z = xRead(&sCtx);
5138 /*
5139 ** Did we reach end-of-file before finding any columns?
5140 ** If so, stop instead of NULL filling the remaining columns.
5141 */
drhdb95f682013-06-26 22:46:00 +00005142 if( z==0 && i==0 ) break;
mistachkin636bf9f2014-07-19 20:15:16 +00005143 /*
5144 ** Did we reach end-of-file OR end-of-line before finding any
5145 ** columns in ASCII mode? If so, stop instead of NULL filling
5146 ** the remaining columns.
5147 */
5148 if( p->mode==MODE_Ascii && (z==0 || z[0]==0) && i==0 ) break;
drhdb95f682013-06-26 22:46:00 +00005149 sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT);
mistachkin636bf9f2014-07-19 20:15:16 +00005150 if( i<nCol-1 && sCtx.cTerm!=sCtx.cColSep ){
mistachkinaae280e2015-12-31 19:06:24 +00005151 utf8_printf(stderr, "%s:%d: expected %d columns but found %d - "
drhdb95f682013-06-26 22:46:00 +00005152 "filling the rest with NULL\n",
mistachkin636bf9f2014-07-19 20:15:16 +00005153 sCtx.zFile, startLine, nCol, i+1);
mistachkina0efb1a2015-02-12 22:45:25 +00005154 i += 2;
mistachkin6fe03382014-06-16 22:45:28 +00005155 while( i<=nCol ){ sqlite3_bind_null(pStmt, i); i++; }
drh18f52e02012-01-16 16:56:31 +00005156 }
drhfeac5f82004-08-01 00:10:45 +00005157 }
mistachkin636bf9f2014-07-19 20:15:16 +00005158 if( sCtx.cTerm==sCtx.cColSep ){
drhdb95f682013-06-26 22:46:00 +00005159 do{
mistachkin636bf9f2014-07-19 20:15:16 +00005160 xRead(&sCtx);
drhdb95f682013-06-26 22:46:00 +00005161 i++;
mistachkin636bf9f2014-07-19 20:15:16 +00005162 }while( sCtx.cTerm==sCtx.cColSep );
mistachkinaae280e2015-12-31 19:06:24 +00005163 utf8_printf(stderr, "%s:%d: expected %d columns but found %d - "
drhdb95f682013-06-26 22:46:00 +00005164 "extras ignored\n",
mistachkin636bf9f2014-07-19 20:15:16 +00005165 sCtx.zFile, startLine, nCol, i);
drhfeac5f82004-08-01 00:10:45 +00005166 }
drhdb95f682013-06-26 22:46:00 +00005167 if( i>=nCol ){
5168 sqlite3_step(pStmt);
5169 rc = sqlite3_reset(pStmt);
5170 if( rc!=SQLITE_OK ){
mistachkinaae280e2015-12-31 19:06:24 +00005171 utf8_printf(stderr, "%s:%d: INSERT failed: %s\n", sCtx.zFile,
5172 startLine, sqlite3_errmsg(p->db));
drhdb95f682013-06-26 22:46:00 +00005173 }
5174 }
mistachkin636bf9f2014-07-19 20:15:16 +00005175 }while( sCtx.cTerm!=EOF );
drhdb95f682013-06-26 22:46:00 +00005176
mistachkin636bf9f2014-07-19 20:15:16 +00005177 xCloser(sCtx.in);
5178 sqlite3_free(sCtx.z);
drhfeac5f82004-08-01 00:10:45 +00005179 sqlite3_finalize(pStmt);
mistachkin8e189222015-04-19 21:43:16 +00005180 if( needCommit ) sqlite3_exec(p->db, "COMMIT", 0, 0, 0);
drhfeac5f82004-08-01 00:10:45 +00005181 }else
5182
drhd12602a2016-12-07 15:49:02 +00005183#ifndef SQLITE_UNTESTABLE
drh16eb5942016-11-03 13:01:38 +00005184 if( c=='i' && strncmp(azArg[0], "imposter", n)==0 ){
5185 char *zSql;
5186 char *zCollist = 0;
5187 sqlite3_stmt *pStmt;
5188 int tnum = 0;
drh59ce2c42016-11-03 13:12:28 +00005189 int i;
drh16eb5942016-11-03 13:01:38 +00005190 if( nArg!=3 ){
5191 utf8_printf(stderr, "Usage: .imposter INDEX IMPOSTER\n");
5192 rc = 1;
5193 goto meta_command_exit;
5194 }
5195 open_db(p, 0);
5196 zSql = sqlite3_mprintf("SELECT rootpage FROM sqlite_master"
5197 " WHERE name='%q' AND type='index'", azArg[1]);
5198 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
5199 sqlite3_free(zSql);
5200 if( sqlite3_step(pStmt)==SQLITE_ROW ){
5201 tnum = sqlite3_column_int(pStmt, 0);
5202 }
5203 sqlite3_finalize(pStmt);
5204 if( tnum==0 ){
5205 utf8_printf(stderr, "no such index: \"%s\"\n", azArg[1]);
5206 rc = 1;
5207 goto meta_command_exit;
5208 }
5209 zSql = sqlite3_mprintf("PRAGMA index_xinfo='%q'", azArg[1]);
5210 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
5211 sqlite3_free(zSql);
drh59ce2c42016-11-03 13:12:28 +00005212 i = 0;
drh16eb5942016-11-03 13:01:38 +00005213 while( sqlite3_step(pStmt)==SQLITE_ROW ){
drh59ce2c42016-11-03 13:12:28 +00005214 char zLabel[20];
drh16eb5942016-11-03 13:01:38 +00005215 const char *zCol = (const char*)sqlite3_column_text(pStmt,2);
drh59ce2c42016-11-03 13:12:28 +00005216 i++;
5217 if( zCol==0 ){
5218 if( sqlite3_column_int(pStmt,1)==-1 ){
5219 zCol = "_ROWID_";
5220 }else{
5221 sqlite3_snprintf(sizeof(zLabel),zLabel,"expr%d",i);
5222 zCol = zLabel;
5223 }
5224 }
drh16eb5942016-11-03 13:01:38 +00005225 if( zCollist==0 ){
5226 zCollist = sqlite3_mprintf("\"%w\"", zCol);
5227 }else{
5228 zCollist = sqlite3_mprintf("%z,\"%w\"", zCollist, zCol);
5229 }
5230 }
5231 sqlite3_finalize(pStmt);
5232 zSql = sqlite3_mprintf(
5233 "CREATE TABLE \"%w\"(%s,PRIMARY KEY(%s))WITHOUT ROWID",
5234 azArg[2], zCollist, zCollist);
5235 sqlite3_free(zCollist);
5236 rc = sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 1, tnum);
5237 if( rc==SQLITE_OK ){
5238 rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
5239 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 0);
5240 if( rc ){
5241 utf8_printf(stderr, "Error in [%s]: %s\n", zSql, sqlite3_errmsg(p->db));
5242 }else{
5243 utf8_printf(stdout, "%s;\n", zSql);
mistachkin2f9a6132016-11-11 05:19:45 +00005244 raw_printf(stdout,
drh16eb5942016-11-03 13:01:38 +00005245 "WARNING: writing to an imposter table will corrupt the index!\n"
5246 );
5247 }
5248 }else{
mistachkin2f9a6132016-11-11 05:19:45 +00005249 raw_printf(stderr, "SQLITE_TESTCTRL_IMPOSTER returns %d\n", rc);
drh16eb5942016-11-03 13:01:38 +00005250 rc = 1;
5251 }
5252 sqlite3_free(zSql);
5253 }else
5254#endif /* !defined(SQLITE_OMIT_TEST_CONTROL) */
5255
drhae5e4452007-05-03 17:18:36 +00005256#ifdef SQLITE_ENABLE_IOTRACE
drhb0603412007-02-28 04:47:26 +00005257 if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){
mistachkin9871a932015-03-27 00:21:52 +00005258 SQLITE_API extern void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...);
drhb0603412007-02-28 04:47:26 +00005259 if( iotrace && iotrace!=stdout ) fclose(iotrace);
5260 iotrace = 0;
5261 if( nArg<2 ){
mlcreech3a00f902008-03-04 17:45:01 +00005262 sqlite3IoTrace = 0;
drhb0603412007-02-28 04:47:26 +00005263 }else if( strcmp(azArg[1], "-")==0 ){
mlcreech3a00f902008-03-04 17:45:01 +00005264 sqlite3IoTrace = iotracePrintf;
drhb0603412007-02-28 04:47:26 +00005265 iotrace = stdout;
5266 }else{
5267 iotrace = fopen(azArg[1], "w");
5268 if( iotrace==0 ){
mistachkinaae280e2015-12-31 19:06:24 +00005269 utf8_printf(stderr, "Error: cannot open \"%s\"\n", azArg[1]);
mlcreech3a00f902008-03-04 17:45:01 +00005270 sqlite3IoTrace = 0;
shane9bd1b442009-10-23 01:27:39 +00005271 rc = 1;
drhb0603412007-02-28 04:47:26 +00005272 }else{
mlcreech3a00f902008-03-04 17:45:01 +00005273 sqlite3IoTrace = iotracePrintf;
drhb0603412007-02-28 04:47:26 +00005274 }
5275 }
5276 }else
drhae5e4452007-05-03 17:18:36 +00005277#endif
drh16eb5942016-11-03 13:01:38 +00005278
drh1a513372015-05-02 17:40:23 +00005279 if( c=='l' && n>=5 && strncmp(azArg[0], "limits", n)==0 ){
5280 static const struct {
5281 const char *zLimitName; /* Name of a limit */
5282 int limitCode; /* Integer code for that limit */
5283 } aLimit[] = {
5284 { "length", SQLITE_LIMIT_LENGTH },
5285 { "sql_length", SQLITE_LIMIT_SQL_LENGTH },
5286 { "column", SQLITE_LIMIT_COLUMN },
5287 { "expr_depth", SQLITE_LIMIT_EXPR_DEPTH },
5288 { "compound_select", SQLITE_LIMIT_COMPOUND_SELECT },
5289 { "vdbe_op", SQLITE_LIMIT_VDBE_OP },
5290 { "function_arg", SQLITE_LIMIT_FUNCTION_ARG },
5291 { "attached", SQLITE_LIMIT_ATTACHED },
5292 { "like_pattern_length", SQLITE_LIMIT_LIKE_PATTERN_LENGTH },
5293 { "variable_number", SQLITE_LIMIT_VARIABLE_NUMBER },
5294 { "trigger_depth", SQLITE_LIMIT_TRIGGER_DEPTH },
5295 { "worker_threads", SQLITE_LIMIT_WORKER_THREADS },
5296 };
5297 int i, n2;
5298 open_db(p, 0);
5299 if( nArg==1 ){
drhf5ed7ad2015-06-15 14:43:25 +00005300 for(i=0; i<ArraySize(aLimit); i++){
mistachkin1fe36bb2016-04-04 02:16:44 +00005301 printf("%20s %d\n", aLimit[i].zLimitName,
drh1a513372015-05-02 17:40:23 +00005302 sqlite3_limit(p->db, aLimit[i].limitCode, -1));
5303 }
5304 }else if( nArg>3 ){
mistachkinaae280e2015-12-31 19:06:24 +00005305 raw_printf(stderr, "Usage: .limit NAME ?NEW-VALUE?\n");
drh1a513372015-05-02 17:40:23 +00005306 rc = 1;
5307 goto meta_command_exit;
5308 }else{
5309 int iLimit = -1;
5310 n2 = strlen30(azArg[1]);
drhf5ed7ad2015-06-15 14:43:25 +00005311 for(i=0; i<ArraySize(aLimit); i++){
drh1a513372015-05-02 17:40:23 +00005312 if( sqlite3_strnicmp(aLimit[i].zLimitName, azArg[1], n2)==0 ){
5313 if( iLimit<0 ){
5314 iLimit = i;
5315 }else{
mistachkinaae280e2015-12-31 19:06:24 +00005316 utf8_printf(stderr, "ambiguous limit: \"%s\"\n", azArg[1]);
drh1a513372015-05-02 17:40:23 +00005317 rc = 1;
5318 goto meta_command_exit;
5319 }
5320 }
5321 }
5322 if( iLimit<0 ){
mistachkinaae280e2015-12-31 19:06:24 +00005323 utf8_printf(stderr, "unknown limit: \"%s\"\n"
drh1a513372015-05-02 17:40:23 +00005324 "enter \".limits\" with no arguments for a list.\n",
5325 azArg[1]);
5326 rc = 1;
5327 goto meta_command_exit;
5328 }
5329 if( nArg==3 ){
mistachkin2c1820c2015-05-08 01:04:39 +00005330 sqlite3_limit(p->db, aLimit[iLimit].limitCode,
5331 (int)integerValue(azArg[2]));
drh1a513372015-05-02 17:40:23 +00005332 }
5333 printf("%20s %d\n", aLimit[iLimit].zLimitName,
5334 sqlite3_limit(p->db, aLimit[iLimit].limitCode, -1));
5335 }
5336 }else
drhb0603412007-02-28 04:47:26 +00005337
dan3c7ebeb2016-12-16 17:28:56 +00005338 if( c=='l' && n>2 && strncmp(azArg[0], "lint", n)==0 ){
drh3fd9f332016-12-16 18:41:11 +00005339 open_db(p, 0);
dan3c7ebeb2016-12-16 17:28:56 +00005340 lintDotCommand(p, azArg, nArg);
5341 }else
5342
drh70df4fe2006-06-13 15:12:21 +00005343#ifndef SQLITE_OMIT_LOAD_EXTENSION
drhc2ce0be2014-05-29 12:36:14 +00005344 if( c=='l' && strncmp(azArg[0], "load", n)==0 ){
drh1e397f82006-06-08 15:28:43 +00005345 const char *zFile, *zProc;
5346 char *zErrMsg = 0;
drhc2ce0be2014-05-29 12:36:14 +00005347 if( nArg<2 ){
mistachkinaae280e2015-12-31 19:06:24 +00005348 raw_printf(stderr, "Usage: .load FILE ?ENTRYPOINT?\n");
drhc2ce0be2014-05-29 12:36:14 +00005349 rc = 1;
5350 goto meta_command_exit;
5351 }
drh1e397f82006-06-08 15:28:43 +00005352 zFile = azArg[1];
5353 zProc = nArg>=3 ? azArg[2] : 0;
drh05782482013-10-24 15:20:20 +00005354 open_db(p, 0);
drh1e397f82006-06-08 15:28:43 +00005355 rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
5356 if( rc!=SQLITE_OK ){
mistachkinaae280e2015-12-31 19:06:24 +00005357 utf8_printf(stderr, "Error: %s\n", zErrMsg);
drh1e397f82006-06-08 15:28:43 +00005358 sqlite3_free(zErrMsg);
drh47ad6842006-11-08 12:25:42 +00005359 rc = 1;
drh1e397f82006-06-08 15:28:43 +00005360 }
5361 }else
drh70df4fe2006-06-13 15:12:21 +00005362#endif
drh1e397f82006-06-08 15:28:43 +00005363
drhc2ce0be2014-05-29 12:36:14 +00005364 if( c=='l' && strncmp(azArg[0], "log", n)==0 ){
5365 if( nArg!=2 ){
mistachkinaae280e2015-12-31 19:06:24 +00005366 raw_printf(stderr, "Usage: .log FILENAME\n");
drhc2ce0be2014-05-29 12:36:14 +00005367 rc = 1;
5368 }else{
5369 const char *zFile = azArg[1];
5370 output_file_close(p->pLog);
5371 p->pLog = output_file_open(zFile);
5372 }
drh127f9d72010-02-23 01:47:00 +00005373 }else
5374
drhc2ce0be2014-05-29 12:36:14 +00005375 if( c=='m' && strncmp(azArg[0], "mode", n)==0 ){
5376 const char *zMode = nArg>=2 ? azArg[1] : "";
5377 int n2 = (int)strlen(zMode);
5378 int c2 = zMode[0];
5379 if( c2=='l' && n2>2 && strncmp(azArg[1],"lines",n2)==0 ){
drh75897232000-05-29 14:26:00 +00005380 p->mode = MODE_Line;
drh7aee83b2017-01-27 01:52:42 +00005381 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
drhc2ce0be2014-05-29 12:36:14 +00005382 }else if( c2=='c' && strncmp(azArg[1],"columns",n2)==0 ){
drh75897232000-05-29 14:26:00 +00005383 p->mode = MODE_Column;
drh7aee83b2017-01-27 01:52:42 +00005384 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
drhc2ce0be2014-05-29 12:36:14 +00005385 }else if( c2=='l' && n2>2 && strncmp(azArg[1],"list",n2)==0 ){
drh75897232000-05-29 14:26:00 +00005386 p->mode = MODE_List;
drh7aee83b2017-01-27 01:52:42 +00005387 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Column);
5388 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
drhc2ce0be2014-05-29 12:36:14 +00005389 }else if( c2=='h' && strncmp(azArg[1],"html",n2)==0 ){
drh1e5d0e92000-05-31 23:33:17 +00005390 p->mode = MODE_Html;
drhc2ce0be2014-05-29 12:36:14 +00005391 }else if( c2=='t' && strncmp(azArg[1],"tcl",n2)==0 ){
drhfeac5f82004-08-01 00:10:45 +00005392 p->mode = MODE_Tcl;
mistachkinfad42082014-07-24 22:13:12 +00005393 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Space);
drh7aee83b2017-01-27 01:52:42 +00005394 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
drhc2ce0be2014-05-29 12:36:14 +00005395 }else if( c2=='c' && strncmp(azArg[1],"csv",n2)==0 ){
drh8e64d1c2004-10-07 00:32:39 +00005396 p->mode = MODE_Csv;
mistachkinfad42082014-07-24 22:13:12 +00005397 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma);
mistachkine0d68852014-12-11 03:12:33 +00005398 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf);
drhc2ce0be2014-05-29 12:36:14 +00005399 }else if( c2=='t' && strncmp(azArg[1],"tabs",n2)==0 ){
drhfeac5f82004-08-01 00:10:45 +00005400 p->mode = MODE_List;
mistachkinfad42082014-07-24 22:13:12 +00005401 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Tab);
drhc2ce0be2014-05-29 12:36:14 +00005402 }else if( c2=='i' && strncmp(azArg[1],"insert",n2)==0 ){
drh28bd4bc2000-06-15 15:57:22 +00005403 p->mode = MODE_Insert;
drhc2ce0be2014-05-29 12:36:14 +00005404 set_table_name(p, nArg>=3 ? azArg[2] : "table");
drh41f5f6e2016-10-21 17:39:30 +00005405 }else if( c2=='q' && strncmp(azArg[1],"quote",n2)==0 ){
5406 p->mode = MODE_Quote;
mistachkin636bf9f2014-07-19 20:15:16 +00005407 }else if( c2=='a' && strncmp(azArg[1],"ascii",n2)==0 ){
5408 p->mode = MODE_Ascii;
mistachkinfad42082014-07-24 22:13:12 +00005409 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Unit);
5410 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Record);
drhdaffd0e2001-04-11 14:28:42 +00005411 }else {
mistachkinaae280e2015-12-31 19:06:24 +00005412 raw_printf(stderr, "Error: mode should be one of: "
drh36f49d02016-11-23 23:18:45 +00005413 "ascii column csv html insert line list quote tabs tcl\n");
shane9bd1b442009-10-23 01:27:39 +00005414 rc = 1;
drh75897232000-05-29 14:26:00 +00005415 }
drh700c2522016-02-09 18:39:25 +00005416 p->cMode = p->mode;
drh75897232000-05-29 14:26:00 +00005417 }else
5418
drhc2ce0be2014-05-29 12:36:14 +00005419 if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 ){
5420 if( nArg==2 ){
mistachkin44b99f72014-12-11 03:29:14 +00005421 sqlite3_snprintf(sizeof(p->nullValue), p->nullValue,
5422 "%.*s", (int)ArraySize(p->nullValue)-1, azArg[1]);
drhc2ce0be2014-05-29 12:36:14 +00005423 }else{
mistachkinaae280e2015-12-31 19:06:24 +00005424 raw_printf(stderr, "Usage: .nullvalue STRING\n");
shanehe2aa9d72009-11-06 17:20:17 +00005425 rc = 1;
5426 }
5427 }else
5428
drh05782482013-10-24 15:20:20 +00005429 if( c=='o' && strncmp(azArg[0], "open", n)==0 && n>=2 ){
drhcd0509e2016-09-16 00:26:08 +00005430 char *zNewFilename; /* Name of the database file to open */
5431 int iName = 1; /* Index in azArg[] of the filename */
drh760c8162016-09-16 02:52:22 +00005432 int newFlag = 0; /* True to delete file before opening */
drhcd0509e2016-09-16 00:26:08 +00005433 /* Close the existing database */
5434 session_close_all(p);
5435 sqlite3_close(p->db);
drh05782482013-10-24 15:20:20 +00005436 p->db = 0;
dan21472212017-03-01 11:30:27 +00005437 p->zDbFilename = 0;
drhcd0509e2016-09-16 00:26:08 +00005438 sqlite3_free(p->zFreeOnClose);
5439 p->zFreeOnClose = 0;
drh760c8162016-09-16 02:52:22 +00005440 /* Check for command-line arguments */
5441 for(iName=1; iName<nArg && azArg[iName][0]=='-'; iName++){
5442 const char *z = azArg[iName];
5443 if( optionMatch(z,"new") ){
5444 newFlag = 1;
5445 }else if( z[0]=='-' ){
5446 utf8_printf(stderr, "unknown option: %s\n", z);
5447 rc = 1;
mistachkin8145fc62016-09-16 20:39:21 +00005448 goto meta_command_exit;
drh760c8162016-09-16 02:52:22 +00005449 }
drhcd0509e2016-09-16 00:26:08 +00005450 }
5451 /* If a filename is specified, try to open it first */
5452 zNewFilename = nArg>iName ? sqlite3_mprintf("%s", azArg[iName]) : 0;
5453 if( zNewFilename ){
drh760c8162016-09-16 02:52:22 +00005454 if( newFlag ) shellDeleteFile(zNewFilename);
drhcd0509e2016-09-16 00:26:08 +00005455 p->zDbFilename = zNewFilename;
5456 open_db(p, 1);
5457 if( p->db==0 ){
5458 utf8_printf(stderr, "Error: cannot open '%s'\n", zNewFilename);
5459 sqlite3_free(zNewFilename);
5460 }else{
5461 p->zFreeOnClose = zNewFilename;
5462 }
5463 }
5464 if( p->db==0 ){
5465 /* As a fall-back open a TEMP database */
5466 p->zDbFilename = 0;
5467 open_db(p, 0);
drh05782482013-10-24 15:20:20 +00005468 }
5469 }else
5470
drhc2ce0be2014-05-29 12:36:14 +00005471 if( c=='o'
5472 && (strncmp(azArg[0], "output", n)==0 || strncmp(azArg[0], "once", n)==0)
5473 ){
5474 const char *zFile = nArg>=2 ? azArg[1] : "stdout";
5475 if( nArg>2 ){
mistachkinaae280e2015-12-31 19:06:24 +00005476 utf8_printf(stderr, "Usage: .%s FILE\n", azArg[0]);
drhc2ce0be2014-05-29 12:36:14 +00005477 rc = 1;
5478 goto meta_command_exit;
drh75897232000-05-29 14:26:00 +00005479 }
drhc2ce0be2014-05-29 12:36:14 +00005480 if( n>1 && strncmp(azArg[0], "once", n)==0 ){
5481 if( nArg<2 ){
mistachkinaae280e2015-12-31 19:06:24 +00005482 raw_printf(stderr, "Usage: .once FILE\n");
drhc2ce0be2014-05-29 12:36:14 +00005483 rc = 1;
5484 goto meta_command_exit;
5485 }
5486 p->outCount = 2;
5487 }else{
5488 p->outCount = 0;
5489 }
5490 output_reset(p);
5491 if( zFile[0]=='|' ){
drh8cd5b252015-03-02 22:06:43 +00005492#ifdef SQLITE_OMIT_POPEN
mistachkinaae280e2015-12-31 19:06:24 +00005493 raw_printf(stderr, "Error: pipes are not supported in this OS\n");
drh8cd5b252015-03-02 22:06:43 +00005494 rc = 1;
5495 p->out = stdout;
5496#else
drhc2ce0be2014-05-29 12:36:14 +00005497 p->out = popen(zFile + 1, "w");
drhe1da8fa2012-03-30 00:05:57 +00005498 if( p->out==0 ){
mistachkinaae280e2015-12-31 19:06:24 +00005499 utf8_printf(stderr,"Error: cannot open pipe \"%s\"\n", zFile + 1);
drhe1da8fa2012-03-30 00:05:57 +00005500 p->out = stdout;
5501 rc = 1;
5502 }else{
drhc2ce0be2014-05-29 12:36:14 +00005503 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
drhe1da8fa2012-03-30 00:05:57 +00005504 }
drh8cd5b252015-03-02 22:06:43 +00005505#endif
drh75897232000-05-29 14:26:00 +00005506 }else{
drhc2ce0be2014-05-29 12:36:14 +00005507 p->out = output_file_open(zFile);
drh75897232000-05-29 14:26:00 +00005508 if( p->out==0 ){
drhc2ce0be2014-05-29 12:36:14 +00005509 if( strcmp(zFile,"off")!=0 ){
mistachkinaae280e2015-12-31 19:06:24 +00005510 utf8_printf(stderr,"Error: cannot write to \"%s\"\n", zFile);
drh42f64e52012-04-04 16:56:23 +00005511 }
drh75897232000-05-29 14:26:00 +00005512 p->out = stdout;
shane9bd1b442009-10-23 01:27:39 +00005513 rc = 1;
persicom7e2dfdd2002-04-18 02:46:52 +00005514 } else {
drhc2ce0be2014-05-29 12:36:14 +00005515 sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
drh75897232000-05-29 14:26:00 +00005516 }
5517 }
5518 }else
5519
drh078b1fd2012-09-21 13:40:02 +00005520 if( c=='p' && n>=3 && strncmp(azArg[0], "print", n)==0 ){
5521 int i;
5522 for(i=1; i<nArg; i++){
mistachkinaae280e2015-12-31 19:06:24 +00005523 if( i>1 ) raw_printf(p->out, " ");
drhe05461c2015-12-30 13:36:57 +00005524 utf8_printf(p->out, "%s", azArg[i]);
drh078b1fd2012-09-21 13:40:02 +00005525 }
mistachkinaae280e2015-12-31 19:06:24 +00005526 raw_printf(p->out, "\n");
drh078b1fd2012-09-21 13:40:02 +00005527 }else
5528
drhc2ce0be2014-05-29 12:36:14 +00005529 if( c=='p' && strncmp(azArg[0], "prompt", n)==0 ){
persicom7e2dfdd2002-04-18 02:46:52 +00005530 if( nArg >= 2) {
5531 strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
5532 }
5533 if( nArg >= 3) {
5534 strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
5535 }
5536 }else
5537
drhc2ce0be2014-05-29 12:36:14 +00005538 if( c=='q' && strncmp(azArg[0], "quit", n)==0 ){
drh47ad6842006-11-08 12:25:42 +00005539 rc = 2;
persicom7e2dfdd2002-04-18 02:46:52 +00005540 }else
5541
drhc2ce0be2014-05-29 12:36:14 +00005542 if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 ){
5543 FILE *alt;
drh4e8142c2016-11-11 14:54:22 +00005544 if( nArg!=2 ){
5545 raw_printf(stderr, "Usage: .read FILE\n");
drhc2ce0be2014-05-29 12:36:14 +00005546 rc = 1;
5547 goto meta_command_exit;
5548 }
drh4e8142c2016-11-11 14:54:22 +00005549 alt = fopen(azArg[1], "rb");
5550 if( alt==0 ){
5551 utf8_printf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
5552 rc = 1;
drhdaffd0e2001-04-11 14:28:42 +00005553 }else{
drh4e8142c2016-11-11 14:54:22 +00005554 rc = process_input(p, alt);
5555 fclose(alt);
drhdaffd0e2001-04-11 14:28:42 +00005556 }
5557 }else
5558
drhc2ce0be2014-05-29 12:36:14 +00005559 if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 ){
drh9ff849f2009-02-04 20:55:57 +00005560 const char *zSrcFile;
5561 const char *zDb;
5562 sqlite3 *pSrc;
5563 sqlite3_backup *pBackup;
drhdc2c4912009-02-04 22:46:47 +00005564 int nTimeout = 0;
5565
drh9ff849f2009-02-04 20:55:57 +00005566 if( nArg==2 ){
5567 zSrcFile = azArg[1];
5568 zDb = "main";
drhc2ce0be2014-05-29 12:36:14 +00005569 }else if( nArg==3 ){
drh9ff849f2009-02-04 20:55:57 +00005570 zSrcFile = azArg[2];
5571 zDb = azArg[1];
drhc2ce0be2014-05-29 12:36:14 +00005572 }else{
mistachkinaae280e2015-12-31 19:06:24 +00005573 raw_printf(stderr, "Usage: .restore ?DB? FILE\n");
drhc2ce0be2014-05-29 12:36:14 +00005574 rc = 1;
5575 goto meta_command_exit;
drh9ff849f2009-02-04 20:55:57 +00005576 }
5577 rc = sqlite3_open(zSrcFile, &pSrc);
5578 if( rc!=SQLITE_OK ){
mistachkinaae280e2015-12-31 19:06:24 +00005579 utf8_printf(stderr, "Error: cannot open \"%s\"\n", zSrcFile);
drh9ff849f2009-02-04 20:55:57 +00005580 sqlite3_close(pSrc);
5581 return 1;
5582 }
drh05782482013-10-24 15:20:20 +00005583 open_db(p, 0);
drh9ff849f2009-02-04 20:55:57 +00005584 pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
5585 if( pBackup==0 ){
mistachkinaae280e2015-12-31 19:06:24 +00005586 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
drh9ff849f2009-02-04 20:55:57 +00005587 sqlite3_close(pSrc);
5588 return 1;
5589 }
drhdc2c4912009-02-04 22:46:47 +00005590 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
5591 || rc==SQLITE_BUSY ){
5592 if( rc==SQLITE_BUSY ){
5593 if( nTimeout++ >= 3 ) break;
5594 sqlite3_sleep(100);
drh9ff849f2009-02-04 20:55:57 +00005595 }
5596 }
5597 sqlite3_backup_finish(pBackup);
5598 if( rc==SQLITE_DONE ){
shane9bd1b442009-10-23 01:27:39 +00005599 rc = 0;
drhdc2c4912009-02-04 22:46:47 +00005600 }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){
mistachkinaae280e2015-12-31 19:06:24 +00005601 raw_printf(stderr, "Error: source database is busy\n");
shane9bd1b442009-10-23 01:27:39 +00005602 rc = 1;
drh9ff849f2009-02-04 20:55:57 +00005603 }else{
mistachkinaae280e2015-12-31 19:06:24 +00005604 utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
shane9bd1b442009-10-23 01:27:39 +00005605 rc = 1;
drh9ff849f2009-02-04 20:55:57 +00005606 }
5607 sqlite3_close(pSrc);
5608 }else
5609
dan8d1edb92014-11-05 09:07:28 +00005610
5611 if( c=='s' && strncmp(azArg[0], "scanstats", n)==0 ){
5612 if( nArg==2 ){
5613 p->scanstatsOn = booleanValue(azArg[1]);
drh15f23c22014-11-06 12:46:16 +00005614#ifndef SQLITE_ENABLE_STMT_SCANSTATUS
mistachkinaae280e2015-12-31 19:06:24 +00005615 raw_printf(stderr, "Warning: .scanstats not available in this build.\n");
drh15f23c22014-11-06 12:46:16 +00005616#endif
dan8d1edb92014-11-05 09:07:28 +00005617 }else{
mistachkinaae280e2015-12-31 19:06:24 +00005618 raw_printf(stderr, "Usage: .scanstats on|off\n");
dan8d1edb92014-11-05 09:07:28 +00005619 rc = 1;
5620 }
5621 }else
5622
drhc2ce0be2014-05-29 12:36:14 +00005623 if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){
drhdcd87a92014-08-18 13:45:42 +00005624 ShellState data;
drh75897232000-05-29 14:26:00 +00005625 char *zErrMsg = 0;
drh05782482013-10-24 15:20:20 +00005626 open_db(p, 0);
drh75897232000-05-29 14:26:00 +00005627 memcpy(&data, p, sizeof(data));
5628 data.showHeader = 0;
drh700c2522016-02-09 18:39:25 +00005629 data.cMode = data.mode = MODE_Semi;
drh4926fec2016-04-13 15:33:42 +00005630 if( nArg>=2 && optionMatch(azArg[1], "indent") ){
5631 data.cMode = data.mode = MODE_Pretty;
5632 nArg--;
5633 if( nArg==2 ) azArg[1] = azArg[2];
5634 }
5635 if( nArg==2 && azArg[1][0]!='-' ){
drhc8d74412004-08-31 23:41:26 +00005636 int i;
drhf0693c82011-10-11 20:41:54 +00005637 for(i=0; azArg[1][i]; i++) azArg[1][i] = ToLower(azArg[1][i]);
drhc8d74412004-08-31 23:41:26 +00005638 if( strcmp(azArg[1],"sqlite_master")==0 ){
drha18c5682000-10-08 22:20:57 +00005639 char *new_argv[2], *new_colv[2];
5640 new_argv[0] = "CREATE TABLE sqlite_master (\n"
5641 " type text,\n"
5642 " name text,\n"
5643 " tbl_name text,\n"
drhadbca9c2001-09-27 15:11:53 +00005644 " rootpage integer,\n"
drha18c5682000-10-08 22:20:57 +00005645 " sql text\n"
5646 ")";
5647 new_argv[1] = 0;
5648 new_colv[0] = "sql";
5649 new_colv[1] = 0;
5650 callback(&data, 1, new_argv, new_colv);
shane9bd1b442009-10-23 01:27:39 +00005651 rc = SQLITE_OK;
drhc8d74412004-08-31 23:41:26 +00005652 }else if( strcmp(azArg[1],"sqlite_temp_master")==0 ){
drhe0bc4042002-06-25 01:09:11 +00005653 char *new_argv[2], *new_colv[2];
5654 new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n"
5655 " type text,\n"
5656 " name text,\n"
5657 " tbl_name text,\n"
5658 " rootpage integer,\n"
5659 " sql text\n"
5660 ")";
5661 new_argv[1] = 0;
5662 new_colv[0] = "sql";
5663 new_colv[1] = 0;
5664 callback(&data, 1, new_argv, new_colv);
shane9bd1b442009-10-23 01:27:39 +00005665 rc = SQLITE_OK;
drha18c5682000-10-08 22:20:57 +00005666 }else{
drhe611f142017-03-08 11:44:00 +00005667 char *zSql;
5668 zSql = sqlite3_mprintf(
drhe0bc4042002-06-25 01:09:11 +00005669 "SELECT sql FROM "
drhac43e982012-05-21 03:15:06 +00005670 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
drh8f800a72009-01-14 23:17:55 +00005671 " FROM sqlite_master UNION ALL"
drhac43e982012-05-21 03:15:06 +00005672 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
drhe611f142017-03-08 11:44:00 +00005673 "WHERE lower(tbl_name) LIKE %Q"
drh6ac7a582011-11-04 00:35:56 +00005674 " AND type!='meta' AND sql NOTNULL "
drhe611f142017-03-08 11:44:00 +00005675 "ORDER BY rowid", azArg[1]);
5676 rc = sqlite3_exec(p->db, zSql, callback, &data, &zErrMsg);
5677 sqlite3_free(zSql);
drha18c5682000-10-08 22:20:57 +00005678 }
drhc2ce0be2014-05-29 12:36:14 +00005679 }else if( nArg==1 ){
shane9bd1b442009-10-23 01:27:39 +00005680 rc = sqlite3_exec(p->db,
drhe0bc4042002-06-25 01:09:11 +00005681 "SELECT sql FROM "
drhac43e982012-05-21 03:15:06 +00005682 " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
drh8f800a72009-01-14 23:17:55 +00005683 " FROM sqlite_master UNION ALL"
drhac43e982012-05-21 03:15:06 +00005684 " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
drh4b2590e2014-08-19 19:28:00 +00005685 "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
drh1ba00292013-05-06 21:01:06 +00005686 "ORDER BY rowid",
drha18c5682000-10-08 22:20:57 +00005687 callback, &data, &zErrMsg
5688 );
drhc2ce0be2014-05-29 12:36:14 +00005689 }else{
drh4926fec2016-04-13 15:33:42 +00005690 raw_printf(stderr, "Usage: .schema ?--indent? ?LIKE-PATTERN?\n");
drhc2ce0be2014-05-29 12:36:14 +00005691 rc = 1;
5692 goto meta_command_exit;
drh75897232000-05-29 14:26:00 +00005693 }
drh75897232000-05-29 14:26:00 +00005694 if( zErrMsg ){
mistachkinaae280e2015-12-31 19:06:24 +00005695 utf8_printf(stderr,"Error: %s\n", zErrMsg);
drh3f4fedb2004-05-31 19:34:33 +00005696 sqlite3_free(zErrMsg);
shane9bd1b442009-10-23 01:27:39 +00005697 rc = 1;
5698 }else if( rc != SQLITE_OK ){
mistachkinaae280e2015-12-31 19:06:24 +00005699 raw_printf(stderr,"Error: querying schema information\n");
shane9bd1b442009-10-23 01:27:39 +00005700 rc = 1;
5701 }else{
5702 rc = 0;
drh75897232000-05-29 14:26:00 +00005703 }
5704 }else
5705
drhabd4c722014-09-20 18:18:33 +00005706#if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
5707 if( c=='s' && n==11 && strncmp(azArg[0], "selecttrace", n)==0 ){
drh2b44fd92017-02-17 01:43:51 +00005708 sqlite3SelectTrace = (int)integerValue(azArg[1]);
drhabd4c722014-09-20 18:18:33 +00005709 }else
5710#endif
5711
drhe6229612014-08-18 15:08:26 +00005712#if defined(SQLITE_ENABLE_SESSION)
5713 if( c=='s' && strncmp(azArg[0],"session",n)==0 && n>=3 ){
5714 OpenSession *pSession = &p->aSession[0];
5715 char **azCmd = &azArg[1];
5716 int iSes = 0;
5717 int nCmd = nArg - 1;
5718 int i;
5719 if( nArg<=1 ) goto session_syntax_error;
drh3a67b042014-08-18 17:56:31 +00005720 open_db(p, 0);
drhe6229612014-08-18 15:08:26 +00005721 if( nArg>=3 ){
5722 for(iSes=0; iSes<p->nSession; iSes++){
5723 if( strcmp(p->aSession[iSes].zName, azArg[1])==0 ) break;
5724 }
5725 if( iSes<p->nSession ){
5726 pSession = &p->aSession[iSes];
5727 azCmd++;
5728 nCmd--;
5729 }else{
5730 pSession = &p->aSession[0];
5731 iSes = 0;
5732 }
5733 }
5734
drh3a67b042014-08-18 17:56:31 +00005735 /* .session attach TABLE
5736 ** Invoke the sqlite3session_attach() interface to attach a particular
5737 ** table so that it is never filtered.
5738 */
5739 if( strcmp(azCmd[0],"attach")==0 ){
5740 if( nCmd!=2 ) goto session_syntax_error;
5741 if( pSession->p==0 ){
5742 session_not_open:
mistachkin899c5c92016-04-03 20:50:02 +00005743 raw_printf(stderr, "ERROR: No sessions are open\n");
drh3a67b042014-08-18 17:56:31 +00005744 }else{
5745 rc = sqlite3session_attach(pSession->p, azCmd[1]);
5746 if( rc ){
mistachkin899c5c92016-04-03 20:50:02 +00005747 raw_printf(stderr, "ERROR: sqlite3session_attach() returns %d\n", rc);
drh3a67b042014-08-18 17:56:31 +00005748 rc = 0;
5749 }
5750 }
5751 }else
5752
5753 /* .session changeset FILE
5754 ** .session patchset FILE
5755 ** Write a changeset or patchset into a file. The file is overwritten.
5756 */
5757 if( strcmp(azCmd[0],"changeset")==0 || strcmp(azCmd[0],"patchset")==0 ){
5758 FILE *out = 0;
5759 if( nCmd!=2 ) goto session_syntax_error;
5760 if( pSession->p==0 ) goto session_not_open;
5761 out = fopen(azCmd[1], "wb");
5762 if( out==0 ){
mistachkin899c5c92016-04-03 20:50:02 +00005763 utf8_printf(stderr, "ERROR: cannot open \"%s\" for writing\n", azCmd[1]);
drh3a67b042014-08-18 17:56:31 +00005764 }else{
5765 int szChng;
5766 void *pChng;
5767 if( azCmd[0][0]=='c' ){
drh2967e0c2014-08-19 00:26:17 +00005768 rc = sqlite3session_changeset(pSession->p, &szChng, &pChng);
drh3a67b042014-08-18 17:56:31 +00005769 }else{
drh2967e0c2014-08-19 00:26:17 +00005770 rc = sqlite3session_patchset(pSession->p, &szChng, &pChng);
5771 }
5772 if( rc ){
5773 printf("Error: error code %d\n", rc);
5774 rc = 0;
drh3a67b042014-08-18 17:56:31 +00005775 }
mistachkin1fe36bb2016-04-04 02:16:44 +00005776 if( pChng
drh3a67b042014-08-18 17:56:31 +00005777 && fwrite(pChng, szChng, 1, out)!=1 ){
mistachkin899c5c92016-04-03 20:50:02 +00005778 raw_printf(stderr, "ERROR: Failed to write entire %d-byte output\n",
drh3a67b042014-08-18 17:56:31 +00005779 szChng);
5780 }
5781 sqlite3_free(pChng);
5782 fclose(out);
5783 }
5784 }else
5785
drhe6229612014-08-18 15:08:26 +00005786 /* .session close
5787 ** Close the identified session
5788 */
5789 if( strcmp(azCmd[0], "close")==0 ){
drh03168ca2014-08-18 20:01:31 +00005790 if( nCmd!=1 ) goto session_syntax_error;
drhe6229612014-08-18 15:08:26 +00005791 if( p->nSession ){
5792 session_close(pSession);
5793 p->aSession[iSes] = p->aSession[--p->nSession];
5794 }
5795 }else
5796
drh03168ca2014-08-18 20:01:31 +00005797 /* .session enable ?BOOLEAN?
5798 ** Query or set the enable flag
5799 */
5800 if( strcmp(azCmd[0], "enable")==0 ){
5801 int ii;
5802 if( nCmd>2 ) goto session_syntax_error;
5803 ii = nCmd==1 ? -1 : booleanValue(azCmd[1]);
5804 if( p->nSession ){
5805 ii = sqlite3session_enable(pSession->p, ii);
mistachkin899c5c92016-04-03 20:50:02 +00005806 utf8_printf(p->out, "session %s enable flag = %d\n",
5807 pSession->zName, ii);
drh03168ca2014-08-18 20:01:31 +00005808 }
5809 }else
5810
5811 /* .session filter GLOB ....
5812 ** Set a list of GLOB patterns of table names to be excluded.
5813 */
5814 if( strcmp(azCmd[0], "filter")==0 ){
5815 int ii, nByte;
5816 if( nCmd<2 ) goto session_syntax_error;
5817 if( p->nSession ){
5818 for(ii=0; ii<pSession->nFilter; ii++){
5819 sqlite3_free(pSession->azFilter[ii]);
5820 }
5821 sqlite3_free(pSession->azFilter);
5822 nByte = sizeof(pSession->azFilter[0])*(nCmd-1);
5823 pSession->azFilter = sqlite3_malloc( nByte );
5824 if( pSession->azFilter==0 ){
mistachkin899c5c92016-04-03 20:50:02 +00005825 raw_printf(stderr, "Error: out or memory\n");
drh03168ca2014-08-18 20:01:31 +00005826 exit(1);
5827 }
5828 for(ii=1; ii<nCmd; ii++){
mistachkin1fe36bb2016-04-04 02:16:44 +00005829 pSession->azFilter[ii-1] = sqlite3_mprintf("%s", azCmd[ii]);
drh03168ca2014-08-18 20:01:31 +00005830 }
5831 pSession->nFilter = ii-1;
5832 }
5833 }else
5834
5835 /* .session indirect ?BOOLEAN?
5836 ** Query or set the indirect flag
5837 */
5838 if( strcmp(azCmd[0], "indirect")==0 ){
5839 int ii;
5840 if( nCmd>2 ) goto session_syntax_error;
5841 ii = nCmd==1 ? -1 : booleanValue(azCmd[1]);
5842 if( p->nSession ){
5843 ii = sqlite3session_indirect(pSession->p, ii);
mistachkin899c5c92016-04-03 20:50:02 +00005844 utf8_printf(p->out, "session %s indirect flag = %d\n",
5845 pSession->zName, ii);
drh03168ca2014-08-18 20:01:31 +00005846 }
5847 }else
5848
5849 /* .session isempty
5850 ** Determine if the session is empty
5851 */
5852 if( strcmp(azCmd[0], "isempty")==0 ){
5853 int ii;
5854 if( nCmd!=1 ) goto session_syntax_error;
5855 if( p->nSession ){
5856 ii = sqlite3session_isempty(pSession->p);
mistachkin899c5c92016-04-03 20:50:02 +00005857 utf8_printf(p->out, "session %s isempty flag = %d\n",
5858 pSession->zName, ii);
drh03168ca2014-08-18 20:01:31 +00005859 }
5860 }else
5861
drhe6229612014-08-18 15:08:26 +00005862 /* .session list
5863 ** List all currently open sessions
5864 */
5865 if( strcmp(azCmd[0],"list")==0 ){
5866 for(i=0; i<p->nSession; i++){
mistachkin899c5c92016-04-03 20:50:02 +00005867 utf8_printf(p->out, "%d %s\n", i, p->aSession[i].zName);
drhe6229612014-08-18 15:08:26 +00005868 }
5869 }else
5870
5871 /* .session open DB NAME
5872 ** Open a new session called NAME on the attached database DB.
5873 ** DB is normally "main".
5874 */
5875 if( strcmp(azCmd[0],"open")==0 ){
5876 char *zName;
5877 if( nCmd!=3 ) goto session_syntax_error;
5878 zName = azCmd[2];
5879 if( zName[0]==0 ) goto session_syntax_error;
5880 for(i=0; i<p->nSession; i++){
5881 if( strcmp(p->aSession[i].zName,zName)==0 ){
mistachkin899c5c92016-04-03 20:50:02 +00005882 utf8_printf(stderr, "Session \"%s\" already exists\n", zName);
drhe6229612014-08-18 15:08:26 +00005883 goto meta_command_exit;
5884 }
5885 }
5886 if( p->nSession>=ArraySize(p->aSession) ){
mistachkin899c5c92016-04-03 20:50:02 +00005887 raw_printf(stderr, "Maximum of %d sessions\n", ArraySize(p->aSession));
drhe6229612014-08-18 15:08:26 +00005888 goto meta_command_exit;
5889 }
5890 pSession = &p->aSession[p->nSession];
5891 rc = sqlite3session_create(p->db, azCmd[1], &pSession->p);
5892 if( rc ){
mistachkin899c5c92016-04-03 20:50:02 +00005893 raw_printf(stderr, "Cannot open session: error code=%d\n", rc);
drh3a67b042014-08-18 17:56:31 +00005894 rc = 0;
drhe6229612014-08-18 15:08:26 +00005895 goto meta_command_exit;
5896 }
drh03168ca2014-08-18 20:01:31 +00005897 pSession->nFilter = 0;
5898 sqlite3session_table_filter(pSession->p, session_filter, pSession);
drhe6229612014-08-18 15:08:26 +00005899 p->nSession++;
5900 pSession->zName = sqlite3_mprintf("%s", zName);
5901 }else
5902 /* If no command name matches, show a syntax error */
5903 session_syntax_error:
5904 session_help(p);
5905 }else
5906#endif
5907
drh340f5822013-06-27 13:01:21 +00005908#ifdef SQLITE_DEBUG
drh348d19c2013-06-03 12:47:43 +00005909 /* Undocumented commands for internal testing. Subject to change
5910 ** without notice. */
5911 if( c=='s' && n>=10 && strncmp(azArg[0], "selftest-", 9)==0 ){
5912 if( strncmp(azArg[0]+9, "boolean", n-9)==0 ){
5913 int i, v;
5914 for(i=1; i<nArg; i++){
5915 v = booleanValue(azArg[i]);
drhe05461c2015-12-30 13:36:57 +00005916 utf8_printf(p->out, "%s: %d 0x%x\n", azArg[i], v, v);
drh348d19c2013-06-03 12:47:43 +00005917 }
5918 }
5919 if( strncmp(azArg[0]+9, "integer", n-9)==0 ){
5920 int i; sqlite3_int64 v;
5921 for(i=1; i<nArg; i++){
drh340f5822013-06-27 13:01:21 +00005922 char zBuf[200];
drh348d19c2013-06-03 12:47:43 +00005923 v = integerValue(azArg[i]);
drhc2ce0be2014-05-29 12:36:14 +00005924 sqlite3_snprintf(sizeof(zBuf),zBuf,"%s: %lld 0x%llx\n", azArg[i],v,v);
drhe05461c2015-12-30 13:36:57 +00005925 utf8_printf(p->out, "%s", zBuf);
drh348d19c2013-06-03 12:47:43 +00005926 }
5927 }
5928 }else
drh340f5822013-06-27 13:01:21 +00005929#endif
drh348d19c2013-06-03 12:47:43 +00005930
drhfb546af2017-03-09 22:00:33 +00005931 if( c=='s' && n>=4 && strncmp(azArg[0],"selftest",n)==0 ){
5932 int bIsInit = 0; /* True to initialize the SELFTEST table */
5933 int bVerbose = 0; /* Verbose output */
5934 int bSelftestExists; /* True if SELFTEST already exists */
5935 char **azTest = 0; /* Content of the SELFTEST table */
5936 int nRow = 0; /* Number of rows in the SELFTEST table */
5937 int nCol = 4; /* Number of columns in the SELFTEST table */
5938 int i; /* Loop counter */
5939 int nTest = 0; /* Number of tests runs */
5940 int nErr = 0; /* Number of errors seen */
5941 ShellText str; /* Answer for a query */
5942 static char *azDefaultTest[] = {
5943 0, 0, 0, 0,
5944 "0", "memo", "Missing SELFTEST table - default checks only", "",
5945 "1", "run", "PRAGMA integrity_check", "ok"
5946 };
5947 static const int nDefaultRow = 2;
5948
5949 open_db(p,0);
5950 for(i=1; i<nArg; i++){
5951 const char *z = azArg[i];
5952 if( z[0]=='-' && z[1]=='-' ) z++;
5953 if( strcmp(z,"-init")==0 ){
5954 bIsInit = 1;
5955 }else
5956 if( strcmp(z,"-v")==0 ){
5957 bVerbose++;
5958 }else
5959 {
5960 utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
5961 azArg[i], azArg[0]);
5962 raw_printf(stderr, "Should be one of: --init -v\n");
5963 rc = 1;
5964 goto meta_command_exit;
5965 }
5966 }
5967 if( sqlite3_table_column_metadata(p->db,"main","selftest",0,0,0,0,0,0)
5968 != SQLITE_OK ){
5969 bSelftestExists = 0;
5970 }else{
5971 bSelftestExists = 1;
5972 }
5973 if( bIsInit ){
drhfb546af2017-03-09 22:00:33 +00005974 createSelftestTable(p);
5975 bSelftestExists = 1;
5976 }
5977 if( bSelftestExists ){
5978 rc = sqlite3_get_table(p->db,
5979 "SELECT tno,op,cmd,ans FROM selftest ORDER BY tno",
5980 &azTest, &nRow, &nCol, 0);
5981 if( rc ){
5982 raw_printf(stderr, "Error querying the selftest table\n");
5983 rc = 1;
5984 sqlite3_free_table(azTest);
5985 goto meta_command_exit;
5986 }else if( nRow==0 ){
5987 sqlite3_free_table(azTest);
5988 azTest = azDefaultTest;
5989 nRow = nDefaultRow;
5990 }
5991 }else{
5992 azTest = azDefaultTest;
5993 nRow = nDefaultRow;
5994 }
5995 initText(&str);
5996 appendText(&str, "x", 0);
5997 for(i=1; i<=nRow; i++){
5998 int tno = atoi(azTest[i*nCol]);
5999 const char *zOp = azTest[i*nCol+1];
6000 const char *zSql = azTest[i*nCol+2];
6001 const char *zAns = azTest[i*nCol+3];
6002
6003 if( bVerbose>0 ){
6004 char *zQuote = sqlite3_mprintf("%q", zSql);
6005 printf("%d: %s %s\n", tno, zOp, zSql);
6006 sqlite3_free(zQuote);
6007 }
6008 if( strcmp(zOp,"memo")==0 ){
6009 utf8_printf(p->out, "%s\n", zSql);
6010 }else
6011 if( strcmp(zOp,"run")==0 ){
6012 char *zErrMsg = 0;
6013 str.n = 0;
6014 str.z[0] = 0;
6015 rc = sqlite3_exec(p->db, zSql, captureOutputCallback, &str, &zErrMsg);
6016 nTest++;
6017 if( bVerbose ){
6018 utf8_printf(p->out, "Result: %s\n", str.z);
6019 }
6020 if( rc || zErrMsg ){
6021 nErr++;
6022 rc = 1;
6023 utf8_printf(p->out, "%d: error-code-%d: %s\n", tno, rc, zErrMsg);
6024 sqlite3_free(zErrMsg);
6025 }else if( strcmp(zAns,str.z)!=0 ){
6026 nErr++;
6027 rc = 1;
6028 utf8_printf(p->out, "%d: Expected: [%s]\n", tno, zAns);
6029 utf8_printf(p->out, "%d: Got: [%s]\n", tno, str.z);
6030 }
6031 }else
6032 {
6033 utf8_printf(stderr,
6034 "Unknown operation \"%s\" on selftest line %d\n", zOp, tno);
6035 rc = 1;
6036 break;
6037 }
6038 }
6039 freeText(&str);
6040 if( azTest!=azDefaultTest ) sqlite3_free_table(azTest);
6041 utf8_printf(p->out, "%d errors out of %d tests\n", nErr, nTest);
6042 }else
6043
drhc2ce0be2014-05-29 12:36:14 +00006044 if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){
drh6976c212014-07-24 12:09:47 +00006045 if( nArg<2 || nArg>3 ){
mistachkinaae280e2015-12-31 19:06:24 +00006046 raw_printf(stderr, "Usage: .separator COL ?ROW?\n");
drhc2ce0be2014-05-29 12:36:14 +00006047 rc = 1;
6048 }
drh6976c212014-07-24 12:09:47 +00006049 if( nArg>=2 ){
mistachkin636bf9f2014-07-19 20:15:16 +00006050 sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator,
mistachkin22c96382014-07-24 22:51:18 +00006051 "%.*s", (int)ArraySize(p->colSeparator)-1, azArg[1]);
drh6976c212014-07-24 12:09:47 +00006052 }
6053 if( nArg>=3 ){
mistachkine0d68852014-12-11 03:12:33 +00006054 sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator,
6055 "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]);
drh6976c212014-07-24 12:09:47 +00006056 }
drh75897232000-05-29 14:26:00 +00006057 }else
6058
drh1554bc82017-03-08 16:10:34 +00006059 if( c=='s' && n>=4 && strncmp(azArg[0],"sha3sum",n)==0 ){
6060 const char *zLike = 0; /* Which table to checksum. 0 means everything */
6061 int i; /* Loop counter */
6062 int bSchema = 0; /* Also hash the schema */
drh3ee83ef2017-03-08 17:56:54 +00006063 int bSeparate = 0; /* Hash each table separately */
drh1554bc82017-03-08 16:10:34 +00006064 int iSize = 224; /* Hash algorithm to use */
6065 int bDebug = 0; /* Only show the query that would have run */
6066 sqlite3_stmt *pStmt; /* For querying tables names */
6067 char *zSql; /* SQL to be run */
drh3ee83ef2017-03-08 17:56:54 +00006068 char *zSep; /* Separator */
6069 ShellText sSql; /* Complete SQL for the query to run the hash */
drh1554bc82017-03-08 16:10:34 +00006070 ShellText sQuery; /* Set of queries used to read all content */
drhf80d4ff2017-03-08 18:06:20 +00006071 open_db(p, 0);
drh1554bc82017-03-08 16:10:34 +00006072 for(i=1; i<nArg; i++){
6073 const char *z = azArg[i];
6074 if( z[0]=='-' ){
6075 z++;
6076 if( z[0]=='-' ) z++;
6077 if( strcmp(z,"schema")==0 ){
6078 bSchema = 1;
6079 }else
6080 if( strcmp(z,"sha3-224")==0 || strcmp(z,"sha3-256")==0
6081 || strcmp(z,"sha3-384")==0 || strcmp(z,"sha3-512")==0
6082 ){
6083 iSize = atoi(&z[5]);
6084 }else
6085 if( strcmp(z,"debug")==0 ){
6086 bDebug = 1;
6087 }else
6088 {
6089 utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
drh3ee83ef2017-03-08 17:56:54 +00006090 azArg[i], azArg[0]);
drh1554bc82017-03-08 16:10:34 +00006091 raw_printf(stderr, "Should be one of: --schema"
6092 " --sha3-224 --sha3-255 --sha3-384 --sha3-512\n");
6093 rc = 1;
6094 goto meta_command_exit;
6095 }
6096 }else if( zLike ){
6097 raw_printf(stderr, "Usage: .sha3sum ?OPTIONS? ?LIKE-PATTERN?\n");
6098 rc = 1;
6099 goto meta_command_exit;
6100 }else{
6101 zLike = z;
drh3ee83ef2017-03-08 17:56:54 +00006102 bSeparate = 1;
6103 if( sqlite3_strlike("sqlite_%", zLike, 0)==0 ) bSchema = 1;
drh1554bc82017-03-08 16:10:34 +00006104 }
6105 }
6106 if( bSchema ){
6107 zSql = "SELECT lower(name) FROM sqlite_master"
6108 " WHERE type='table' AND coalesce(rootpage,0)>1"
6109 " UNION ALL SELECT 'sqlite_master'"
6110 " ORDER BY 1 collate nocase";
6111 }else{
6112 zSql = "SELECT lower(name) FROM sqlite_master"
6113 " WHERE type='table' AND coalesce(rootpage,0)>1"
6114 " AND name NOT LIKE 'sqlite_%'"
6115 " ORDER BY 1 collate nocase";
6116 }
6117 sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
6118 initText(&sQuery);
drh3ee83ef2017-03-08 17:56:54 +00006119 initText(&sSql);
6120 appendText(&sSql, "WITH [sha3sum$query](a,b) AS(",0);
6121 zSep = "VALUES(";
drh1554bc82017-03-08 16:10:34 +00006122 while( SQLITE_ROW==sqlite3_step(pStmt) ){
6123 const char *zTab = (const char*)sqlite3_column_text(pStmt,0);
6124 if( zLike && sqlite3_strlike(zLike, zTab, 0)!=0 ) continue;
6125 if( strncmp(zTab, "sqlite_",7)!=0 ){
6126 appendText(&sQuery,"SELECT * FROM ", 0);
6127 appendText(&sQuery,zTab,'"');
6128 appendText(&sQuery," NOT INDEXED;", 0);
6129 }else if( strcmp(zTab, "sqlite_master")==0 ){
6130 appendText(&sQuery,"SELECT type,name,tbl_name,sql FROM sqlite_master"
6131 " ORDER BY name;", 0);
6132 }else if( strcmp(zTab, "sqlite_sequence")==0 ){
6133 appendText(&sQuery,"SELECT name,seq FROM sqlite_sequence"
6134 " ORDER BY name;", 0);
6135 }else if( strcmp(zTab, "sqlite_stat1")==0 ){
6136 appendText(&sQuery,"SELECT tbl,idx,stat FROM sqlite_stat1"
6137 " ORDER BY tbl,idx;", 0);
6138 }else if( strcmp(zTab, "sqlite_stat3")==0
6139 || strcmp(zTab, "sqlite_stat4")==0 ){
6140 appendText(&sQuery, "SELECT * FROM ", 0);
6141 appendText(&sQuery, zTab, 0);
6142 appendText(&sQuery, " ORDER BY tbl, idx, rowid;\n", 0);
6143 }
drh3ee83ef2017-03-08 17:56:54 +00006144 appendText(&sSql, zSep, 0);
6145 appendText(&sSql, sQuery.z, '\'');
6146 sQuery.n = 0;
6147 appendText(&sSql, ",", 0);
6148 appendText(&sSql, zTab, '\'');
6149 zSep = "),(";
drh1554bc82017-03-08 16:10:34 +00006150 }
6151 sqlite3_finalize(pStmt);
drh3ee83ef2017-03-08 17:56:54 +00006152 if( bSeparate ){
6153 zSql = sqlite3_mprintf(
6154 "%s))"
6155 " SELECT lower(hex(sha3_query(a,%d))) AS hash, b AS label"
6156 " FROM [sha3sum$query]",
6157 sSql.z, iSize);
6158 }else{
6159 zSql = sqlite3_mprintf(
6160 "%s))"
6161 " SELECT lower(hex(sha3_query(group_concat(a,''),%d))) AS hash"
6162 " FROM [sha3sum$query]",
6163 sSql.z, iSize);
6164 }
drh1554bc82017-03-08 16:10:34 +00006165 freeText(&sQuery);
drh3ee83ef2017-03-08 17:56:54 +00006166 freeText(&sSql);
drh1554bc82017-03-08 16:10:34 +00006167 if( bDebug ){
6168 utf8_printf(p->out, "%s\n", zSql);
6169 }else{
6170 shell_exec(p->db, zSql, shell_callback, p, 0);
6171 }
6172 sqlite3_free(zSql);
6173 }else
6174
drh62cdde52014-05-28 20:22:28 +00006175 if( c=='s'
6176 && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0)
drh62cdde52014-05-28 20:22:28 +00006177 ){
6178 char *zCmd;
drh54027102014-08-06 14:36:53 +00006179 int i, x;
drhc2ce0be2014-05-29 12:36:14 +00006180 if( nArg<2 ){
mistachkinaae280e2015-12-31 19:06:24 +00006181 raw_printf(stderr, "Usage: .system COMMAND\n");
drhc2ce0be2014-05-29 12:36:14 +00006182 rc = 1;
6183 goto meta_command_exit;
6184 }
drhdcb3e3d2014-05-29 03:17:29 +00006185 zCmd = sqlite3_mprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]);
drh62cdde52014-05-28 20:22:28 +00006186 for(i=2; i<nArg; i++){
drhdcb3e3d2014-05-29 03:17:29 +00006187 zCmd = sqlite3_mprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"",
6188 zCmd, azArg[i]);
drh62cdde52014-05-28 20:22:28 +00006189 }
drh54027102014-08-06 14:36:53 +00006190 x = system(zCmd);
drh62cdde52014-05-28 20:22:28 +00006191 sqlite3_free(zCmd);
mistachkinaae280e2015-12-31 19:06:24 +00006192 if( x ) raw_printf(stderr, "System command returns %d\n", x);
drh62cdde52014-05-28 20:22:28 +00006193 }else
6194
drhc2ce0be2014-05-29 12:36:14 +00006195 if( c=='s' && strncmp(azArg[0], "show", n)==0 ){
drheacd29d2016-04-15 15:03:27 +00006196 static const char *azBool[] = { "off", "on", "full", "unk" };
persicom7e2dfdd2002-04-18 02:46:52 +00006197 int i;
drhc2ce0be2014-05-29 12:36:14 +00006198 if( nArg!=1 ){
mistachkinaae280e2015-12-31 19:06:24 +00006199 raw_printf(stderr, "Usage: .show\n");
drhc2ce0be2014-05-29 12:36:14 +00006200 rc = 1;
6201 goto meta_command_exit;
6202 }
drhe6e1d122017-03-09 13:50:49 +00006203 utf8_printf(p->out, "%12.12s: %s\n","echo",
6204 azBool[ShellHasFlag(p, SHFLG_Echo)]);
drheacd29d2016-04-15 15:03:27 +00006205 utf8_printf(p->out, "%12.12s: %s\n","eqp", azBool[p->autoEQP&3]);
drh700c2522016-02-09 18:39:25 +00006206 utf8_printf(p->out, "%12.12s: %s\n","explain",
6207 p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off");
drheacd29d2016-04-15 15:03:27 +00006208 utf8_printf(p->out,"%12.12s: %s\n","headers", azBool[p->showHeader!=0]);
mistachkinaae280e2015-12-31 19:06:24 +00006209 utf8_printf(p->out, "%12.12s: %s\n","mode", modeDescr[p->mode]);
6210 utf8_printf(p->out, "%12.12s: ", "nullvalue");
mistachkin44b99f72014-12-11 03:29:14 +00006211 output_c_string(p->out, p->nullValue);
mistachkinaae280e2015-12-31 19:06:24 +00006212 raw_printf(p->out, "\n");
6213 utf8_printf(p->out,"%12.12s: %s\n","output",
drh4f21c4a2008-12-10 22:15:00 +00006214 strlen30(p->outfile) ? p->outfile : "stdout");
mistachkinaae280e2015-12-31 19:06:24 +00006215 utf8_printf(p->out,"%12.12s: ", "colseparator");
mistachkin636bf9f2014-07-19 20:15:16 +00006216 output_c_string(p->out, p->colSeparator);
mistachkinaae280e2015-12-31 19:06:24 +00006217 raw_printf(p->out, "\n");
6218 utf8_printf(p->out,"%12.12s: ", "rowseparator");
mistachkin636bf9f2014-07-19 20:15:16 +00006219 output_c_string(p->out, p->rowSeparator);
mistachkinaae280e2015-12-31 19:06:24 +00006220 raw_printf(p->out, "\n");
drheacd29d2016-04-15 15:03:27 +00006221 utf8_printf(p->out, "%12.12s: %s\n","stats", azBool[p->statsOn!=0]);
mistachkinaae280e2015-12-31 19:06:24 +00006222 utf8_printf(p->out, "%12.12s: ", "width");
persicom7e2dfdd2002-04-18 02:46:52 +00006223 for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) {
mistachkinaae280e2015-12-31 19:06:24 +00006224 raw_printf(p->out, "%d ", p->colWidth[i]);
persicom7e2dfdd2002-04-18 02:46:52 +00006225 }
mistachkinaae280e2015-12-31 19:06:24 +00006226 raw_printf(p->out, "\n");
drhcd0509e2016-09-16 00:26:08 +00006227 utf8_printf(p->out, "%12.12s: %s\n", "filename",
6228 p->zDbFilename ? p->zDbFilename : "");
persicom7e2dfdd2002-04-18 02:46:52 +00006229 }else
6230
drhc2ce0be2014-05-29 12:36:14 +00006231 if( c=='s' && strncmp(azArg[0], "stats", n)==0 ){
6232 if( nArg==2 ){
6233 p->statsOn = booleanValue(azArg[1]);
drh34784902016-02-27 17:12:36 +00006234 }else if( nArg==1 ){
6235 display_stats(p->db, p, 0);
drhc2ce0be2014-05-29 12:36:14 +00006236 }else{
drh34784902016-02-27 17:12:36 +00006237 raw_printf(stderr, "Usage: .stats ?on|off?\n");
drhc2ce0be2014-05-29 12:36:14 +00006238 rc = 1;
6239 }
shaneh642d8b82010-07-28 16:05:34 +00006240 }else
6241
drh6a5a4202016-12-24 21:32:40 +00006242 if( (c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0)
6243 || (c=='i' && (strncmp(azArg[0], "indices", n)==0
6244 || strncmp(azArg[0], "indexes", n)==0) )
6245 ){
drh98781232012-04-23 12:38:05 +00006246 sqlite3_stmt *pStmt;
drhe3710332000-09-29 13:30:53 +00006247 char **azResult;
drh98781232012-04-23 12:38:05 +00006248 int nRow, nAlloc;
6249 char *zSql = 0;
6250 int ii;
drh05782482013-10-24 15:20:20 +00006251 open_db(p, 0);
drh98781232012-04-23 12:38:05 +00006252 rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
dand95bb392015-09-30 11:19:05 +00006253 if( rc ) return shellDatabaseError(p->db);
6254
6255 /* Create an SQL statement to query for the list of tables in the
6256 ** main and all attached databases where the table name matches the
6257 ** LIKE pattern bound to variable "?1". */
drh6a5a4202016-12-24 21:32:40 +00006258 if( c=='t' ){
6259 zSql = sqlite3_mprintf(
6260 "SELECT name FROM sqlite_master"
6261 " WHERE type IN ('table','view')"
6262 " AND name NOT LIKE 'sqlite_%%'"
6263 " AND name LIKE ?1");
6264 }else if( nArg>2 ){
6265 /* It is an historical accident that the .indexes command shows an error
6266 ** when called with the wrong number of arguments whereas the .tables
6267 ** command does not. */
6268 raw_printf(stderr, "Usage: .indexes ?LIKE-PATTERN?\n");
6269 rc = 1;
6270 goto meta_command_exit;
6271 }else{
6272 zSql = sqlite3_mprintf(
6273 "SELECT name FROM sqlite_master"
6274 " WHERE type='index'"
6275 " AND tbl_name LIKE ?1");
6276 }
drha4b81d22016-12-24 18:04:28 +00006277 for(ii=0; zSql && sqlite3_step(pStmt)==SQLITE_ROW; ii++){
drh98781232012-04-23 12:38:05 +00006278 const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1);
drha4b81d22016-12-24 18:04:28 +00006279 if( zDbName==0 || ii==0 ) continue;
drh6a5a4202016-12-24 21:32:40 +00006280 if( c=='t' ){
drh98781232012-04-23 12:38:05 +00006281 zSql = sqlite3_mprintf(
6282 "%z UNION ALL "
6283 "SELECT '%q.' || name FROM \"%w\".sqlite_master"
6284 " WHERE type IN ('table','view')"
6285 " AND name NOT LIKE 'sqlite_%%'"
6286 " AND name LIKE ?1", zSql, zDbName, zDbName);
drh6a5a4202016-12-24 21:32:40 +00006287 }else{
6288 zSql = sqlite3_mprintf(
6289 "%z UNION ALL "
6290 "SELECT '%q.' || name FROM \"%w\".sqlite_master"
6291 " WHERE type='index'"
6292 " AND tbl_name LIKE ?1", zSql, zDbName, zDbName);
drh98781232012-04-23 12:38:05 +00006293 }
drha50da102000-08-08 20:19:09 +00006294 }
dand95bb392015-09-30 11:19:05 +00006295 rc = sqlite3_finalize(pStmt);
6296 if( zSql && rc==SQLITE_OK ){
6297 zSql = sqlite3_mprintf("%z ORDER BY 1", zSql);
6298 if( zSql ) rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
6299 }
drh98781232012-04-23 12:38:05 +00006300 sqlite3_free(zSql);
dand95bb392015-09-30 11:19:05 +00006301 if( !zSql ) return shellNomemError();
6302 if( rc ) return shellDatabaseError(p->db);
6303
6304 /* Run the SQL statement prepared by the above block. Store the results
6305 ** as an array of nul-terminated strings in azResult[]. */
drh98781232012-04-23 12:38:05 +00006306 nRow = nAlloc = 0;
6307 azResult = 0;
6308 if( nArg>1 ){
6309 sqlite3_bind_text(pStmt, 1, azArg[1], -1, SQLITE_TRANSIENT);
shane9bd1b442009-10-23 01:27:39 +00006310 }else{
drh98781232012-04-23 12:38:05 +00006311 sqlite3_bind_text(pStmt, 1, "%", -1, SQLITE_STATIC);
6312 }
6313 while( sqlite3_step(pStmt)==SQLITE_ROW ){
6314 if( nRow>=nAlloc ){
6315 char **azNew;
mistachkin8e189222015-04-19 21:43:16 +00006316 int n2 = nAlloc*2 + 10;
drhf3cdcdc2015-04-29 16:50:28 +00006317 azNew = sqlite3_realloc64(azResult, sizeof(azResult[0])*n2);
drh98781232012-04-23 12:38:05 +00006318 if( azNew==0 ){
dand95bb392015-09-30 11:19:05 +00006319 rc = shellNomemError();
drh98781232012-04-23 12:38:05 +00006320 break;
6321 }
mistachkin8e189222015-04-19 21:43:16 +00006322 nAlloc = n2;
drh98781232012-04-23 12:38:05 +00006323 azResult = azNew;
6324 }
6325 azResult[nRow] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0));
dand95bb392015-09-30 11:19:05 +00006326 if( 0==azResult[nRow] ){
6327 rc = shellNomemError();
6328 break;
6329 }
6330 nRow++;
drh98781232012-04-23 12:38:05 +00006331 }
dand95bb392015-09-30 11:19:05 +00006332 if( sqlite3_finalize(pStmt)!=SQLITE_OK ){
6333 rc = shellDatabaseError(p->db);
6334 }
6335
6336 /* Pretty-print the contents of array azResult[] to the output */
6337 if( rc==0 && nRow>0 ){
drhe3710332000-09-29 13:30:53 +00006338 int len, maxlen = 0;
6339 int i, j;
6340 int nPrintCol, nPrintRow;
drh98781232012-04-23 12:38:05 +00006341 for(i=0; i<nRow; i++){
drh4f21c4a2008-12-10 22:15:00 +00006342 len = strlen30(azResult[i]);
drhe3710332000-09-29 13:30:53 +00006343 if( len>maxlen ) maxlen = len;
6344 }
6345 nPrintCol = 80/(maxlen+2);
6346 if( nPrintCol<1 ) nPrintCol = 1;
6347 nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
6348 for(i=0; i<nPrintRow; i++){
drh98781232012-04-23 12:38:05 +00006349 for(j=i; j<nRow; j+=nPrintRow){
6350 char *zSp = j<nPrintRow ? "" : " ";
drhe05461c2015-12-30 13:36:57 +00006351 utf8_printf(p->out, "%s%-*s", zSp, maxlen,
6352 azResult[j] ? azResult[j]:"");
drhe3710332000-09-29 13:30:53 +00006353 }
mistachkinaae280e2015-12-31 19:06:24 +00006354 raw_printf(p->out, "\n");
drhe3710332000-09-29 13:30:53 +00006355 }
6356 }
dand95bb392015-09-30 11:19:05 +00006357
drh98781232012-04-23 12:38:05 +00006358 for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]);
6359 sqlite3_free(azResult);
drh75897232000-05-29 14:26:00 +00006360 }else
6361
drh2db82112016-09-15 21:35:24 +00006362 /* Begin redirecting output to the file "testcase-out.txt" */
6363 if( c=='t' && strcmp(azArg[0],"testcase")==0 ){
6364 output_reset(p);
6365 p->out = output_file_open("testcase-out.txt");
6366 if( p->out==0 ){
mistachkin2f9a6132016-11-11 05:19:45 +00006367 raw_printf(stderr, "Error: cannot open 'testcase-out.txt'\n");
drh2db82112016-09-15 21:35:24 +00006368 }
drh760c8162016-09-16 02:52:22 +00006369 if( nArg>=2 ){
6370 sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "%s", azArg[1]);
6371 }else{
6372 sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "?");
6373 }
drh2db82112016-09-15 21:35:24 +00006374 }else
drh2db82112016-09-15 21:35:24 +00006375
drhd12602a2016-12-07 15:49:02 +00006376#ifndef SQLITE_UNTESTABLE
shaneh96887e12011-02-10 21:08:58 +00006377 if( c=='t' && n>=8 && strncmp(azArg[0], "testctrl", n)==0 && nArg>=2 ){
drhd416fe72011-03-17 16:45:50 +00006378 static const struct {
6379 const char *zCtrlName; /* Name of a test-control option */
6380 int ctrlCode; /* Integer code for that option */
6381 } aCtrl[] = {
6382 { "prng_save", SQLITE_TESTCTRL_PRNG_SAVE },
6383 { "prng_restore", SQLITE_TESTCTRL_PRNG_RESTORE },
6384 { "prng_reset", SQLITE_TESTCTRL_PRNG_RESET },
6385 { "bitvec_test", SQLITE_TESTCTRL_BITVEC_TEST },
6386 { "fault_install", SQLITE_TESTCTRL_FAULT_INSTALL },
6387 { "benign_malloc_hooks", SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS },
6388 { "pending_byte", SQLITE_TESTCTRL_PENDING_BYTE },
6389 { "assert", SQLITE_TESTCTRL_ASSERT },
6390 { "always", SQLITE_TESTCTRL_ALWAYS },
6391 { "reserve", SQLITE_TESTCTRL_RESERVE },
6392 { "optimizations", SQLITE_TESTCTRL_OPTIMIZATIONS },
6393 { "iskeyword", SQLITE_TESTCTRL_ISKEYWORD },
drhd416fe72011-03-17 16:45:50 +00006394 { "scratchmalloc", SQLITE_TESTCTRL_SCRATCHMALLOC },
drh2cf4acb2014-04-18 00:06:02 +00006395 { "byteorder", SQLITE_TESTCTRL_BYTEORDER },
drhe4bb23a2015-01-19 15:05:54 +00006396 { "never_corrupt", SQLITE_TESTCTRL_NEVER_CORRUPT },
drh1ffede82015-01-30 20:59:27 +00006397 { "imposter", SQLITE_TESTCTRL_IMPOSTER },
drhd416fe72011-03-17 16:45:50 +00006398 };
shaneh96887e12011-02-10 21:08:58 +00006399 int testctrl = -1;
mistachkin8e189222015-04-19 21:43:16 +00006400 int rc2 = 0;
6401 int i, n2;
drh05782482013-10-24 15:20:20 +00006402 open_db(p, 0);
shaneh96887e12011-02-10 21:08:58 +00006403
drhd416fe72011-03-17 16:45:50 +00006404 /* convert testctrl text option to value. allow any unique prefix
6405 ** of the option name, or a numerical value. */
mistachkin8e189222015-04-19 21:43:16 +00006406 n2 = strlen30(azArg[1]);
drhf5ed7ad2015-06-15 14:43:25 +00006407 for(i=0; i<ArraySize(aCtrl); i++){
mistachkin8e189222015-04-19 21:43:16 +00006408 if( strncmp(azArg[1], aCtrl[i].zCtrlName, n2)==0 ){
drhd416fe72011-03-17 16:45:50 +00006409 if( testctrl<0 ){
6410 testctrl = aCtrl[i].ctrlCode;
6411 }else{
mistachkinaae280e2015-12-31 19:06:24 +00006412 utf8_printf(stderr, "ambiguous option name: \"%s\"\n", azArg[1]);
drhd416fe72011-03-17 16:45:50 +00006413 testctrl = -1;
6414 break;
6415 }
6416 }
6417 }
drh348d19c2013-06-03 12:47:43 +00006418 if( testctrl<0 ) testctrl = (int)integerValue(azArg[1]);
shaneh96887e12011-02-10 21:08:58 +00006419 if( (testctrl<SQLITE_TESTCTRL_FIRST) || (testctrl>SQLITE_TESTCTRL_LAST) ){
mistachkinaae280e2015-12-31 19:06:24 +00006420 utf8_printf(stderr,"Error: invalid testctrl option: %s\n", azArg[1]);
shaneh96887e12011-02-10 21:08:58 +00006421 }else{
6422 switch(testctrl){
6423
6424 /* sqlite3_test_control(int, db, int) */
6425 case SQLITE_TESTCTRL_OPTIMIZATIONS:
mistachkin1fe36bb2016-04-04 02:16:44 +00006426 case SQLITE_TESTCTRL_RESERVE:
shaneh96887e12011-02-10 21:08:58 +00006427 if( nArg==3 ){
mistachkin1fe36bb2016-04-04 02:16:44 +00006428 int opt = (int)strtol(azArg[2], 0, 0);
mistachkin8e189222015-04-19 21:43:16 +00006429 rc2 = sqlite3_test_control(testctrl, p->db, opt);
mistachkinaae280e2015-12-31 19:06:24 +00006430 raw_printf(p->out, "%d (0x%08x)\n", rc2, rc2);
shaneh96887e12011-02-10 21:08:58 +00006431 } else {
mistachkinaae280e2015-12-31 19:06:24 +00006432 utf8_printf(stderr,"Error: testctrl %s takes a single int option\n",
drhd416fe72011-03-17 16:45:50 +00006433 azArg[1]);
shaneh96887e12011-02-10 21:08:58 +00006434 }
6435 break;
6436
6437 /* sqlite3_test_control(int) */
drh2cf4acb2014-04-18 00:06:02 +00006438 case SQLITE_TESTCTRL_PRNG_SAVE:
6439 case SQLITE_TESTCTRL_PRNG_RESTORE:
shaneh96887e12011-02-10 21:08:58 +00006440 case SQLITE_TESTCTRL_PRNG_RESET:
drh2cf4acb2014-04-18 00:06:02 +00006441 case SQLITE_TESTCTRL_BYTEORDER:
shaneh96887e12011-02-10 21:08:58 +00006442 if( nArg==2 ){
mistachkin8e189222015-04-19 21:43:16 +00006443 rc2 = sqlite3_test_control(testctrl);
mistachkinaae280e2015-12-31 19:06:24 +00006444 raw_printf(p->out, "%d (0x%08x)\n", rc2, rc2);
shaneh96887e12011-02-10 21:08:58 +00006445 } else {
mistachkinaae280e2015-12-31 19:06:24 +00006446 utf8_printf(stderr,"Error: testctrl %s takes no options\n",
6447 azArg[1]);
shaneh96887e12011-02-10 21:08:58 +00006448 }
6449 break;
6450
6451 /* sqlite3_test_control(int, uint) */
mistachkin1fe36bb2016-04-04 02:16:44 +00006452 case SQLITE_TESTCTRL_PENDING_BYTE:
shaneh96887e12011-02-10 21:08:58 +00006453 if( nArg==3 ){
drhaf664332013-07-18 20:28:29 +00006454 unsigned int opt = (unsigned int)integerValue(azArg[2]);
mistachkin8e189222015-04-19 21:43:16 +00006455 rc2 = sqlite3_test_control(testctrl, opt);
mistachkinaae280e2015-12-31 19:06:24 +00006456 raw_printf(p->out, "%d (0x%08x)\n", rc2, rc2);
shaneh96887e12011-02-10 21:08:58 +00006457 } else {
mistachkinaae280e2015-12-31 19:06:24 +00006458 utf8_printf(stderr,"Error: testctrl %s takes a single unsigned"
drhd416fe72011-03-17 16:45:50 +00006459 " int option\n", azArg[1]);
shaneh96887e12011-02-10 21:08:58 +00006460 }
6461 break;
mistachkin1fe36bb2016-04-04 02:16:44 +00006462
shaneh96887e12011-02-10 21:08:58 +00006463 /* sqlite3_test_control(int, int) */
mistachkin1fe36bb2016-04-04 02:16:44 +00006464 case SQLITE_TESTCTRL_ASSERT:
6465 case SQLITE_TESTCTRL_ALWAYS:
6466 case SQLITE_TESTCTRL_NEVER_CORRUPT:
shaneh96887e12011-02-10 21:08:58 +00006467 if( nArg==3 ){
mistachkin1fe36bb2016-04-04 02:16:44 +00006468 int opt = booleanValue(azArg[2]);
mistachkin8e189222015-04-19 21:43:16 +00006469 rc2 = sqlite3_test_control(testctrl, opt);
mistachkinaae280e2015-12-31 19:06:24 +00006470 raw_printf(p->out, "%d (0x%08x)\n", rc2, rc2);
shaneh96887e12011-02-10 21:08:58 +00006471 } else {
mistachkinaae280e2015-12-31 19:06:24 +00006472 utf8_printf(stderr,"Error: testctrl %s takes a single int option\n",
drhd416fe72011-03-17 16:45:50 +00006473 azArg[1]);
shaneh96887e12011-02-10 21:08:58 +00006474 }
6475 break;
6476
6477 /* sqlite3_test_control(int, char *) */
6478#ifdef SQLITE_N_KEYWORD
mistachkin1fe36bb2016-04-04 02:16:44 +00006479 case SQLITE_TESTCTRL_ISKEYWORD:
shaneh96887e12011-02-10 21:08:58 +00006480 if( nArg==3 ){
mistachkin1fe36bb2016-04-04 02:16:44 +00006481 const char *opt = azArg[2];
mistachkin8e189222015-04-19 21:43:16 +00006482 rc2 = sqlite3_test_control(testctrl, opt);
mistachkinaae280e2015-12-31 19:06:24 +00006483 raw_printf(p->out, "%d (0x%08x)\n", rc2, rc2);
shaneh96887e12011-02-10 21:08:58 +00006484 } else {
mistachkinaae280e2015-12-31 19:06:24 +00006485 utf8_printf(stderr,
6486 "Error: testctrl %s takes a single char * option\n",
6487 azArg[1]);
shaneh96887e12011-02-10 21:08:58 +00006488 }
6489 break;
6490#endif
6491
drh1ffede82015-01-30 20:59:27 +00006492 case SQLITE_TESTCTRL_IMPOSTER:
drh8964b342015-01-29 17:54:52 +00006493 if( nArg==5 ){
mistachkin1fe36bb2016-04-04 02:16:44 +00006494 rc2 = sqlite3_test_control(testctrl, p->db,
drh1ffede82015-01-30 20:59:27 +00006495 azArg[2],
drh8964b342015-01-29 17:54:52 +00006496 integerValue(azArg[3]),
6497 integerValue(azArg[4]));
mistachkinaae280e2015-12-31 19:06:24 +00006498 raw_printf(p->out, "%d (0x%08x)\n", rc2, rc2);
drh8964b342015-01-29 17:54:52 +00006499 }else{
mistachkinaae280e2015-12-31 19:06:24 +00006500 raw_printf(stderr,"Usage: .testctrl imposter dbName onoff tnum\n");
drh8964b342015-01-29 17:54:52 +00006501 }
6502 break;
6503
mistachkin1fe36bb2016-04-04 02:16:44 +00006504 case SQLITE_TESTCTRL_BITVEC_TEST:
6505 case SQLITE_TESTCTRL_FAULT_INSTALL:
6506 case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS:
6507 case SQLITE_TESTCTRL_SCRATCHMALLOC:
shaneh96887e12011-02-10 21:08:58 +00006508 default:
mistachkinaae280e2015-12-31 19:06:24 +00006509 utf8_printf(stderr,
6510 "Error: CLI support for testctrl %s not implemented\n",
6511 azArg[1]);
shaneh96887e12011-02-10 21:08:58 +00006512 break;
6513 }
6514 }
6515 }else
drhf1969722017-02-17 23:52:00 +00006516#endif /* !defined(SQLITE_UNTESTABLE) */
shaneh96887e12011-02-10 21:08:58 +00006517
drhc2ce0be2014-05-29 12:36:14 +00006518 if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 ){
drh05782482013-10-24 15:20:20 +00006519 open_db(p, 0);
drhc2ce0be2014-05-29 12:36:14 +00006520 sqlite3_busy_timeout(p->db, nArg>=2 ? (int)integerValue(azArg[1]) : 0);
shanehe2aa9d72009-11-06 17:20:17 +00006521 }else
mistachkin1fe36bb2016-04-04 02:16:44 +00006522
drhc2ce0be2014-05-29 12:36:14 +00006523 if( c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 ){
6524 if( nArg==2 ){
6525 enableTimer = booleanValue(azArg[1]);
6526 if( enableTimer && !HAS_TIMER ){
mistachkinaae280e2015-12-31 19:06:24 +00006527 raw_printf(stderr, "Error: timer not available on this system.\n");
drhc2ce0be2014-05-29 12:36:14 +00006528 enableTimer = 0;
6529 }
6530 }else{
mistachkinaae280e2015-12-31 19:06:24 +00006531 raw_printf(stderr, "Usage: .timer on|off\n");
drhc2ce0be2014-05-29 12:36:14 +00006532 rc = 1;
6533 }
shanehe2aa9d72009-11-06 17:20:17 +00006534 }else
mistachkin1fe36bb2016-04-04 02:16:44 +00006535
drhc2ce0be2014-05-29 12:36:14 +00006536 if( c=='t' && strncmp(azArg[0], "trace", n)==0 ){
drh05782482013-10-24 15:20:20 +00006537 open_db(p, 0);
drhc2ce0be2014-05-29 12:36:14 +00006538 if( nArg!=2 ){
mistachkinaae280e2015-12-31 19:06:24 +00006539 raw_printf(stderr, "Usage: .trace FILE|off\n");
drhc2ce0be2014-05-29 12:36:14 +00006540 rc = 1;
6541 goto meta_command_exit;
6542 }
drh657b4a82015-03-19 13:30:41 +00006543 output_file_close(p->traceOut);
drh42f64e52012-04-04 16:56:23 +00006544 p->traceOut = output_file_open(azArg[1]);
drhbbb0be82012-06-27 16:12:27 +00006545#if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)
drh42f64e52012-04-04 16:56:23 +00006546 if( p->traceOut==0 ){
drh4b363a52016-07-23 20:27:41 +00006547 sqlite3_trace_v2(p->db, 0, 0, 0);
drh42f64e52012-04-04 16:56:23 +00006548 }else{
drh4b363a52016-07-23 20:27:41 +00006549 sqlite3_trace_v2(p->db, SQLITE_TRACE_STMT, sql_trace_callback,p->traceOut);
drh42f64e52012-04-04 16:56:23 +00006550 }
6551#endif
6552 }else
6553
drhf442e332014-09-10 19:01:14 +00006554#if SQLITE_USER_AUTHENTICATION
6555 if( c=='u' && strncmp(azArg[0], "user", n)==0 ){
6556 if( nArg<2 ){
mistachkinaae280e2015-12-31 19:06:24 +00006557 raw_printf(stderr, "Usage: .user SUBCOMMAND ...\n");
drhf442e332014-09-10 19:01:14 +00006558 rc = 1;
6559 goto meta_command_exit;
6560 }
drh7883ecf2014-09-11 16:19:31 +00006561 open_db(p, 0);
drhf442e332014-09-10 19:01:14 +00006562 if( strcmp(azArg[1],"login")==0 ){
6563 if( nArg!=4 ){
mistachkinaae280e2015-12-31 19:06:24 +00006564 raw_printf(stderr, "Usage: .user login USER PASSWORD\n");
drhf442e332014-09-10 19:01:14 +00006565 rc = 1;
6566 goto meta_command_exit;
6567 }
drhd39c40f2014-09-11 00:27:53 +00006568 rc = sqlite3_user_authenticate(p->db, azArg[2], azArg[3],
6569 (int)strlen(azArg[3]));
drhf442e332014-09-10 19:01:14 +00006570 if( rc ){
mistachkinaae280e2015-12-31 19:06:24 +00006571 utf8_printf(stderr, "Authentication failed for user %s\n", azArg[2]);
drhf442e332014-09-10 19:01:14 +00006572 rc = 1;
6573 }
6574 }else if( strcmp(azArg[1],"add")==0 ){
6575 if( nArg!=5 ){
mistachkinaae280e2015-12-31 19:06:24 +00006576 raw_printf(stderr, "Usage: .user add USER PASSWORD ISADMIN\n");
drhf442e332014-09-10 19:01:14 +00006577 rc = 1;
6578 goto meta_command_exit;
6579 }
drhd39c40f2014-09-11 00:27:53 +00006580 rc = sqlite3_user_add(p->db, azArg[2],
6581 azArg[3], (int)strlen(azArg[3]),
6582 booleanValue(azArg[4]));
drhf442e332014-09-10 19:01:14 +00006583 if( rc ){
mistachkinaae280e2015-12-31 19:06:24 +00006584 raw_printf(stderr, "User-Add failed: %d\n", rc);
drhf442e332014-09-10 19:01:14 +00006585 rc = 1;
6586 }
6587 }else if( strcmp(azArg[1],"edit")==0 ){
6588 if( nArg!=5 ){
mistachkinaae280e2015-12-31 19:06:24 +00006589 raw_printf(stderr, "Usage: .user edit USER PASSWORD ISADMIN\n");
drhf442e332014-09-10 19:01:14 +00006590 rc = 1;
6591 goto meta_command_exit;
6592 }
drhd39c40f2014-09-11 00:27:53 +00006593 rc = sqlite3_user_change(p->db, azArg[2],
6594 azArg[3], (int)strlen(azArg[3]),
6595 booleanValue(azArg[4]));
drhf442e332014-09-10 19:01:14 +00006596 if( rc ){
mistachkinaae280e2015-12-31 19:06:24 +00006597 raw_printf(stderr, "User-Edit failed: %d\n", rc);
drhf442e332014-09-10 19:01:14 +00006598 rc = 1;
6599 }
6600 }else if( strcmp(azArg[1],"delete")==0 ){
6601 if( nArg!=3 ){
mistachkinaae280e2015-12-31 19:06:24 +00006602 raw_printf(stderr, "Usage: .user delete USER\n");
drhf442e332014-09-10 19:01:14 +00006603 rc = 1;
6604 goto meta_command_exit;
6605 }
6606 rc = sqlite3_user_delete(p->db, azArg[2]);
6607 if( rc ){
mistachkinaae280e2015-12-31 19:06:24 +00006608 raw_printf(stderr, "User-Delete failed: %d\n", rc);
drhf442e332014-09-10 19:01:14 +00006609 rc = 1;
6610 }
6611 }else{
mistachkinaae280e2015-12-31 19:06:24 +00006612 raw_printf(stderr, "Usage: .user login|add|edit|delete ...\n");
drhf442e332014-09-10 19:01:14 +00006613 rc = 1;
6614 goto meta_command_exit;
mistachkin1fe36bb2016-04-04 02:16:44 +00006615 }
drhf442e332014-09-10 19:01:14 +00006616 }else
6617#endif /* SQLITE_USER_AUTHENTICATION */
6618
drh9fd301b2011-06-03 13:28:22 +00006619 if( c=='v' && strncmp(azArg[0], "version", n)==0 ){
mistachkinaae280e2015-12-31 19:06:24 +00006620 utf8_printf(p->out, "SQLite %s %s\n" /*extra-version-info*/,
drh9fd301b2011-06-03 13:28:22 +00006621 sqlite3_libversion(), sqlite3_sourceid());
6622 }else
6623
drh790f2872015-11-28 18:06:36 +00006624 if( c=='v' && strncmp(azArg[0], "vfsinfo", n)==0 ){
6625 const char *zDbName = nArg==2 ? azArg[1] : "main";
drh38305ab2017-01-22 16:34:35 +00006626 sqlite3_vfs *pVfs = 0;
drh790f2872015-11-28 18:06:36 +00006627 if( p->db ){
6628 sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFS_POINTER, &pVfs);
6629 if( pVfs ){
mistachkinaae280e2015-12-31 19:06:24 +00006630 utf8_printf(p->out, "vfs.zName = \"%s\"\n", pVfs->zName);
6631 raw_printf(p->out, "vfs.iVersion = %d\n", pVfs->iVersion);
6632 raw_printf(p->out, "vfs.szOsFile = %d\n", pVfs->szOsFile);
6633 raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname);
drh790f2872015-11-28 18:06:36 +00006634 }
6635 }
6636 }else
6637
drhb19e7352016-01-12 19:37:20 +00006638 if( c=='v' && strncmp(azArg[0], "vfslist", n)==0 ){
6639 sqlite3_vfs *pVfs;
6640 sqlite3_vfs *pCurrent = 0;
6641 if( p->db ){
6642 sqlite3_file_control(p->db, "main", SQLITE_FCNTL_VFS_POINTER, &pCurrent);
6643 }
6644 for(pVfs=sqlite3_vfs_find(0); pVfs; pVfs=pVfs->pNext){
6645 utf8_printf(p->out, "vfs.zName = \"%s\"%s\n", pVfs->zName,
6646 pVfs==pCurrent ? " <--- CURRENT" : "");
6647 raw_printf(p->out, "vfs.iVersion = %d\n", pVfs->iVersion);
6648 raw_printf(p->out, "vfs.szOsFile = %d\n", pVfs->szOsFile);
6649 raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname);
6650 if( pVfs->pNext ){
6651 raw_printf(p->out, "-----------------------------------\n");
6652 }
6653 }
6654 }else
6655
drhde60fc22011-12-14 17:53:36 +00006656 if( c=='v' && strncmp(azArg[0], "vfsname", n)==0 ){
6657 const char *zDbName = nArg==2 ? azArg[1] : "main";
6658 char *zVfsName = 0;
6659 if( p->db ){
6660 sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName);
6661 if( zVfsName ){
mistachkinaae280e2015-12-31 19:06:24 +00006662 utf8_printf(p->out, "%s\n", zVfsName);
drhde60fc22011-12-14 17:53:36 +00006663 sqlite3_free(zVfsName);
6664 }
6665 }
6666 }else
6667
drhcef4fc82012-09-21 22:50:45 +00006668#if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
6669 if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){
drhc2ce0be2014-05-29 12:36:14 +00006670 sqlite3WhereTrace = nArg>=2 ? booleanValue(azArg[1]) : 0xff;
drhcef4fc82012-09-21 22:50:45 +00006671 }else
6672#endif
6673
drhc2ce0be2014-05-29 12:36:14 +00006674 if( c=='w' && strncmp(azArg[0], "width", n)==0 ){
drh75897232000-05-29 14:26:00 +00006675 int j;
drh43617e92006-03-06 20:55:46 +00006676 assert( nArg<=ArraySize(azArg) );
drh75897232000-05-29 14:26:00 +00006677 for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){
drh348d19c2013-06-03 12:47:43 +00006678 p->colWidth[j-1] = (int)integerValue(azArg[j]);
drh75897232000-05-29 14:26:00 +00006679 }
6680 }else
6681
6682 {
mistachkinaae280e2015-12-31 19:06:24 +00006683 utf8_printf(stderr, "Error: unknown command or invalid arguments: "
drh67505e72002-04-19 12:34:06 +00006684 " \"%s\". Enter \".help\" for help\n", azArg[0]);
shane9bd1b442009-10-23 01:27:39 +00006685 rc = 1;
drh75897232000-05-29 14:26:00 +00006686 }
drh67505e72002-04-19 12:34:06 +00006687
drhc2ce0be2014-05-29 12:36:14 +00006688meta_command_exit:
6689 if( p->outCount ){
6690 p->outCount--;
6691 if( p->outCount==0 ) output_reset(p);
6692 }
drh67505e72002-04-19 12:34:06 +00006693 return rc;
drh75897232000-05-29 14:26:00 +00006694}
6695
drh67505e72002-04-19 12:34:06 +00006696/*
drh91a66392007-09-07 01:12:32 +00006697** Return TRUE if a semicolon occurs anywhere in the first N characters
6698** of string z[].
drh324ccef2003-02-05 14:06:20 +00006699*/
drh9f099fd2013-08-06 14:01:46 +00006700static int line_contains_semicolon(const char *z, int N){
drh91a66392007-09-07 01:12:32 +00006701 int i;
6702 for(i=0; i<N; i++){ if( z[i]==';' ) return 1; }
6703 return 0;
drh324ccef2003-02-05 14:06:20 +00006704}
6705
6706/*
drh70c7a4b2003-04-26 03:03:06 +00006707** Test to see if a line consists entirely of whitespace.
6708*/
6709static int _all_whitespace(const char *z){
6710 for(; *z; z++){
drhf0693c82011-10-11 20:41:54 +00006711 if( IsSpace(z[0]) ) continue;
drh70c7a4b2003-04-26 03:03:06 +00006712 if( *z=='/' && z[1]=='*' ){
6713 z += 2;
6714 while( *z && (*z!='*' || z[1]!='/') ){ z++; }
6715 if( *z==0 ) return 0;
6716 z++;
6717 continue;
6718 }
6719 if( *z=='-' && z[1]=='-' ){
6720 z += 2;
6721 while( *z && *z!='\n' ){ z++; }
6722 if( *z==0 ) return 1;
6723 continue;
6724 }
6725 return 0;
6726 }
6727 return 1;
6728}
6729
6730/*
drha9b17162003-04-29 18:01:28 +00006731** Return TRUE if the line typed in is an SQL command terminator other
6732** than a semi-colon. The SQL Server style "go" command is understood
6733** as is the Oracle "/".
6734*/
drh9f099fd2013-08-06 14:01:46 +00006735static int line_is_command_terminator(const char *zLine){
drhf0693c82011-10-11 20:41:54 +00006736 while( IsSpace(zLine[0]) ){ zLine++; };
drh233a5312008-12-18 22:25:13 +00006737 if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ){
6738 return 1; /* Oracle */
6739 }
drhf0693c82011-10-11 20:41:54 +00006740 if( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o'
drhc8d74412004-08-31 23:41:26 +00006741 && _all_whitespace(&zLine[2]) ){
drha9b17162003-04-29 18:01:28 +00006742 return 1; /* SQL Server */
6743 }
6744 return 0;
6745}
6746
6747/*
drh233a5312008-12-18 22:25:13 +00006748** Return true if zSql is a complete SQL statement. Return false if it
6749** ends in the middle of a string literal or C-style comment.
6750*/
drh9f099fd2013-08-06 14:01:46 +00006751static int line_is_complete(char *zSql, int nSql){
drh233a5312008-12-18 22:25:13 +00006752 int rc;
6753 if( zSql==0 ) return 1;
6754 zSql[nSql] = ';';
6755 zSql[nSql+1] = 0;
6756 rc = sqlite3_complete(zSql);
6757 zSql[nSql] = 0;
6758 return rc;
6759}
6760
6761/*
drh4e8142c2016-11-11 14:54:22 +00006762** Run a single line of SQL
6763*/
6764static int runOneSqlLine(ShellState *p, char *zSql, FILE *in, int startline){
6765 int rc;
6766 char *zErrMsg = 0;
6767
6768 open_db(p, 0);
drhe6e1d122017-03-09 13:50:49 +00006769 if( ShellHasFlag(p,SHFLG_Backslash) ) resolve_backslashes(zSql);
drh4e8142c2016-11-11 14:54:22 +00006770 BEGIN_TIMER;
6771 rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
6772 END_TIMER;
6773 if( rc || zErrMsg ){
6774 char zPrefix[100];
6775 if( in!=0 || !stdin_is_interactive ){
6776 sqlite3_snprintf(sizeof(zPrefix), zPrefix,
6777 "Error: near line %d:", startline);
6778 }else{
6779 sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:");
6780 }
6781 if( zErrMsg!=0 ){
6782 utf8_printf(stderr, "%s %s\n", zPrefix, zErrMsg);
6783 sqlite3_free(zErrMsg);
6784 zErrMsg = 0;
6785 }else{
6786 utf8_printf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
6787 }
6788 return 1;
drhe6e1d122017-03-09 13:50:49 +00006789 }else if( ShellHasFlag(p, SHFLG_CountChanges) ){
drh4e8142c2016-11-11 14:54:22 +00006790 raw_printf(p->out, "changes: %3d total_changes: %d\n",
6791 sqlite3_changes(p->db), sqlite3_total_changes(p->db));
6792 }
6793 return 0;
6794}
6795
6796
6797/*
drh67505e72002-04-19 12:34:06 +00006798** Read input from *in and process it. If *in==0 then input
6799** is interactive - the user is typing it it. Otherwise, input
6800** is coming from a file or device. A prompt is issued and history
6801** is saved only if input is interactive. An interrupt signal will
6802** cause this routine to exit immediately, unless input is interactive.
drhc28490c2006-10-26 14:25:58 +00006803**
6804** Return the number of errors.
drh67505e72002-04-19 12:34:06 +00006805*/
drhdcd87a92014-08-18 13:45:42 +00006806static int process_input(ShellState *p, FILE *in){
drh9f099fd2013-08-06 14:01:46 +00006807 char *zLine = 0; /* A single input line */
6808 char *zSql = 0; /* Accumulated SQL text */
6809 int nLine; /* Length of current line */
6810 int nSql = 0; /* Bytes of zSql[] used */
6811 int nAlloc = 0; /* Allocated zSql[] space */
6812 int nSqlPrior = 0; /* Bytes of zSql[] used by prior line */
drh9f099fd2013-08-06 14:01:46 +00006813 int rc; /* Error code */
6814 int errCnt = 0; /* Number of errors seen */
6815 int lineno = 0; /* Current line number */
6816 int startline = 0; /* Line number for start of current input */
drhc49f44e2006-10-26 18:15:42 +00006817
6818 while( errCnt==0 || !bail_on_error || (in==0 && stdin_is_interactive) ){
6819 fflush(p->out);
drh9f099fd2013-08-06 14:01:46 +00006820 zLine = one_input_line(in, zLine, nSql>0);
drhc49f44e2006-10-26 18:15:42 +00006821 if( zLine==0 ){
drh9b8d3572012-04-21 11:33:39 +00006822 /* End of input */
drhfc8b40f2016-09-07 10:10:18 +00006823 if( in==0 && stdin_is_interactive ) printf("\n");
drh9b8d3572012-04-21 11:33:39 +00006824 break;
drhc49f44e2006-10-26 18:15:42 +00006825 }
drh67505e72002-04-19 12:34:06 +00006826 if( seenInterrupt ){
6827 if( in!=0 ) break;
6828 seenInterrupt = 0;
6829 }
drhc28490c2006-10-26 14:25:58 +00006830 lineno++;
drh849a9d92013-12-21 15:46:06 +00006831 if( nSql==0 && _all_whitespace(zLine) ){
drhe6e1d122017-03-09 13:50:49 +00006832 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
drh849a9d92013-12-21 15:46:06 +00006833 continue;
6834 }
drh2af0b2d2002-02-21 02:25:02 +00006835 if( zLine && zLine[0]=='.' && nSql==0 ){
drhe6e1d122017-03-09 13:50:49 +00006836 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
drhc49f44e2006-10-26 18:15:42 +00006837 rc = do_meta_command(zLine, p);
shane916f9612009-10-23 00:37:15 +00006838 if( rc==2 ){ /* exit requested */
drh47ad6842006-11-08 12:25:42 +00006839 break;
6840 }else if( rc ){
drhc49f44e2006-10-26 18:15:42 +00006841 errCnt++;
6842 }
drhdaffd0e2001-04-11 14:28:42 +00006843 continue;
6844 }
drh9f099fd2013-08-06 14:01:46 +00006845 if( line_is_command_terminator(zLine) && line_is_complete(zSql, nSql) ){
drh5bb3eb92007-05-04 13:15:55 +00006846 memcpy(zLine,";",2);
drha9b17162003-04-29 18:01:28 +00006847 }
drh9f099fd2013-08-06 14:01:46 +00006848 nLine = strlen30(zLine);
6849 if( nSql+nLine+2>=nAlloc ){
6850 nAlloc = nSql+nLine+100;
6851 zSql = realloc(zSql, nAlloc);
drhdaffd0e2001-04-11 14:28:42 +00006852 if( zSql==0 ){
mistachkinaae280e2015-12-31 19:06:24 +00006853 raw_printf(stderr, "Error: out of memory\n");
drhdaffd0e2001-04-11 14:28:42 +00006854 exit(1);
6855 }
drhdaffd0e2001-04-11 14:28:42 +00006856 }
drh9f099fd2013-08-06 14:01:46 +00006857 nSqlPrior = nSql;
6858 if( nSql==0 ){
6859 int i;
6860 for(i=0; zLine[i] && IsSpace(zLine[i]); i++){}
drh77dfd5b2013-08-19 11:15:48 +00006861 assert( nAlloc>0 && zSql!=0 );
drh9f099fd2013-08-06 14:01:46 +00006862 memcpy(zSql, zLine+i, nLine+1-i);
6863 startline = lineno;
6864 nSql = nLine-i;
6865 }else{
6866 zSql[nSql++] = '\n';
6867 memcpy(zSql+nSql, zLine, nLine+1);
6868 nSql += nLine;
6869 }
6870 if( nSql && line_contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
drh91a66392007-09-07 01:12:32 +00006871 && sqlite3_complete(zSql) ){
drh4e8142c2016-11-11 14:54:22 +00006872 errCnt += runOneSqlLine(p, zSql, in, startline);
drhdaffd0e2001-04-11 14:28:42 +00006873 nSql = 0;
drhc2ce0be2014-05-29 12:36:14 +00006874 if( p->outCount ){
6875 output_reset(p);
6876 p->outCount = 0;
6877 }
drh9f099fd2013-08-06 14:01:46 +00006878 }else if( nSql && _all_whitespace(zSql) ){
drhe6e1d122017-03-09 13:50:49 +00006879 if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zSql);
drh7a411f42013-04-17 17:33:17 +00006880 nSql = 0;
drhdaffd0e2001-04-11 14:28:42 +00006881 }
6882 }
drh4e8142c2016-11-11 14:54:22 +00006883 if( nSql && !_all_whitespace(zSql) ){
6884 runOneSqlLine(p, zSql, in, startline);
drhdaffd0e2001-04-11 14:28:42 +00006885 }
drh1f9ca2c2015-08-25 16:57:52 +00006886 free(zSql);
danielk19772ac27622007-07-03 05:31:16 +00006887 free(zLine);
drh4d15a0d2012-12-01 20:21:22 +00006888 return errCnt>0;
drhdaffd0e2001-04-11 14:28:42 +00006889}
6890
drh67505e72002-04-19 12:34:06 +00006891/*
6892** Return a pathname which is the user's home directory. A
drh85e72432012-04-11 11:38:53 +00006893** 0 return indicates an error of some kind.
drh67505e72002-04-19 12:34:06 +00006894*/
drhd1459152016-09-16 19:11:03 +00006895static char *find_home_dir(int clearFlag){
drh85e72432012-04-11 11:38:53 +00006896 static char *home_dir = NULL;
drhd1459152016-09-16 19:11:03 +00006897 if( clearFlag ){
6898 free(home_dir);
6899 home_dir = 0;
6900 return 0;
6901 }
drh85e72432012-04-11 11:38:53 +00006902 if( home_dir ) return home_dir;
persicom7e2dfdd2002-04-18 02:46:52 +00006903
drh4ace5362014-11-10 14:42:28 +00006904#if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) \
6905 && !defined(__RTP__) && !defined(_WRS_KERNEL)
mistachkinc8bde372012-06-18 08:00:56 +00006906 {
6907 struct passwd *pwent;
6908 uid_t uid = getuid();
6909 if( (pwent=getpwuid(uid)) != NULL) {
6910 home_dir = pwent->pw_dir;
6911 }
drh67505e72002-04-19 12:34:06 +00006912 }
6913#endif
6914
chw65d3c132007-11-12 21:09:10 +00006915#if defined(_WIN32_WCE)
6916 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
6917 */
drh85e72432012-04-11 11:38:53 +00006918 home_dir = "/";
chw65d3c132007-11-12 21:09:10 +00006919#else
6920
drh83905c92012-06-21 13:00:37 +00006921#if defined(_WIN32) || defined(WIN32)
drh164a1b62006-08-19 11:15:20 +00006922 if (!home_dir) {
6923 home_dir = getenv("USERPROFILE");
6924 }
6925#endif
6926
drh67505e72002-04-19 12:34:06 +00006927 if (!home_dir) {
6928 home_dir = getenv("HOME");
drh67505e72002-04-19 12:34:06 +00006929 }
6930
drh83905c92012-06-21 13:00:37 +00006931#if defined(_WIN32) || defined(WIN32)
drhe98d4fa2002-04-21 19:06:22 +00006932 if (!home_dir) {
drh164a1b62006-08-19 11:15:20 +00006933 char *zDrive, *zPath;
6934 int n;
6935 zDrive = getenv("HOMEDRIVE");
6936 zPath = getenv("HOMEPATH");
6937 if( zDrive && zPath ){
drh4f21c4a2008-12-10 22:15:00 +00006938 n = strlen30(zDrive) + strlen30(zPath) + 1;
drh164a1b62006-08-19 11:15:20 +00006939 home_dir = malloc( n );
6940 if( home_dir==0 ) return 0;
6941 sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath);
6942 return home_dir;
6943 }
6944 home_dir = "c:\\";
drhe98d4fa2002-04-21 19:06:22 +00006945 }
6946#endif
6947
chw65d3c132007-11-12 21:09:10 +00006948#endif /* !_WIN32_WCE */
6949
drh67505e72002-04-19 12:34:06 +00006950 if( home_dir ){
drh4f21c4a2008-12-10 22:15:00 +00006951 int n = strlen30(home_dir) + 1;
drh5bb3eb92007-05-04 13:15:55 +00006952 char *z = malloc( n );
6953 if( z ) memcpy(z, home_dir, n);
drh67505e72002-04-19 12:34:06 +00006954 home_dir = z;
6955 }
drhe98d4fa2002-04-21 19:06:22 +00006956
drh67505e72002-04-19 12:34:06 +00006957 return home_dir;
6958}
6959
6960/*
6961** Read input from the file given by sqliterc_override. Or if that
6962** parameter is NULL, take input from ~/.sqliterc
shane9bd1b442009-10-23 01:27:39 +00006963**
6964** Returns the number of errors.
drh67505e72002-04-19 12:34:06 +00006965*/
drh534f4df2015-02-28 14:03:35 +00006966static void process_sqliterc(
drhdcd87a92014-08-18 13:45:42 +00006967 ShellState *p, /* Configuration data */
drh22fbcb82004-02-01 01:22:50 +00006968 const char *sqliterc_override /* Name of config file. NULL to use default */
6969){
persicom7e2dfdd2002-04-18 02:46:52 +00006970 char *home_dir = NULL;
drh22fbcb82004-02-01 01:22:50 +00006971 const char *sqliterc = sqliterc_override;
drh43617e92006-03-06 20:55:46 +00006972 char *zBuf = 0;
persicom7e2dfdd2002-04-18 02:46:52 +00006973 FILE *in = NULL;
6974
6975 if (sqliterc == NULL) {
drhd1459152016-09-16 19:11:03 +00006976 home_dir = find_home_dir(0);
drhe98d4fa2002-04-21 19:06:22 +00006977 if( home_dir==0 ){
mistachkinaae280e2015-12-31 19:06:24 +00006978 raw_printf(stderr, "-- warning: cannot find home directory;"
drh534f4df2015-02-28 14:03:35 +00006979 " cannot read ~/.sqliterc\n");
6980 return;
drhe98d4fa2002-04-21 19:06:22 +00006981 }
drh2f3de322012-06-27 16:41:31 +00006982 sqlite3_initialize();
drh85e72432012-04-11 11:38:53 +00006983 zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir);
6984 sqliterc = zBuf;
persicom7e2dfdd2002-04-18 02:46:52 +00006985 }
drha1f9b5e2004-02-14 16:31:02 +00006986 in = fopen(sqliterc,"rb");
drh22fbcb82004-02-01 01:22:50 +00006987 if( in ){
drhc28490c2006-10-26 14:25:58 +00006988 if( stdin_is_interactive ){
mistachkinaae280e2015-12-31 19:06:24 +00006989 utf8_printf(stderr,"-- Loading resources from %s\n",sqliterc);
drh22fbcb82004-02-01 01:22:50 +00006990 }
drh534f4df2015-02-28 14:03:35 +00006991 process_input(p,in);
drhdd45df82002-04-18 12:39:03 +00006992 fclose(in);
persicom7e2dfdd2002-04-18 02:46:52 +00006993 }
drh85e72432012-04-11 11:38:53 +00006994 sqlite3_free(zBuf);
persicom7e2dfdd2002-04-18 02:46:52 +00006995}
6996
drh67505e72002-04-19 12:34:06 +00006997/*
drhe1e38c42003-05-04 18:30:59 +00006998** Show available command line options
6999*/
mistachkin1fe36bb2016-04-04 02:16:44 +00007000static const char zOptions[] =
mistachkin636bf9f2014-07-19 20:15:16 +00007001 " -ascii set output mode to 'ascii'\n"
drhc49f44e2006-10-26 18:15:42 +00007002 " -bail stop after hitting an error\n"
drhc49f44e2006-10-26 18:15:42 +00007003 " -batch force batch I/O\n"
drhe1e38c42003-05-04 18:30:59 +00007004 " -column set output mode to 'column'\n"
mistachkin6d81d752012-10-25 15:43:28 +00007005 " -cmd COMMAND run \"COMMAND\" before reading stdin\n"
drhc49f44e2006-10-26 18:15:42 +00007006 " -csv set output mode to 'csv'\n"
drhcc3b4f82012-02-07 14:13:50 +00007007 " -echo print commands before execution\n"
mistachkin6d81d752012-10-25 15:43:28 +00007008 " -init FILENAME read/process named file\n"
drhcc3b4f82012-02-07 14:13:50 +00007009 " -[no]header turn headers on or off\n"
drh98d312f2012-10-25 15:23:14 +00007010#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
7011 " -heap SIZE Size of heap for memsys3 or memsys5\n"
7012#endif
drhcc3b4f82012-02-07 14:13:50 +00007013 " -help show this message\n"
drhe1e38c42003-05-04 18:30:59 +00007014 " -html set output mode to HTML\n"
drhcc3b4f82012-02-07 14:13:50 +00007015 " -interactive force interactive I/O\n"
drhe1e38c42003-05-04 18:30:59 +00007016 " -line set output mode to 'line'\n"
7017 " -list set output mode to 'list'\n"
drh44dec872014-08-30 15:49:25 +00007018 " -lookaside SIZE N use N entries of SZ bytes for lookaside memory\n"
drh7d9f3942013-04-03 01:26:54 +00007019 " -mmap N default mmap size set to N\n"
drhcc3b4f82012-02-07 14:13:50 +00007020#ifdef SQLITE_ENABLE_MULTIPLEX
7021 " -multiplex enable the multiplexor VFS\n"
7022#endif
mistachkine0d68852014-12-11 03:12:33 +00007023 " -newline SEP set output row separator. Default: '\\n'\n"
drh98d312f2012-10-25 15:23:14 +00007024 " -nullvalue TEXT set text string for NULL values. Default ''\n"
drh44dec872014-08-30 15:49:25 +00007025 " -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n"
7026 " -scratch SIZE N use N slots of SZ bytes each for scratch memory\n"
mistachkine0d68852014-12-11 03:12:33 +00007027 " -separator SEP set output column separator. Default: '|'\n"
shaneh642d8b82010-07-28 16:05:34 +00007028 " -stats print memory stats before each finalize\n"
drhe1e38c42003-05-04 18:30:59 +00007029 " -version show SQLite version\n"
drha7e61d82011-03-12 17:02:57 +00007030 " -vfs NAME use NAME as the default VFS\n"
drh2b625e22011-03-16 17:05:28 +00007031#ifdef SQLITE_ENABLE_VFSTRACE
7032 " -vfstrace enable tracing of all VFS calls\n"
7033#endif
drhe1e38c42003-05-04 18:30:59 +00007034;
7035static void usage(int showDetail){
mistachkinaae280e2015-12-31 19:06:24 +00007036 utf8_printf(stderr,
mistachkin1fe36bb2016-04-04 02:16:44 +00007037 "Usage: %s [OPTIONS] FILENAME [SQL]\n"
drh80e8be92006-08-29 12:04:19 +00007038 "FILENAME is the name of an SQLite database. A new database is created\n"
7039 "if the file does not previously exist.\n", Argv0);
drhe1e38c42003-05-04 18:30:59 +00007040 if( showDetail ){
mistachkinaae280e2015-12-31 19:06:24 +00007041 utf8_printf(stderr, "OPTIONS include:\n%s", zOptions);
drhe1e38c42003-05-04 18:30:59 +00007042 }else{
mistachkinaae280e2015-12-31 19:06:24 +00007043 raw_printf(stderr, "Use the -help option for additional information\n");
drhe1e38c42003-05-04 18:30:59 +00007044 }
7045 exit(1);
7046}
7047
7048/*
drh67505e72002-04-19 12:34:06 +00007049** Initialize the state information in data
7050*/
drhdcd87a92014-08-18 13:45:42 +00007051static void main_init(ShellState *data) {
persicom7e2dfdd2002-04-18 02:46:52 +00007052 memset(data, 0, sizeof(*data));
drh700c2522016-02-09 18:39:25 +00007053 data->normalMode = data->cMode = data->mode = MODE_List;
7054 data->autoExplain = 1;
mistachkinfad42082014-07-24 22:13:12 +00007055 memcpy(data->colSeparator,SEP_Column, 2);
7056 memcpy(data->rowSeparator,SEP_Row, 2);
persicom7e2dfdd2002-04-18 02:46:52 +00007057 data->showHeader = 0;
drh44dec872014-08-30 15:49:25 +00007058 data->shellFlgs = SHFLG_Lookaside;
drh52784bd2011-05-18 17:15:06 +00007059 sqlite3_config(SQLITE_CONFIG_URI, 1);
drh127f9d72010-02-23 01:47:00 +00007060 sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data);
drh44dec872014-08-30 15:49:25 +00007061 sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
drh5bb3eb92007-05-04 13:15:55 +00007062 sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");
7063 sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> ");
persicom7e2dfdd2002-04-18 02:46:52 +00007064}
7065
drh98d312f2012-10-25 15:23:14 +00007066/*
drh5c7976f2014-02-10 19:59:27 +00007067** Output text to the console in a font that attracts extra attention.
drh1247aa42014-02-10 19:27:05 +00007068*/
7069#ifdef _WIN32
drh5c7976f2014-02-10 19:59:27 +00007070static void printBold(const char *zText){
7071 HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
7072 CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo;
7073 GetConsoleScreenBufferInfo(out, &defaultScreenInfo);
7074 SetConsoleTextAttribute(out,
7075 FOREGROUND_RED|FOREGROUND_INTENSITY
7076 );
7077 printf("%s", zText);
7078 SetConsoleTextAttribute(out, defaultScreenInfo.wAttributes);
drh1247aa42014-02-10 19:27:05 +00007079}
7080#else
drh5c7976f2014-02-10 19:59:27 +00007081static void printBold(const char *zText){
7082 printf("\033[1m%s\033[0m", zText);
drh1247aa42014-02-10 19:27:05 +00007083}
7084#endif
7085
7086/*
drh98d312f2012-10-25 15:23:14 +00007087** Get the argument to an --option. Throw an error and die if no argument
7088** is available.
7089*/
7090static char *cmdline_option_value(int argc, char **argv, int i){
7091 if( i==argc ){
mistachkinaae280e2015-12-31 19:06:24 +00007092 utf8_printf(stderr, "%s: Error: missing argument to %s\n",
drh98d312f2012-10-25 15:23:14 +00007093 argv[0], argv[argc-1]);
7094 exit(1);
7095 }
7096 return argv[i];
7097}
7098
mistachkin1fe36bb2016-04-04 02:16:44 +00007099#ifndef SQLITE_SHELL_IS_UTF8
7100# if (defined(_WIN32) || defined(WIN32)) && defined(_MSC_VER)
7101# define SQLITE_SHELL_IS_UTF8 (0)
7102# else
7103# define SQLITE_SHELL_IS_UTF8 (1)
7104# endif
7105#endif
7106
7107#if SQLITE_SHELL_IS_UTF8
mistachkin44723ce2015-03-21 02:22:37 +00007108int SQLITE_CDECL main(int argc, char **argv){
mistachkin1fe36bb2016-04-04 02:16:44 +00007109#else
7110int SQLITE_CDECL wmain(int argc, wchar_t **wargv){
mistachkin1810f222016-04-04 02:33:34 +00007111 char **argv;
mistachkin1fe36bb2016-04-04 02:16:44 +00007112#endif
drh75897232000-05-29 14:26:00 +00007113 char *zErrMsg = 0;
drhdcd87a92014-08-18 13:45:42 +00007114 ShellState data;
drh22fbcb82004-02-01 01:22:50 +00007115 const char *zInitFile = 0;
drh44c2eb12003-04-30 11:38:26 +00007116 int i;
drhc28490c2006-10-26 14:25:58 +00007117 int rc = 0;
drhb3735912014-02-10 16:13:42 +00007118 int warnInmemoryDb = 0;
drhac5649a2014-11-28 13:35:03 +00007119 int readStdin = 1;
7120 int nCmd = 0;
7121 char **azCmd = 0;
drh75897232000-05-29 14:26:00 +00007122
mistachkin1fe36bb2016-04-04 02:16:44 +00007123 setBinaryMode(stdin, 0);
7124 setvbuf(stderr, 0, _IONBF, 0); /* Make sure stderr is unbuffered */
mistachkin1810f222016-04-04 02:33:34 +00007125 stdin_is_interactive = isatty(0);
7126 stdout_is_console = isatty(1);
mistachkin1fe36bb2016-04-04 02:16:44 +00007127
drh69b30ab2014-02-27 15:11:52 +00007128#if USE_SYSTEM_SQLITE+0!=1
drh52784bd2011-05-18 17:15:06 +00007129 if( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)!=0 ){
mistachkinaae280e2015-12-31 19:06:24 +00007130 utf8_printf(stderr, "SQLite header and source version mismatch\n%s\n%s\n",
drh52784bd2011-05-18 17:15:06 +00007131 sqlite3_sourceid(), SQLITE_SOURCE_ID);
7132 exit(1);
7133 }
drhc7181902014-02-27 15:04:13 +00007134#endif
persicom7e2dfdd2002-04-18 02:46:52 +00007135 main_init(&data);
mistachkin1fe36bb2016-04-04 02:16:44 +00007136#if !SQLITE_SHELL_IS_UTF8
7137 sqlite3_initialize();
7138 argv = sqlite3_malloc64(sizeof(argv[0])*argc);
7139 if( argv==0 ){
7140 raw_printf(stderr, "out of memory\n");
7141 exit(1);
7142 }
7143 for(i=0; i<argc; i++){
7144 argv[i] = sqlite3_win32_unicode_to_utf8(wargv[i]);
7145 if( argv[i]==0 ){
7146 raw_printf(stderr, "out of memory\n");
7147 exit(1);
7148 }
7149 }
7150#endif
mistachkin1810f222016-04-04 02:33:34 +00007151 assert( argc>=1 && argv && argv[0] );
mistachkin1fe36bb2016-04-04 02:16:44 +00007152 Argv0 = argv[0];
persicom7e2dfdd2002-04-18 02:46:52 +00007153
drh44c2eb12003-04-30 11:38:26 +00007154 /* Make sure we have a valid signal handler early, before anything
7155 ** else is done.
7156 */
drh4c504392000-10-16 22:06:40 +00007157#ifdef SIGINT
7158 signal(SIGINT, interrupt_handler);
7159#endif
drh44c2eb12003-04-30 11:38:26 +00007160
drhac5649a2014-11-28 13:35:03 +00007161#ifdef SQLITE_SHELL_DBNAME_PROC
7162 {
7163 /* If the SQLITE_SHELL_DBNAME_PROC macro is defined, then it is the name
7164 ** of a C-function that will provide the name of the database file. Use
7165 ** this compile-time option to embed this shell program in larger
7166 ** applications. */
7167 extern void SQLITE_SHELL_DBNAME_PROC(const char**);
7168 SQLITE_SHELL_DBNAME_PROC(&data.zDbFilename);
7169 warnInmemoryDb = 0;
7170 }
7171#endif
7172
drh22fbcb82004-02-01 01:22:50 +00007173 /* Do an initial pass through the command-line argument to locate
7174 ** the name of the database file, the name of the initialization file,
drh9c88d682010-12-17 14:03:01 +00007175 ** the size of the alternative malloc heap,
drh22fbcb82004-02-01 01:22:50 +00007176 ** and the first command to execute.
drh44c2eb12003-04-30 11:38:26 +00007177 */
drh98d312f2012-10-25 15:23:14 +00007178 for(i=1; i<argc; i++){
drhc28490c2006-10-26 14:25:58 +00007179 char *z;
drhc28490c2006-10-26 14:25:58 +00007180 z = argv[i];
drh98d312f2012-10-25 15:23:14 +00007181 if( z[0]!='-' ){
7182 if( data.zDbFilename==0 ){
7183 data.zDbFilename = z;
drhac5649a2014-11-28 13:35:03 +00007184 }else{
7185 /* Excesss arguments are interpreted as SQL (or dot-commands) and
7186 ** mean that nothing is read from stdin */
7187 readStdin = 0;
7188 nCmd++;
7189 azCmd = realloc(azCmd, sizeof(azCmd[0])*nCmd);
7190 if( azCmd==0 ){
mistachkinaae280e2015-12-31 19:06:24 +00007191 raw_printf(stderr, "out of memory\n");
drhac5649a2014-11-28 13:35:03 +00007192 exit(1);
7193 }
7194 azCmd[nCmd-1] = z;
drh98d312f2012-10-25 15:23:14 +00007195 }
drh98d312f2012-10-25 15:23:14 +00007196 }
drhcc3b4f82012-02-07 14:13:50 +00007197 if( z[1]=='-' ) z++;
7198 if( strcmp(z,"-separator")==0
7199 || strcmp(z,"-nullvalue")==0
drh6976c212014-07-24 12:09:47 +00007200 || strcmp(z,"-newline")==0
drhcc3b4f82012-02-07 14:13:50 +00007201 || strcmp(z,"-cmd")==0
7202 ){
drh98d312f2012-10-25 15:23:14 +00007203 (void)cmdline_option_value(argc, argv, ++i);
drhcc3b4f82012-02-07 14:13:50 +00007204 }else if( strcmp(z,"-init")==0 ){
drh98d312f2012-10-25 15:23:14 +00007205 zInitFile = cmdline_option_value(argc, argv, ++i);
drhcc3b4f82012-02-07 14:13:50 +00007206 }else if( strcmp(z,"-batch")==0 ){
drh98d312f2012-10-25 15:23:14 +00007207 /* Need to check for batch mode here to so we can avoid printing
mistachkin1fe36bb2016-04-04 02:16:44 +00007208 ** informational messages (like from process_sqliterc) before
drh98d312f2012-10-25 15:23:14 +00007209 ** we do the actual processing of arguments later in a second pass.
7210 */
shanef69573d2009-10-24 02:06:14 +00007211 stdin_is_interactive = 0;
drhcc3b4f82012-02-07 14:13:50 +00007212 }else if( strcmp(z,"-heap")==0 ){
drhb07028f2011-10-14 21:49:18 +00007213#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
drh9c88d682010-12-17 14:03:01 +00007214 const char *zSize;
7215 sqlite3_int64 szHeap;
7216
drh98d312f2012-10-25 15:23:14 +00007217 zSize = cmdline_option_value(argc, argv, ++i);
drh7d9f3942013-04-03 01:26:54 +00007218 szHeap = integerValue(zSize);
drh9c88d682010-12-17 14:03:01 +00007219 if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000;
drh9c88d682010-12-17 14:03:01 +00007220 sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64);
drhc530b9c2016-07-25 11:27:22 +00007221#else
7222 (void)cmdline_option_value(argc, argv, ++i);
drh9c88d682010-12-17 14:03:01 +00007223#endif
drh44dec872014-08-30 15:49:25 +00007224 }else if( strcmp(z,"-scratch")==0 ){
7225 int n, sz;
mistachkin31970cc2014-09-01 01:16:49 +00007226 sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
drh44dec872014-08-30 15:49:25 +00007227 if( sz>400000 ) sz = 400000;
7228 if( sz<2500 ) sz = 2500;
mistachkin31970cc2014-09-01 01:16:49 +00007229 n = (int)integerValue(cmdline_option_value(argc,argv,++i));
drh44dec872014-08-30 15:49:25 +00007230 if( n>10 ) n = 10;
7231 if( n<1 ) n = 1;
7232 sqlite3_config(SQLITE_CONFIG_SCRATCH, malloc(n*sz+1), sz, n);
7233 data.shellFlgs |= SHFLG_Scratch;
7234 }else if( strcmp(z,"-pagecache")==0 ){
7235 int n, sz;
mistachkin31970cc2014-09-01 01:16:49 +00007236 sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
drh44dec872014-08-30 15:49:25 +00007237 if( sz>70000 ) sz = 70000;
drh3d38cec2015-11-11 15:28:52 +00007238 if( sz<0 ) sz = 0;
mistachkin31970cc2014-09-01 01:16:49 +00007239 n = (int)integerValue(cmdline_option_value(argc,argv,++i));
drh3d38cec2015-11-11 15:28:52 +00007240 sqlite3_config(SQLITE_CONFIG_PAGECACHE,
7241 (n>0 && sz>0) ? malloc(n*sz) : 0, sz, n);
drh44dec872014-08-30 15:49:25 +00007242 data.shellFlgs |= SHFLG_Pagecache;
7243 }else if( strcmp(z,"-lookaside")==0 ){
7244 int n, sz;
mistachkin31970cc2014-09-01 01:16:49 +00007245 sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
drh44dec872014-08-30 15:49:25 +00007246 if( sz<0 ) sz = 0;
mistachkin31970cc2014-09-01 01:16:49 +00007247 n = (int)integerValue(cmdline_option_value(argc,argv,++i));
drh44dec872014-08-30 15:49:25 +00007248 if( n<0 ) n = 0;
7249 sqlite3_config(SQLITE_CONFIG_LOOKASIDE, sz, n);
7250 if( sz*n==0 ) data.shellFlgs &= ~SHFLG_Lookaside;
drh97ae8ff2011-03-16 16:56:29 +00007251#ifdef SQLITE_ENABLE_VFSTRACE
drhcc3b4f82012-02-07 14:13:50 +00007252 }else if( strcmp(z,"-vfstrace")==0 ){
drh97ae8ff2011-03-16 16:56:29 +00007253 extern int vfstrace_register(
7254 const char *zTraceName,
7255 const char *zOldVfsName,
7256 int (*xOut)(const char*,void*),
7257 void *pOutArg,
7258 int makeDefault
7259 );
drh2b625e22011-03-16 17:05:28 +00007260 vfstrace_register("trace",0,(int(*)(const char*,void*))fputs,stderr,1);
drh97ae8ff2011-03-16 16:56:29 +00007261#endif
drh6f25e892011-07-08 17:02:57 +00007262#ifdef SQLITE_ENABLE_MULTIPLEX
drhcc3b4f82012-02-07 14:13:50 +00007263 }else if( strcmp(z,"-multiplex")==0 ){
drh6f25e892011-07-08 17:02:57 +00007264 extern int sqlite3_multiple_initialize(const char*,int);
7265 sqlite3_multiplex_initialize(0, 1);
7266#endif
drh7d9f3942013-04-03 01:26:54 +00007267 }else if( strcmp(z,"-mmap")==0 ){
drh9b4c59f2013-04-15 17:03:42 +00007268 sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));
7269 sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz);
drhcc3b4f82012-02-07 14:13:50 +00007270 }else if( strcmp(z,"-vfs")==0 ){
drh98d312f2012-10-25 15:23:14 +00007271 sqlite3_vfs *pVfs = sqlite3_vfs_find(cmdline_option_value(argc,argv,++i));
drha7e61d82011-03-12 17:02:57 +00007272 if( pVfs ){
7273 sqlite3_vfs_register(pVfs, 1);
7274 }else{
mistachkinaae280e2015-12-31 19:06:24 +00007275 utf8_printf(stderr, "no such VFS: \"%s\"\n", argv[i]);
drha7e61d82011-03-12 17:02:57 +00007276 exit(1);
7277 }
drh44c2eb12003-04-30 11:38:26 +00007278 }
7279 }
drh98d312f2012-10-25 15:23:14 +00007280 if( data.zDbFilename==0 ){
danielk197703aded42004-11-22 05:26:27 +00007281#ifndef SQLITE_OMIT_MEMORYDB
drh22fbcb82004-02-01 01:22:50 +00007282 data.zDbFilename = ":memory:";
drh1247aa42014-02-10 19:27:05 +00007283 warnInmemoryDb = argc==1;
danielk197703aded42004-11-22 05:26:27 +00007284#else
mistachkinaae280e2015-12-31 19:06:24 +00007285 utf8_printf(stderr,"%s: Error: no database filename specified\n", Argv0);
shane86f5bdb2009-10-24 02:00:07 +00007286 return 1;
drh01b41712005-08-29 23:06:23 +00007287#endif
drh98d312f2012-10-25 15:23:14 +00007288 }
7289 data.out = stdout;
drh01b41712005-08-29 23:06:23 +00007290
drh44c2eb12003-04-30 11:38:26 +00007291 /* Go ahead and open the database file if it already exists. If the
7292 ** file does not exist, delay opening it. This prevents empty database
7293 ** files from being created if a user mistypes the database name argument
7294 ** to the sqlite command-line tool.
7295 */
drhc8d74412004-08-31 23:41:26 +00007296 if( access(data.zDbFilename, 0)==0 ){
drh05782482013-10-24 15:20:20 +00007297 open_db(&data, 0);
drh44c2eb12003-04-30 11:38:26 +00007298 }
7299
drh22fbcb82004-02-01 01:22:50 +00007300 /* Process the initialization file if there is one. If no -init option
7301 ** is given on the command line, look for a file named ~/.sqliterc and
7302 ** try to process it.
drh44c2eb12003-04-30 11:38:26 +00007303 */
drh534f4df2015-02-28 14:03:35 +00007304 process_sqliterc(&data,zInitFile);
drh44c2eb12003-04-30 11:38:26 +00007305
drh22fbcb82004-02-01 01:22:50 +00007306 /* Make a second pass through the command-line argument and set
7307 ** options. This second pass is delayed until after the initialization
7308 ** file is processed so that the command-line arguments will override
7309 ** settings in the initialization file.
drh44c2eb12003-04-30 11:38:26 +00007310 */
drh98d312f2012-10-25 15:23:14 +00007311 for(i=1; i<argc; i++){
drh22fbcb82004-02-01 01:22:50 +00007312 char *z = argv[i];
drh98d312f2012-10-25 15:23:14 +00007313 if( z[0]!='-' ) continue;
drhc28490c2006-10-26 14:25:58 +00007314 if( z[1]=='-' ){ z++; }
drh2e584cd2006-09-25 13:09:22 +00007315 if( strcmp(z,"-init")==0 ){
drh22fbcb82004-02-01 01:22:50 +00007316 i++;
7317 }else if( strcmp(z,"-html")==0 ){
drh1e5d0e92000-05-31 23:33:17 +00007318 data.mode = MODE_Html;
drh22fbcb82004-02-01 01:22:50 +00007319 }else if( strcmp(z,"-list")==0 ){
drh1e5d0e92000-05-31 23:33:17 +00007320 data.mode = MODE_List;
drh22fbcb82004-02-01 01:22:50 +00007321 }else if( strcmp(z,"-line")==0 ){
drh1e5d0e92000-05-31 23:33:17 +00007322 data.mode = MODE_Line;
drh22fbcb82004-02-01 01:22:50 +00007323 }else if( strcmp(z,"-column")==0 ){
drh8b32e172002-04-08 02:42:57 +00007324 data.mode = MODE_Column;
drhc49f44e2006-10-26 18:15:42 +00007325 }else if( strcmp(z,"-csv")==0 ){
7326 data.mode = MODE_Csv;
mistachkin636bf9f2014-07-19 20:15:16 +00007327 memcpy(data.colSeparator,",",2);
7328 }else if( strcmp(z,"-ascii")==0 ){
7329 data.mode = MODE_Ascii;
7330 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
mistachkinfad42082014-07-24 22:13:12 +00007331 SEP_Unit);
mistachkin636bf9f2014-07-19 20:15:16 +00007332 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
mistachkinfad42082014-07-24 22:13:12 +00007333 SEP_Record);
drh22fbcb82004-02-01 01:22:50 +00007334 }else if( strcmp(z,"-separator")==0 ){
mistachkin636bf9f2014-07-19 20:15:16 +00007335 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
drh98d312f2012-10-25 15:23:14 +00007336 "%s",cmdline_option_value(argc,argv,++i));
drh6976c212014-07-24 12:09:47 +00007337 }else if( strcmp(z,"-newline")==0 ){
mistachkine0d68852014-12-11 03:12:33 +00007338 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
drh6976c212014-07-24 12:09:47 +00007339 "%s",cmdline_option_value(argc,argv,++i));
drh22fbcb82004-02-01 01:22:50 +00007340 }else if( strcmp(z,"-nullvalue")==0 ){
mistachkin44b99f72014-12-11 03:29:14 +00007341 sqlite3_snprintf(sizeof(data.nullValue), data.nullValue,
drh98d312f2012-10-25 15:23:14 +00007342 "%s",cmdline_option_value(argc,argv,++i));
drh22fbcb82004-02-01 01:22:50 +00007343 }else if( strcmp(z,"-header")==0 ){
drh1e5d0e92000-05-31 23:33:17 +00007344 data.showHeader = 1;
drh22fbcb82004-02-01 01:22:50 +00007345 }else if( strcmp(z,"-noheader")==0 ){
drh1e5d0e92000-05-31 23:33:17 +00007346 data.showHeader = 0;
drh22fbcb82004-02-01 01:22:50 +00007347 }else if( strcmp(z,"-echo")==0 ){
drhe6e1d122017-03-09 13:50:49 +00007348 ShellSetFlag(&data, SHFLG_Echo);
drhefbf3b12014-02-28 20:47:24 +00007349 }else if( strcmp(z,"-eqp")==0 ){
7350 data.autoEQP = 1;
drheacd29d2016-04-15 15:03:27 +00007351 }else if( strcmp(z,"-eqpfull")==0 ){
7352 data.autoEQP = 2;
shaneh642d8b82010-07-28 16:05:34 +00007353 }else if( strcmp(z,"-stats")==0 ){
7354 data.statsOn = 1;
dan8d1edb92014-11-05 09:07:28 +00007355 }else if( strcmp(z,"-scanstats")==0 ){
7356 data.scanstatsOn = 1;
drh9569f602015-04-16 15:05:04 +00007357 }else if( strcmp(z,"-backslash")==0 ){
7358 /* Undocumented command-line option: -backslash
7359 ** Causes C-style backslash escapes to be evaluated in SQL statements
7360 ** prior to sending the SQL into SQLite. Useful for injecting
7361 ** crazy bytes in the middle of SQL statements for testing and debugging.
7362 */
drhe6e1d122017-03-09 13:50:49 +00007363 ShellSetFlag(&data, SHFLG_Backslash);
drhc49f44e2006-10-26 18:15:42 +00007364 }else if( strcmp(z,"-bail")==0 ){
7365 bail_on_error = 1;
drh22fbcb82004-02-01 01:22:50 +00007366 }else if( strcmp(z,"-version")==0 ){
drh9fd301b2011-06-03 13:28:22 +00007367 printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
drh151e3e12006-06-06 12:32:21 +00007368 return 0;
drhc28490c2006-10-26 14:25:58 +00007369 }else if( strcmp(z,"-interactive")==0 ){
7370 stdin_is_interactive = 1;
7371 }else if( strcmp(z,"-batch")==0 ){
7372 stdin_is_interactive = 0;
drh9c88d682010-12-17 14:03:01 +00007373 }else if( strcmp(z,"-heap")==0 ){
7374 i++;
drh44dec872014-08-30 15:49:25 +00007375 }else if( strcmp(z,"-scratch")==0 ){
7376 i+=2;
7377 }else if( strcmp(z,"-pagecache")==0 ){
7378 i+=2;
7379 }else if( strcmp(z,"-lookaside")==0 ){
7380 i+=2;
drh7d9f3942013-04-03 01:26:54 +00007381 }else if( strcmp(z,"-mmap")==0 ){
7382 i++;
drha7e61d82011-03-12 17:02:57 +00007383 }else if( strcmp(z,"-vfs")==0 ){
7384 i++;
drh6f25e892011-07-08 17:02:57 +00007385#ifdef SQLITE_ENABLE_VFSTRACE
drh97ae8ff2011-03-16 16:56:29 +00007386 }else if( strcmp(z,"-vfstrace")==0 ){
7387 i++;
drh6f25e892011-07-08 17:02:57 +00007388#endif
7389#ifdef SQLITE_ENABLE_MULTIPLEX
7390 }else if( strcmp(z,"-multiplex")==0 ){
7391 i++;
7392#endif
drhcc3b4f82012-02-07 14:13:50 +00007393 }else if( strcmp(z,"-help")==0 ){
drhe1e38c42003-05-04 18:30:59 +00007394 usage(1);
drhcc3b4f82012-02-07 14:13:50 +00007395 }else if( strcmp(z,"-cmd")==0 ){
drhac5649a2014-11-28 13:35:03 +00007396 /* Run commands that follow -cmd first and separately from commands
7397 ** that simply appear on the command-line. This seems goofy. It would
7398 ** be better if all commands ran in the order that they appear. But
7399 ** we retain the goofy behavior for historical compatibility. */
drhcc3b4f82012-02-07 14:13:50 +00007400 if( i==argc-1 ) break;
drh98d312f2012-10-25 15:23:14 +00007401 z = cmdline_option_value(argc,argv,++i);
drhcc3b4f82012-02-07 14:13:50 +00007402 if( z[0]=='.' ){
7403 rc = do_meta_command(z, &data);
drh99b39082013-04-17 12:19:48 +00007404 if( rc && bail_on_error ) return rc==2 ? 0 : rc;
drhcc3b4f82012-02-07 14:13:50 +00007405 }else{
drh05782482013-10-24 15:20:20 +00007406 open_db(&data, 0);
drhcc3b4f82012-02-07 14:13:50 +00007407 rc = shell_exec(data.db, z, shell_callback, &data, &zErrMsg);
7408 if( zErrMsg!=0 ){
mistachkinaae280e2015-12-31 19:06:24 +00007409 utf8_printf(stderr,"Error: %s\n", zErrMsg);
drhcc3b4f82012-02-07 14:13:50 +00007410 if( bail_on_error ) return rc!=0 ? rc : 1;
7411 }else if( rc!=0 ){
mistachkinaae280e2015-12-31 19:06:24 +00007412 utf8_printf(stderr,"Error: unable to process SQL \"%s\"\n", z);
drhcc3b4f82012-02-07 14:13:50 +00007413 if( bail_on_error ) return rc;
7414 }
7415 }
drh1e5d0e92000-05-31 23:33:17 +00007416 }else{
mistachkinaae280e2015-12-31 19:06:24 +00007417 utf8_printf(stderr,"%s: Error: unknown option: %s\n", Argv0, z);
7418 raw_printf(stderr,"Use -help for a list of options.\n");
drh1e5d0e92000-05-31 23:33:17 +00007419 return 1;
7420 }
drh700c2522016-02-09 18:39:25 +00007421 data.cMode = data.mode;
drh1e5d0e92000-05-31 23:33:17 +00007422 }
drh44c2eb12003-04-30 11:38:26 +00007423
drhac5649a2014-11-28 13:35:03 +00007424 if( !readStdin ){
7425 /* Run all arguments that do not begin with '-' as if they were separate
7426 ** command-line inputs, except for the argToSkip argument which contains
7427 ** the database filename.
drh44c2eb12003-04-30 11:38:26 +00007428 */
drhac5649a2014-11-28 13:35:03 +00007429 for(i=0; i<nCmd; i++){
7430 if( azCmd[i][0]=='.' ){
7431 rc = do_meta_command(azCmd[i], &data);
7432 if( rc ) return rc==2 ? 0 : rc;
7433 }else{
7434 open_db(&data, 0);
7435 rc = shell_exec(data.db, azCmd[i], shell_callback, &data, &zErrMsg);
7436 if( zErrMsg!=0 ){
mistachkinaae280e2015-12-31 19:06:24 +00007437 utf8_printf(stderr,"Error: %s\n", zErrMsg);
drhac5649a2014-11-28 13:35:03 +00007438 return rc!=0 ? rc : 1;
7439 }else if( rc!=0 ){
mistachkinaae280e2015-12-31 19:06:24 +00007440 utf8_printf(stderr,"Error: unable to process SQL: %s\n", azCmd[i]);
drhac5649a2014-11-28 13:35:03 +00007441 return rc;
7442 }
drh6ff13852001-11-25 13:18:23 +00007443 }
drh75897232000-05-29 14:26:00 +00007444 }
drhac5649a2014-11-28 13:35:03 +00007445 free(azCmd);
drh75897232000-05-29 14:26:00 +00007446 }else{
drh44c2eb12003-04-30 11:38:26 +00007447 /* Run commands received from standard input
7448 */
drhc28490c2006-10-26 14:25:58 +00007449 if( stdin_is_interactive ){
drh67505e72002-04-19 12:34:06 +00007450 char *zHome;
7451 char *zHistory = 0;
drh5bb3eb92007-05-04 13:15:55 +00007452 int nHistory;
drh75897232000-05-29 14:26:00 +00007453 printf(
drh743e0032011-12-12 16:51:50 +00007454 "SQLite version %s %.19s\n" /*extra-version-info*/
drh1247aa42014-02-10 19:27:05 +00007455 "Enter \".help\" for usage hints.\n",
drh9fd301b2011-06-03 13:28:22 +00007456 sqlite3_libversion(), sqlite3_sourceid()
drh75897232000-05-29 14:26:00 +00007457 );
drhb3735912014-02-10 16:13:42 +00007458 if( warnInmemoryDb ){
drh1247aa42014-02-10 19:27:05 +00007459 printf("Connected to a ");
mistachkin378d01a2014-03-06 02:15:42 +00007460 printBold("transient in-memory database");
7461 printf(".\nUse \".open FILENAME\" to reopen on a "
drh1247aa42014-02-10 19:27:05 +00007462 "persistent database.\n");
drhb3735912014-02-10 16:13:42 +00007463 }
drhd1459152016-09-16 19:11:03 +00007464 zHome = find_home_dir(0);
drhea678832008-12-10 19:26:22 +00007465 if( zHome ){
drh4f21c4a2008-12-10 22:15:00 +00007466 nHistory = strlen30(zHome) + 20;
drhea678832008-12-10 19:26:22 +00007467 if( (zHistory = malloc(nHistory))!=0 ){
7468 sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
7469 }
drh67505e72002-04-19 12:34:06 +00007470 }
drhf5ed7ad2015-06-15 14:43:25 +00007471 if( zHistory ){ shell_read_history(zHistory); }
drhc28490c2006-10-26 14:25:58 +00007472 rc = process_input(&data, 0);
drh67505e72002-04-19 12:34:06 +00007473 if( zHistory ){
danfd34d6d2015-02-25 10:54:53 +00007474 shell_stifle_history(100);
7475 shell_write_history(zHistory);
adamd0a3daa32006-07-28 20:16:14 +00007476 free(zHistory);
drh67505e72002-04-19 12:34:06 +00007477 }
drhdaffd0e2001-04-11 14:28:42 +00007478 }else{
drhc28490c2006-10-26 14:25:58 +00007479 rc = process_input(&data, stdin);
drh75897232000-05-29 14:26:00 +00007480 }
7481 }
drh33048c02001-10-01 14:29:22 +00007482 set_table_name(&data, 0);
drh72af0772010-05-06 20:19:55 +00007483 if( data.db ){
drhe6229612014-08-18 15:08:26 +00007484 session_close_all(&data);
drhe14cd932010-12-08 03:28:17 +00007485 sqlite3_close(data.db);
adamd0a3daa32006-07-28 20:16:14 +00007486 }
mistachkin1fe36bb2016-04-04 02:16:44 +00007487 sqlite3_free(data.zFreeOnClose);
drhd1459152016-09-16 19:11:03 +00007488 find_home_dir(1);
mistachkin1fe36bb2016-04-04 02:16:44 +00007489#if !SQLITE_SHELL_IS_UTF8
7490 for(i=0; i<argc; i++) sqlite3_free(argv[i]);
7491 sqlite3_free(argv);
7492#endif
drhc28490c2006-10-26 14:25:58 +00007493 return rc;
drh75897232000-05-29 14:26:00 +00007494}