/*

** 2001 September 15

**

** The author disclaims copyright to this source code. In place of

** a legal notice, here is a blessing:

**

** May you do good and not evil.

** May you find forgiveness for yourself and forgive others.

** May you share freely, never taking more than you give.

**

*************************************************************************

** This file contains code to implement the "sqlite" command line

** utility for accessing SQLite databases.

*/

#if (defined(_WIN32) || defined(WIN32)) && !defined(_CRT_SECURE_NO_WARNINGS)

/* This needs to come before any includes for MSVC compiler */

#define _CRT_SECURE_NO_WARNINGS

#endif

/*

** Warning pragmas copied from msvc.h in the core.

*/

#if defined(_MSC_VER)

#pragma warning(disable : 4054)

#pragma warning(disable : 4055)

#pragma warning(disable : 4100)

#pragma warning(disable : 4127)

#pragma warning(disable : 4130)

#pragma warning(disable : 4152)

#pragma warning(disable : 4189)

#pragma warning(disable : 4206)

#pragma warning(disable : 4210)

#pragma warning(disable : 4232)

#pragma warning(disable : 4244)

#pragma warning(disable : 4305)

#pragma warning(disable : 4306)

#pragma warning(disable : 4702)

#pragma warning(disable : 4706)

#endif /* defined(_MSC_VER) */

/*

** No support for loadable extensions in VxWorks.

*/

#if (defined(__RTP__) || defined(_WRS_KERNEL)) && !SQLITE_OMIT_LOAD_EXTENSION

# define SQLITE_OMIT_LOAD_EXTENSION 1

#endif

/*

** Enable large-file support for fopen() and friends on unix.

*/

#ifndef SQLITE_DISABLE_LFS

# define _LARGE_FILE 1

# ifndef _FILE_OFFSET_BITS

# define _FILE_OFFSET_BITS 64

# endif

# define _LARGEFILE_SOURCE 1

#endif

#include <stdlib.h>

#include <string.h>

#include <stdio.h>

#include <assert.h>

#include "sqlite3.h"

#if SQLITE_USER_AUTHENTICATION

# include "sqlite3userauth.h"

#endif

#include <ctype.h>

#include <stdarg.h>

#if !defined(_WIN32) && !defined(WIN32)

# include <signal.h>

# if !defined(__RTP__) && !defined(_WRS_KERNEL)

# include <pwd.h>

# endif

# include <unistd.h>

# include <sys/types.h>

#endif

#if HAVE_READLINE

# include <readline/readline.h>

# include <readline/history.h>

#endif

#if HAVE_EDITLINE

# include <editline/readline.h>

#endif

#if HAVE_EDITLINE || HAVE_READLINE

# define shell_add_history(X) add_history(X)

# define shell_read_history(X) read_history(X)

# define shell_write_history(X) write_history(X)

# define shell_stifle_history(X) stifle_history(X)

# define shell_readline(X) readline(X)

#elif HAVE_LINENOISE

# include "linenoise.h"

# define shell_add_history(X) linenoiseHistoryAdd(X)

# define shell_read_history(X) linenoiseHistoryLoad(X)

# define shell_write_history(X) linenoiseHistorySave(X)

# define shell_stifle_history(X) linenoiseHistorySetMaxLen(X)

# define shell_readline(X) linenoise(X)

#else

# define shell_read_history(X)

# define shell_write_history(X)

# define shell_stifle_history(X)

# define SHELL_USE_LOCAL_GETLINE 1

#endif

#if defined(_WIN32) || defined(WIN32)

# include <io.h>

# include <fcntl.h>

# define isatty(h) _isatty(h)

# ifndef access

# define access(f,m) _access((f),(m))

# endif

# undef popen

# define popen _popen

# undef pclose

# define pclose _pclose

#else

/* Make sure isatty() has a prototype. */

extern int isatty(int);

# if !defined(__RTP__) && !defined(_WRS_KERNEL)

/* popen and pclose are not C89 functions and so are

** sometimes omitted from the <stdio.h> header */

extern FILE *popen(const char*,const char*);

extern int pclose(FILE*);

# else

# define SQLITE_OMIT_POPEN 1

