/*

** 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

/*

** Optionally #include a user-defined header, whereby compilation options

** may be set prior to where they take effect, but after platform setup.

** If SQLITE_CUSTOM_INCLUDE=? is defined, its value names the #include

** file. Note that this macro has a like effect on sqlite3.c compilation.

*/

# define SHELL_STRINGIFY_(f) #f

# define SHELL_STRINGIFY(f) SHELL_STRINGIFY_(f)

#ifdef SQLITE_CUSTOM_INCLUDE

# include SHELL_STRINGIFY(SQLITE_CUSTOM_INCLUDE)

#endif

/*

** Determine if we are dealing with WinRT, which provides only a subset of

** the full Win32 API.

*/

#if !defined(SQLITE_OS_WINRT)

# define SQLITE_OS_WINRT 0

#endif

/*

** If SQLITE_SHELL_FIDDLE is defined then the shell is modified

** somewhat for use as a WASM module in a web browser. This flag

** should only be used when building the "fiddle" web application, as

** the browser-mode build has much different user input requirements

** and this build mode rewires the user input subsystem to account for

** that.

*/

/*

** 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"

typedef sqlite3_int64 i64;

typedef sqlite3_uint64 u64;

typedef unsigned char u8;

#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

#endif

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

# include <unistd.h>

# include <dirent.h>

# define GETPID getpid

# if defined(__MINGW32__)

# define DIRENT dirent

# ifndef S_ISLNK

# define S_ISLNK(mode) (0)

# endif

# endif

#else

# define GETPID (int)GetCurrentProcessId

#endif

#include <sys/types.h>

#include <sys/stat.h>

#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)

# if SQLITE_OS_WINRT

# define SQLITE_OMIT_POPEN 1

# else

# include <io.h>

# include <fcntl.h>

# define isatty(h) _isatty(h)

# ifndef access

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

# endif

# ifndef unlink

# define unlink _unlink

# endif

# ifndef strdup

# define strdup _strdup

# endif

# undef popen

# define popen _popen

# undef pclose

# define pclose _pclose

# endif

#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)

#if SQLITE_OS_WINRT

#include <intrin.h>

#endif

#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)) && !SQLITE_OS_WINRT

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==0 ) return 0; /* Never actually happens */

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 {

#if !SQLITE_OS_WINRT

/* 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);

}

}

#endif

}

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)

/*

** Number of elements in an array

*/

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

/*

** 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

/* Indicate out-of-memory and exit. */

static void shell_out_of_memory(void){

raw_printf(stderr,"Error: out of memory\n");

exit(1);

}

/* Check a pointer to see if it is NULL. If it is NULL, exit with an

** out-of-memory error.

*/

static void shell_check_oom(void *p){

if( p==0 ) shell_out_of_memory();

}

/*

** 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;

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;

}

/*

** Return open FILE * if zFile exists, can be opened for read

** and is an ordinary file or a character stream source.

** Otherwise return 0.

*/

static FILE * openChrSource(const char *zFile){

#ifdef _WIN32

struct _stat x = {0};

# define STAT_CHR_SRC(mode) ((mode & (_S_IFCHR|_S_IFIFO|_S_IFREG))!=0)

/* On Windows, open first, then check the stream nature. This order

** is necessary because _stat() and sibs, when checking a named pipe,

** effectively break the pipe as its supplier sees it. */

FILE *rv = fopen(zFile, "rb");

if( rv==0 ) return 0;

if( _fstat(_fileno(rv), &x) != 0

|| !STAT_CHR_SRC(x.st_mode)){

fclose(rv);

rv = 0;

}

return rv;

#else

struct stat x = {0};

int rc = stat(zFile, &x);

# define STAT_CHR_SRC(mode) (S_ISREG(mode)||S_ISFIFO(mode)||S_ISCHR(mode))

if( rc!=0 ) return 0;

if( STAT_CHR_SRC(x.st_mode) ){

return fopen(zFile, "rb");

}else{

return 0;

}

#endif

#undef STAT_CHR_SRC

}

/*

** 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);

shell_check_oom(zLine);

}

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);

shell_check_oom(zLine);

}

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.

*/

#ifndef SQLITE_SHELL_FIDDLE

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;

}

#endif /* !SQLITE_SHELL_FIDDLE */

/*

** Return the value of a hexadecimal digit. Return -1 if the input

** is not a hex digit.

*/

static int hexDigitValue(char c){

if( c>='0' && c<='9' ) return c - '0';

if( c>='a' && c<='f' ) return c - 'a' + 10;

if( c>='A' && c<='F' ) return c - 'A' + 10;

return -1;

}

