/* DO NOT EDIT!

** This file is automatically generated by the script in the canonical

** SQLite source tree at tool/mkshellc.tcl. That script combines source

** code from various constituent source files of SQLite into this single

** "shell.c" file used to implement the SQLite command-line shell.

**

** Most of the code found below comes from the "src/shell.c.in" file in

** the canonical SQLite source tree. That main file contains "INCLUDE"

** lines that specify other files in the canonical source tree that are

** inserted to getnerate this complete program source file.

**

** The code from multiple files is combined into this single "shell.c"

** source file to help make the command-line program easier to compile.

**

** To modify this program, get a copy of the canonical SQLite source tree,

** edit the src/shell.c.in" and/or some of the other files that are included

** by "src/shell.c.in", then rerun the tool/mkshellc.tcl script.

*/

/*

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

/************************* Begin ../ext/misc/shathree.c ******************/

/*

** 2017-03-08

**

** 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 SQLite extension implements a functions that compute SHA1 hashes.

** Two SQL functions are implemented:

**

** sha3(X,SIZE)

** sha3_query(Y,SIZE)

**

** The sha3(X) function computes the SHA3 hash of the input X, or NULL if

** X is NULL.

**

** The sha3_query(Y) function evalutes all queries in the SQL statements of Y

** and returns a hash of their results.

**

** The SIZE argument is optional. If omitted, the SHA3-256 hash algorithm

** is used. If SIZE is included it must be one of the integers 224, 256,

** 384, or 512, to determine SHA3 hash variant that is computed.

*/

SQLITE_EXTENSION_INIT1

#include <assert.h>

#include <string.h>

#include <stdarg.h>

typedef sqlite3_uint64 u64;

/******************************************************************************

** The Hash Engine

*/

/*

** Macros to determine whether the machine is big or little endian,

** and whether or not that determination is run-time or compile-time.

**

** For best performance, an attempt is made to guess at the byte-order

** using C-preprocessor macros. If that is unsuccessful, or if

** -DSHA3_BYTEORDER=0 is set, then byte-order is determined

** at run-time.

*/

#ifndef SHA3_BYTEORDER

# if defined(i386) || defined(__i386__) || defined(_M_IX86) || \

defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \

defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \

defined(__arm__)

# define SHA3_BYTEORDER 1234

# elif defined(sparc) || defined(__ppc__)

# define SHA3_BYTEORDER 4321

# else

# define SHA3_BYTEORDER 0

# endif

#endif

/*

** State structure for a SHA3 hash in progress

*/

typedef struct SHA3Context SHA3Context;

struct SHA3Context {

union {

u64 s[25]; /* Keccak state. 5x5 lines of 64 bits each */

unsigned char x[1600]; /* ... or 1600 bytes */

} u;

unsigned nRate; /* Bytes of input accepted per Keccak iteration */

unsigned nLoaded; /* Input bytes loaded into u.x[] so far this cycle */

unsigned ixMask; /* Insert next input into u.x[nLoaded^ixMask]. */

};

/*

** A single step of the Keccak mixing function for a 1600-bit state

*/