# endif

#endif

#if defined(_WIN32_WCE)

/* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty()

* thus we always assume that we have a console. That can be

* overridden with the -batch command line option.

*/

#define isatty(x) 1

#endif

/* ctype macros that work with signed characters */

#define IsSpace(X) isspace((unsigned char)X)

#define IsDigit(X) isdigit((unsigned char)X)

#define ToLower(X) (char)tolower((unsigned char)X)

#if defined(_WIN32) || defined(WIN32)

#include <windows.h>

/* string conversion routines only needed on Win32 */

extern char *sqlite3_win32_unicode_to_utf8(LPCWSTR);

extern char *sqlite3_win32_mbcs_to_utf8_v2(const char *, int);

extern char *sqlite3_win32_utf8_to_mbcs_v2(const char *, int);

extern LPWSTR sqlite3_win32_utf8_to_unicode(const char *zText);

#endif

/* On Windows, we normally run with output mode of TEXT so that \n characters

** are automatically translated into \r\n. However, this behavior needs

** to be disabled in some cases (ex: when generating CSV output and when

** rendering quoted strings that contain \n characters). The following

** routines take care of that.

*/

#if defined(_WIN32) || defined(WIN32)

static void setBinaryMode(FILE *file, int isOutput){

if( isOutput ) fflush(file);

_setmode(_fileno(file), _O_BINARY);

}

static void setTextMode(FILE *file, int isOutput){

if( isOutput ) fflush(file);

_setmode(_fileno(file), _O_TEXT);

}

#else

# define setBinaryMode(X,Y)

# define setTextMode(X,Y)

#endif

/* True if the timer is enabled */

static int enableTimer = 0;

/* Return the current wall-clock time */

static sqlite3_int64 timeOfDay(void){

static sqlite3_vfs *clockVfs = 0;

sqlite3_int64 t;

if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0);

if( clockVfs->iVersion>=2 && clockVfs->xCurrentTimeInt64!=0 ){

clockVfs->xCurrentTimeInt64(clockVfs, &t);

}else{

double r;

clockVfs->xCurrentTime(clockVfs, &r);

t = (sqlite3_int64)(r*86400000.0);

}

return t;

}

#if !defined(_WIN32) && !defined(WIN32) && !defined(__minux)

#include <sys/time.h>

#include <sys/resource.h>

/* VxWorks does not support getrusage() as far as we can determine */

#if defined(_WRS_KERNEL) || defined(__RTP__)

struct rusage {

struct timeval ru_utime; /* user CPU time used */

struct timeval ru_stime; /* system CPU time used */

};

#define getrusage(A,B) memset(B,0,sizeof(*B))

#endif

/* Saved resource information for the beginning of an operation */

static struct rusage sBegin; /* CPU time at start */

static sqlite3_int64 iBegin; /* Wall-clock time at start */

/*

** Begin timing an operation

*/

static void beginTimer(void){

if( enableTimer ){

getrusage(RUSAGE_SELF, &sBegin);

iBegin = timeOfDay();

}

}

/* Return the difference of two time_structs in seconds */

static double timeDiff(struct timeval *pStart, struct timeval *pEnd){

return (pEnd->tv_usec - pStart->tv_usec)*0.000001 +

(double)(pEnd->tv_sec - pStart->tv_sec);

}

/*

** Print the timing results.

*/

static void endTimer(void){

if( enableTimer ){

sqlite3_int64 iEnd = timeOfDay();

struct rusage sEnd;

getrusage(RUSAGE_SELF, &sEnd);

printf("Run Time: real %.3f user %f sys %f\n",

(iEnd - iBegin)*0.001,

timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),

timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));

}

}

#define BEGIN_TIMER beginTimer()

#define END_TIMER endTimer()

#define HAS_TIMER 1

#elif (defined(_WIN32) || defined(WIN32))

/* Saved resource information for the beginning of an operation */

static HANDLE hProcess;

static FILETIME ftKernelBegin;

static FILETIME ftUserBegin;

static sqlite3_int64 ftWallBegin;

typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME,

LPFILETIME, LPFILETIME);

