/*

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

/*

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

#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 defined(HAVE_READLINE) && HAVE_READLINE!=0

# include <readline/readline.h>

# include <readline/history.h>

#else

# undef HAVE_READLINE

#endif

#if defined(HAVE_EDITLINE) && !defined(HAVE_READLINE)

# define HAVE_READLINE 1

# include <editline/readline.h>

#endif

#if !defined(HAVE_READLINE)

# define add_history(X)

# define read_history(X)

# define write_history(X)

# define stifle_history(X)

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

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

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

/* 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>=1 && 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(_WRS_KERNEL) \

&& !defined(__minux)

#include <sys/time.h>

#include <sys/resource.h>

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

struct rusage sEnd;

sqlite3_int64 iEnd = timeOfDay();

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

#include <windows.h>

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

/*

** 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 *db = 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: " ...> " */

/*

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

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

sqlite3_free(z);

}

#endif

/*

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

}

/*

** A global char* and an SQL function to access its current value

** from within an SQL statement. This program used to use the

** sqlite_exec_printf() API to substitue a string into an SQL statement.

** The correct way to do this with sqlite3 is to use the bind API, but

** since the shell is built around the callback paradigm it would be a lot

** of work. Instead just use this hack, which is quite harmless.

*/

static const char *zShellStatic = 0;

static void shellstaticFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

assert( 0==argc );

assert( zShellStatic );

UNUSED_PARAMETER(argc);

UNUSED_PARAMETER(argv);

sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC);

}

/*

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

}

}

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 defined(HAVE_READLINE)

free(zPrior);

zResult = readline(zPrompt);

if( zResult && *zResult ) add_history(zResult);

#else

printf("%s", zPrompt);

fflush(stdout);

zResult = local_getline(zPrior, stdin);

#endif

}

return zResult;

}

struct previous_mode_data {

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

int mode;

int showHeader;

int colWidth[100];

};

/*

** An pointer to an instance of this structure is passed from

** the main program to the callback. This is used to communicate

** state and mode information.

*/

struct callback_data {

sqlite3 *db; /* The database */

int echoOn; /* True to echo input commands */

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

int statsOn; /* True to display memory 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 writableSchema; /* True if PRAGMA writable_schema=ON */

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

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

char separator[20]; /* Separator character for MODE_List */

char newline[20]; /* Record separator in MODE_Csv */

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

struct previous_mode_data explainPrev;

/* Holds the mode information just before

** .explain ON */

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[] */

};

/*

** 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_Tcl 6 /* Generate ANSI-C or TCL quoted elements */

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

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

static const char *modeDescr[] = {

"line",

"column",

"list",

"semi",

"html",

"insert",

"tcl",

"csv",

"explain",

};

/*

** Number of elements in an array

*/

#define ArraySize(X) (int)(sizeof(X)/sizeof(X[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);

}

/*

** A callback for the sqlite3_log() interface.

*/

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

struct callback_data *p = (struct callback_data*)pArg;

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

fprintf(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;

fprintf(out,"X'");

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

fprintf(out,"'");

}

/*

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

*/

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

int i;

int nSingle = 0;

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

if( z[i]=='\'' ) nSingle++;

}

if( nSingle==0 ){

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

}else{

fprintf(out,"'");

while( *z ){

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

if( i==0 ){

fprintf(out,"''");

z++;

}else if( z[i]=='\'' ){

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

z += i+1;

}else{

fprintf(out,"%s",z);

break;

}

}

fprintf(out,"'");

}

}

/*

** Output the given string as a quoted according to C or TCL quoting rules.

*/

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

unsigned int c;

fputc('"', out);

while( (c = *(z++))!=0 ){

if( c=='\\' ){

fputc(c, out);

fputc(c, out);

}else if( c=='"' ){

fputc('\\', out);

fputc('"', out);

}else if( c=='\t' ){

fputc('\\', out);

fputc('t', out);

}else if( c=='\n' ){

fputc('\\', out);

fputc('n', out);

}else if( c=='\r' ){

fputc('\\', out);

fputc('r', out);

}else if( !isprint(c&0xff) ){

fprintf(out, "\\%03o", c&0xff);

}else{

fputc(c, out);

}

}

fputc('"', out);

}

/*

** Output the given string with characters that are special to

** HTML escaped.

*/

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

int i;

if( z==0 ) z = "";

while( *z ){

for(i=0; z[i]

&& z[i]!='<'

&& z[i]!='&'

&& z[i]!='>'

&& z[i]!='\"'

&& z[i]!='\'';

i++){}

if( i>0 ){

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

}

if( z[i]=='<' ){

fprintf(out,"&lt;");

}else if( z[i]=='&' ){

fprintf(out,"&amp;");

}else if( z[i]=='>' ){

fprintf(out,"&gt;");

}else if( z[i]=='\"' ){

fprintf(out,"&quot;");

}else if( z[i]=='\'' ){

fprintf(out,"&#39;");

}else{

break;

}

z += i + 1;

}

}

