1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sqlite3api/SQLite/shell.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,2096 @@
1.4 +/*
1.5 +** 2001 September 15
1.6 +**
1.7 +** The author disclaims copyright to this source code. In place of
1.8 +** a legal notice, here is a blessing:
1.9 +**
1.10 +** May you do good and not evil.
1.11 +** May you find forgiveness for yourself and forgive others.
1.12 +** May you share freely, never taking more than you give.
1.13 +**
1.14 +*************************************************************************
1.15 +** This file contains code to implement the "sqlite" command line
1.16 +** utility for accessing SQLite databases.
1.17 +**
1.18 +** $Id: shell.c,v 1.185 2008/08/11 19:12:35 drh Exp $
1.19 +*/
1.20 +#include <stdlib.h>
1.21 +#include <string.h>
1.22 +#include <stdio.h>
1.23 +#include <assert.h>
1.24 +#include "sqlite3.h"
1.25 +#include <ctype.h>
1.26 +#include <stdarg.h>
1.27 +
1.28 +#if !defined(_WIN32) && !defined(WIN32) && !defined(__OS2__)
1.29 +# include <signal.h>
1.30 +# include <pwd.h>
1.31 +# include <unistd.h>
1.32 +# include <sys/types.h>
1.33 +#endif
1.34 +
1.35 +#ifdef __OS2__
1.36 +# include <unistd.h>
1.37 +#endif
1.38 +
1.39 +#if defined(HAVE_READLINE) && HAVE_READLINE==1
1.40 +# include <readline/readline.h>
1.41 +# include <readline/history.h>
1.42 +#else
1.43 +# define readline(p) local_getline(p,stdin)
1.44 +# define add_history(X)
1.45 +# define read_history(X)
1.46 +# define write_history(X)
1.47 +# define stifle_history(X)
1.48 +#endif
1.49 +
1.50 +#if defined(_WIN32) || defined(WIN32)
1.51 +# include <io.h>
1.52 +#else
1.53 +/* Make sure isatty() has a prototype.
1.54 +*/
1.55 +extern int isatty();
1.56 +#endif
1.57 +
1.58 +#if defined(_WIN32_WCE)
1.59 +/* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty()
1.60 + * thus we always assume that we have a console. That can be
1.61 + * overridden with the -batch command line option.
1.62 + */
1.63 +#define isatty(x) 1
1.64 +#endif
1.65 +
1.66 +#if !defined(_WIN32) && !defined(WIN32) && !defined(__OS2__)
1.67 +#include <sys/time.h>
1.68 +#include <sys/resource.h>
1.69 +
1.70 +/* Saved resource information for the beginning of an operation */
1.71 +static struct rusage sBegin;
1.72 +
1.73 +/* True if the timer is enabled */
1.74 +static int enableTimer = 0;
1.75 +
1.76 +/*
1.77 +** Begin timing an operation
1.78 +*/
1.79 +static void beginTimer(void){
1.80 + if( enableTimer ){
1.81 + getrusage(RUSAGE_SELF, &sBegin);
1.82 + }
1.83 +}
1.84 +
1.85 +/* Return the difference of two time_structs in seconds */
1.86 +static double timeDiff(struct timeval *pStart, struct timeval *pEnd){
1.87 + return (pEnd->tv_usec - pStart->tv_usec)*0.000001 +
1.88 + (double)(pEnd->tv_sec - pStart->tv_sec);
1.89 +}
1.90 +
1.91 +/*
1.92 +** Print the timing results.
1.93 +*/
1.94 +static void endTimer(void){
1.95 + if( enableTimer ){
1.96 + struct rusage sEnd;
1.97 + getrusage(RUSAGE_SELF, &sEnd);
1.98 + printf("CPU Time: user %f sys %f\n",
1.99 + timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
1.100 + timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
1.101 + }
1.102 +}
1.103 +#define BEGIN_TIMER beginTimer()
1.104 +#define END_TIMER endTimer()
1.105 +#define HAS_TIMER 1
1.106 +#else
1.107 +#define BEGIN_TIMER
1.108 +#define END_TIMER
1.109 +#define HAS_TIMER 0
1.110 +#endif
1.111 +
1.112 +
1.113 +/*
1.114 +** If the following flag is set, then command execution stops
1.115 +** at an error if we are not interactive.
1.116 +*/
1.117 +static int bail_on_error = 0;
1.118 +
1.119 +/*
1.120 +** Threat stdin as an interactive input if the following variable
1.121 +** is true. Otherwise, assume stdin is connected to a file or pipe.
1.122 +*/
1.123 +static int stdin_is_interactive = 1;
1.124 +
1.125 +/*
1.126 +** The following is the open SQLite database. We make a pointer
1.127 +** to this database a static variable so that it can be accessed
1.128 +** by the SIGINT handler to interrupt database processing.
1.129 +*/
1.130 +static sqlite3 *db = 0;
1.131 +
1.132 +/*
1.133 +** True if an interrupt (Control-C) has been received.
1.134 +*/
1.135 +static volatile int seenInterrupt = 0;
1.136 +
1.137 +/*
1.138 +** This is the name of our program. It is set in main(), used
1.139 +** in a number of other places, mostly for error messages.
1.140 +*/
1.141 +static char *Argv0;
1.142 +
1.143 +/*
1.144 +** Prompt strings. Initialized in main. Settable with
1.145 +** .prompt main continue
1.146 +*/
1.147 +static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/
1.148 +static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */
1.149 +
1.150 +/*
1.151 +** Write I/O traces to the following stream.
1.152 +*/
1.153 +#ifdef SQLITE_ENABLE_IOTRACE
1.154 +static FILE *iotrace = 0;
1.155 +#endif
1.156 +
1.157 +/*
1.158 +** This routine works like printf in that its first argument is a
1.159 +** format string and subsequent arguments are values to be substituted
1.160 +** in place of % fields. The result of formatting this string
1.161 +** is written to iotrace.
1.162 +*/
1.163 +#ifdef SQLITE_ENABLE_IOTRACE
1.164 +static void iotracePrintf(const char *zFormat, ...){
1.165 + va_list ap;
1.166 + char *z;
1.167 + if( iotrace==0 ) return;
1.168 + va_start(ap, zFormat);
1.169 + z = sqlite3_vmprintf(zFormat, ap);
1.170 + va_end(ap);
1.171 + fprintf(iotrace, "%s", z);
1.172 + sqlite3_free(z);
1.173 +}
1.174 +#endif
1.175 +
1.176 +
1.177 +/*
1.178 +** Determines if a string is a number of not.
1.179 +*/
1.180 +static int isNumber(const char *z, int *realnum){
1.181 + if( *z=='-' || *z=='+' ) z++;
1.182 + if( !isdigit(*z) ){
1.183 + return 0;
1.184 + }
1.185 + z++;
1.186 + if( realnum ) *realnum = 0;
1.187 + while( isdigit(*z) ){ z++; }
1.188 + if( *z=='.' ){
1.189 + z++;
1.190 + if( !isdigit(*z) ) return 0;
1.191 + while( isdigit(*z) ){ z++; }
1.192 + if( realnum ) *realnum = 1;
1.193 + }
1.194 + if( *z=='e' || *z=='E' ){
1.195 + z++;
1.196 + if( *z=='+' || *z=='-' ) z++;
1.197 + if( !isdigit(*z) ) return 0;
1.198 + while( isdigit(*z) ){ z++; }
1.199 + if( realnum ) *realnum = 1;
1.200 + }
1.201 + return *z==0;
1.202 +}
1.203 +
1.204 +/*
1.205 +** A global char* and an SQL function to access its current value
1.206 +** from within an SQL statement. This program used to use the
1.207 +** sqlite_exec_printf() API to substitue a string into an SQL statement.
1.208 +** The correct way to do this with sqlite3 is to use the bind API, but
1.209 +** since the shell is built around the callback paradigm it would be a lot
1.210 +** of work. Instead just use this hack, which is quite harmless.
1.211 +*/
1.212 +static const char *zShellStatic = 0;
1.213 +static void shellstaticFunc(
1.214 + sqlite3_context *context,
1.215 + int argc,
1.216 + sqlite3_value **argv
1.217 +){
1.218 + assert( 0==argc );
1.219 + assert( zShellStatic );
1.220 + sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC);
1.221 +}
1.222 +
1.223 +
1.224 +/*
1.225 +** This routine reads a line of text from FILE in, stores
1.226 +** the text in memory obtained from malloc() and returns a pointer
1.227 +** to the text. NULL is returned at end of file, or if malloc()
1.228 +** fails.
1.229 +**
1.230 +** The interface is like "readline" but no command-line editing
1.231 +** is done.
1.232 +*/
1.233 +static char *local_getline(char *zPrompt, FILE *in){
1.234 + char *zLine;
1.235 + int nLine;
1.236 + int n;
1.237 + int eol;
1.238 +
1.239 + if( zPrompt && *zPrompt ){
1.240 + printf("%s",zPrompt);
1.241 + fflush(stdout);
1.242 + }
1.243 + nLine = 100;
1.244 + zLine = malloc( nLine );
1.245 + if( zLine==0 ) return 0;
1.246 + n = 0;
1.247 + eol = 0;
1.248 + while( !eol ){
1.249 + if( n+100>nLine ){
1.250 + nLine = nLine*2 + 100;
1.251 + zLine = realloc(zLine, nLine);
1.252 + if( zLine==0 ) return 0;
1.253 + }
1.254 + if( fgets(&zLine[n], nLine - n, in)==0 ){
1.255 + if( n==0 ){
1.256 + free(zLine);
1.257 + return 0;
1.258 + }
1.259 + zLine[n] = 0;
1.260 + eol = 1;
1.261 + break;
1.262 + }
1.263 + while( zLine[n] ){ n++; }
1.264 + if( n>0 && zLine[n-1]=='\n' ){
1.265 + n--;
1.266 + zLine[n] = 0;
1.267 + eol = 1;
1.268 + }
1.269 + }
1.270 + zLine = realloc( zLine, n+1 );
1.271 + return zLine;
1.272 +}
1.273 +
1.274 +/*
1.275 +** Retrieve a single line of input text.
1.276 +**
1.277 +** zPrior is a string of prior text retrieved. If not the empty
1.278 +** string, then issue a continuation prompt.
1.279 +*/
1.280 +static char *one_input_line(const char *zPrior, FILE *in){
1.281 + char *zPrompt;
1.282 + char *zResult;
1.283 + if( in!=0 ){
1.284 + return local_getline(0, in);
1.285 + }
1.286 + if( zPrior && zPrior[0] ){
1.287 + zPrompt = continuePrompt;
1.288 + }else{
1.289 + zPrompt = mainPrompt;
1.290 + }
1.291 + zResult = readline(zPrompt);
1.292 +#if defined(HAVE_READLINE) && HAVE_READLINE==1
1.293 + if( zResult && *zResult ) add_history(zResult);
1.294 +#endif
1.295 + return zResult;
1.296 +}
1.297 +
1.298 +struct previous_mode_data {
1.299 + int valid; /* Is there legit data in here? */
1.300 + int mode;
1.301 + int showHeader;
1.302 + int colWidth[100];
1.303 +};
1.304 +
1.305 +/*
1.306 +** An pointer to an instance of this structure is passed from
1.307 +** the main program to the callback. This is used to communicate
1.308 +** state and mode information.
1.309 +*/
1.310 +struct callback_data {
1.311 + sqlite3 *db; /* The database */
1.312 + int echoOn; /* True to echo input commands */
1.313 + int cnt; /* Number of records displayed so far */
1.314 + FILE *out; /* Write results here */
1.315 + int mode; /* An output mode setting */
1.316 + int writableSchema; /* True if PRAGMA writable_schema=ON */
1.317 + int showHeader; /* True to show column names in List or Column mode */
1.318 + char *zDestTable; /* Name of destination table when MODE_Insert */
1.319 + char separator[20]; /* Separator character for MODE_List */
1.320 + int colWidth[100]; /* Requested width of each column when in column mode*/
1.321 + int actualWidth[100]; /* Actual width of each column */
1.322 + char nullvalue[20]; /* The text to print when a NULL comes back from
1.323 + ** the database */
1.324 + struct previous_mode_data explainPrev;
1.325 + /* Holds the mode information just before
1.326 + ** .explain ON */
1.327 + char outfile[FILENAME_MAX]; /* Filename for *out */
1.328 + const char *zDbFilename; /* name of the database file */
1.329 +};
1.330 +
1.331 +/*
1.332 +** These are the allowed modes.
1.333 +*/
1.334 +#define MODE_Line 0 /* One column per line. Blank line between records */
1.335 +#define MODE_Column 1 /* One record per line in neat columns */
1.336 +#define MODE_List 2 /* One record per line with a separator */
1.337 +#define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */
1.338 +#define MODE_Html 4 /* Generate an XHTML table */
1.339 +#define MODE_Insert 5 /* Generate SQL "insert" statements */
1.340 +#define MODE_Tcl 6 /* Generate ANSI-C or TCL quoted elements */
1.341 +#define MODE_Csv 7 /* Quote strings, numbers are plain */
1.342 +#define MODE_Explain 8 /* Like MODE_Column, but do not truncate data */
1.343 +
1.344 +static const char *modeDescr[] = {
1.345 + "line",
1.346 + "column",
1.347 + "list",
1.348 + "semi",
1.349 + "html",
1.350 + "insert",
1.351 + "tcl",
1.352 + "csv",
1.353 + "explain",
1.354 +};
1.355 +
1.356 +/*
1.357 +** Number of elements in an array
1.358 +*/
1.359 +#define ArraySize(X) (sizeof(X)/sizeof(X[0]))
1.360 +
1.361 +/*
1.362 +** Output the given string as a quoted string using SQL quoting conventions.
1.363 +*/
1.364 +static void output_quoted_string(FILE *out, const char *z){
1.365 + int i;
1.366 + int nSingle = 0;
1.367 + for(i=0; z[i]; i++){
1.368 + if( z[i]=='\'' ) nSingle++;
1.369 + }
1.370 + if( nSingle==0 ){
1.371 + fprintf(out,"'%s'",z);
1.372 + }else{
1.373 + fprintf(out,"'");
1.374 + while( *z ){
1.375 + for(i=0; z[i] && z[i]!='\''; i++){}
1.376 + if( i==0 ){
1.377 + fprintf(out,"''");
1.378 + z++;
1.379 + }else if( z[i]=='\'' ){
1.380 + fprintf(out,"%.*s''",i,z);
1.381 + z += i+1;
1.382 + }else{
1.383 + fprintf(out,"%s",z);
1.384 + break;
1.385 + }
1.386 + }
1.387 + fprintf(out,"'");
1.388 + }
1.389 +}
1.390 +
1.391 +/*
1.392 +** Output the given string as a quoted according to C or TCL quoting rules.
1.393 +*/
1.394 +static void output_c_string(FILE *out, const char *z){
1.395 + unsigned int c;
1.396 + fputc('"', out);
1.397 + while( (c = *(z++))!=0 ){
1.398 + if( c=='\\' ){
1.399 + fputc(c, out);
1.400 + fputc(c, out);
1.401 + }else if( c=='\t' ){
1.402 + fputc('\\', out);
1.403 + fputc('t', out);
1.404 + }else if( c=='\n' ){
1.405 + fputc('\\', out);
1.406 + fputc('n', out);
1.407 + }else if( c=='\r' ){
1.408 + fputc('\\', out);
1.409 + fputc('r', out);
1.410 + }else if( !isprint(c) ){
1.411 + fprintf(out, "\\%03o", c&0xff);
1.412 + }else{
1.413 + fputc(c, out);
1.414 + }
1.415 + }
1.416 + fputc('"', out);
1.417 +}
1.418 +
1.419 +/*
1.420 +** Output the given string with characters that are special to
1.421 +** HTML escaped.
1.422 +*/
1.423 +static void output_html_string(FILE *out, const char *z){
1.424 + int i;
1.425 + while( *z ){
1.426 + for(i=0; z[i] && z[i]!='<' && z[i]!='&'; i++){}
1.427 + if( i>0 ){
1.428 + fprintf(out,"%.*s",i,z);
1.429 + }
1.430 + if( z[i]=='<' ){
1.431 + fprintf(out,"<");
1.432 + }else if( z[i]=='&' ){
1.433 + fprintf(out,"&");
1.434 + }else{
1.435 + break;
1.436 + }
1.437 + z += i + 1;
1.438 + }
1.439 +}
1.440 +
1.441 +/*
1.442 +** If a field contains any character identified by a 1 in the following
1.443 +** array, then the string must be quoted for CSV.
1.444 +*/
1.445 +static const char needCsvQuote[] = {
1.446 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1.447 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1.448 + 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
1.449 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1.450 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1.451 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1.452 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1.453 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
1.454 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1.455 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1.456 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1.457 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1.458 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1.459 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1.460 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1.461 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1.462 +};
1.463 +
1.464 +/*
1.465 +** Output a single term of CSV. Actually, p->separator is used for
1.466 +** the separator, which may or may not be a comma. p->nullvalue is
1.467 +** the null value. Strings are quoted using ANSI-C rules. Numbers
1.468 +** appear outside of quotes.
1.469 +*/
1.470 +static void output_csv(struct callback_data *p, const char *z, int bSep){
1.471 + FILE *out = p->out;
1.472 + if( z==0 ){
1.473 + fprintf(out,"%s",p->nullvalue);
1.474 + }else{
1.475 + int i;
1.476 + int nSep = strlen(p->separator);
1.477 + for(i=0; z[i]; i++){
1.478 + if( needCsvQuote[((unsigned char*)z)[i]]
1.479 + || (z[i]==p->separator[0] &&
1.480 + (nSep==1 || memcmp(z, p->separator, nSep)==0)) ){
1.481 + i = 0;
1.482 + break;
1.483 + }
1.484 + }
1.485 + if( i==0 ){
1.486 + putc('"', out);
1.487 + for(i=0; z[i]; i++){
1.488 + if( z[i]=='"' ) putc('"', out);
1.489 + putc(z[i], out);
1.490 + }
1.491 + putc('"', out);
1.492 + }else{
1.493 + fprintf(out, "%s", z);
1.494 + }
1.495 + }
1.496 + if( bSep ){
1.497 + fprintf(p->out, "%s", p->separator);
1.498 + }
1.499 +}
1.500 +
1.501 +#ifdef SIGINT
1.502 +/*
1.503 +** This routine runs when the user presses Ctrl-C
1.504 +*/
1.505 +static void interrupt_handler(int NotUsed){
1.506 + seenInterrupt = 1;
1.507 + if( db ) sqlite3_interrupt(db);
1.508 +}
1.509 +#endif
1.510 +
1.511 +/*
1.512 +** This is the callback routine that the SQLite library
1.513 +** invokes for each row of a query result.
1.514 +*/
1.515 +static int callback(void *pArg, int nArg, char **azArg, char **azCol){
1.516 + int i;
1.517 + struct callback_data *p = (struct callback_data*)pArg;
1.518 + switch( p->mode ){
1.519 + case MODE_Line: {
1.520 + int w = 5;
1.521 + if( azArg==0 ) break;
1.522 + for(i=0; i<nArg; i++){
1.523 + int len = strlen(azCol[i] ? azCol[i] : "");
1.524 + if( len>w ) w = len;
1.525 + }
1.526 + if( p->cnt++>0 ) fprintf(p->out,"\n");
1.527 + for(i=0; i<nArg; i++){
1.528 + fprintf(p->out,"%*s = %s\n", w, azCol[i],
1.529 + azArg[i] ? azArg[i] : p->nullvalue);
1.530 + }
1.531 + break;
1.532 + }
1.533 + case MODE_Explain:
1.534 + case MODE_Column: {
1.535 + if( p->cnt++==0 ){
1.536 + for(i=0; i<nArg; i++){
1.537 + int w, n;
1.538 + if( i<ArraySize(p->colWidth) ){
1.539 + w = p->colWidth[i];
1.540 + }else{
1.541 + w = 0;
1.542 + }
1.543 + if( w<=0 ){
1.544 + w = strlen(azCol[i] ? azCol[i] : "");
1.545 + if( w<10 ) w = 10;
1.546 + n = strlen(azArg && azArg[i] ? azArg[i] : p->nullvalue);
1.547 + if( w<n ) w = n;
1.548 + }
1.549 + if( i<ArraySize(p->actualWidth) ){
1.550 + p->actualWidth[i] = w;
1.551 + }
1.552 + if( p->showHeader ){
1.553 + fprintf(p->out,"%-*.*s%s",w,w,azCol[i], i==nArg-1 ? "\n": " ");
1.554 + }
1.555 + }
1.556 + if( p->showHeader ){
1.557 + for(i=0; i<nArg; i++){
1.558 + int w;
1.559 + if( i<ArraySize(p->actualWidth) ){
1.560 + w = p->actualWidth[i];
1.561 + }else{
1.562 + w = 10;
1.563 + }
1.564 + fprintf(p->out,"%-*.*s%s",w,w,"-----------------------------------"
1.565 + "----------------------------------------------------------",
1.566 + i==nArg-1 ? "\n": " ");
1.567 + }
1.568 + }
1.569 + }
1.570 + if( azArg==0 ) break;
1.571 + for(i=0; i<nArg; i++){
1.572 + int w;
1.573 + if( i<ArraySize(p->actualWidth) ){
1.574 + w = p->actualWidth[i];
1.575 + }else{
1.576 + w = 10;
1.577 + }
1.578 + if( p->mode==MODE_Explain && azArg[i] && strlen(azArg[i])>w ){
1.579 + w = strlen(azArg[i]);
1.580 + }
1.581 + fprintf(p->out,"%-*.*s%s",w,w,
1.582 + azArg[i] ? azArg[i] : p->nullvalue, i==nArg-1 ? "\n": " ");
1.583 + }
1.584 + break;
1.585 + }
1.586 + case MODE_Semi:
1.587 + case MODE_List: {
1.588 + if( p->cnt++==0 && p->showHeader ){
1.589 + for(i=0; i<nArg; i++){
1.590 + fprintf(p->out,"%s%s",azCol[i], i==nArg-1 ? "\n" : p->separator);
1.591 + }
1.592 + }
1.593 + if( azArg==0 ) break;
1.594 + for(i=0; i<nArg; i++){
1.595 + char *z = azArg[i];
1.596 + if( z==0 ) z = p->nullvalue;
1.597 + fprintf(p->out, "%s", z);
1.598 + if( i<nArg-1 ){
1.599 + fprintf(p->out, "%s", p->separator);
1.600 + }else if( p->mode==MODE_Semi ){
1.601 + fprintf(p->out, ";\n");
1.602 + }else{
1.603 + fprintf(p->out, "\n");
1.604 + }
1.605 + }
1.606 + break;
1.607 + }
1.608 + case MODE_Html: {
1.609 + if( p->cnt++==0 && p->showHeader ){
1.610 + fprintf(p->out,"<TR>");
1.611 + for(i=0; i<nArg; i++){
1.612 + fprintf(p->out,"<TH>%s</TH>",azCol[i]);
1.613 + }
1.614 + fprintf(p->out,"</TR>\n");
1.615 + }
1.616 + if( azArg==0 ) break;
1.617 + fprintf(p->out,"<TR>");
1.618 + for(i=0; i<nArg; i++){
1.619 + fprintf(p->out,"<TD>");
1.620 + output_html_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);
1.621 + fprintf(p->out,"</TD>\n");
1.622 + }
1.623 + fprintf(p->out,"</TR>\n");
1.624 + break;
1.625 + }
1.626 + case MODE_Tcl: {
1.627 + if( p->cnt++==0 && p->showHeader ){
1.628 + for(i=0; i<nArg; i++){
1.629 + output_c_string(p->out,azCol[i] ? azCol[i] : "");
1.630 + fprintf(p->out, "%s", p->separator);
1.631 + }
1.632 + fprintf(p->out,"\n");
1.633 + }
1.634 + if( azArg==0 ) break;
1.635 + for(i=0; i<nArg; i++){
1.636 + output_c_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);
1.637 + fprintf(p->out, "%s", p->separator);
1.638 + }
1.639 + fprintf(p->out,"\n");
1.640 + break;
1.641 + }
1.642 + case MODE_Csv: {
1.643 + if( p->cnt++==0 && p->showHeader ){
1.644 + for(i=0; i<nArg; i++){
1.645 + output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
1.646 + }
1.647 + fprintf(p->out,"\n");
1.648 + }
1.649 + if( azArg==0 ) break;
1.650 + for(i=0; i<nArg; i++){
1.651 + output_csv(p, azArg[i], i<nArg-1);
1.652 + }
1.653 + fprintf(p->out,"\n");
1.654 + break;
1.655 + }
1.656 + case MODE_Insert: {
1.657 + if( azArg==0 ) break;
1.658 + fprintf(p->out,"INSERT INTO %s VALUES(",p->zDestTable);
1.659 + for(i=0; i<nArg; i++){
1.660 + char *zSep = i>0 ? ",": "";
1.661 + if( azArg[i]==0 ){
1.662 + fprintf(p->out,"%sNULL",zSep);
1.663 + }else if( isNumber(azArg[i], 0) ){
1.664 + fprintf(p->out,"%s%s",zSep, azArg[i]);
1.665 + }else{
1.666 + if( zSep[0] ) fprintf(p->out,"%s",zSep);
1.667 + output_quoted_string(p->out, azArg[i]);
1.668 + }
1.669 + }
1.670 + fprintf(p->out,");\n");
1.671 + break;
1.672 + }
1.673 + }
1.674 + return 0;
1.675 +}
1.676 +
1.677 +/*
1.678 +** Set the destination table field of the callback_data structure to
1.679 +** the name of the table given. Escape any quote characters in the
1.680 +** table name.
1.681 +*/
1.682 +static void set_table_name(struct callback_data *p, const char *zName){
1.683 + int i, n;
1.684 + int needQuote;
1.685 + char *z;
1.686 +
1.687 + if( p->zDestTable ){
1.688 + free(p->zDestTable);
1.689 + p->zDestTable = 0;
1.690 + }
1.691 + if( zName==0 ) return;
1.692 + needQuote = !isalpha((unsigned char)*zName) && *zName!='_';
1.693 + for(i=n=0; zName[i]; i++, n++){
1.694 + if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){
1.695 + needQuote = 1;
1.696 + if( zName[i]=='\'' ) n++;
1.697 + }
1.698 + }
1.699 + if( needQuote ) n += 2;
1.700 + z = p->zDestTable = malloc( n+1 );
1.701 + if( z==0 ){
1.702 + fprintf(stderr,"Out of memory!\n");
1.703 + exit(1);
1.704 + }
1.705 + n = 0;
1.706 + if( needQuote ) z[n++] = '\'';
1.707 + for(i=0; zName[i]; i++){
1.708 + z[n++] = zName[i];
1.709 + if( zName[i]=='\'' ) z[n++] = '\'';
1.710 + }
1.711 + if( needQuote ) z[n++] = '\'';
1.712 + z[n] = 0;
1.713 +}
1.714 +
1.715 +/* zIn is either a pointer to a NULL-terminated string in memory obtained
1.716 +** from malloc(), or a NULL pointer. The string pointed to by zAppend is
1.717 +** added to zIn, and the result returned in memory obtained from malloc().
1.718 +** zIn, if it was not NULL, is freed.
1.719 +**
1.720 +** If the third argument, quote, is not '\0', then it is used as a
1.721 +** quote character for zAppend.
1.722 +*/
1.723 +static char *appendText(char *zIn, char const *zAppend, char quote){
1.724 + int len;
1.725 + int i;
1.726 + int nAppend = strlen(zAppend);
1.727 + int nIn = (zIn?strlen(zIn):0);
1.728 +
1.729 + len = nAppend+nIn+1;
1.730 + if( quote ){
1.731 + len += 2;
1.732 + for(i=0; i<nAppend; i++){
1.733 + if( zAppend[i]==quote ) len++;
1.734 + }
1.735 + }
1.736 +
1.737 + zIn = (char *)realloc(zIn, len);
1.738 + if( !zIn ){
1.739 + return 0;
1.740 + }
1.741 +
1.742 + if( quote ){
1.743 + char *zCsr = &zIn[nIn];
1.744 + *zCsr++ = quote;
1.745 + for(i=0; i<nAppend; i++){
1.746 + *zCsr++ = zAppend[i];
1.747 + if( zAppend[i]==quote ) *zCsr++ = quote;
1.748 + }
1.749 + *zCsr++ = quote;
1.750 + *zCsr++ = '\0';
1.751 + assert( (zCsr-zIn)==len );
1.752 + }else{
1.753 + memcpy(&zIn[nIn], zAppend, nAppend);
1.754 + zIn[len-1] = '\0';
1.755 + }
1.756 +
1.757 + return zIn;
1.758 +}
1.759 +
1.760 +
1.761 +/*
1.762 +** Execute a query statement that has a single result column. Print
1.763 +** that result column on a line by itself with a semicolon terminator.
1.764 +**
1.765 +** This is used, for example, to show the schema of the database by
1.766 +** querying the SQLITE_MASTER table.
1.767 +*/
1.768 +static int run_table_dump_query(FILE *out, sqlite3 *db, const char *zSelect){
1.769 + sqlite3_stmt *pSelect;
1.770 + int rc;
1.771 + rc = sqlite3_prepare(db, zSelect, -1, &pSelect, 0);
1.772 + if( rc!=SQLITE_OK || !pSelect ){
1.773 + return rc;
1.774 + }
1.775 + rc = sqlite3_step(pSelect);
1.776 + while( rc==SQLITE_ROW ){
1.777 + fprintf(out, "%s;\n", sqlite3_column_text(pSelect, 0));
1.778 + rc = sqlite3_step(pSelect);
1.779 + }
1.780 + return sqlite3_finalize(pSelect);
1.781 +}
1.782 +
1.783 +
1.784 +/*
1.785 +** This is a different callback routine used for dumping the database.
1.786 +** Each row received by this callback consists of a table name,
1.787 +** the table type ("index" or "table") and SQL to create the table.
1.788 +** This routine should print text sufficient to recreate the table.
1.789 +*/
1.790 +static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
1.791 + int rc;
1.792 + const char *zTable;
1.793 + const char *zType;
1.794 + const char *zSql;
1.795 + struct callback_data *p = (struct callback_data *)pArg;
1.796 +
1.797 + if( nArg!=3 ) return 1;
1.798 + zTable = azArg[0];
1.799 + zType = azArg[1];
1.800 + zSql = azArg[2];
1.801 +
1.802 + if( strcmp(zTable, "sqlite_sequence")==0 ){
1.803 + fprintf(p->out, "DELETE FROM sqlite_sequence;\n");
1.804 + }else if( strcmp(zTable, "sqlite_stat1")==0 ){
1.805 + fprintf(p->out, "ANALYZE sqlite_master;\n");
1.806 + }else if( strncmp(zTable, "sqlite_", 7)==0 ){
1.807 + return 0;
1.808 + }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
1.809 + char *zIns;
1.810 + if( !p->writableSchema ){
1.811 + fprintf(p->out, "PRAGMA writable_schema=ON;\n");
1.812 + p->writableSchema = 1;
1.813 + }
1.814 + zIns = sqlite3_mprintf(
1.815 + "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
1.816 + "VALUES('table','%q','%q',0,'%q');",
1.817 + zTable, zTable, zSql);
1.818 + fprintf(p->out, "%s\n", zIns);
1.819 + sqlite3_free(zIns);
1.820 + return 0;
1.821 + }else{
1.822 + fprintf(p->out, "%s;\n", zSql);
1.823 + }
1.824 +
1.825 + if( strcmp(zType, "table")==0 ){
1.826 + sqlite3_stmt *pTableInfo = 0;
1.827 + char *zSelect = 0;
1.828 + char *zTableInfo = 0;
1.829 + char *zTmp = 0;
1.830 +
1.831 + zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);
1.832 + zTableInfo = appendText(zTableInfo, zTable, '"');
1.833 + zTableInfo = appendText(zTableInfo, ");", 0);
1.834 +
1.835 + rc = sqlite3_prepare(p->db, zTableInfo, -1, &pTableInfo, 0);
1.836 + if( zTableInfo ) free(zTableInfo);
1.837 + if( rc!=SQLITE_OK || !pTableInfo ){
1.838 + return 1;
1.839 + }
1.840 +
1.841 + zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0);
1.842 + zTmp = appendText(zTmp, zTable, '"');
1.843 + if( zTmp ){
1.844 + zSelect = appendText(zSelect, zTmp, '\'');
1.845 + }
1.846 + zSelect = appendText(zSelect, " || ' VALUES(' || ", 0);
1.847 + rc = sqlite3_step(pTableInfo);
1.848 + while( rc==SQLITE_ROW ){
1.849 + const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1);
1.850 + zSelect = appendText(zSelect, "quote(", 0);
1.851 + zSelect = appendText(zSelect, zText, '"');
1.852 + rc = sqlite3_step(pTableInfo);
1.853 + if( rc==SQLITE_ROW ){
1.854 + zSelect = appendText(zSelect, ") || ',' || ", 0);
1.855 + }else{
1.856 + zSelect = appendText(zSelect, ") ", 0);
1.857 + }
1.858 + }
1.859 + rc = sqlite3_finalize(pTableInfo);
1.860 + if( rc!=SQLITE_OK ){
1.861 + if( zSelect ) free(zSelect);
1.862 + return 1;
1.863 + }
1.864 + zSelect = appendText(zSelect, "|| ')' FROM ", 0);
1.865 + zSelect = appendText(zSelect, zTable, '"');
1.866 +
1.867 + rc = run_table_dump_query(p->out, p->db, zSelect);
1.868 + if( rc==SQLITE_CORRUPT ){
1.869 + zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);
1.870 + rc = run_table_dump_query(p->out, p->db, zSelect);
1.871 + }
1.872 + if( zSelect ) free(zSelect);
1.873 + }
1.874 + return 0;
1.875 +}
1.876 +
1.877 +/*
1.878 +** Run zQuery. Use dump_callback() as the callback routine so that
1.879 +** the contents of the query are output as SQL statements.
1.880 +**
1.881 +** If we get a SQLITE_CORRUPT error, rerun the query after appending
1.882 +** "ORDER BY rowid DESC" to the end.
1.883 +*/
1.884 +static int run_schema_dump_query(
1.885 + struct callback_data *p,
1.886 + const char *zQuery,
1.887 + char **pzErrMsg
1.888 +){
1.889 + int rc;
1.890 + rc = sqlite3_exec(p->db, zQuery, dump_callback, p, pzErrMsg);
1.891 + if( rc==SQLITE_CORRUPT ){
1.892 + char *zQ2;
1.893 + int len = strlen(zQuery);
1.894 + if( pzErrMsg ) sqlite3_free(*pzErrMsg);
1.895 + zQ2 = malloc( len+100 );
1.896 + if( zQ2==0 ) return rc;
1.897 + sqlite3_snprintf(sizeof(zQ2), zQ2, "%s ORDER BY rowid DESC", zQuery);
1.898 + rc = sqlite3_exec(p->db, zQ2, dump_callback, p, pzErrMsg);
1.899 + free(zQ2);
1.900 + }
1.901 + return rc;
1.902 +}
1.903 +
1.904 +/*
1.905 +** Text of a help message
1.906 +*/
1.907 +static char zHelp[] =
1.908 + ".bail ON|OFF Stop after hitting an error. Default OFF\n"
1.909 + ".databases List names and files of attached databases\n"
1.910 + ".dump ?TABLE? ... Dump the database in an SQL text format\n"
1.911 + ".echo ON|OFF Turn command echo on or off\n"
1.912 + ".exit Exit this program\n"
1.913 + ".explain ON|OFF Turn output mode suitable for EXPLAIN on or off.\n"
1.914 + ".header(s) ON|OFF Turn display of headers on or off\n"
1.915 + ".help Show this message\n"
1.916 + ".import FILE TABLE Import data from FILE into TABLE\n"
1.917 + ".indices TABLE Show names of all indices on TABLE\n"
1.918 +#ifdef SQLITE_ENABLE_IOTRACE
1.919 + ".iotrace FILE Enable I/O diagnostic logging to FILE\n"
1.920 +#endif
1.921 +#ifndef SQLITE_OMIT_LOAD_EXTENSION
1.922 + ".load FILE ?ENTRY? Load an extension library\n"
1.923 +#endif
1.924 + ".mode MODE ?TABLE? Set output mode where MODE is one of:\n"
1.925 + " csv Comma-separated values\n"
1.926 + " column Left-aligned columns. (See .width)\n"
1.927 + " html HTML <table> code\n"
1.928 + " insert SQL insert statements for TABLE\n"
1.929 + " line One value per line\n"
1.930 + " list Values delimited by .separator string\n"
1.931 + " tabs Tab-separated values\n"
1.932 + " tcl TCL list elements\n"
1.933 + ".nullvalue STRING Print STRING in place of NULL values\n"
1.934 + ".output FILENAME Send output to FILENAME\n"
1.935 + ".output stdout Send output to the screen\n"
1.936 + ".prompt MAIN CONTINUE Replace the standard prompts\n"
1.937 + ".quit Exit this program\n"
1.938 + ".read FILENAME Execute SQL in FILENAME\n"
1.939 + ".schema ?TABLE? Show the CREATE statements\n"
1.940 + ".separator STRING Change separator used by output mode and .import\n"
1.941 + ".show Show the current values for various settings\n"
1.942 + ".tables ?PATTERN? List names of tables matching a LIKE pattern\n"
1.943 + ".timeout MS Try opening locked tables for MS milliseconds\n"
1.944 +#if HAS_TIMER
1.945 + ".timer ON|OFF Turn the CPU timer measurement on or off\n"
1.946 +#endif
1.947 + ".width NUM NUM ... Set column widths for \"column\" mode\n"
1.948 +;
1.949 +
1.950 +/* Forward reference */
1.951 +static int process_input(struct callback_data *p, FILE *in);
1.952 +
1.953 +/*
1.954 +** Make sure the database is open. If it is not, then open it. If
1.955 +** the database fails to open, print an error message and exit.
1.956 +*/
1.957 +static void open_db(struct callback_data *p){
1.958 + if( p->db==0 ){
1.959 + sqlite3_open(p->zDbFilename, &p->db);
1.960 + db = p->db;
1.961 + if( db && sqlite3_errcode(db)==SQLITE_OK ){
1.962 + sqlite3_create_function(db, "shellstatic", 0, SQLITE_UTF8, 0,
1.963 + shellstaticFunc, 0, 0);
1.964 + }
1.965 + if( db==0 || SQLITE_OK!=sqlite3_errcode(db) ){
1.966 + fprintf(stderr,"Unable to open database \"%s\": %s\n",
1.967 + p->zDbFilename, sqlite3_errmsg(db));
1.968 + exit(1);
1.969 + }
1.970 +#ifndef SQLITE_OMIT_LOAD_EXTENSION
1.971 + sqlite3_enable_load_extension(p->db, 1);
1.972 +#endif
1.973 + }
1.974 +}
1.975 +
1.976 +/*
1.977 +** Do C-language style dequoting.
1.978 +**
1.979 +** \t -> tab
1.980 +** \n -> newline
1.981 +** \r -> carriage return
1.982 +** \NNN -> ascii character NNN in octal
1.983 +** \\ -> backslash
1.984 +*/
1.985 +static void resolve_backslashes(char *z){
1.986 + int i, j, c;
1.987 + for(i=j=0; (c = z[i])!=0; i++, j++){
1.988 + if( c=='\\' ){
1.989 + c = z[++i];
1.990 + if( c=='n' ){
1.991 + c = '\n';
1.992 + }else if( c=='t' ){
1.993 + c = '\t';
1.994 + }else if( c=='r' ){
1.995 + c = '\r';
1.996 + }else if( c>='0' && c<='7' ){
1.997 + c -= '0';
1.998 + if( z[i+1]>='0' && z[i+1]<='7' ){
1.999 + i++;
1.1000 + c = (c<<3) + z[i] - '0';
1.1001 + if( z[i+1]>='0' && z[i+1]<='7' ){
1.1002 + i++;
1.1003 + c = (c<<3) + z[i] - '0';
1.1004 + }
1.1005 + }
1.1006 + }
1.1007 + }
1.1008 + z[j] = c;
1.1009 + }
1.1010 + z[j] = 0;
1.1011 +}
1.1012 +
1.1013 +/*
1.1014 +** Interpret zArg as a boolean value. Return either 0 or 1.
1.1015 +*/
1.1016 +static int booleanValue(char *zArg){
1.1017 + int val = atoi(zArg);
1.1018 + int j;
1.1019 + for(j=0; zArg[j]; j++){
1.1020 + zArg[j] = tolower(zArg[j]);
1.1021 + }
1.1022 + if( strcmp(zArg,"on")==0 ){
1.1023 + val = 1;
1.1024 + }else if( strcmp(zArg,"yes")==0 ){
1.1025 + val = 1;
1.1026 + }
1.1027 + return val;
1.1028 +}
1.1029 +
1.1030 +/*
1.1031 +** If an input line begins with "." then invoke this routine to
1.1032 +** process that line.
1.1033 +**
1.1034 +** Return 1 on error, 2 to exit, and 0 otherwise.
1.1035 +*/
1.1036 +static int do_meta_command(char *zLine, struct callback_data *p){
1.1037 + int i = 1;
1.1038 + int nArg = 0;
1.1039 + int n, c;
1.1040 + int rc = 0;
1.1041 + char *azArg[50];
1.1042 +
1.1043 + /* Parse the input line into tokens.
1.1044 + */
1.1045 + while( zLine[i] && nArg<ArraySize(azArg) ){
1.1046 + while( isspace((unsigned char)zLine[i]) ){ i++; }
1.1047 + if( zLine[i]==0 ) break;
1.1048 + if( zLine[i]=='\'' || zLine[i]=='"' ){
1.1049 + int delim = zLine[i++];
1.1050 + azArg[nArg++] = &zLine[i];
1.1051 + while( zLine[i] && zLine[i]!=delim ){ i++; }
1.1052 + if( zLine[i]==delim ){
1.1053 + zLine[i++] = 0;
1.1054 + }
1.1055 + if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
1.1056 + }else{
1.1057 + azArg[nArg++] = &zLine[i];
1.1058 + while( zLine[i] && !isspace((unsigned char)zLine[i]) ){ i++; }
1.1059 + if( zLine[i] ) zLine[i++] = 0;
1.1060 + resolve_backslashes(azArg[nArg-1]);
1.1061 + }
1.1062 + }
1.1063 +
1.1064 + /* Process the input line.
1.1065 + */
1.1066 + if( nArg==0 ) return rc;
1.1067 + n = strlen(azArg[0]);
1.1068 + c = azArg[0][0];
1.1069 + if( c=='b' && n>1 && strncmp(azArg[0], "bail", n)==0 && nArg>1 ){
1.1070 + bail_on_error = booleanValue(azArg[1]);
1.1071 + }else
1.1072 +
1.1073 + if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){
1.1074 + struct callback_data data;
1.1075 + char *zErrMsg = 0;
1.1076 + open_db(p);
1.1077 + memcpy(&data, p, sizeof(data));
1.1078 + data.showHeader = 1;
1.1079 + data.mode = MODE_Column;
1.1080 + data.colWidth[0] = 3;
1.1081 + data.colWidth[1] = 15;
1.1082 + data.colWidth[2] = 58;
1.1083 + data.cnt = 0;
1.1084 + sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg);
1.1085 + if( zErrMsg ){
1.1086 + fprintf(stderr,"Error: %s\n", zErrMsg);
1.1087 + sqlite3_free(zErrMsg);
1.1088 + }
1.1089 + }else
1.1090 +
1.1091 + if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
1.1092 + char *zErrMsg = 0;
1.1093 + open_db(p);
1.1094 + fprintf(p->out, "BEGIN TRANSACTION;\n");
1.1095 + p->writableSchema = 0;
1.1096 + sqlite3_exec(p->db, "PRAGMA writable_schema=ON", 0, 0, 0);
1.1097 + if( nArg==1 ){
1.1098 + run_schema_dump_query(p,
1.1099 + "SELECT name, type, sql FROM sqlite_master "
1.1100 + "WHERE sql NOT NULL AND type=='table'", 0
1.1101 + );
1.1102 + run_table_dump_query(p->out, p->db,
1.1103 + "SELECT sql FROM sqlite_master "
1.1104 + "WHERE sql NOT NULL AND type IN ('index','trigger','view')"
1.1105 + );
1.1106 + }else{
1.1107 + int i;
1.1108 + for(i=1; i<nArg; i++){
1.1109 + zShellStatic = azArg[i];
1.1110 + run_schema_dump_query(p,
1.1111 + "SELECT name, type, sql FROM sqlite_master "
1.1112 + "WHERE tbl_name LIKE shellstatic() AND type=='table'"
1.1113 + " AND sql NOT NULL", 0);
1.1114 + run_table_dump_query(p->out, p->db,
1.1115 + "SELECT sql FROM sqlite_master "
1.1116 + "WHERE sql NOT NULL"
1.1117 + " AND type IN ('index','trigger','view')"
1.1118 + " AND tbl_name LIKE shellstatic()"
1.1119 + );
1.1120 + zShellStatic = 0;
1.1121 + }
1.1122 + }
1.1123 + if( p->writableSchema ){
1.1124 + fprintf(p->out, "PRAGMA writable_schema=OFF;\n");
1.1125 + p->writableSchema = 0;
1.1126 + }
1.1127 + sqlite3_exec(p->db, "PRAGMA writable_schema=OFF", 0, 0, 0);
1.1128 + if( zErrMsg ){
1.1129 + fprintf(stderr,"Error: %s\n", zErrMsg);
1.1130 + sqlite3_free(zErrMsg);
1.1131 + }else{
1.1132 + fprintf(p->out, "COMMIT;\n");
1.1133 + }
1.1134 + }else
1.1135 +
1.1136 + if( c=='e' && strncmp(azArg[0], "echo", n)==0 && nArg>1 ){
1.1137 + p->echoOn = booleanValue(azArg[1]);
1.1138 + }else
1.1139 +
1.1140 + if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){
1.1141 + rc = 2;
1.1142 + }else
1.1143 +
1.1144 + if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){
1.1145 + int val = nArg>=2 ? booleanValue(azArg[1]) : 1;
1.1146 + if(val == 1) {
1.1147 + if(!p->explainPrev.valid) {
1.1148 + p->explainPrev.valid = 1;
1.1149 + p->explainPrev.mode = p->mode;
1.1150 + p->explainPrev.showHeader = p->showHeader;
1.1151 + memcpy(p->explainPrev.colWidth,p->colWidth,sizeof(p->colWidth));
1.1152 + }
1.1153 + /* We could put this code under the !p->explainValid
1.1154 + ** condition so that it does not execute if we are already in
1.1155 + ** explain mode. However, always executing it allows us an easy
1.1156 + ** was to reset to explain mode in case the user previously
1.1157 + ** did an .explain followed by a .width, .mode or .header
1.1158 + ** command.
1.1159 + */
1.1160 + p->mode = MODE_Explain;
1.1161 + p->showHeader = 1;
1.1162 + memset(p->colWidth,0,ArraySize(p->colWidth));
1.1163 + p->colWidth[0] = 4; /* addr */
1.1164 + p->colWidth[1] = 13; /* opcode */
1.1165 + p->colWidth[2] = 4; /* P1 */
1.1166 + p->colWidth[3] = 4; /* P2 */
1.1167 + p->colWidth[4] = 4; /* P3 */
1.1168 + p->colWidth[5] = 13; /* P4 */
1.1169 + p->colWidth[6] = 2; /* P5 */
1.1170 + p->colWidth[7] = 13; /* Comment */
1.1171 + }else if (p->explainPrev.valid) {
1.1172 + p->explainPrev.valid = 0;
1.1173 + p->mode = p->explainPrev.mode;
1.1174 + p->showHeader = p->explainPrev.showHeader;
1.1175 + memcpy(p->colWidth,p->explainPrev.colWidth,sizeof(p->colWidth));
1.1176 + }
1.1177 + }else
1.1178 +
1.1179 + if( c=='h' && (strncmp(azArg[0], "header", n)==0 ||
1.1180 + strncmp(azArg[0], "headers", n)==0 )&& nArg>1 ){
1.1181 + p->showHeader = booleanValue(azArg[1]);
1.1182 + }else
1.1183 +
1.1184 + if( c=='h' && strncmp(azArg[0], "help", n)==0 ){
1.1185 + fprintf(stderr,zHelp);
1.1186 + }else
1.1187 +
1.1188 + if( c=='i' && strncmp(azArg[0], "import", n)==0 && nArg>=3 ){
1.1189 + char *zTable = azArg[2]; /* Insert data into this table */
1.1190 + char *zFile = azArg[1]; /* The file from which to extract data */
1.1191 + sqlite3_stmt *pStmt; /* A statement */
1.1192 + int rc; /* Result code */
1.1193 + int nCol; /* Number of columns in the table */
1.1194 + int nByte; /* Number of bytes in an SQL string */
1.1195 + int i, j; /* Loop counters */
1.1196 + int nSep; /* Number of bytes in p->separator[] */
1.1197 + char *zSql; /* An SQL statement */
1.1198 + char *zLine; /* A single line of input from the file */
1.1199 + char **azCol; /* zLine[] broken up into columns */
1.1200 + char *zCommit; /* How to commit changes */
1.1201 + FILE *in; /* The input file */
1.1202 + int lineno = 0; /* Line number of input file */
1.1203 +
1.1204 + open_db(p);
1.1205 + nSep = strlen(p->separator);
1.1206 + if( nSep==0 ){
1.1207 + fprintf(stderr, "non-null separator required for import\n");
1.1208 + return 0;
1.1209 + }
1.1210 + zSql = sqlite3_mprintf("SELECT * FROM '%q'", zTable);
1.1211 + if( zSql==0 ) return 0;
1.1212 + nByte = strlen(zSql);
1.1213 + rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
1.1214 + sqlite3_free(zSql);
1.1215 + if( rc ){
1.1216 + fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
1.1217 + nCol = 0;
1.1218 + rc = 1;
1.1219 + }else{
1.1220 + nCol = sqlite3_column_count(pStmt);
1.1221 + }
1.1222 + sqlite3_finalize(pStmt);
1.1223 + if( nCol==0 ) return 0;
1.1224 + zSql = malloc( nByte + 20 + nCol*2 );
1.1225 + if( zSql==0 ) return 0;
1.1226 + sqlite3_snprintf(nByte+20, zSql, "INSERT INTO '%q' VALUES(?", zTable);
1.1227 + j = strlen(zSql);
1.1228 + for(i=1; i<nCol; i++){
1.1229 + zSql[j++] = ',';
1.1230 + zSql[j++] = '?';
1.1231 + }
1.1232 + zSql[j++] = ')';
1.1233 + zSql[j] = 0;
1.1234 + rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
1.1235 + free(zSql);
1.1236 + if( rc ){
1.1237 + fprintf(stderr, "Error: %s\n", sqlite3_errmsg(db));
1.1238 + sqlite3_finalize(pStmt);
1.1239 + return 1;
1.1240 + }
1.1241 + in = fopen(zFile, "rb");
1.1242 + if( in==0 ){
1.1243 + fprintf(stderr, "cannot open file: %s\n", zFile);
1.1244 + sqlite3_finalize(pStmt);
1.1245 + return 0;
1.1246 + }
1.1247 + azCol = malloc( sizeof(azCol[0])*(nCol+1) );
1.1248 + if( azCol==0 ){
1.1249 + fclose(in);
1.1250 + return 0;
1.1251 + }
1.1252 + sqlite3_exec(p->db, "BEGIN", 0, 0, 0);
1.1253 + zCommit = "COMMIT";
1.1254 + while( (zLine = local_getline(0, in))!=0 ){
1.1255 + char *z;
1.1256 + i = 0;
1.1257 + lineno++;
1.1258 + azCol[0] = zLine;
1.1259 + for(i=0, z=zLine; *z && *z!='\n' && *z!='\r'; z++){
1.1260 + if( *z==p->separator[0] && strncmp(z, p->separator, nSep)==0 ){
1.1261 + *z = 0;
1.1262 + i++;
1.1263 + if( i<nCol ){
1.1264 + azCol[i] = &z[nSep];
1.1265 + z += nSep-1;
1.1266 + }
1.1267 + }
1.1268 + }
1.1269 + *z = 0;
1.1270 + if( i+1!=nCol ){
1.1271 + fprintf(stderr,"%s line %d: expected %d columns of data but found %d\n",
1.1272 + zFile, lineno, nCol, i+1);
1.1273 + zCommit = "ROLLBACK";
1.1274 + break;
1.1275 + }
1.1276 + for(i=0; i<nCol; i++){
1.1277 + sqlite3_bind_text(pStmt, i+1, azCol[i], -1, SQLITE_STATIC);
1.1278 + }
1.1279 + sqlite3_step(pStmt);
1.1280 + rc = sqlite3_reset(pStmt);
1.1281 + free(zLine);
1.1282 + if( rc!=SQLITE_OK ){
1.1283 + fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
1.1284 + zCommit = "ROLLBACK";
1.1285 + rc = 1;
1.1286 + break;
1.1287 + }
1.1288 + }
1.1289 + free(azCol);
1.1290 + fclose(in);
1.1291 + sqlite3_finalize(pStmt);
1.1292 + sqlite3_exec(p->db, zCommit, 0, 0, 0);
1.1293 + }else
1.1294 +
1.1295 + if( c=='i' && strncmp(azArg[0], "indices", n)==0 && nArg>1 ){
1.1296 + struct callback_data data;
1.1297 + char *zErrMsg = 0;
1.1298 + open_db(p);
1.1299 + memcpy(&data, p, sizeof(data));
1.1300 + data.showHeader = 0;
1.1301 + data.mode = MODE_List;
1.1302 + zShellStatic = azArg[1];
1.1303 + sqlite3_exec(p->db,
1.1304 + "SELECT name FROM sqlite_master "
1.1305 + "WHERE type='index' AND tbl_name LIKE shellstatic() "
1.1306 + "UNION ALL "
1.1307 + "SELECT name FROM sqlite_temp_master "
1.1308 + "WHERE type='index' AND tbl_name LIKE shellstatic() "
1.1309 + "ORDER BY 1",
1.1310 + callback, &data, &zErrMsg
1.1311 + );
1.1312 + zShellStatic = 0;
1.1313 + if( zErrMsg ){
1.1314 + fprintf(stderr,"Error: %s\n", zErrMsg);
1.1315 + sqlite3_free(zErrMsg);
1.1316 + }
1.1317 + }else
1.1318 +
1.1319 +#ifdef SQLITE_ENABLE_IOTRACE
1.1320 + if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){
1.1321 + extern void (*sqlite3IoTrace)(const char*, ...);
1.1322 + if( iotrace && iotrace!=stdout ) fclose(iotrace);
1.1323 + iotrace = 0;
1.1324 + if( nArg<2 ){
1.1325 + sqlite3IoTrace = 0;
1.1326 + }else if( strcmp(azArg[1], "-")==0 ){
1.1327 + sqlite3IoTrace = iotracePrintf;
1.1328 + iotrace = stdout;
1.1329 + }else{
1.1330 + iotrace = fopen(azArg[1], "w");
1.1331 + if( iotrace==0 ){
1.1332 + fprintf(stderr, "cannot open \"%s\"\n", azArg[1]);
1.1333 + sqlite3IoTrace = 0;
1.1334 + }else{
1.1335 + sqlite3IoTrace = iotracePrintf;
1.1336 + }
1.1337 + }
1.1338 + }else
1.1339 +#endif
1.1340 +
1.1341 +#ifndef SQLITE_OMIT_LOAD_EXTENSION
1.1342 + if( c=='l' && strncmp(azArg[0], "load", n)==0 && nArg>=2 ){
1.1343 + const char *zFile, *zProc;
1.1344 + char *zErrMsg = 0;
1.1345 + int rc;
1.1346 + zFile = azArg[1];
1.1347 + zProc = nArg>=3 ? azArg[2] : 0;
1.1348 + open_db(p);
1.1349 + rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
1.1350 + if( rc!=SQLITE_OK ){
1.1351 + fprintf(stderr, "%s\n", zErrMsg);
1.1352 + sqlite3_free(zErrMsg);
1.1353 + rc = 1;
1.1354 + }
1.1355 + }else
1.1356 +#endif
1.1357 +
1.1358 + if( c=='m' && strncmp(azArg[0], "mode", n)==0 && nArg>=2 ){
1.1359 + int n2 = strlen(azArg[1]);
1.1360 + if( strncmp(azArg[1],"line",n2)==0
1.1361 + ||
1.1362 + strncmp(azArg[1],"lines",n2)==0 ){
1.1363 + p->mode = MODE_Line;
1.1364 + }else if( strncmp(azArg[1],"column",n2)==0
1.1365 + ||
1.1366 + strncmp(azArg[1],"columns",n2)==0 ){
1.1367 + p->mode = MODE_Column;
1.1368 + }else if( strncmp(azArg[1],"list",n2)==0 ){
1.1369 + p->mode = MODE_List;
1.1370 + }else if( strncmp(azArg[1],"html",n2)==0 ){
1.1371 + p->mode = MODE_Html;
1.1372 + }else if( strncmp(azArg[1],"tcl",n2)==0 ){
1.1373 + p->mode = MODE_Tcl;
1.1374 + }else if( strncmp(azArg[1],"csv",n2)==0 ){
1.1375 + p->mode = MODE_Csv;
1.1376 + sqlite3_snprintf(sizeof(p->separator), p->separator, ",");
1.1377 + }else if( strncmp(azArg[1],"tabs",n2)==0 ){
1.1378 + p->mode = MODE_List;
1.1379 + sqlite3_snprintf(sizeof(p->separator), p->separator, "\t");
1.1380 + }else if( strncmp(azArg[1],"insert",n2)==0 ){
1.1381 + p->mode = MODE_Insert;
1.1382 + if( nArg>=3 ){
1.1383 + set_table_name(p, azArg[2]);
1.1384 + }else{
1.1385 + set_table_name(p, "table");
1.1386 + }
1.1387 + }else {
1.1388 + fprintf(stderr,"mode should be one of: "
1.1389 + "column csv html insert line list tabs tcl\n");
1.1390 + }
1.1391 + }else
1.1392 +
1.1393 + if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 && nArg==2 ) {
1.1394 + sqlite3_snprintf(sizeof(p->nullvalue), p->nullvalue,
1.1395 + "%.*s", (int)ArraySize(p->nullvalue)-1, azArg[1]);
1.1396 + }else
1.1397 +
1.1398 + if( c=='o' && strncmp(azArg[0], "output", n)==0 && nArg==2 ){
1.1399 + if( p->out!=stdout ){
1.1400 + fclose(p->out);
1.1401 + }
1.1402 + if( strcmp(azArg[1],"stdout")==0 ){
1.1403 + p->out = stdout;
1.1404 + sqlite3_snprintf(sizeof(p->outfile), p->outfile, "stdout");
1.1405 + }else{
1.1406 + p->out = fopen(azArg[1], "wb");
1.1407 + if( p->out==0 ){
1.1408 + fprintf(stderr,"can't write to \"%s\"\n", azArg[1]);
1.1409 + p->out = stdout;
1.1410 + } else {
1.1411 + sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", azArg[1]);
1.1412 + }
1.1413 + }
1.1414 + }else
1.1415 +
1.1416 + if( c=='p' && strncmp(azArg[0], "prompt", n)==0 && (nArg==2 || nArg==3)){
1.1417 + if( nArg >= 2) {
1.1418 + strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
1.1419 + }
1.1420 + if( nArg >= 3) {
1.1421 + strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
1.1422 + }
1.1423 + }else
1.1424 +
1.1425 + if( c=='q' && strncmp(azArg[0], "quit", n)==0 ){
1.1426 + rc = 2;
1.1427 + }else
1.1428 +
1.1429 + if( c=='r' && strncmp(azArg[0], "read", n)==0 && nArg==2 ){
1.1430 + FILE *alt = fopen(azArg[1], "rb");
1.1431 + if( alt==0 ){
1.1432 + fprintf(stderr,"can't open \"%s\"\n", azArg[1]);
1.1433 + }else{
1.1434 + process_input(p, alt);
1.1435 + fclose(alt);
1.1436 + }
1.1437 + }else
1.1438 +
1.1439 + if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){
1.1440 + struct callback_data data;
1.1441 + char *zErrMsg = 0;
1.1442 + open_db(p);
1.1443 + memcpy(&data, p, sizeof(data));
1.1444 + data.showHeader = 0;
1.1445 + data.mode = MODE_Semi;
1.1446 + if( nArg>1 ){
1.1447 + int i;
1.1448 + for(i=0; azArg[1][i]; i++) azArg[1][i] = tolower(azArg[1][i]);
1.1449 + if( strcmp(azArg[1],"sqlite_master")==0 ){
1.1450 + char *new_argv[2], *new_colv[2];
1.1451 + new_argv[0] = "CREATE TABLE sqlite_master (\n"
1.1452 + " type text,\n"
1.1453 + " name text,\n"
1.1454 + " tbl_name text,\n"
1.1455 + " rootpage integer,\n"
1.1456 + " sql text\n"
1.1457 + ")";
1.1458 + new_argv[1] = 0;
1.1459 + new_colv[0] = "sql";
1.1460 + new_colv[1] = 0;
1.1461 + callback(&data, 1, new_argv, new_colv);
1.1462 + }else if( strcmp(azArg[1],"sqlite_temp_master")==0 ){
1.1463 + char *new_argv[2], *new_colv[2];
1.1464 + new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n"
1.1465 + " type text,\n"
1.1466 + " name text,\n"
1.1467 + " tbl_name text,\n"
1.1468 + " rootpage integer,\n"
1.1469 + " sql text\n"
1.1470 + ")";
1.1471 + new_argv[1] = 0;
1.1472 + new_colv[0] = "sql";
1.1473 + new_colv[1] = 0;
1.1474 + callback(&data, 1, new_argv, new_colv);
1.1475 + }else{
1.1476 + zShellStatic = azArg[1];
1.1477 + sqlite3_exec(p->db,
1.1478 + "SELECT sql FROM "
1.1479 + " (SELECT * FROM sqlite_master UNION ALL"
1.1480 + " SELECT * FROM sqlite_temp_master) "
1.1481 + "WHERE tbl_name LIKE shellstatic() AND type!='meta' AND sql NOTNULL "
1.1482 + "ORDER BY substr(type,2,1), name",
1.1483 + callback, &data, &zErrMsg);
1.1484 + zShellStatic = 0;
1.1485 + }
1.1486 + }else{
1.1487 + sqlite3_exec(p->db,
1.1488 + "SELECT sql FROM "
1.1489 + " (SELECT * FROM sqlite_master UNION ALL"
1.1490 + " SELECT * FROM sqlite_temp_master) "
1.1491 + "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%'"
1.1492 + "ORDER BY substr(type,2,1), name",
1.1493 + callback, &data, &zErrMsg
1.1494 + );
1.1495 + }
1.1496 + if( zErrMsg ){
1.1497 + fprintf(stderr,"Error: %s\n", zErrMsg);
1.1498 + sqlite3_free(zErrMsg);
1.1499 + }
1.1500 + }else
1.1501 +
1.1502 + if( c=='s' && strncmp(azArg[0], "separator", n)==0 && nArg==2 ){
1.1503 + sqlite3_snprintf(sizeof(p->separator), p->separator,
1.1504 + "%.*s", (int)sizeof(p->separator)-1, azArg[1]);
1.1505 + }else
1.1506 +
1.1507 + if( c=='s' && strncmp(azArg[0], "show", n)==0){
1.1508 + int i;
1.1509 + fprintf(p->out,"%9.9s: %s\n","echo", p->echoOn ? "on" : "off");
1.1510 + fprintf(p->out,"%9.9s: %s\n","explain", p->explainPrev.valid ? "on" :"off");
1.1511 + fprintf(p->out,"%9.9s: %s\n","headers", p->showHeader ? "on" : "off");
1.1512 + fprintf(p->out,"%9.9s: %s\n","mode", modeDescr[p->mode]);
1.1513 + fprintf(p->out,"%9.9s: ", "nullvalue");
1.1514 + output_c_string(p->out, p->nullvalue);
1.1515 + fprintf(p->out, "\n");
1.1516 + fprintf(p->out,"%9.9s: %s\n","output",
1.1517 + strlen(p->outfile) ? p->outfile : "stdout");
1.1518 + fprintf(p->out,"%9.9s: ", "separator");
1.1519 + output_c_string(p->out, p->separator);
1.1520 + fprintf(p->out, "\n");
1.1521 + fprintf(p->out,"%9.9s: ","width");
1.1522 + for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) {
1.1523 + fprintf(p->out,"%d ",p->colWidth[i]);
1.1524 + }
1.1525 + fprintf(p->out,"\n");
1.1526 + }else
1.1527 +
1.1528 + if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 ){
1.1529 + char **azResult;
1.1530 + int nRow, rc;
1.1531 + char *zErrMsg;
1.1532 + open_db(p);
1.1533 + if( nArg==1 ){
1.1534 + rc = sqlite3_get_table(p->db,
1.1535 + "SELECT name FROM sqlite_master "
1.1536 + "WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%'"
1.1537 + "UNION ALL "
1.1538 + "SELECT name FROM sqlite_temp_master "
1.1539 + "WHERE type IN ('table','view') "
1.1540 + "ORDER BY 1",
1.1541 + &azResult, &nRow, 0, &zErrMsg
1.1542 + );
1.1543 + }else{
1.1544 + zShellStatic = azArg[1];
1.1545 + rc = sqlite3_get_table(p->db,
1.1546 + "SELECT name FROM sqlite_master "
1.1547 + "WHERE type IN ('table','view') AND name LIKE '%'||shellstatic()||'%' "
1.1548 + "UNION ALL "
1.1549 + "SELECT name FROM sqlite_temp_master "
1.1550 + "WHERE type IN ('table','view') AND name LIKE '%'||shellstatic()||'%' "
1.1551 + "ORDER BY 1",
1.1552 + &azResult, &nRow, 0, &zErrMsg
1.1553 + );
1.1554 + zShellStatic = 0;
1.1555 + }
1.1556 + if( zErrMsg ){
1.1557 + fprintf(stderr,"Error: %s\n", zErrMsg);
1.1558 + sqlite3_free(zErrMsg);
1.1559 + }
1.1560 + if( rc==SQLITE_OK ){
1.1561 + int len, maxlen = 0;
1.1562 + int i, j;
1.1563 + int nPrintCol, nPrintRow;
1.1564 + for(i=1; i<=nRow; i++){
1.1565 + if( azResult[i]==0 ) continue;
1.1566 + len = strlen(azResult[i]);
1.1567 + if( len>maxlen ) maxlen = len;
1.1568 + }
1.1569 + nPrintCol = 80/(maxlen+2);
1.1570 + if( nPrintCol<1 ) nPrintCol = 1;
1.1571 + nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
1.1572 + for(i=0; i<nPrintRow; i++){
1.1573 + for(j=i+1; j<=nRow; j+=nPrintRow){
1.1574 + char *zSp = j<=nPrintRow ? "" : " ";
1.1575 + printf("%s%-*s", zSp, maxlen, azResult[j] ? azResult[j] : "");
1.1576 + }
1.1577 + printf("\n");
1.1578 + }
1.1579 + }else{
1.1580 + rc = 1;
1.1581 + }
1.1582 + sqlite3_free_table(azResult);
1.1583 + }else
1.1584 +
1.1585 + if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 && nArg>=2 ){
1.1586 + open_db(p);
1.1587 + sqlite3_busy_timeout(p->db, atoi(azArg[1]));
1.1588 + }else
1.1589 +
1.1590 +#if HAS_TIMER
1.1591 + if( c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 && nArg>1 ){
1.1592 + enableTimer = booleanValue(azArg[1]);
1.1593 + }else
1.1594 +#endif
1.1595 +
1.1596 + if( c=='w' && strncmp(azArg[0], "width", n)==0 ){
1.1597 + int j;
1.1598 + assert( nArg<=ArraySize(azArg) );
1.1599 + for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){
1.1600 + p->colWidth[j-1] = atoi(azArg[j]);
1.1601 + }
1.1602 + }else
1.1603 +
1.1604 +
1.1605 + {
1.1606 + fprintf(stderr, "unknown command or invalid arguments: "
1.1607 + " \"%s\". Enter \".help\" for help\n", azArg[0]);
1.1608 + }
1.1609 +
1.1610 + return rc;
1.1611 +}
1.1612 +
1.1613 +/*
1.1614 +** Return TRUE if a semicolon occurs anywhere in the first N characters
1.1615 +** of string z[].
1.1616 +*/
1.1617 +static int _contains_semicolon(const char *z, int N){
1.1618 + int i;
1.1619 + for(i=0; i<N; i++){ if( z[i]==';' ) return 1; }
1.1620 + return 0;
1.1621 +}
1.1622 +
1.1623 +/*
1.1624 +** Test to see if a line consists entirely of whitespace.
1.1625 +*/
1.1626 +static int _all_whitespace(const char *z){
1.1627 + for(; *z; z++){
1.1628 + if( isspace(*(unsigned char*)z) ) continue;
1.1629 + if( *z=='/' && z[1]=='*' ){
1.1630 + z += 2;
1.1631 + while( *z && (*z!='*' || z[1]!='/') ){ z++; }
1.1632 + if( *z==0 ) return 0;
1.1633 + z++;
1.1634 + continue;
1.1635 + }
1.1636 + if( *z=='-' && z[1]=='-' ){
1.1637 + z += 2;
1.1638 + while( *z && *z!='\n' ){ z++; }
1.1639 + if( *z==0 ) return 1;
1.1640 + continue;
1.1641 + }
1.1642 + return 0;
1.1643 + }
1.1644 + return 1;
1.1645 +}
1.1646 +
1.1647 +/*
1.1648 +** Return TRUE if the line typed in is an SQL command terminator other
1.1649 +** than a semi-colon. The SQL Server style "go" command is understood
1.1650 +** as is the Oracle "/".
1.1651 +*/
1.1652 +static int _is_command_terminator(const char *zLine){
1.1653 + while( isspace(*(unsigned char*)zLine) ){ zLine++; };
1.1654 + if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ) return 1; /* Oracle */
1.1655 + if( tolower(zLine[0])=='g' && tolower(zLine[1])=='o'
1.1656 + && _all_whitespace(&zLine[2]) ){
1.1657 + return 1; /* SQL Server */
1.1658 + }
1.1659 + return 0;
1.1660 +}
1.1661 +
1.1662 +/*
1.1663 +** Read input from *in and process it. If *in==0 then input
1.1664 +** is interactive - the user is typing it it. Otherwise, input
1.1665 +** is coming from a file or device. A prompt is issued and history
1.1666 +** is saved only if input is interactive. An interrupt signal will
1.1667 +** cause this routine to exit immediately, unless input is interactive.
1.1668 +**
1.1669 +** Return the number of errors.
1.1670 +*/
1.1671 +static int process_input(struct callback_data *p, FILE *in){
1.1672 + char *zLine = 0;
1.1673 + char *zSql = 0;
1.1674 + int nSql = 0;
1.1675 + int nSqlPrior = 0;
1.1676 + char *zErrMsg;
1.1677 + int rc;
1.1678 + int errCnt = 0;
1.1679 + int lineno = 0;
1.1680 + int startline = 0;
1.1681 +
1.1682 + while( errCnt==0 || !bail_on_error || (in==0 && stdin_is_interactive) ){
1.1683 + fflush(p->out);
1.1684 + free(zLine);
1.1685 + zLine = one_input_line(zSql, in);
1.1686 + if( zLine==0 ){
1.1687 + break; /* We have reached EOF */
1.1688 + }
1.1689 + if( seenInterrupt ){
1.1690 + if( in!=0 ) break;
1.1691 + seenInterrupt = 0;
1.1692 + }
1.1693 + lineno++;
1.1694 + if( p->echoOn ) printf("%s\n", zLine);
1.1695 + if( (zSql==0 || zSql[0]==0) && _all_whitespace(zLine) ) continue;
1.1696 + if( zLine && zLine[0]=='.' && nSql==0 ){
1.1697 + rc = do_meta_command(zLine, p);
1.1698 + if( rc==2 ){
1.1699 + break;
1.1700 + }else if( rc ){
1.1701 + errCnt++;
1.1702 + }
1.1703 + continue;
1.1704 + }
1.1705 + if( _is_command_terminator(zLine) ){
1.1706 + memcpy(zLine,";",2);
1.1707 + }
1.1708 + nSqlPrior = nSql;
1.1709 + if( zSql==0 ){
1.1710 + int i;
1.1711 + for(i=0; zLine[i] && isspace((unsigned char)zLine[i]); i++){}
1.1712 + if( zLine[i]!=0 ){
1.1713 + nSql = strlen(zLine);
1.1714 + zSql = malloc( nSql+1 );
1.1715 + if( zSql==0 ){
1.1716 + fprintf(stderr, "out of memory\n");
1.1717 + exit(1);
1.1718 + }
1.1719 + memcpy(zSql, zLine, nSql+1);
1.1720 + startline = lineno;
1.1721 + }
1.1722 + }else{
1.1723 + int len = strlen(zLine);
1.1724 + zSql = realloc( zSql, nSql + len + 2 );
1.1725 + if( zSql==0 ){
1.1726 + fprintf(stderr,"%s: out of memory!\n", Argv0);
1.1727 + exit(1);
1.1728 + }
1.1729 + zSql[nSql++] = '\n';
1.1730 + memcpy(&zSql[nSql], zLine, len+1);
1.1731 + nSql += len;
1.1732 + }
1.1733 + if( zSql && _contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
1.1734 + && sqlite3_complete(zSql) ){
1.1735 + p->cnt = 0;
1.1736 + open_db(p);
1.1737 + BEGIN_TIMER;
1.1738 + rc = sqlite3_exec(p->db, zSql, callback, p, &zErrMsg);
1.1739 + END_TIMER;
1.1740 + if( rc || zErrMsg ){
1.1741 + char zPrefix[100];
1.1742 + if( in!=0 || !stdin_is_interactive ){
1.1743 + sqlite3_snprintf(sizeof(zPrefix), zPrefix,
1.1744 + "SQL error near line %d:", startline);
1.1745 + }else{
1.1746 + sqlite3_snprintf(sizeof(zPrefix), zPrefix, "SQL error:");
1.1747 + }
1.1748 + if( zErrMsg!=0 ){
1.1749 + printf("%s %s\n", zPrefix, zErrMsg);
1.1750 + sqlite3_free(zErrMsg);
1.1751 + zErrMsg = 0;
1.1752 + }else{
1.1753 + printf("%s %s\n", zPrefix, sqlite3_errmsg(p->db));
1.1754 + }
1.1755 + errCnt++;
1.1756 + }
1.1757 + free(zSql);
1.1758 + zSql = 0;
1.1759 + nSql = 0;
1.1760 + }
1.1761 + }
1.1762 + if( zSql ){
1.1763 + if( !_all_whitespace(zSql) ) printf("Incomplete SQL: %s\n", zSql);
1.1764 + free(zSql);
1.1765 + }
1.1766 + free(zLine);
1.1767 + return errCnt;
1.1768 +}
1.1769 +
1.1770 +/*
1.1771 +** Return a pathname which is the user's home directory. A
1.1772 +** 0 return indicates an error of some kind. Space to hold the
1.1773 +** resulting string is obtained from malloc(). The calling
1.1774 +** function should free the result.
1.1775 +*/
1.1776 +static char *find_home_dir(void){
1.1777 + char *home_dir = NULL;
1.1778 +
1.1779 +#if !defined(_WIN32) && !defined(WIN32) && !defined(__OS2__) && !defined(_WIN32_WCE)
1.1780 + struct passwd *pwent;
1.1781 + uid_t uid = getuid();
1.1782 + if( (pwent=getpwuid(uid)) != NULL) {
1.1783 + home_dir = pwent->pw_dir;
1.1784 + }
1.1785 +#endif
1.1786 +
1.1787 +#if defined(_WIN32_WCE)
1.1788 + /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
1.1789 + */
1.1790 + home_dir = strdup("/");
1.1791 +#else
1.1792 +
1.1793 +#if defined(_WIN32) || defined(WIN32) || defined(__OS2__)
1.1794 + if (!home_dir) {
1.1795 + home_dir = getenv("USERPROFILE");
1.1796 + }
1.1797 +#endif
1.1798 +
1.1799 + if (!home_dir) {
1.1800 + home_dir = getenv("HOME");
1.1801 + }
1.1802 +
1.1803 +#if defined(_WIN32) || defined(WIN32) || defined(__OS2__)
1.1804 + if (!home_dir) {
1.1805 + char *zDrive, *zPath;
1.1806 + int n;
1.1807 + zDrive = getenv("HOMEDRIVE");
1.1808 + zPath = getenv("HOMEPATH");
1.1809 + if( zDrive && zPath ){
1.1810 + n = strlen(zDrive) + strlen(zPath) + 1;
1.1811 + home_dir = malloc( n );
1.1812 + if( home_dir==0 ) return 0;
1.1813 + sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath);
1.1814 + return home_dir;
1.1815 + }
1.1816 + home_dir = "c:\\";
1.1817 + }
1.1818 +#endif
1.1819 +
1.1820 +#endif /* !_WIN32_WCE */
1.1821 +
1.1822 + if( home_dir ){
1.1823 + int n = strlen(home_dir) + 1;
1.1824 + char *z = malloc( n );
1.1825 + if( z ) memcpy(z, home_dir, n);
1.1826 + home_dir = z;
1.1827 + }
1.1828 +
1.1829 + return home_dir;
1.1830 +}
1.1831 +
1.1832 +/*
1.1833 +** Read input from the file given by sqliterc_override. Or if that
1.1834 +** parameter is NULL, take input from ~/.sqliterc
1.1835 +*/
1.1836 +static void process_sqliterc(
1.1837 + struct callback_data *p, /* Configuration data */
1.1838 + const char *sqliterc_override /* Name of config file. NULL to use default */
1.1839 +){
1.1840 + char *home_dir = NULL;
1.1841 + const char *sqliterc = sqliterc_override;
1.1842 + char *zBuf = 0;
1.1843 + FILE *in = NULL;
1.1844 + int nBuf;
1.1845 +
1.1846 + if (sqliterc == NULL) {
1.1847 + home_dir = find_home_dir();
1.1848 + if( home_dir==0 ){
1.1849 + fprintf(stderr,"%s: cannot locate your home directory!\n", Argv0);
1.1850 + return;
1.1851 + }
1.1852 + nBuf = strlen(home_dir) + 16;
1.1853 + zBuf = malloc( nBuf );
1.1854 + if( zBuf==0 ){
1.1855 + fprintf(stderr,"%s: out of memory!\n", Argv0);
1.1856 + exit(1);
1.1857 + }
1.1858 + sqlite3_snprintf(nBuf, zBuf,"%s/.sqliterc",home_dir);
1.1859 + free(home_dir);
1.1860 + sqliterc = (const char*)zBuf;
1.1861 + }
1.1862 + in = fopen(sqliterc,"rb");
1.1863 + if( in ){
1.1864 + if( stdin_is_interactive ){
1.1865 + printf("-- Loading resources from %s\n",sqliterc);
1.1866 + }
1.1867 + process_input(p,in);
1.1868 + fclose(in);
1.1869 + }
1.1870 + free(zBuf);
1.1871 + return;
1.1872 +}
1.1873 +
1.1874 +/*
1.1875 +** Show available command line options
1.1876 +*/
1.1877 +static const char zOptions[] =
1.1878 + " -init filename read/process named file\n"
1.1879 + " -echo print commands before execution\n"
1.1880 + " -[no]header turn headers on or off\n"
1.1881 + " -bail stop after hitting an error\n"
1.1882 + " -interactive force interactive I/O\n"
1.1883 + " -batch force batch I/O\n"
1.1884 + " -column set output mode to 'column'\n"
1.1885 + " -csv set output mode to 'csv'\n"
1.1886 + " -html set output mode to HTML\n"
1.1887 + " -line set output mode to 'line'\n"
1.1888 + " -list set output mode to 'list'\n"
1.1889 + " -separator 'x' set output field separator (|)\n"
1.1890 + " -nullvalue 'text' set text string for NULL values\n"
1.1891 + " -version show SQLite version\n"
1.1892 +;
1.1893 +static void usage(int showDetail){
1.1894 + fprintf(stderr,
1.1895 + "Usage: %s [OPTIONS] FILENAME [SQL]\n"
1.1896 + "FILENAME is the name of an SQLite database. A new database is created\n"
1.1897 + "if the file does not previously exist.\n", Argv0);
1.1898 + if( showDetail ){
1.1899 + fprintf(stderr, "OPTIONS include:\n%s", zOptions);
1.1900 + }else{
1.1901 + fprintf(stderr, "Use the -help option for additional information\n");
1.1902 + }
1.1903 + exit(1);
1.1904 +}
1.1905 +
1.1906 +/*
1.1907 +** Initialize the state information in data
1.1908 +*/
1.1909 +static void main_init(struct callback_data *data) {
1.1910 + memset(data, 0, sizeof(*data));
1.1911 + data->mode = MODE_List;
1.1912 + memcpy(data->separator,"|", 2);
1.1913 + data->showHeader = 0;
1.1914 + sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");
1.1915 + sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> ");
1.1916 +}
1.1917 +
1.1918 +int main(int argc, char **argv){
1.1919 + char *zErrMsg = 0;
1.1920 + struct callback_data data;
1.1921 + const char *zInitFile = 0;
1.1922 + char *zFirstCmd = 0;
1.1923 + int i;
1.1924 + int rc = 0;
1.1925 +
1.1926 + Argv0 = argv[0];
1.1927 + main_init(&data);
1.1928 + stdin_is_interactive = isatty(0);
1.1929 +
1.1930 + /* Make sure we have a valid signal handler early, before anything
1.1931 + ** else is done.
1.1932 + */
1.1933 +#ifdef SIGINT
1.1934 + signal(SIGINT, interrupt_handler);
1.1935 +#endif
1.1936 +
1.1937 + /* Do an initial pass through the command-line argument to locate
1.1938 + ** the name of the database file, the name of the initialization file,
1.1939 + ** and the first command to execute.
1.1940 + */
1.1941 + for(i=1; i<argc-1; i++){
1.1942 + char *z;
1.1943 + if( argv[i][0]!='-' ) break;
1.1944 + z = argv[i];
1.1945 + if( z[0]=='-' && z[1]=='-' ) z++;
1.1946 + if( strcmp(argv[i],"-separator")==0 || strcmp(argv[i],"-nullvalue")==0 ){
1.1947 + i++;
1.1948 + }else if( strcmp(argv[i],"-init")==0 ){
1.1949 + i++;
1.1950 + zInitFile = argv[i];
1.1951 + }
1.1952 + }
1.1953 + if( i<argc ){
1.1954 +#if defined(SQLITE_OS_OS2) && SQLITE_OS_OS2
1.1955 + data.zDbFilename = (const char *)convertCpPathToUtf8( argv[i++] );
1.1956 +#else
1.1957 + data.zDbFilename = argv[i++];
1.1958 +#endif
1.1959 + }else{
1.1960 +#ifndef SQLITE_OMIT_MEMORYDB
1.1961 + data.zDbFilename = ":memory:";
1.1962 +#else
1.1963 + data.zDbFilename = 0;
1.1964 +#endif
1.1965 + }
1.1966 + if( i<argc ){
1.1967 + zFirstCmd = argv[i++];
1.1968 + }
1.1969 + data.out = stdout;
1.1970 +
1.1971 +#ifdef SQLITE_OMIT_MEMORYDB
1.1972 + if( data.zDbFilename==0 ){
1.1973 + fprintf(stderr,"%s: no database filename specified\n", argv[0]);
1.1974 + exit(1);
1.1975 + }
1.1976 +#endif
1.1977 +
1.1978 + /* Go ahead and open the database file if it already exists. If the
1.1979 + ** file does not exist, delay opening it. This prevents empty database
1.1980 + ** files from being created if a user mistypes the database name argument
1.1981 + ** to the sqlite command-line tool.
1.1982 + */
1.1983 + if( access(data.zDbFilename, 0)==0 ){
1.1984 + open_db(&data);
1.1985 + }
1.1986 +
1.1987 + /* Process the initialization file if there is one. If no -init option
1.1988 + ** is given on the command line, look for a file named ~/.sqliterc and
1.1989 + ** try to process it.
1.1990 + */
1.1991 + process_sqliterc(&data,zInitFile);
1.1992 +
1.1993 + /* Make a second pass through the command-line argument and set
1.1994 + ** options. This second pass is delayed until after the initialization
1.1995 + ** file is processed so that the command-line arguments will override
1.1996 + ** settings in the initialization file.
1.1997 + */
1.1998 + for(i=1; i<argc && argv[i][0]=='-'; i++){
1.1999 + char *z = argv[i];
1.2000 + if( z[1]=='-' ){ z++; }
1.2001 + if( strcmp(z,"-init")==0 ){
1.2002 + i++;
1.2003 + }else if( strcmp(z,"-html")==0 ){
1.2004 + data.mode = MODE_Html;
1.2005 + }else if( strcmp(z,"-list")==0 ){
1.2006 + data.mode = MODE_List;
1.2007 + }else if( strcmp(z,"-line")==0 ){
1.2008 + data.mode = MODE_Line;
1.2009 + }else if( strcmp(z,"-column")==0 ){
1.2010 + data.mode = MODE_Column;
1.2011 + }else if( strcmp(z,"-csv")==0 ){
1.2012 + data.mode = MODE_Csv;
1.2013 + memcpy(data.separator,",",2);
1.2014 + }else if( strcmp(z,"-separator")==0 ){
1.2015 + i++;
1.2016 + sqlite3_snprintf(sizeof(data.separator), data.separator,
1.2017 + "%.*s",(int)sizeof(data.separator)-1,argv[i]);
1.2018 + }else if( strcmp(z,"-nullvalue")==0 ){
1.2019 + i++;
1.2020 + sqlite3_snprintf(sizeof(data.nullvalue), data.nullvalue,
1.2021 + "%.*s",(int)sizeof(data.nullvalue)-1,argv[i]);
1.2022 + }else if( strcmp(z,"-header")==0 ){
1.2023 + data.showHeader = 1;
1.2024 + }else if( strcmp(z,"-noheader")==0 ){
1.2025 + data.showHeader = 0;
1.2026 + }else if( strcmp(z,"-echo")==0 ){
1.2027 + data.echoOn = 1;
1.2028 + }else if( strcmp(z,"-bail")==0 ){
1.2029 + bail_on_error = 1;
1.2030 + }else if( strcmp(z,"-version")==0 ){
1.2031 + printf("%s\n", sqlite3_libversion());
1.2032 + return 0;
1.2033 + }else if( strcmp(z,"-interactive")==0 ){
1.2034 + stdin_is_interactive = 1;
1.2035 + }else if( strcmp(z,"-batch")==0 ){
1.2036 + stdin_is_interactive = 0;
1.2037 + }else if( strcmp(z,"-help")==0 || strcmp(z, "--help")==0 ){
1.2038 + usage(1);
1.2039 + }else{
1.2040 + fprintf(stderr,"%s: unknown option: %s\n", Argv0, z);
1.2041 + fprintf(stderr,"Use -help for a list of options.\n");
1.2042 + return 1;
1.2043 + }
1.2044 + }
1.2045 +
1.2046 + if( zFirstCmd ){
1.2047 + /* Run just the command that follows the database name
1.2048 + */
1.2049 + if( zFirstCmd[0]=='.' ){
1.2050 + do_meta_command(zFirstCmd, &data);
1.2051 + exit(0);
1.2052 + }else{
1.2053 + int rc;
1.2054 + open_db(&data);
1.2055 + rc = sqlite3_exec(data.db, zFirstCmd, callback, &data, &zErrMsg);
1.2056 + if( rc!=0 && zErrMsg!=0 ){
1.2057 + fprintf(stderr,"SQL error: %s\n", zErrMsg);
1.2058 + exit(1);
1.2059 + }
1.2060 + }
1.2061 + }else{
1.2062 + /* Run commands received from standard input
1.2063 + */
1.2064 + if( stdin_is_interactive ){
1.2065 + char *zHome;
1.2066 + char *zHistory = 0;
1.2067 + int nHistory;
1.2068 + printf(
1.2069 + "SQLite version %s\n"
1.2070 + "Enter \".help\" for instructions\n"
1.2071 + "Enter SQL statements terminated with a \";\"\n",
1.2072 + sqlite3_libversion()
1.2073 + );
1.2074 + zHome = find_home_dir();
1.2075 + if( zHome && (zHistory = malloc(nHistory = strlen(zHome)+20))!=0 ){
1.2076 + sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
1.2077 + }
1.2078 +#if defined(HAVE_READLINE) && HAVE_READLINE==1
1.2079 + if( zHistory ) read_history(zHistory);
1.2080 +#endif
1.2081 + rc = process_input(&data, 0);
1.2082 + if( zHistory ){
1.2083 + stifle_history(100);
1.2084 + write_history(zHistory);
1.2085 + free(zHistory);
1.2086 + }
1.2087 + free(zHome);
1.2088 + }else{
1.2089 + rc = process_input(&data, stdin);
1.2090 + }
1.2091 + }
1.2092 + set_table_name(&data, 0);
1.2093 + if( db ){
1.2094 + if( sqlite3_close(db)!=SQLITE_OK ){
1.2095 + fprintf(stderr,"error closing database: %s\n", sqlite3_errmsg(db));
1.2096 + }
1.2097 + }
1.2098 + return rc;
1.2099 +}