static GETPROCTIMES getProcessTimesAddr = NULL;

/*

** Check to see if we have timer support. Return 1 if necessary

** support found (or found previously).

*/

static int hasTimer(void){

if( getProcessTimesAddr ){

return 1;

} else {

/* GetProcessTimes() isn't supported in WIN95 and some other Windows

** versions. See if the version we are running on has it, and if it

** does, save off a pointer to it and the current process handle.

*/

hProcess = GetCurrentProcess();

if( hProcess ){

HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll"));

if( NULL != hinstLib ){

getProcessTimesAddr =

(GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes");

if( NULL != getProcessTimesAddr ){

return 1;

}

FreeLibrary(hinstLib);

}

}

}

return 0;

}

/*

** Begin timing an operation

*/

static void beginTimer(void){

if( enableTimer && getProcessTimesAddr ){

FILETIME ftCreation, ftExit;

getProcessTimesAddr(hProcess,&ftCreation,&ftExit,

&ftKernelBegin,&ftUserBegin);

ftWallBegin = timeOfDay();

}

}

/* Return the difference of two FILETIME structs in seconds */

static double timeDiff(FILETIME *pStart, FILETIME *pEnd){

sqlite_int64 i64Start = *((sqlite_int64 *) pStart);

sqlite_int64 i64End = *((sqlite_int64 *) pEnd);

return (double) ((i64End - i64Start) / 10000000.0);

}

/*

** Print the timing results.

*/

static void endTimer(void){

if( enableTimer && getProcessTimesAddr){

FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd;

sqlite3_int64 ftWallEnd = timeOfDay();

getProcessTimesAddr(hProcess,&ftCreation,&ftExit,&ftKernelEnd,&ftUserEnd);

printf("Run Time: real %.3f user %f sys %f\n",

(ftWallEnd - ftWallBegin)*0.001,

timeDiff(&ftUserBegin, &ftUserEnd),

timeDiff(&ftKernelBegin, &ftKernelEnd));

}

}

#define BEGIN_TIMER beginTimer()

#define END_TIMER endTimer()

#define HAS_TIMER hasTimer()

#else

#define BEGIN_TIMER

#define END_TIMER

#define HAS_TIMER 0

#endif

/*

** Used to prevent warnings about unused parameters

*/

#define UNUSED_PARAMETER(x) (void)(x)

/*

** If the following flag is set, then command execution stops

** at an error if we are not interactive.

*/

static int bail_on_error = 0;

/*

** Threat stdin as an interactive input if the following variable

** is true. Otherwise, assume stdin is connected to a file or pipe.

*/

static int stdin_is_interactive = 1;

/*

** On Windows systems we have to know if standard output is a console

** in order to translate UTF-8 into MBCS. The following variable is

** true if translation is required.

*/

static int stdout_is_console = 1;

/*

** The following is the open SQLite database. We make a pointer

** to this database a static variable so that it can be accessed

** by the SIGINT handler to interrupt database processing.

*/

static sqlite3 *globalDb = 0;

/*

** True if an interrupt (Control-C) has been received.

*/

static volatile int seenInterrupt = 0;

/*

** This is the name of our program. It is set in main(), used

** in a number of other places, mostly for error messages.

*/

static char *Argv0;

/*

** Prompt strings. Initialized in main. Settable with

** .prompt main continue

*/

static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/

static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */

/*

** Render output like fprintf(). Except, if the output is going to the

** console and if this is running on a Windows machine, translate the

** output from UTF-8 into MBCS.

*/

#if defined(_WIN32) || defined(WIN32)

void utf8_printf(FILE *out, const char *zFormat, ...){

va_list ap;

va_start(ap, zFormat);

if( stdout_is_console && (out==stdout || out==stderr) ){

char *z1 = sqlite3_vmprintf(zFormat, ap);

char *z2 = sqlite3_win32_utf8_to_mbcs_v2(z1, 0);

sqlite3_free(z1);

fputs(z2, out);

sqlite3_free(z2);

}else{

vfprintf(out, zFormat, ap);

}

va_end(ap);

}

#elif !defined(utf8_printf)

# define utf8_printf fprintf

#endif

/*

** Render output like fprintf(). This should not be used on anything that

** includes string formatting (e.g. "%s").

*/

#if !defined(raw_printf)

# define raw_printf fprintf

#endif

/*

** Write I/O traces to the following stream.

*/

#ifdef SQLITE_ENABLE_IOTRACE

static FILE *iotrace = 0;

#endif

/*

** This routine works like printf in that its first argument is a

** format string and subsequent arguments are values to be substituted

** in place of % fields. The result of formatting this string

** is written to iotrace.

*/

#ifdef SQLITE_ENABLE_IOTRACE

static void SQLITE_CDECL iotracePrintf(const char *zFormat, ...){

va_list ap;

char *z;

if( iotrace==0 ) return;

va_start(ap, zFormat);

z = sqlite3_vmprintf(zFormat, ap);

va_end(ap);

utf8_printf(iotrace, "%s", z);

sqlite3_free(z);

}

#endif

/*

** Output string zUtf to stream pOut as w characters. If w is negative,

** then right-justify the text. W is the width in UTF-8 characters, not

** in bytes. This is different from the %*.*s specification in printf

** since with %*.*s the width is measured in bytes, not characters.

*/

static void utf8_width_print(FILE *pOut, int w, const char *zUtf){

int i;

int n;

int aw = w<0 ? -w : w;

char zBuf[1000];

if( aw>(int)sizeof(zBuf)/3 ) aw = (int)sizeof(zBuf)/3;

for(i=n=0; zUtf[i]; i++){

if( (zUtf[i]&0xc0)!=0x80 ){

n++;

if( n==aw ){

do{ i++; }while( (zUtf[i]&0xc0)==0x80 );

break;

}

}

}

if( n>=aw ){

utf8_printf(pOut, "%.*s", i, zUtf);

}else if( w<0 ){

utf8_printf(pOut, "%*s%s", aw-n, "", zUtf);

}else{

utf8_printf(pOut, "%s%*s", zUtf, aw-n, "");

}

}

/*

** Determines if a string is a number of not.

*/

static int isNumber(const char *z, int *realnum){

if( *z=='-' || *z=='+' ) z++;

if( !IsDigit(*z) ){

return 0;

}

z++;

if( realnum ) *realnum = 0;

while( IsDigit(*z) ){ z++; }

if( *z=='.' ){

z++;

if( !IsDigit(*z) ) return 0;

while( IsDigit(*z) ){ z++; }

if( realnum ) *realnum = 1;

}

if( *z=='e' || *z=='E' ){

z++;

if( *z=='+' || *z=='-' ) z++;

if( !IsDigit(*z) ) return 0;

while( IsDigit(*z) ){ z++; }

if( realnum ) *realnum = 1;

}

return *z==0;

}

/*

** Compute a string length that is limited to what can be stored in

** lower 30 bits of a 32-bit signed integer.

*/

static int strlen30(const char *z){

const char *z2 = z;

while( *z2 ){ z2++; }

return 0x3fffffff & (int)(z2 - z);

}

/*

** Return the length of a string in characters. Multibyte UTF8 characters

** count as a single character.

*/

static int strlenChar(const char *z){

int n = 0;

while( *z ){

if( (0xc0&*(z++))!=0x80 ) n++;

}

return n;

}

/*

** This routine reads a line of text from FILE in, stores

** the text in memory obtained from malloc() and returns a pointer

** to the text. NULL is returned at end of file, or if malloc()

** fails.

**

** If zLine is not NULL then it is a malloced buffer returned from

** a previous call to this routine that may be reused.

*/

static char *local_getline(char *zLine, FILE *in){

int nLine = zLine==0 ? 0 : 100;

int n = 0;

while( 1 ){

if( n+100>nLine ){

nLine = nLine*2 + 100;

zLine = realloc(zLine, nLine);

if( zLine==0 ) return 0;

}

if( fgets(&zLine[n], nLine - n, in)==0 ){

if( n==0 ){

free(zLine);

return 0;

}

zLine[n] = 0;

break;

}

while( zLine[n] ) n++;

if( n>0 && zLine[n-1]=='\n' ){

n--;

if( n>0 && zLine[n-1]=='\r' ) n--;

zLine[n] = 0;

break;

}

}

#if defined(_WIN32) || defined(WIN32)

/* For interactive input on Windows systems, translate the

** multi-byte characterset characters into UTF-8. */

if( stdin_is_interactive && in==stdin ){

char *zTrans = sqlite3_win32_mbcs_to_utf8_v2(zLine, 0);

if( zTrans ){

int nTrans = strlen30(zTrans)+1;

if( nTrans>nLine ){

zLine = realloc(zLine, nTrans);

if( zLine==0 ){

sqlite3_free(zTrans);

return 0;

}

}

memcpy(zLine, zTrans, nTrans);

sqlite3_free(zTrans);

}

}

#endif /* defined(_WIN32) || defined(WIN32) */

return zLine;

}

/*

** Retrieve a single line of input text.

**

** If in==0 then read from standard input and prompt before each line.

** If isContinuation is true, then a continuation prompt is appropriate.

** If isContinuation is zero, then the main prompt should be used.

**

** If zPrior is not NULL then it is a buffer from a prior call to this

** routine that can be reused.

**

** The result is stored in space obtained from malloc() and must either

** be freed by the caller or else passed back into this routine via the

** zPrior argument for reuse.

*/

static char *one_input_line(FILE *in, char *zPrior, int isContinuation){

char *zPrompt;

char *zResult;

if( in!=0 ){

zResult = local_getline(zPrior, in);

}else{

zPrompt = isContinuation ? continuePrompt : mainPrompt;

#if SHELL_USE_LOCAL_GETLINE

printf("%s", zPrompt);

fflush(stdout);

zResult = local_getline(zPrior, stdin);

#else

free(zPrior);

zResult = shell_readline(zPrompt);

if( zResult && *zResult ) shell_add_history(zResult);

#endif

}

return zResult;

}

/*

** A variable length string to which one can append text.

*/

typedef struct ShellText ShellText;

struct ShellText {

char *z;

int n;

int nAlloc;

};

/*

** Initialize and destroy a ShellText object

*/

static void initText(ShellText *p){

memset(p, 0, sizeof(*p));

}

static void freeText(ShellText *p){

free(p->z);

initText(p);

}

/* zIn is either a pointer to a NULL-terminated string in memory obtained

** from malloc(), or a NULL pointer. The string pointed to by zAppend is

** added to zIn, and the result returned in memory obtained from malloc().

** zIn, if it was not NULL, is freed.

**

** If the third argument, quote, is not '\0', then it is used as a

** quote character for zAppend.

*/

static void appendText(ShellText *p, char const *zAppend, char quote){

int len;

int i;

int nAppend = strlen30(zAppend);

len = nAppend+p->n+1;

if( quote ){

len += 2;

for(i=0; i<nAppend; i++){

if( zAppend[i]==quote ) len++;

}

}

if( p->n+len>=p->nAlloc ){

p->nAlloc = p->nAlloc*2 + len + 20;

p->z = realloc(p->z, p->nAlloc);

if( p->z==0 ){

memset(p, 0, sizeof(*p));

return;

}

}

if( quote ){

char *zCsr = p->z+p->n;

*zCsr++ = quote;

for(i=0; i<nAppend; i++){

*zCsr++ = zAppend[i];

if( zAppend[i]==quote ) *zCsr++ = quote;

}

*zCsr++ = quote;

p->n = (int)(zCsr - p->z);

*zCsr = '\0';

}else{

memcpy(p->z+p->n, zAppend, nAppend);

p->n += nAppend;

p->z[p->n] = '\0';

}

}

/*

** Attempt to determine if identifier zName needs to be quoted, either

** because it contains non-alphanumeric characters, or because it is an

** SQLite keyword. Be conservative in this estimate: When in doubt assume

** that quoting is required.

**

** Return '"' if quoting is required. Return 0 if no quoting is required.

*/

static char quoteChar(const char *zName){

/* All SQLite keywords, in alphabetical order */

static const char *azKeywords[] = {

"ABORT", "ACTION", "ADD", "AFTER", "ALL", "ALTER", "ANALYZE", "AND", "AS",

"ASC", "ATTACH", "AUTOINCREMENT", "BEFORE", "BEGIN", "BETWEEN", "BY",

"CASCADE", "CASE", "CAST", "CHECK", "COLLATE", "COLUMN", "COMMIT",

"CONFLICT", "CONSTRAINT", "CREATE", "CROSS", "CURRENT_DATE",

"CURRENT_TIME", "CURRENT_TIMESTAMP", "DATABASE", "DEFAULT", "DEFERRABLE",

"DEFERRED", "DELETE", "DESC", "DETACH", "DISTINCT", "DROP", "EACH",

"ELSE", "END", "ESCAPE", "EXCEPT", "EXCLUSIVE", "EXISTS", "EXPLAIN",

"FAIL", "FOR", "FOREIGN", "FROM", "FULL", "GLOB", "GROUP", "HAVING", "IF",

"IGNORE", "IMMEDIATE", "IN", "INDEX", "INDEXED", "INITIALLY", "INNER",

"INSERT", "INSTEAD", "INTERSECT", "INTO", "IS", "ISNULL", "JOIN", "KEY",

"LEFT", "LIKE", "LIMIT", "MATCH", "NATURAL", "NO", "NOT", "NOTNULL",

"NULL", "OF", "OFFSET", "ON", "OR", "ORDER", "OUTER", "PLAN", "PRAGMA",

"PRIMARY", "QUERY", "RAISE", "RECURSIVE", "REFERENCES", "REGEXP",

"REINDEX", "RELEASE", "RENAME", "REPLACE", "RESTRICT", "RIGHT",

"ROLLBACK", "ROW", "SAVEPOINT", "SELECT", "SET", "TABLE", "TEMP",

"TEMPORARY", "THEN", "TO", "TRANSACTION", "TRIGGER", "UNION", "UNIQUE",

"UPDATE", "USING", "VACUUM", "VALUES", "VIEW", "VIRTUAL", "WHEN", "WHERE",

"WITH", "WITHOUT",

};

int i, lwr, upr, mid, c;

if( !isalpha((unsigned char)zName[0]) && zName[0]!='_' ) return '"';

for(i=0; zName[i]; i++){

if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ) return '"';

}

lwr = 0;

upr = sizeof(azKeywords)/sizeof(azKeywords[0]) - 1;

while( lwr<=upr ){

mid = (lwr+upr)/2;

c = sqlite3_stricmp(azKeywords[mid], zName);

if( c==0 ) return '"';

if( c<0 ){

lwr = mid+1;

}else{

upr = mid-1;

}

}

return 0;

}