/*

** If a field contains any character identified by a 1 in the following

** array, then the string must be quoted for CSV.

*/

static const char needCsvQuote[] = {

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

};

/*

** Output a single term of CSV. Actually, p->separator is used for

** the separator, which may or may not be a comma. p->nullvalue is

** the null value. Strings are quoted if necessary. The separator

** is only issued if bSep is true.

*/

static void output_csv(struct callback_data *p, const char *z, int bSep){

FILE *out = p->out;

if( z==0 ){

fprintf(out,"%s",p->nullvalue);

}else{

int i;

int nSep = strlen30(p->separator);

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

if( needCsvQuote[((unsigned char*)z)[i]]

|| (z[i]==p->separator[0] &&

(nSep==1 || memcmp(z, p->separator, nSep)==0)) ){

i = 0;

break;

}

}

if( i==0 ){

putc('"', out);

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

if( z[i]=='"' ) putc('"', out);

putc(z[i], out);

}

putc('"', out);

}else{

fprintf(out, "%s", z);

}

}

if( bSep ){

fprintf(p->out, "%s", p->separator);

}

}

#ifdef SIGINT

/*

** This routine runs when the user presses Ctrl-C

*/

static void interrupt_handler(int NotUsed){

UNUSED_PARAMETER(NotUsed);

seenInterrupt++;

if( seenInterrupt>2 ) exit(1);

if( db ) sqlite3_interrupt(db);

}

#endif

/*

** This is the callback routine that the shell

** invokes for each row of a query result.

*/

static int shell_callback(void *pArg, int nArg, char **azArg, char **azCol, int *aiType){

int i;

struct callback_data *p = (struct callback_data*)pArg;

switch( p->mode ){

case MODE_Line: {

int w = 5;

if( azArg==0 ) break;

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

int len = strlen30(azCol[i] ? azCol[i] : "");

if( len>w ) w = len;

}

if( p->cnt++>0 ) fprintf(p->out,"\n");

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

fprintf(p->out,"%*s = %s\n", w, azCol[i],

azArg[i] ? azArg[i] : p->nullvalue);

}

break;

}

case MODE_Explain:

case MODE_Column: {

if( p->cnt++==0 ){

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

int w, n;

if( i<ArraySize(p->colWidth) ){

w = p->colWidth[i];

}else{

w = 0;

}

if( w==0 ){

w = strlen30(azCol[i] ? azCol[i] : "");

if( w<10 ) w = 10;

n = strlen30(azArg && azArg[i] ? azArg[i] : p->nullvalue);

if( w<n ) w = n;

}

if( i<ArraySize(p->actualWidth) ){

p->actualWidth[i] = w;

}

if( p->showHeader ){

if( w<0 ){

fprintf(p->out,"%*.*s%s",-w,-w,azCol[i], i==nArg-1 ? "\n": " ");

}else{

fprintf(p->out,"%-*.*s%s",w,w,azCol[i], i==nArg-1 ? "\n": " ");

}

}

}

if( p->showHeader ){

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

int w;

if( i<ArraySize(p->actualWidth) ){

w = p->actualWidth[i];

if( w<0 ) w = -w;

}else{

w = 10;

}

fprintf(p->out,"%-*.*s%s",w,w,"-----------------------------------"

"----------------------------------------------------------",

i==nArg-1 ? "\n": " ");

}

}

}

if( azArg==0 ) break;

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

int w;

if( i<ArraySize(p->actualWidth) ){

w = p->actualWidth[i];

}else{

w = 10;

}

if( p->mode==MODE_Explain && azArg[i] && strlen30(azArg[i])>w ){

w = strlen30(azArg[i]);

}

if( i==1 && p->aiIndent && p->pStmt ){

if( p->iIndent<p->nIndent ){

fprintf(p->out, "%*.s", p->aiIndent[p->iIndent], "");

}

p->iIndent++;

}

if( w<0 ){

fprintf(p->out,"%*.*s%s",-w,-w,

azArg[i] ? azArg[i] : p->nullvalue, i==nArg-1 ? "\n": " ");

}else{

fprintf(p->out,"%-*.*s%s",w,w,

azArg[i] ? azArg[i] : p->nullvalue, i==nArg-1 ? "\n": " ");

}

}

break;

}

case MODE_Semi:

case MODE_List: {

if( p->cnt++==0 && p->showHeader ){

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

fprintf(p->out,"%s%s",azCol[i], i==nArg-1 ? "\n" : p->separator);

}

}

if( azArg==0 ) break;

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

char *z = azArg[i];

if( z==0 ) z = p->nullvalue;

fprintf(p->out, "%s", z);

