/*

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

/*

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

/*

** When compiling with emcc (a.k.a. emscripten), we're building a

** WebAssembly (WASM) bundle and need to disable and rewire a few

** things.

*/

#ifdef __EMSCRIPTEN__

#define SQLITE_SHELL_WASM_MODE

#else

#undef SQLITE_SHELL_WASM_MODE

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

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

/* BEGIN SQLCIPHER */

#ifdef SQLITE_HAS_CODEC

/* Simplistic filtering of input lines to prevent PRAGKA key and

PRAGMA rekey statements from being stored in readline history.

Note that this will only prevent single line statements, but that

will be sufficient for common cases. */

if(zResult && *zResult && (

sqlite3_strlike("%pragma%key%=%", zResult, 0)==0 ||

sqlite3_strlike("%attach%database%as%key%", zResult, 0)==0

)

) return zResult;

#endif

/* END SQLCIPHER */

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

#endif

}

return zResult;

}

#endif /* !SQLITE_SHELL_WASM_MODE */

/*

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

}

}