/*

** SQL function: shell_add_schema(S,X)

**

** Add the schema name X to the CREATE statement in S and return the result.

** Examples:

**

** CREATE TABLE t1(x) -> CREATE TABLE xyz.t1(x);

**

** Also works on

**

** CREATE INDEX

** CREATE UNIQUE INDEX

** CREATE VIEW

** CREATE TRIGGER

** CREATE VIRTUAL TABLE

**

** This UDF is used by the .schema command to insert the schema name of

** attached databases into the middle of the sqlite_master.sql field.

*/

static void shellAddSchemaName(

sqlite3_context *pCtx,

int nVal,

sqlite3_value **apVal

){

static const char *aPrefix[] = {

"TABLE",

"INDEX",

"UNIQUE INDEX",

"VIEW",

"TRIGGER",

"VIRTUAL TABLE"

};

int i = 0;

const char *zIn = (const char*)sqlite3_value_text(apVal[0]);

const char *zSchema = (const char*)sqlite3_value_text(apVal[1]);

assert( nVal==2 );

if( zIn!=0 && strncmp(zIn, "CREATE ", 7)==0 ){

for(i=0; i<(int)(sizeof(aPrefix)/sizeof(aPrefix[0])); i++){

int n = strlen30(aPrefix[i]);

if( strncmp(zIn+7, aPrefix[i], n)==0 && zIn[n+7]==' ' ){

char cQuote = quoteChar(zSchema);

char *z;

if( cQuote ){

z = sqlite3_mprintf("%.*s \"%w\".%s", n+7, zIn, zSchema, zIn+n+8);

}else{

z = sqlite3_mprintf("%.*s %s.%s", n+7, zIn, zSchema, zIn+n+8);

}

sqlite3_result_text(pCtx, z, -1, sqlite3_free);

return;

}

}

}

sqlite3_result_value(pCtx, apVal[0]);

}