/*

** Interpret zArg as an integer value, possibly with suffixes.

*/

static sqlite3_int64 integerValue(const char *zArg){

sqlite3_int64 v = 0;

static const struct { char *zSuffix; int iMult; } aMult[] = {

{ "KiB", 1024 },

{ "MiB", 1024*1024 },

{ "GiB", 1024*1024*1024 },

{ "KB", 1000 },

{ "MB", 1000000 },

{ "GB", 1000000000 },

{ "K", 1000 },

{ "M", 1000000 },

{ "G", 1000000000 },

};

int i;

int isNeg = 0;

if( zArg[0]=='-' ){

isNeg = 1;

zArg++;

}else if( zArg[0]=='+' ){

zArg++;

}

if( zArg[0]=='0' && zArg[1]=='x' ){

int x;

zArg += 2;

while( (x = hexDigitValue(zArg[0]))>=0 ){

v = (v<<4) + x;

zArg++;

}

}else{

while( IsDigit(zArg[0]) ){

v = v*10 + zArg[0] - '0';

zArg++;

}

}

for(i=0; i<ArraySize(aMult); i++){

if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){

v *= aMult[i].iMult;

break;

}

}

return isNeg? -v : v;

}

/*

** 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, const char *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->z==0 || p->n+len>=p->nAlloc ){

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

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

shell_check_oom(p->z);

}

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){

int i;

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

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

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

}

return sqlite3_keyword_check(zName, i) ? '"' : 0;

}

/*

** Construct a fake object name and column list to describe the structure

** of the view, virtual table, or table valued function zSchema.zName.

*/

static char *shellFakeSchema(

sqlite3 *db, /* The database connection containing the vtab */

const char *zSchema, /* Schema of the database holding the vtab */

const char *zName /* The name of the virtual table */

){

sqlite3_stmt *pStmt = 0;

char *zSql;

ShellText s;

char cQuote;

char *zDiv = "(";

int nRow = 0;

zSql = sqlite3_mprintf("PRAGMA \"%w\".table_info=%Q;",

zSchema ? zSchema : "main", zName);

shell_check_oom(zSql);

sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);

sqlite3_free(zSql);

initText(&s);

if( zSchema ){

cQuote = quoteChar(zSchema);

if( cQuote && sqlite3_stricmp(zSchema,"temp")==0 ) cQuote = 0;

appendText(&s, zSchema, cQuote);

appendText(&s, ".", 0);

}

cQuote = quoteChar(zName);

appendText(&s, zName, cQuote);

while( sqlite3_step(pStmt)==SQLITE_ROW ){

const char *zCol = (const char*)sqlite3_column_text(pStmt, 1);

nRow++;

appendText(&s, zDiv, 0);

zDiv = ",";

if( zCol==0 ) zCol = "";

cQuote = quoteChar(zCol);

appendText(&s, zCol, cQuote);

}

appendText(&s, ")", 0);

sqlite3_finalize(pStmt);

if( nRow==0 ){

freeText(&s);

s.z = 0;

}

return s.z;

}

/*

** SQL function: shell_module_schema(X)

**

** Return a fake schema for the table-valued function or eponymous virtual

** table X.

*/

static void shellModuleSchema(

sqlite3_context *pCtx,

int nVal,

sqlite3_value **apVal

){

const char *zName;

char *zFake;

UNUSED_PARAMETER(nVal);

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

zFake = zName ? shellFakeSchema(sqlite3_context_db_handle(pCtx), 0, zName) : 0;

if( zFake ){

sqlite3_result_text(pCtx, sqlite3_mprintf("/* %s */", zFake),

-1, sqlite3_free);

free(zFake);

}

}

/*

** 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_schema.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]);

const char *zName = (const char*)sqlite3_value_text(apVal[2]);

sqlite3 *db = sqlite3_context_db_handle(pCtx);

UNUSED_PARAMETER(nVal);

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

for(i=0; i<ArraySize(aPrefix); i++){

int n = strlen30(aPrefix[i]);

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

char *z = 0;

char *zFake = 0;

if( zSchema ){

char cQuote = quoteChar(zSchema);

if( cQuote && sqlite3_stricmp(zSchema,"temp")!=0 ){

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);

}

}

if( zName

&& aPrefix[i][0]=='V'

&& (zFake = shellFakeSchema(db, zSchema, zName))!=0

){

if( z==0 ){

z = sqlite3_mprintf("%s\n/* %s */", zIn, zFake);

}else{

z = sqlite3_mprintf("%z\n/* %s */", z, zFake);

}

free(zFake);

}

if( z ){

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

return;

}