if( i<nArg-1 ){

fprintf(p->out, "%s", p->separator);

}else if( p->mode==MODE_Semi ){

fprintf(p->out, ";\n");

}else{

fprintf(p->out, "\n");

}

}

break;

}

case MODE_Html: {

if( p->cnt++==0 && p->showHeader ){

fprintf(p->out,"<TR>");

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

fprintf(p->out,"<TH>");

output_html_string(p->out, azCol[i]);

fprintf(p->out,"</TH>\n");

}

fprintf(p->out,"</TR>\n");

}

if( azArg==0 ) break;

fprintf(p->out,"<TR>");

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

fprintf(p->out,"<TD>");

output_html_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);

fprintf(p->out,"</TD>\n");

}

fprintf(p->out,"</TR>\n");

break;

}

case MODE_Tcl: {

if( p->cnt++==0 && p->showHeader ){

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

output_c_string(p->out,azCol[i] ? azCol[i] : "");

if(i<nArg-1) fprintf(p->out, "%s", p->separator);

}

fprintf(p->out,"\n");

}

if( azArg==0 ) break;

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

output_c_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);

if(i<nArg-1) fprintf(p->out, "%s", p->separator);

}

fprintf(p->out,"\n");

break;

}

case MODE_Csv: {

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

fflush(p->out);

_setmode(_fileno(p->out), _O_BINARY);

#endif

if( p->cnt++==0 && p->showHeader ){

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

output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);

}

fprintf(p->out,"%s",p->newline);

}

if( azArg>0 ){

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

output_csv(p, azArg[i], i<nArg-1);

}

fprintf(p->out,"%s",p->newline);

}

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

fflush(p->out);

_setmode(_fileno(p->out), _O_TEXT);

#endif

break;

}

case MODE_Insert: {

p->cnt++;

if( azArg==0 ) break;

fprintf(p->out,"INSERT INTO %s VALUES(",p->zDestTable);

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

char *zSep = i>0 ? ",": "";

if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){

fprintf(p->out,"%sNULL",zSep);

}else if( aiType && aiType[i]==SQLITE_TEXT ){

if( zSep[0] ) fprintf(p->out,"%s",zSep);

output_quoted_string(p->out, azArg[i]);

}else if( aiType && (aiType[i]==SQLITE_INTEGER

|| aiType[i]==SQLITE_FLOAT) ){

fprintf(p->out,"%s%s",zSep, azArg[i]);

}else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){

const void *pBlob = sqlite3_column_blob(p->pStmt, i);

int nBlob = sqlite3_column_bytes(p->pStmt, i);

if( zSep[0] ) fprintf(p->out,"%s",zSep);

output_hex_blob(p->out, pBlob, nBlob);

}else if( isNumber(azArg[i], 0) ){

fprintf(p->out,"%s%s",zSep, azArg[i]);

}else{

if( zSep[0] ) fprintf(p->out,"%s",zSep);

output_quoted_string(p->out, azArg[i]);

}

}

fprintf(p->out,");\n");

break;

}

}

return 0;

}

/*

** This is the callback routine that the SQLite library

** invokes for each row of a query result.

*/

static int callback(void *pArg, int nArg, char **azArg, char **azCol){

/* since we don't have type info, call the shell_callback with a NULL value */

return shell_callback(pArg, nArg, azArg, azCol, NULL);

}

/*

** Set the destination table field of the callback_data structure to

** the name of the table given. Escape any quote characters in the

** table name.

*/

static void set_table_name(struct callback_data *p, const char *zName){

int i, n;

int needQuote;

char *z;

if( p->zDestTable ){

free(p->zDestTable);

p->zDestTable = 0;

}

if( zName==0 ) return;

needQuote = !isalpha((unsigned char)*zName) && *zName!='_';

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

if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){

needQuote = 1;

if( zName[i]=='\'' ) n++;

}

}

if( needQuote ) n += 2;

z = p->zDestTable = malloc( n+1 );

if( z==0 ){

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

exit(1);

}

n = 0;

if( needQuote ) z[n++] = '\'';

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

z[n++] = zName[i];

if( zName[i]=='\'' ) z[n++] = '\'';

}

if( needQuote ) z[n++] = '\'';

z[n] = 0;

}

/* 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 char *appendText(char *zIn, char const *zAppend, char quote){

int len;

int i;

int nAppend = strlen30(zAppend);

int nIn = (zIn?strlen30(zIn):0);

len = nAppend+nIn+1;

if( quote ){

len += 2;

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

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

}

}

zIn = (char *)realloc(zIn, len);

if( !zIn ){

return 0;

}

if( quote ){

char *zCsr = &zIn[nIn];

*zCsr++ = quote;

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

*zCsr++ = zAppend[i];

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

}

*zCsr++ = quote;

*zCsr++ = '\0';

assert( (zCsr-zIn)==len );

}else{