/*

** The source code for several run-time loadable extensions is inserted

** below by the ../tool/mkshellc.tcl script. Before processing that included

** code, we need to override some macros to make the included program code

** work here in the middle of this regular program.

*/

#define SQLITE_EXTENSION_INIT1

#define SQLITE_EXTENSION_INIT2(X) (void)(X)

INCLUDE ../ext/misc/shathree.c

INCLUDE ../ext/misc/fileio.c

INCLUDE ../ext/misc/completion.c

#if defined(SQLITE_ENABLE_SESSION)

/*

** State information for a single open session

*/

typedef struct OpenSession OpenSession;

struct OpenSession {

char *zName; /* Symbolic name for this session */

int nFilter; /* Number of xFilter rejection GLOB patterns */

char **azFilter; /* Array of xFilter rejection GLOB patterns */

sqlite3_session *p; /* The open session */

};

#endif

/*

** Shell output mode information from before ".explain on",

** saved so that it can be restored by ".explain off"

*/

typedef struct SavedModeInfo SavedModeInfo;

struct SavedModeInfo {

int valid; /* Is there legit data in here? */

int mode; /* Mode prior to ".explain on" */

int showHeader; /* The ".header" setting prior to ".explain on" */

int colWidth[100]; /* Column widths prior to ".explain on" */

};