static void KeccakF1600Step(SHA3Context *p){

int i;

u64 B0, B1, B2, B3, B4;

u64 C0, C1, C2, C3, C4;

u64 D0, D1, D2, D3, D4;

static const u64 RC[] = {

0x0000000000000001ULL, 0x0000000000008082ULL,

0x800000000000808aULL, 0x8000000080008000ULL,

0x000000000000808bULL, 0x0000000080000001ULL,

0x8000000080008081ULL, 0x8000000000008009ULL,

0x000000000000008aULL, 0x0000000000000088ULL,

0x0000000080008009ULL, 0x000000008000000aULL,

0x000000008000808bULL, 0x800000000000008bULL,

0x8000000000008089ULL, 0x8000000000008003ULL,

0x8000000000008002ULL, 0x8000000000000080ULL,

0x000000000000800aULL, 0x800000008000000aULL,

0x8000000080008081ULL, 0x8000000000008080ULL,

0x0000000080000001ULL, 0x8000000080008008ULL

};

# define A00 (p->u.s[0])

# define A01 (p->u.s[1])

# define A02 (p->u.s[2])

# define A03 (p->u.s[3])

# define A04 (p->u.s[4])

# define A10 (p->u.s[5])

# define A11 (p->u.s[6])

# define A12 (p->u.s[7])

# define A13 (p->u.s[8])

# define A14 (p->u.s[9])

# define A20 (p->u.s[10])

# define A21 (p->u.s[11])

# define A22 (p->u.s[12])

# define A23 (p->u.s[13])

# define A24 (p->u.s[14])

# define A30 (p->u.s[15])

# define A31 (p->u.s[16])

# define A32 (p->u.s[17])

# define A33 (p->u.s[18])

# define A34 (p->u.s[19])

# define A40 (p->u.s[20])

# define A41 (p->u.s[21])

# define A42 (p->u.s[22])

# define A43 (p->u.s[23])

# define A44 (p->u.s[24])

# define ROL64(a,x) ((a<<x)|(a>>(64-x)))

for(i=0; i<24; i+=4){

C0 = A00^A10^A20^A30^A40;

C1 = A01^A11^A21^A31^A41;

C2 = A02^A12^A22^A32^A42;

C3 = A03^A13^A23^A33^A43;

C4 = A04^A14^A24^A34^A44;

D0 = C4^ROL64(C1, 1);

D1 = C0^ROL64(C2, 1);

D2 = C1^ROL64(C3, 1);

D3 = C2^ROL64(C4, 1);

D4 = C3^ROL64(C0, 1);

B0 = (A00^D0);

B1 = ROL64((A11^D1), 44);

B2 = ROL64((A22^D2), 43);

B3 = ROL64((A33^D3), 21);

B4 = ROL64((A44^D4), 14);

A00 = B0 ^((~B1)& B2 );

A00 ^= RC[i];

A11 = B1 ^((~B2)& B3 );

A22 = B2 ^((~B3)& B4 );

A33 = B3 ^((~B4)& B0 );

A44 = B4 ^((~B0)& B1 );

B2 = ROL64((A20^D0), 3);

B3 = ROL64((A31^D1), 45);

B4 = ROL64((A42^D2), 61);

B0 = ROL64((A03^D3), 28);

B1 = ROL64((A14^D4), 20);

A20 = B0 ^((~B1)& B2 );

A31 = B1 ^((~B2)& B3 );

A42 = B2 ^((~B3)& B4 );

A03 = B3 ^((~B4)& B0 );

A14 = B4 ^((~B0)& B1 );

B4 = ROL64((A40^D0), 18);

B0 = ROL64((A01^D1), 1);

B1 = ROL64((A12^D2), 6);

B2 = ROL64((A23^D3), 25);

B3 = ROL64((A34^D4), 8);

A40 = B0 ^((~B1)& B2 );

A01 = B1 ^((~B2)& B3 );

A12 = B2 ^((~B3)& B4 );

A23 = B3 ^((~B4)& B0 );

A34 = B4 ^((~B0)& B1 );

B1 = ROL64((A10^D0), 36);

B2 = ROL64((A21^D1), 10);

B3 = ROL64((A32^D2), 15);

B4 = ROL64((A43^D3), 56);

B0 = ROL64((A04^D4), 27);

A10 = B0 ^((~B1)& B2 );

A21 = B1 ^((~B2)& B3 );

A32 = B2 ^((~B3)& B4 );

A43 = B3 ^((~B4)& B0 );

A04 = B4 ^((~B0)& B1 );

B3 = ROL64((A30^D0), 41);

B4 = ROL64((A41^D1), 2);

B0 = ROL64((A02^D2), 62);

B1 = ROL64((A13^D3), 55);

B2 = ROL64((A24^D4), 39);

A30 = B0 ^((~B1)& B2 );