/*

** State information about the database connection is contained in an

** instance of the following structure.

*/

typedef struct ShellState ShellState;

struct ShellState {

sqlite3 *db; /* The database */

int autoExplain; /* Automatically turn on .explain mode */

int autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */

int statsOn; /* True to display memory stats before each finalize */

int scanstatsOn; /* True to display scan stats before each finalize */

int outCount; /* Revert to stdout when reaching zero */

int cnt; /* Number of records displayed so far */

FILE *out; /* Write results here */

FILE *traceOut; /* Output for sqlite3_trace() */

int nErr; /* Number of errors seen */

int mode; /* An output mode setting */

int cMode; /* temporary output mode for the current query */

int normalMode; /* Output mode before ".explain on" */

int writableSchema; /* True if PRAGMA writable_schema=ON */

int showHeader; /* True to show column names in List or Column mode */

int nCheck; /* Number of ".check" commands run */

unsigned shellFlgs; /* Various flags */

char *zDestTable; /* Name of destination table when MODE_Insert */

char zTestcase[30]; /* Name of current test case */

char colSeparator[20]; /* Column separator character for several modes */

char rowSeparator[20]; /* Row separator character for MODE_Ascii */

int colWidth[100]; /* Requested width of each column when in column mode*/

int actualWidth[100]; /* Actual width of each column */

char nullValue[20]; /* The text to print when a NULL comes back from

** the database */

char outfile[FILENAME_MAX]; /* Filename for *out */

const char *zDbFilename; /* name of the database file */

char *zFreeOnClose; /* Filename to free when closing */

const char *zVfs; /* Name of VFS to use */

sqlite3_stmt *pStmt; /* Current statement if any. */

FILE *pLog; /* Write log output here */

int *aiIndent; /* Array of indents used in MODE_Explain */

int nIndent; /* Size of array aiIndent[] */

int iIndent; /* Index of current op in aiIndent[] */

#if defined(SQLITE_ENABLE_SESSION)

int nSession; /* Number of active sessions */

OpenSession aSession[4]; /* Array of sessions. [0] is in focus. */

#endif

};

/*

** These are the allowed shellFlgs values

*/

#define SHFLG_Scratch 0x00000001 /* The --scratch option is used */

#define SHFLG_Pagecache 0x00000002 /* The --pagecache option is used */

#define SHFLG_Lookaside 0x00000004 /* Lookaside memory is used */

#define SHFLG_Backslash 0x00000008 /* The --backslash option is used */

#define SHFLG_PreserveRowid 0x00000010 /* .dump preserves rowid values */

#define SHFLG_Newlines 0x00000020 /* .dump --newline flag */

#define SHFLG_CountChanges 0x00000040 /* .changes setting */

#define SHFLG_Echo 0x00000080 /* .echo or --echo setting */

/*

** Macros for testing and setting shellFlgs

*/

#define ShellHasFlag(P,X) (((P)->shellFlgs & (X))!=0)

#define ShellSetFlag(P,X) ((P)->shellFlgs|=(X))

#define ShellClearFlag(P,X) ((P)->shellFlgs&=(~(X)))

/*

** These are the allowed modes.

*/

#define MODE_Line 0 /* One column per line. Blank line between records */

#define MODE_Column 1 /* One record per line in neat columns */

#define MODE_List 2 /* One record per line with a separator */

#define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */

#define MODE_Html 4 /* Generate an XHTML table */

#define MODE_Insert 5 /* Generate SQL "insert" statements */

#define MODE_Quote 6 /* Quote values as for SQL */

#define MODE_Tcl 7 /* Generate ANSI-C or TCL quoted elements */

#define MODE_Csv 8 /* Quote strings, numbers are plain */

#define MODE_Explain 9 /* Like MODE_Column, but do not truncate data */

#define MODE_Ascii 10 /* Use ASCII unit and record separators (0x1F/0x1E) */

#define MODE_Pretty 11 /* Pretty-print schemas */

static const char *modeDescr[] = {

"line",

"column",

"list",

"semi",

"html",

"insert",

"quote",

"tcl",

"csv",

"explain",

"ascii",

"prettyprint",

};

/*

** These are the column/row/line separators used by the various

** import/export modes.

*/

#define SEP_Column "|"

#define SEP_Row "\n"

#define SEP_Tab "\t"

#define SEP_Space " "

#define SEP_Comma ","

#define SEP_CrLf "\r\n"

#define SEP_Unit "\x1F"

#define SEP_Record "\x1E"

/*

** Number of elements in an array

*/

#define ArraySize(X) (int)(sizeof(X)/sizeof(X[0]))

/*

** A callback for the sqlite3_log() interface.

*/

static void shellLog(void *pArg, int iErrCode, const char *zMsg){

ShellState *p = (ShellState*)pArg;

if( p->pLog==0 ) return;

utf8_printf(p->pLog, "(%d) %s\n", iErrCode, zMsg);

fflush(p->pLog);

}

/*

** Output the given string as a hex-encoded blob (eg. X'1234' )

*/

static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){

int i;

char *zBlob = (char *)pBlob;

raw_printf(out,"X'");

for(i=0; i<nBlob; i++){ raw_printf(out,"%02x",zBlob[i]&0xff); }

raw_printf(out,"'");

}

/*

** Find a string that is not found anywhere in z[]. Return a pointer

** to that string.

**

** Try to use zA and zB first. If both of those are already found in z[]

** then make up some string and store it in the buffer zBuf.

*/

static const char *unused_string(

const char *z, /* Result must not appear anywhere in z */

const char *zA, const char *zB, /* Try these first */

char *zBuf /* Space to store a generated string */

){

unsigned i = 0;

if( strstr(z, zA)==0 ) return zA;

if( strstr(z, zB)==0 ) return zB;

do{

sqlite3_snprintf(20,zBuf,"(%s%u)", zA, i++);

}while( strstr(z,zBuf)!=0 );

return zBuf;

}

/*

** Output the given string as a quoted string using SQL quoting conventions.

**

** See also: output_quoted_escaped_string()

*/

static void output_quoted_string(FILE *out, const char *z){

int i;

char c;

setBinaryMode(out, 1);

for(i=0; (c = z[i])!=0 && c!='\''; i++){}

if( c==0 ){

utf8_printf(out,"'%s'",z);

}else{

raw_printf(out, "'");

while( *z ){

for(i=0; (c = z[i])!=0 && c!='\''; i++){}

if( c=='\'' ) i++;

if( i ){

utf8_printf(out, "%.*s", i, z);

z += i;