xref: /titanic_50/usr/src/cmd/sqlite/shell.c (revision c5c4113dfcabb1eed3d4bdf7609de5170027a794)
1*c5c4113dSnw141292 /*
2*c5c4113dSnw141292  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
3*c5c4113dSnw141292  * Use is subject to license terms.
4*c5c4113dSnw141292  */
5*c5c4113dSnw141292 
6*c5c4113dSnw141292 #pragma ident	"%Z%%M%	%I%	%E% SMI"
7*c5c4113dSnw141292 
8*c5c4113dSnw141292 /*
9*c5c4113dSnw141292 ** 2001 September 15
10*c5c4113dSnw141292 **
11*c5c4113dSnw141292 ** The author disclaims copyright to this source code.  In place of
12*c5c4113dSnw141292 ** a legal notice, here is a blessing:
13*c5c4113dSnw141292 **
14*c5c4113dSnw141292 **    May you do good and not evil.
15*c5c4113dSnw141292 **    May you find forgiveness for yourself and forgive others.
16*c5c4113dSnw141292 **    May you share freely, never taking more than you give.
17*c5c4113dSnw141292 **
18*c5c4113dSnw141292 *************************************************************************
19*c5c4113dSnw141292 ** This file contains code to implement the "sqlite" command line
20*c5c4113dSnw141292 ** utility for accessing SQLite databases.
21*c5c4113dSnw141292 **
22*c5c4113dSnw141292 ** $Id: shell.c,v 1.93 2004/03/17 23:42:13 drh Exp $
23*c5c4113dSnw141292 */
24*c5c4113dSnw141292 #include <stdlib.h>
25*c5c4113dSnw141292 #include <string.h>
26*c5c4113dSnw141292 #include <stdio.h>
27*c5c4113dSnw141292 #include "sqlite.h"
28*c5c4113dSnw141292 #include "sqlite-misc.h"				/* SUNW addition */
29*c5c4113dSnw141292 #include <ctype.h>
30*c5c4113dSnw141292 
31*c5c4113dSnw141292 #if !defined(_WIN32) && !defined(WIN32) && !defined(__MACOS__)
32*c5c4113dSnw141292 # include <signal.h>
33*c5c4113dSnw141292 # include <pwd.h>
34*c5c4113dSnw141292 # include <unistd.h>
35*c5c4113dSnw141292 # include <sys/types.h>
36*c5c4113dSnw141292 #endif
37*c5c4113dSnw141292 
38*c5c4113dSnw141292 #ifdef __MACOS__
39*c5c4113dSnw141292 # include <console.h>
40*c5c4113dSnw141292 # include <signal.h>
41*c5c4113dSnw141292 # include <unistd.h>
42*c5c4113dSnw141292 # include <extras.h>
43*c5c4113dSnw141292 # include <Files.h>
44*c5c4113dSnw141292 # include <Folders.h>
45*c5c4113dSnw141292 #endif
46*c5c4113dSnw141292 
47*c5c4113dSnw141292 #if defined(HAVE_READLINE) && HAVE_READLINE==1
48*c5c4113dSnw141292 # include <readline/readline.h>
49*c5c4113dSnw141292 # include <readline/history.h>
50*c5c4113dSnw141292 #else
51*c5c4113dSnw141292 # define readline(p) local_getline(p,stdin)
52*c5c4113dSnw141292 # define add_history(X)
53*c5c4113dSnw141292 # define read_history(X)
54*c5c4113dSnw141292 # define write_history(X)
55*c5c4113dSnw141292 # define stifle_history(X)
56*c5c4113dSnw141292 #endif
57*c5c4113dSnw141292 
58*c5c4113dSnw141292 /* Make sure isatty() has a prototype.
59*c5c4113dSnw141292 */
60*c5c4113dSnw141292 extern int isatty();
61*c5c4113dSnw141292 
62*c5c4113dSnw141292 /*
63*c5c4113dSnw141292 ** The following is the open SQLite database.  We make a pointer
64*c5c4113dSnw141292 ** to this database a static variable so that it can be accessed
65*c5c4113dSnw141292 ** by the SIGINT handler to interrupt database processing.
66*c5c4113dSnw141292 */
67*c5c4113dSnw141292 static sqlite *db = 0;
68*c5c4113dSnw141292 
69*c5c4113dSnw141292 /*
70*c5c4113dSnw141292 ** True if an interrupt (Control-C) has been received.
71*c5c4113dSnw141292 */
72*c5c4113dSnw141292 static int seenInterrupt = 0;
73*c5c4113dSnw141292 
74*c5c4113dSnw141292 /*
75*c5c4113dSnw141292 ** This is the name of our program. It is set in main(), used
76*c5c4113dSnw141292 ** in a number of other places, mostly for error messages.
77*c5c4113dSnw141292 */
78*c5c4113dSnw141292 static char *Argv0;
79*c5c4113dSnw141292 
80*c5c4113dSnw141292 /*
81*c5c4113dSnw141292 ** Prompt strings. Initialized in main. Settable with
82*c5c4113dSnw141292 **   .prompt main continue
83*c5c4113dSnw141292 */
84*c5c4113dSnw141292 static char mainPrompt[20];     /* First line prompt. default: "sqlite> "*/
85*c5c4113dSnw141292 static char continuePrompt[20]; /* Continuation prompt. default: "   ...> " */
86*c5c4113dSnw141292 
87*c5c4113dSnw141292 
88*c5c4113dSnw141292 /*
89*c5c4113dSnw141292 ** Determines if a string is a number of not.
90*c5c4113dSnw141292 */
91*c5c4113dSnw141292 extern int sqliteIsNumber(const char*);
92*c5c4113dSnw141292 
93*c5c4113dSnw141292 /*
94*c5c4113dSnw141292 ** This routine reads a line of text from standard input, stores
95*c5c4113dSnw141292 ** the text in memory obtained from malloc() and returns a pointer
96*c5c4113dSnw141292 ** to the text.  NULL is returned at end of file, or if malloc()
97*c5c4113dSnw141292 ** fails.
98*c5c4113dSnw141292 **
99*c5c4113dSnw141292 ** The interface is like "readline" but no command-line editing
100*c5c4113dSnw141292 ** is done.
101*c5c4113dSnw141292 */
local_getline(char * zPrompt,FILE * in)102*c5c4113dSnw141292 static char *local_getline(char *zPrompt, FILE *in){
103*c5c4113dSnw141292   char *zLine;
104*c5c4113dSnw141292   int nLine;
105*c5c4113dSnw141292   int n;
106*c5c4113dSnw141292   int eol;
107*c5c4113dSnw141292 
108*c5c4113dSnw141292   if( zPrompt && *zPrompt ){
109*c5c4113dSnw141292     printf("%s",zPrompt);
110*c5c4113dSnw141292     fflush(stdout);
111*c5c4113dSnw141292   }
112*c5c4113dSnw141292   nLine = 100;
113*c5c4113dSnw141292   zLine = malloc( nLine );
114*c5c4113dSnw141292   if( zLine==0 ) return 0;
115*c5c4113dSnw141292   n = 0;
116*c5c4113dSnw141292   eol = 0;
117*c5c4113dSnw141292   while( !eol ){
118*c5c4113dSnw141292     if( n+100>nLine ){
119*c5c4113dSnw141292       nLine = nLine*2 + 100;
120*c5c4113dSnw141292       zLine = realloc(zLine, nLine);
121*c5c4113dSnw141292       if( zLine==0 ) return 0;
122*c5c4113dSnw141292     }
123*c5c4113dSnw141292     if( fgets(&zLine[n], nLine - n, in)==0 ){
124*c5c4113dSnw141292       if( n==0 ){
125*c5c4113dSnw141292         free(zLine);
126*c5c4113dSnw141292         return 0;
127*c5c4113dSnw141292       }
128*c5c4113dSnw141292       zLine[n] = 0;
129*c5c4113dSnw141292       eol = 1;
130*c5c4113dSnw141292       break;
131*c5c4113dSnw141292     }
132*c5c4113dSnw141292     while( zLine[n] ){ n++; }
133*c5c4113dSnw141292     if( n>0 && zLine[n-1]=='\n' ){
134*c5c4113dSnw141292       n--;
135*c5c4113dSnw141292       zLine[n] = 0;
136*c5c4113dSnw141292       eol = 1;
137*c5c4113dSnw141292     }
138*c5c4113dSnw141292   }
139*c5c4113dSnw141292   zLine = realloc( zLine, n+1 );
140*c5c4113dSnw141292   return zLine;
141*c5c4113dSnw141292 }
142*c5c4113dSnw141292 
143*c5c4113dSnw141292 /*
144*c5c4113dSnw141292 ** Retrieve a single line of input text.  "isatty" is true if text
145*c5c4113dSnw141292 ** is coming from a terminal.  In that case, we issue a prompt and
146*c5c4113dSnw141292 ** attempt to use "readline" for command-line editing.  If "isatty"
147*c5c4113dSnw141292 ** is false, use "local_getline" instead of "readline" and issue no prompt.
148*c5c4113dSnw141292 **
149*c5c4113dSnw141292 ** zPrior is a string of prior text retrieved.  If not the empty
150*c5c4113dSnw141292 ** string, then issue a continuation prompt.
151*c5c4113dSnw141292 */
one_input_line(const char * zPrior,FILE * in)152*c5c4113dSnw141292 static char *one_input_line(const char *zPrior, FILE *in){
153*c5c4113dSnw141292   char *zPrompt;
154*c5c4113dSnw141292   char *zResult;
155*c5c4113dSnw141292   if( in!=0 ){
156*c5c4113dSnw141292     return local_getline(0, in);
157*c5c4113dSnw141292   }
158*c5c4113dSnw141292   if( zPrior && zPrior[0] ){
159*c5c4113dSnw141292     zPrompt = continuePrompt;
160*c5c4113dSnw141292   }else{
161*c5c4113dSnw141292     zPrompt = mainPrompt;
162*c5c4113dSnw141292   }
163*c5c4113dSnw141292   zResult = readline(zPrompt);
164*c5c4113dSnw141292   if( zResult ) add_history(zResult);
165*c5c4113dSnw141292   return zResult;
166*c5c4113dSnw141292 }
167*c5c4113dSnw141292 
168*c5c4113dSnw141292 struct previous_mode_data {
169*c5c4113dSnw141292   int valid;        /* Is there legit data in here? */
170*c5c4113dSnw141292   int mode;
171*c5c4113dSnw141292   int showHeader;
172*c5c4113dSnw141292   int colWidth[100];
173*c5c4113dSnw141292 };
174*c5c4113dSnw141292 /*
175*c5c4113dSnw141292 ** An pointer to an instance of this structure is passed from
176*c5c4113dSnw141292 ** the main program to the callback.  This is used to communicate
177*c5c4113dSnw141292 ** state and mode information.
178*c5c4113dSnw141292 */
179*c5c4113dSnw141292 struct callback_data {
180*c5c4113dSnw141292   sqlite *db;            /* The database */
181*c5c4113dSnw141292   int echoOn;            /* True to echo input commands */
182*c5c4113dSnw141292   int cnt;               /* Number of records displayed so far */
183*c5c4113dSnw141292   FILE *out;             /* Write results here */
184*c5c4113dSnw141292   int mode;              /* An output mode setting */
185*c5c4113dSnw141292   int showHeader;        /* True to show column names in List or Column mode */
186*c5c4113dSnw141292   char *zDestTable;      /* Name of destination table when MODE_Insert */
187*c5c4113dSnw141292   char separator[20];    /* Separator character for MODE_List */
188*c5c4113dSnw141292   int colWidth[100];     /* Requested width of each column when in column mode*/
189*c5c4113dSnw141292   int actualWidth[100];  /* Actual width of each column */
190*c5c4113dSnw141292   char nullvalue[20];    /* The text to print when a NULL comes back from
191*c5c4113dSnw141292                          ** the database */
192*c5c4113dSnw141292   struct previous_mode_data explainPrev;
193*c5c4113dSnw141292                          /* Holds the mode information just before
194*c5c4113dSnw141292                          ** .explain ON */
195*c5c4113dSnw141292   char outfile[FILENAME_MAX]; /* Filename for *out */
196*c5c4113dSnw141292   const char *zDbFilename;    /* name of the database file */
197*c5c4113dSnw141292   char *zKey;                 /* Encryption key */
198*c5c4113dSnw141292 };
199*c5c4113dSnw141292 
200*c5c4113dSnw141292 /*
201*c5c4113dSnw141292 ** These are the allowed modes.
202*c5c4113dSnw141292 */
203*c5c4113dSnw141292 #define MODE_Line     0  /* One column per line.  Blank line between records */
204*c5c4113dSnw141292 #define MODE_Column   1  /* One record per line in neat columns */
205*c5c4113dSnw141292 #define MODE_List     2  /* One record per line with a separator */
206*c5c4113dSnw141292 #define MODE_Semi     3  /* Same as MODE_List but append ";" to each line */
207*c5c4113dSnw141292 #define MODE_Html     4  /* Generate an XHTML table */
208*c5c4113dSnw141292 #define MODE_Insert   5  /* Generate SQL "insert" statements */
209*c5c4113dSnw141292 #define MODE_NUM_OF   6  /* The number of modes (not a mode itself) */
210*c5c4113dSnw141292 
211*c5c4113dSnw141292 char *modeDescr[MODE_NUM_OF] = {
212*c5c4113dSnw141292   "line",
213*c5c4113dSnw141292   "column",
214*c5c4113dSnw141292   "list",
215*c5c4113dSnw141292   "semi",
216*c5c4113dSnw141292   "html",
217*c5c4113dSnw141292   "insert"
218*c5c4113dSnw141292 };
219*c5c4113dSnw141292 
220*c5c4113dSnw141292 /*
221*c5c4113dSnw141292 ** Number of elements in an array
222*c5c4113dSnw141292 */
223*c5c4113dSnw141292 #define ArraySize(X)  (sizeof(X)/sizeof(X[0]))
224*c5c4113dSnw141292 
225*c5c4113dSnw141292 /*
226*c5c4113dSnw141292 ** Output the given string as a quoted string using SQL quoting conventions.
227*c5c4113dSnw141292 */
output_quoted_string(FILE * out,const char * z)228*c5c4113dSnw141292 static void output_quoted_string(FILE *out, const char *z){
229*c5c4113dSnw141292   int i;
230*c5c4113dSnw141292   int nSingle = 0;
231*c5c4113dSnw141292   for(i=0; z[i]; i++){
232*c5c4113dSnw141292     if( z[i]=='\'' ) nSingle++;
233*c5c4113dSnw141292   }
234*c5c4113dSnw141292   if( nSingle==0 ){
235*c5c4113dSnw141292     fprintf(out,"'%s'",z);
236*c5c4113dSnw141292   }else{
237*c5c4113dSnw141292     fprintf(out,"'");
238*c5c4113dSnw141292     while( *z ){
239*c5c4113dSnw141292       for(i=0; z[i] && z[i]!='\''; i++){}
240*c5c4113dSnw141292       if( i==0 ){
241*c5c4113dSnw141292         fprintf(out,"''");
242*c5c4113dSnw141292         z++;
243*c5c4113dSnw141292       }else if( z[i]=='\'' ){
244*c5c4113dSnw141292         fprintf(out,"%.*s''",i,z);
245*c5c4113dSnw141292         z += i+1;
246*c5c4113dSnw141292       }else{
247*c5c4113dSnw141292         fprintf(out,"%s",z);
248*c5c4113dSnw141292         break;
249*c5c4113dSnw141292       }
250*c5c4113dSnw141292     }
251*c5c4113dSnw141292     fprintf(out,"'");
252*c5c4113dSnw141292   }
253*c5c4113dSnw141292 }
254*c5c4113dSnw141292 
255*c5c4113dSnw141292 /*
256*c5c4113dSnw141292 ** Output the given string with characters that are special to
257*c5c4113dSnw141292 ** HTML escaped.
258*c5c4113dSnw141292 */
output_html_string(FILE * out,const char * z)259*c5c4113dSnw141292 static void output_html_string(FILE *out, const char *z){
260*c5c4113dSnw141292   int i;
261*c5c4113dSnw141292   while( *z ){
262*c5c4113dSnw141292     for(i=0; z[i] && z[i]!='<' && z[i]!='&'; i++){}
263*c5c4113dSnw141292     if( i>0 ){
264*c5c4113dSnw141292       fprintf(out,"%.*s",i,z);
265*c5c4113dSnw141292     }
266*c5c4113dSnw141292     if( z[i]=='<' ){
267*c5c4113dSnw141292       fprintf(out,"&lt;");
268*c5c4113dSnw141292     }else if( z[i]=='&' ){
269*c5c4113dSnw141292       fprintf(out,"&amp;");
270*c5c4113dSnw141292     }else{
271*c5c4113dSnw141292       break;
272*c5c4113dSnw141292     }
273*c5c4113dSnw141292     z += i + 1;
274*c5c4113dSnw141292   }
275*c5c4113dSnw141292 }
276*c5c4113dSnw141292 
277*c5c4113dSnw141292 /*
278*c5c4113dSnw141292 ** This routine runs when the user presses Ctrl-C
279*c5c4113dSnw141292 */
interrupt_handler(int NotUsed)280*c5c4113dSnw141292 static void interrupt_handler(int NotUsed){
281*c5c4113dSnw141292   seenInterrupt = 1;
282*c5c4113dSnw141292   if( db ) sqlite_interrupt(db);
283*c5c4113dSnw141292 }
284*c5c4113dSnw141292 
285*c5c4113dSnw141292 /*
286*c5c4113dSnw141292 ** This is the callback routine that the SQLite library
287*c5c4113dSnw141292 ** invokes for each row of a query result.
288*c5c4113dSnw141292 */
callback(void * pArg,int nArg,char ** azArg,char ** azCol)289*c5c4113dSnw141292 static int callback(void *pArg, int nArg, char **azArg, char **azCol){
290*c5c4113dSnw141292   int i;
291*c5c4113dSnw141292   struct callback_data *p = (struct callback_data*)pArg;
292*c5c4113dSnw141292   switch( p->mode ){
293*c5c4113dSnw141292     case MODE_Line: {
294*c5c4113dSnw141292       int w = 5;
295*c5c4113dSnw141292       if( azArg==0 ) break;
296*c5c4113dSnw141292       for(i=0; i<nArg; i++){
297*c5c4113dSnw141292         int len = strlen(azCol[i]);
298*c5c4113dSnw141292         if( len>w ) w = len;
299*c5c4113dSnw141292       }
300*c5c4113dSnw141292       if( p->cnt++>0 ) fprintf(p->out,"\n");
301*c5c4113dSnw141292       for(i=0; i<nArg; i++){
302*c5c4113dSnw141292         fprintf(p->out,"%*s = %s\n", w, azCol[i],
303*c5c4113dSnw141292                 azArg[i] ? azArg[i] : p->nullvalue);
304*c5c4113dSnw141292       }
305*c5c4113dSnw141292       break;
306*c5c4113dSnw141292     }
307*c5c4113dSnw141292     case MODE_Column: {
308*c5c4113dSnw141292       if( p->cnt++==0 ){
309*c5c4113dSnw141292         for(i=0; i<nArg; i++){
310*c5c4113dSnw141292           int w, n;
311*c5c4113dSnw141292           if( i<ArraySize(p->colWidth) ){
312*c5c4113dSnw141292              w = p->colWidth[i];
313*c5c4113dSnw141292           }else{
314*c5c4113dSnw141292              w = 0;
315*c5c4113dSnw141292           }
316*c5c4113dSnw141292           if( w<=0 ){
317*c5c4113dSnw141292             w = strlen(azCol[i] ? azCol[i] : "");
318*c5c4113dSnw141292             if( w<10 ) w = 10;
319*c5c4113dSnw141292             n = strlen(azArg && azArg[i] ? azArg[i] : p->nullvalue);
320*c5c4113dSnw141292             if( w<n ) w = n;
321*c5c4113dSnw141292           }
322*c5c4113dSnw141292           if( i<ArraySize(p->actualWidth) ){
323*c5c4113dSnw141292             p->actualWidth[i] = w;
324*c5c4113dSnw141292           }
325*c5c4113dSnw141292           if( p->showHeader ){
326*c5c4113dSnw141292             fprintf(p->out,"%-*.*s%s",w,w,azCol[i], i==nArg-1 ? "\n": "  ");
327*c5c4113dSnw141292           }
328*c5c4113dSnw141292         }
329*c5c4113dSnw141292         if( p->showHeader ){
330*c5c4113dSnw141292           for(i=0; i<nArg; i++){
331*c5c4113dSnw141292             int w;
332*c5c4113dSnw141292             if( i<ArraySize(p->actualWidth) ){
333*c5c4113dSnw141292                w = p->actualWidth[i];
334*c5c4113dSnw141292             }else{
335*c5c4113dSnw141292                w = 10;
336*c5c4113dSnw141292             }
337*c5c4113dSnw141292             fprintf(p->out,"%-*.*s%s",w,w,"-----------------------------------"
338*c5c4113dSnw141292                    "----------------------------------------------------------",
339*c5c4113dSnw141292                     i==nArg-1 ? "\n": "  ");
340*c5c4113dSnw141292           }
341*c5c4113dSnw141292         }
342*c5c4113dSnw141292       }
343*c5c4113dSnw141292       if( azArg==0 ) break;
344*c5c4113dSnw141292       for(i=0; i<nArg; i++){
345*c5c4113dSnw141292         int w;
346*c5c4113dSnw141292         if( i<ArraySize(p->actualWidth) ){
347*c5c4113dSnw141292            w = p->actualWidth[i];
348*c5c4113dSnw141292         }else{
349*c5c4113dSnw141292            w = 10;
350*c5c4113dSnw141292         }
351*c5c4113dSnw141292         fprintf(p->out,"%-*.*s%s",w,w,
352*c5c4113dSnw141292             azArg[i] ? azArg[i] : p->nullvalue, i==nArg-1 ? "\n": "  ");
353*c5c4113dSnw141292       }
354*c5c4113dSnw141292       break;
355*c5c4113dSnw141292     }
356*c5c4113dSnw141292     case MODE_Semi:
357*c5c4113dSnw141292     case MODE_List: {
358*c5c4113dSnw141292       if( p->cnt++==0 && p->showHeader ){
359*c5c4113dSnw141292         for(i=0; i<nArg; i++){
360*c5c4113dSnw141292           fprintf(p->out,"%s%s",azCol[i], i==nArg-1 ? "\n" : p->separator);
361*c5c4113dSnw141292         }
362*c5c4113dSnw141292       }
363*c5c4113dSnw141292       if( azArg==0 ) break;
364*c5c4113dSnw141292       for(i=0; i<nArg; i++){
365*c5c4113dSnw141292         char *z = azArg[i];
366*c5c4113dSnw141292         if( z==0 ) z = p->nullvalue;
367*c5c4113dSnw141292         fprintf(p->out, "%s", z);
368*c5c4113dSnw141292         if( i<nArg-1 ){
369*c5c4113dSnw141292           fprintf(p->out, "%s", p->separator);
370*c5c4113dSnw141292         }else if( p->mode==MODE_Semi ){
371*c5c4113dSnw141292           fprintf(p->out, ";\n");
372*c5c4113dSnw141292         }else{
373*c5c4113dSnw141292           fprintf(p->out, "\n");
374*c5c4113dSnw141292         }
375*c5c4113dSnw141292       }
376*c5c4113dSnw141292       break;
377*c5c4113dSnw141292     }
378*c5c4113dSnw141292     case MODE_Html: {
379*c5c4113dSnw141292       if( p->cnt++==0 && p->showHeader ){
380*c5c4113dSnw141292         fprintf(p->out,"<TR>");
381*c5c4113dSnw141292         for(i=0; i<nArg; i++){
382*c5c4113dSnw141292           fprintf(p->out,"<TH>%s</TH>",azCol[i]);
383*c5c4113dSnw141292         }
384*c5c4113dSnw141292         fprintf(p->out,"</TR>\n");
385*c5c4113dSnw141292       }
386*c5c4113dSnw141292       if( azArg==0 ) break;
387*c5c4113dSnw141292       fprintf(p->out,"<TR>");
388*c5c4113dSnw141292       for(i=0; i<nArg; i++){
389*c5c4113dSnw141292         fprintf(p->out,"<TD>");
390*c5c4113dSnw141292         output_html_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);
391*c5c4113dSnw141292         fprintf(p->out,"</TD>\n");
392*c5c4113dSnw141292       }
393*c5c4113dSnw141292       fprintf(p->out,"</TR>\n");
394*c5c4113dSnw141292       break;
395*c5c4113dSnw141292     }
396*c5c4113dSnw141292     case MODE_Insert: {
397*c5c4113dSnw141292       if( azArg==0 ) break;
398*c5c4113dSnw141292       fprintf(p->out,"INSERT INTO %s VALUES(",p->zDestTable);
399*c5c4113dSnw141292       for(i=0; i<nArg; i++){
400*c5c4113dSnw141292         char *zSep = i>0 ? ",": "";
401*c5c4113dSnw141292         if( azArg[i]==0 ){
402*c5c4113dSnw141292           fprintf(p->out,"%sNULL",zSep);
403*c5c4113dSnw141292         }else if( sqliteIsNumber(azArg[i]) ){
404*c5c4113dSnw141292           fprintf(p->out,"%s%s",zSep, azArg[i]);
405*c5c4113dSnw141292         }else{
406*c5c4113dSnw141292           if( zSep[0] ) fprintf(p->out,"%s",zSep);
407*c5c4113dSnw141292           output_quoted_string(p->out, azArg[i]);
408*c5c4113dSnw141292         }
409*c5c4113dSnw141292       }
410*c5c4113dSnw141292       fprintf(p->out,");\n");
411*c5c4113dSnw141292       break;
412*c5c4113dSnw141292     }
413*c5c4113dSnw141292   }
414*c5c4113dSnw141292   return 0;
415*c5c4113dSnw141292 }
416*c5c4113dSnw141292 
417*c5c4113dSnw141292 /*
418*c5c4113dSnw141292 ** Set the destination table field of the callback_data structure to
419*c5c4113dSnw141292 ** the name of the table given.  Escape any quote characters in the
420*c5c4113dSnw141292 ** table name.
421*c5c4113dSnw141292 */
set_table_name(struct callback_data * p,const char * zName)422*c5c4113dSnw141292 static void set_table_name(struct callback_data *p, const char *zName){
423*c5c4113dSnw141292   int i, n;
424*c5c4113dSnw141292   int needQuote;
425*c5c4113dSnw141292   char *z;
426*c5c4113dSnw141292 
427*c5c4113dSnw141292   if( p->zDestTable ){
428*c5c4113dSnw141292     free(p->zDestTable);
429*c5c4113dSnw141292     p->zDestTable = 0;
430*c5c4113dSnw141292   }
431*c5c4113dSnw141292   if( zName==0 ) return;
432*c5c4113dSnw141292   needQuote = !isalpha(*zName) && *zName!='_';
433*c5c4113dSnw141292   for(i=n=0; zName[i]; i++, n++){
434*c5c4113dSnw141292     if( !isalnum(zName[i]) && zName[i]!='_' ){
435*c5c4113dSnw141292       needQuote = 1;
436*c5c4113dSnw141292       if( zName[i]=='\'' ) n++;
437*c5c4113dSnw141292     }
438*c5c4113dSnw141292   }
439*c5c4113dSnw141292   if( needQuote ) n += 2;
440*c5c4113dSnw141292   z = p->zDestTable = malloc( n+1 );
441*c5c4113dSnw141292   if( z==0 ){
442*c5c4113dSnw141292     fprintf(stderr,"Out of memory!\n");
443*c5c4113dSnw141292     exit(1);
444*c5c4113dSnw141292   }
445*c5c4113dSnw141292   n = 0;
446*c5c4113dSnw141292   if( needQuote ) z[n++] = '\'';
447*c5c4113dSnw141292   for(i=0; zName[i]; i++){
448*c5c4113dSnw141292     z[n++] = zName[i];
449*c5c4113dSnw141292     if( zName[i]=='\'' ) z[n++] = '\'';
450*c5c4113dSnw141292   }
451*c5c4113dSnw141292   if( needQuote ) z[n++] = '\'';
452*c5c4113dSnw141292   z[n] = 0;
453*c5c4113dSnw141292 }
454*c5c4113dSnw141292 
455*c5c4113dSnw141292 /*
456*c5c4113dSnw141292 ** This is a different callback routine used for dumping the database.
457*c5c4113dSnw141292 ** Each row received by this callback consists of a table name,
458*c5c4113dSnw141292 ** the table type ("index" or "table") and SQL to create the table.
459*c5c4113dSnw141292 ** This routine should print text sufficient to recreate the table.
460*c5c4113dSnw141292 */
dump_callback(void * pArg,int nArg,char ** azArg,char ** azCol)461*c5c4113dSnw141292 static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
462*c5c4113dSnw141292   struct callback_data *p = (struct callback_data *)pArg;
463*c5c4113dSnw141292   if( nArg!=3 ) return 1;
464*c5c4113dSnw141292   fprintf(p->out, "%s;\n", azArg[2]);
465*c5c4113dSnw141292   if( strcmp(azArg[1],"table")==0 ){
466*c5c4113dSnw141292     struct callback_data d2;
467*c5c4113dSnw141292     d2 = *p;
468*c5c4113dSnw141292     d2.mode = MODE_Insert;
469*c5c4113dSnw141292     d2.zDestTable = 0;
470*c5c4113dSnw141292     set_table_name(&d2, azArg[0]);
471*c5c4113dSnw141292     sqlite_exec_printf(p->db,
472*c5c4113dSnw141292        "SELECT * FROM '%q'",
473*c5c4113dSnw141292        callback, &d2, 0, azArg[0]
474*c5c4113dSnw141292     );
475*c5c4113dSnw141292     set_table_name(&d2, 0);
476*c5c4113dSnw141292   }
477*c5c4113dSnw141292   return 0;
478*c5c4113dSnw141292 }
479*c5c4113dSnw141292 
480*c5c4113dSnw141292 /*
481*c5c4113dSnw141292 ** Text of a help message
482*c5c4113dSnw141292 */
483*c5c4113dSnw141292 static char zHelp[] =
484*c5c4113dSnw141292   ".databases             List names and files of attached databases\n"
485*c5c4113dSnw141292   ".dump ?TABLE? ...      Dump the database in a text format\n"
486*c5c4113dSnw141292   ".echo ON|OFF           Turn command echo on or off\n"
487*c5c4113dSnw141292   ".exit                  Exit this program\n"
488*c5c4113dSnw141292   ".explain ON|OFF        Turn output mode suitable for EXPLAIN on or off.\n"
489*c5c4113dSnw141292   ".header(s) ON|OFF      Turn display of headers on or off\n"
490*c5c4113dSnw141292   ".help                  Show this message\n"
491*c5c4113dSnw141292   ".indices TABLE         Show names of all indices on TABLE\n"
492*c5c4113dSnw141292   ".mode MODE             Set mode to one of \"line(s)\", \"column(s)\", \n"
493*c5c4113dSnw141292   "                       \"insert\", \"list\", or \"html\"\n"
494*c5c4113dSnw141292   ".mode insert TABLE     Generate SQL insert statements for TABLE\n"
495*c5c4113dSnw141292   ".nullvalue STRING      Print STRING instead of nothing for NULL data\n"
496*c5c4113dSnw141292   ".output FILENAME       Send output to FILENAME\n"
497*c5c4113dSnw141292   ".output stdout         Send output to the screen\n"
498*c5c4113dSnw141292   ".prompt MAIN CONTINUE  Replace the standard prompts\n"
499*c5c4113dSnw141292   ".quit                  Exit this program\n"
500*c5c4113dSnw141292   ".read FILENAME         Execute SQL in FILENAME\n"
501*c5c4113dSnw141292 #ifdef SQLITE_HAS_CODEC
502*c5c4113dSnw141292   ".rekey OLD NEW NEW     Change the encryption key\n"
503*c5c4113dSnw141292 #endif
504*c5c4113dSnw141292   ".schema ?TABLE?        Show the CREATE statements\n"
505*c5c4113dSnw141292   ".separator STRING      Change separator string for \"list\" mode\n"
506*c5c4113dSnw141292   ".show                  Show the current values for various settings\n"
507*c5c4113dSnw141292   ".tables ?PATTERN?      List names of tables matching a pattern\n"
508*c5c4113dSnw141292   ".timeout MS            Try opening locked tables for MS milliseconds\n"
509*c5c4113dSnw141292   ".width NUM NUM ...     Set column widths for \"column\" mode\n"
510*c5c4113dSnw141292 ;
511*c5c4113dSnw141292 
512*c5c4113dSnw141292 /* Forward reference */
513*c5c4113dSnw141292 static void process_input(struct callback_data *p, FILE *in);
514*c5c4113dSnw141292 
515*c5c4113dSnw141292 /*
516*c5c4113dSnw141292 ** Make sure the database is open.  If it is not, then open it.  If
517*c5c4113dSnw141292 ** the database fails to open, print an error message and exit.
518*c5c4113dSnw141292 */
open_db(struct callback_data * p)519*c5c4113dSnw141292 static void open_db(struct callback_data *p){
520*c5c4113dSnw141292   if( p->db==0 ){
521*c5c4113dSnw141292     char *zErrMsg = 0;
522*c5c4113dSnw141292 #ifdef SQLITE_HAS_CODEC
523*c5c4113dSnw141292     int n = p->zKey ? strlen(p->zKey) : 0;
524*c5c4113dSnw141292     db = p->db = sqlite_open_encrypted(p->zDbFilename, p->zKey, n, 0, &zErrMsg);
525*c5c4113dSnw141292 #else
526*c5c4113dSnw141292     db = p->db = sqlite_open(p->zDbFilename, 0, &zErrMsg);
527*c5c4113dSnw141292 #endif
528*c5c4113dSnw141292     if( p->db==0 ){
529*c5c4113dSnw141292       if( zErrMsg ){
530*c5c4113dSnw141292         fprintf(stderr,"Unable to open database \"%s\": %s\n",
531*c5c4113dSnw141292            p->zDbFilename, zErrMsg);
532*c5c4113dSnw141292       }else{
533*c5c4113dSnw141292         fprintf(stderr,"Unable to open database %s\n", p->zDbFilename);
534*c5c4113dSnw141292       }
535*c5c4113dSnw141292       exit(1);
536*c5c4113dSnw141292     }
537*c5c4113dSnw141292   }
538*c5c4113dSnw141292 }
539*c5c4113dSnw141292 
540*c5c4113dSnw141292 /*
541*c5c4113dSnw141292 ** If an input line begins with "." then invoke this routine to
542*c5c4113dSnw141292 ** process that line.
543*c5c4113dSnw141292 **
544*c5c4113dSnw141292 ** Return 1 to exit and 0 to continue.
545*c5c4113dSnw141292 */
do_meta_command(char * zLine,struct callback_data * p)546*c5c4113dSnw141292 static int do_meta_command(char *zLine, struct callback_data *p){
547*c5c4113dSnw141292   int i = 1;
548*c5c4113dSnw141292   int nArg = 0;
549*c5c4113dSnw141292   int n, c;
550*c5c4113dSnw141292   int rc = 0;
551*c5c4113dSnw141292   char *azArg[50];
552*c5c4113dSnw141292 
553*c5c4113dSnw141292   /* Parse the input line into tokens.
554*c5c4113dSnw141292   */
555*c5c4113dSnw141292   while( zLine[i] && nArg<ArraySize(azArg) ){
556*c5c4113dSnw141292     while( isspace(zLine[i]) ){ i++; }
557*c5c4113dSnw141292     if( zLine[i]==0 ) break;
558*c5c4113dSnw141292     if( zLine[i]=='\'' || zLine[i]=='"' ){
559*c5c4113dSnw141292       int delim = zLine[i++];
560*c5c4113dSnw141292       azArg[nArg++] = &zLine[i];
561*c5c4113dSnw141292       while( zLine[i] && zLine[i]!=delim ){ i++; }
562*c5c4113dSnw141292       if( zLine[i]==delim ){
563*c5c4113dSnw141292         zLine[i++] = 0;
564*c5c4113dSnw141292       }
565*c5c4113dSnw141292     }else{
566*c5c4113dSnw141292       azArg[nArg++] = &zLine[i];
567*c5c4113dSnw141292       while( zLine[i] && !isspace(zLine[i]) ){ i++; }
568*c5c4113dSnw141292       if( zLine[i] ) zLine[i++] = 0;
569*c5c4113dSnw141292     }
570*c5c4113dSnw141292   }
571*c5c4113dSnw141292 
572*c5c4113dSnw141292   /* Process the input line.
573*c5c4113dSnw141292   */
574*c5c4113dSnw141292   if( nArg==0 ) return rc;
575*c5c4113dSnw141292   n = strlen(azArg[0]);
576*c5c4113dSnw141292   c = azArg[0][0];
577*c5c4113dSnw141292   if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){
578*c5c4113dSnw141292     struct callback_data data;
579*c5c4113dSnw141292     char *zErrMsg = 0;
580*c5c4113dSnw141292     open_db(p);
581*c5c4113dSnw141292     memcpy(&data, p, sizeof(data));
582*c5c4113dSnw141292     data.showHeader = 1;
583*c5c4113dSnw141292     data.mode = MODE_Column;
584*c5c4113dSnw141292     data.colWidth[0] = 3;
585*c5c4113dSnw141292     data.colWidth[1] = 15;
586*c5c4113dSnw141292     data.colWidth[2] = 58;
587*c5c4113dSnw141292     sqlite_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg);
588*c5c4113dSnw141292     if( zErrMsg ){
589*c5c4113dSnw141292       fprintf(stderr,"Error: %s\n", zErrMsg);
590*c5c4113dSnw141292       sqlite_freemem(zErrMsg);
591*c5c4113dSnw141292     }
592*c5c4113dSnw141292   }else
593*c5c4113dSnw141292 
594*c5c4113dSnw141292   if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
595*c5c4113dSnw141292     char *zErrMsg = 0;
596*c5c4113dSnw141292     open_db(p);
597*c5c4113dSnw141292     fprintf(p->out, "BEGIN TRANSACTION;\n");
598*c5c4113dSnw141292     if( nArg==1 ){
599*c5c4113dSnw141292       sqlite_exec(p->db,
600*c5c4113dSnw141292         "SELECT name, type, sql FROM sqlite_master "
601*c5c4113dSnw141292         "WHERE type!='meta' AND sql NOT NULL "
602*c5c4113dSnw141292         "ORDER BY substr(type,2,1), name",
603*c5c4113dSnw141292         dump_callback, p, &zErrMsg
604*c5c4113dSnw141292       );
605*c5c4113dSnw141292     }else{
606*c5c4113dSnw141292       int i;
607*c5c4113dSnw141292       for(i=1; i<nArg && zErrMsg==0; i++){
608*c5c4113dSnw141292         sqlite_exec_printf(p->db,
609*c5c4113dSnw141292           "SELECT name, type, sql FROM sqlite_master "
610*c5c4113dSnw141292           "WHERE tbl_name LIKE '%q' AND type!='meta' AND sql NOT NULL "
611*c5c4113dSnw141292           "ORDER BY substr(type,2,1), name",
612*c5c4113dSnw141292           dump_callback, p, &zErrMsg, azArg[i]
613*c5c4113dSnw141292         );
614*c5c4113dSnw141292       }
615*c5c4113dSnw141292     }
616*c5c4113dSnw141292     if( zErrMsg ){
617*c5c4113dSnw141292       fprintf(stderr,"Error: %s\n", zErrMsg);
618*c5c4113dSnw141292       sqlite_freemem(zErrMsg);
619*c5c4113dSnw141292     }else{
620*c5c4113dSnw141292       fprintf(p->out, "COMMIT;\n");
621*c5c4113dSnw141292     }
622*c5c4113dSnw141292   }else
623*c5c4113dSnw141292 
624*c5c4113dSnw141292   if( c=='e' && strncmp(azArg[0], "echo", n)==0 && nArg>1 ){
625*c5c4113dSnw141292     int j;
626*c5c4113dSnw141292     char *z = azArg[1];
627*c5c4113dSnw141292     int val = atoi(azArg[1]);
628*c5c4113dSnw141292     for(j=0; z[j]; j++){
629*c5c4113dSnw141292       if( isupper(z[j]) ) z[j] = tolower(z[j]);
630*c5c4113dSnw141292     }
631*c5c4113dSnw141292     if( strcmp(z,"on")==0 ){
632*c5c4113dSnw141292       val = 1;
633*c5c4113dSnw141292     }else if( strcmp(z,"yes")==0 ){
634*c5c4113dSnw141292       val = 1;
635*c5c4113dSnw141292     }
636*c5c4113dSnw141292     p->echoOn = val;
637*c5c4113dSnw141292   }else
638*c5c4113dSnw141292 
639*c5c4113dSnw141292   if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){
640*c5c4113dSnw141292     rc = 1;
641*c5c4113dSnw141292   }else
642*c5c4113dSnw141292 
643*c5c4113dSnw141292   if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){
644*c5c4113dSnw141292     int j;
645*c5c4113dSnw141292     char *z = nArg>=2 ? azArg[1] : "1";
646*c5c4113dSnw141292     int val = atoi(z);
647*c5c4113dSnw141292     for(j=0; z[j]; j++){
648*c5c4113dSnw141292       if( isupper(z[j]) ) z[j] = tolower(z[j]);
649*c5c4113dSnw141292     }
650*c5c4113dSnw141292     if( strcmp(z,"on")==0 ){
651*c5c4113dSnw141292       val = 1;
652*c5c4113dSnw141292     }else if( strcmp(z,"yes")==0 ){
653*c5c4113dSnw141292       val = 1;
654*c5c4113dSnw141292     }
655*c5c4113dSnw141292     if(val == 1) {
656*c5c4113dSnw141292       if(!p->explainPrev.valid) {
657*c5c4113dSnw141292         p->explainPrev.valid = 1;
658*c5c4113dSnw141292         p->explainPrev.mode = p->mode;
659*c5c4113dSnw141292         p->explainPrev.showHeader = p->showHeader;
660*c5c4113dSnw141292         memcpy(p->explainPrev.colWidth,p->colWidth,sizeof(p->colWidth));
661*c5c4113dSnw141292       }
662*c5c4113dSnw141292       /* We could put this code under the !p->explainValid
663*c5c4113dSnw141292       ** condition so that it does not execute if we are already in
664*c5c4113dSnw141292       ** explain mode. However, always executing it allows us an easy
665*c5c4113dSnw141292       ** was to reset to explain mode in case the user previously
666*c5c4113dSnw141292       ** did an .explain followed by a .width, .mode or .header
667*c5c4113dSnw141292       ** command.
668*c5c4113dSnw141292       */
669*c5c4113dSnw141292       p->mode = MODE_Column;
670*c5c4113dSnw141292       p->showHeader = 1;
671*c5c4113dSnw141292       memset(p->colWidth,0,ArraySize(p->colWidth));
672*c5c4113dSnw141292       p->colWidth[0] = 4;
673*c5c4113dSnw141292       p->colWidth[1] = 12;
674*c5c4113dSnw141292       p->colWidth[2] = 10;
675*c5c4113dSnw141292       p->colWidth[3] = 10;
676*c5c4113dSnw141292       p->colWidth[4] = 35;
677*c5c4113dSnw141292     }else if (p->explainPrev.valid) {
678*c5c4113dSnw141292       p->explainPrev.valid = 0;
679*c5c4113dSnw141292       p->mode = p->explainPrev.mode;
680*c5c4113dSnw141292       p->showHeader = p->explainPrev.showHeader;
681*c5c4113dSnw141292       memcpy(p->colWidth,p->explainPrev.colWidth,sizeof(p->colWidth));
682*c5c4113dSnw141292     }
683*c5c4113dSnw141292   }else
684*c5c4113dSnw141292 
685*c5c4113dSnw141292   if( c=='h' && (strncmp(azArg[0], "header", n)==0
686*c5c4113dSnw141292                  ||
687*c5c4113dSnw141292                  strncmp(azArg[0], "headers", n)==0 )&& nArg>1 ){
688*c5c4113dSnw141292     int j;
689*c5c4113dSnw141292     char *z = azArg[1];
690*c5c4113dSnw141292     int val = atoi(azArg[1]);
691*c5c4113dSnw141292     for(j=0; z[j]; j++){
692*c5c4113dSnw141292       if( isupper(z[j]) ) z[j] = tolower(z[j]);
693*c5c4113dSnw141292     }
694*c5c4113dSnw141292     if( strcmp(z,"on")==0 ){
695*c5c4113dSnw141292       val = 1;
696*c5c4113dSnw141292     }else if( strcmp(z,"yes")==0 ){
697*c5c4113dSnw141292       val = 1;
698*c5c4113dSnw141292     }
699*c5c4113dSnw141292     p->showHeader = val;
700*c5c4113dSnw141292   }else
701*c5c4113dSnw141292 
702*c5c4113dSnw141292   if( c=='h' && strncmp(azArg[0], "help", n)==0 ){
703*c5c4113dSnw141292     fprintf(stderr,zHelp);
704*c5c4113dSnw141292   }else
705*c5c4113dSnw141292 
706*c5c4113dSnw141292   if( c=='i' && strncmp(azArg[0], "indices", n)==0 && nArg>1 ){
707*c5c4113dSnw141292     struct callback_data data;
708*c5c4113dSnw141292     char *zErrMsg = 0;
709*c5c4113dSnw141292     open_db(p);
710*c5c4113dSnw141292     memcpy(&data, p, sizeof(data));
711*c5c4113dSnw141292     data.showHeader = 0;
712*c5c4113dSnw141292     data.mode = MODE_List;
713*c5c4113dSnw141292     sqlite_exec_printf(p->db,
714*c5c4113dSnw141292       "SELECT name FROM sqlite_master "
715*c5c4113dSnw141292       "WHERE type='index' AND tbl_name LIKE '%q' "
716*c5c4113dSnw141292       "UNION ALL "
717*c5c4113dSnw141292       "SELECT name FROM sqlite_temp_master "
718*c5c4113dSnw141292       "WHERE type='index' AND tbl_name LIKE '%q' "
719*c5c4113dSnw141292       "ORDER BY 1",
720*c5c4113dSnw141292       callback, &data, &zErrMsg, azArg[1], azArg[1]
721*c5c4113dSnw141292     );
722*c5c4113dSnw141292     if( zErrMsg ){
723*c5c4113dSnw141292       fprintf(stderr,"Error: %s\n", zErrMsg);
724*c5c4113dSnw141292       sqlite_freemem(zErrMsg);
725*c5c4113dSnw141292     }
726*c5c4113dSnw141292   }else
727*c5c4113dSnw141292 
728*c5c4113dSnw141292   if( c=='m' && strncmp(azArg[0], "mode", n)==0 && nArg>=2 ){
729*c5c4113dSnw141292     int n2 = strlen(azArg[1]);
730*c5c4113dSnw141292     if( strncmp(azArg[1],"line",n2)==0
731*c5c4113dSnw141292         ||
732*c5c4113dSnw141292         strncmp(azArg[1],"lines",n2)==0 ){
733*c5c4113dSnw141292       p->mode = MODE_Line;
734*c5c4113dSnw141292     }else if( strncmp(azArg[1],"column",n2)==0
735*c5c4113dSnw141292               ||
736*c5c4113dSnw141292               strncmp(azArg[1],"columns",n2)==0 ){
737*c5c4113dSnw141292       p->mode = MODE_Column;
738*c5c4113dSnw141292     }else if( strncmp(azArg[1],"list",n2)==0 ){
739*c5c4113dSnw141292       p->mode = MODE_List;
740*c5c4113dSnw141292     }else if( strncmp(azArg[1],"html",n2)==0 ){
741*c5c4113dSnw141292       p->mode = MODE_Html;
742*c5c4113dSnw141292     }else if( strncmp(azArg[1],"insert",n2)==0 ){
743*c5c4113dSnw141292       p->mode = MODE_Insert;
744*c5c4113dSnw141292       if( nArg>=3 ){
745*c5c4113dSnw141292         set_table_name(p, azArg[2]);
746*c5c4113dSnw141292       }else{
747*c5c4113dSnw141292         set_table_name(p, "table");
748*c5c4113dSnw141292       }
749*c5c4113dSnw141292     }else {
750*c5c4113dSnw141292       fprintf(stderr,"mode should be on of: column html insert line list\n");
751*c5c4113dSnw141292     }
752*c5c4113dSnw141292   }else
753*c5c4113dSnw141292 
754*c5c4113dSnw141292   if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 && nArg==2 ) {
755*c5c4113dSnw141292     sprintf(p->nullvalue, "%.*s", (int)ArraySize(p->nullvalue)-1, azArg[1]);
756*c5c4113dSnw141292   }else
757*c5c4113dSnw141292 
758*c5c4113dSnw141292   if( c=='o' && strncmp(azArg[0], "output", n)==0 && nArg==2 ){
759*c5c4113dSnw141292     if( p->out!=stdout ){
760*c5c4113dSnw141292       fclose(p->out);
761*c5c4113dSnw141292     }
762*c5c4113dSnw141292     if( strcmp(azArg[1],"stdout")==0 ){
763*c5c4113dSnw141292       p->out = stdout;
764*c5c4113dSnw141292       strcpy(p->outfile,"stdout");
765*c5c4113dSnw141292     }else{
766*c5c4113dSnw141292       p->out = fopen(azArg[1], "wb");
767*c5c4113dSnw141292       if( p->out==0 ){
768*c5c4113dSnw141292         fprintf(stderr,"can't write to \"%s\"\n", azArg[1]);
769*c5c4113dSnw141292         p->out = stdout;
770*c5c4113dSnw141292       } else {
771*c5c4113dSnw141292          strcpy(p->outfile,azArg[1]);
772*c5c4113dSnw141292       }
773*c5c4113dSnw141292     }
774*c5c4113dSnw141292   }else
775*c5c4113dSnw141292 
776*c5c4113dSnw141292   if( c=='p' && strncmp(azArg[0], "prompt", n)==0 && (nArg==2 || nArg==3)){
777*c5c4113dSnw141292     if( nArg >= 2) {
778*c5c4113dSnw141292       strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
779*c5c4113dSnw141292     }
780*c5c4113dSnw141292     if( nArg >= 3) {
781*c5c4113dSnw141292       strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
782*c5c4113dSnw141292     }
783*c5c4113dSnw141292   }else
784*c5c4113dSnw141292 
785*c5c4113dSnw141292   if( c=='q' && strncmp(azArg[0], "quit", n)==0 ){
786*c5c4113dSnw141292     rc = 1;
787*c5c4113dSnw141292   }else
788*c5c4113dSnw141292 
789*c5c4113dSnw141292   if( c=='r' && strncmp(azArg[0], "read", n)==0 && nArg==2 ){
790*c5c4113dSnw141292     FILE *alt = fopen(azArg[1], "rb");
791*c5c4113dSnw141292     if( alt==0 ){
792*c5c4113dSnw141292       fprintf(stderr,"can't open \"%s\"\n", azArg[1]);
793*c5c4113dSnw141292     }else{
794*c5c4113dSnw141292       process_input(p, alt);
795*c5c4113dSnw141292       fclose(alt);
796*c5c4113dSnw141292     }
797*c5c4113dSnw141292   }else
798*c5c4113dSnw141292 
799*c5c4113dSnw141292 #ifdef SQLITE_HAS_CODEC
800*c5c4113dSnw141292   if( c=='r' && strncmp(azArg[0],"rekey", n)==0 && nArg==4 ){
801*c5c4113dSnw141292     char *zOld = p->zKey;
802*c5c4113dSnw141292     if( zOld==0 ) zOld = "";
803*c5c4113dSnw141292     if( strcmp(azArg[1],zOld) ){
804*c5c4113dSnw141292       fprintf(stderr,"old key is incorrect\n");
805*c5c4113dSnw141292     }else if( strcmp(azArg[2], azArg[3]) ){
806*c5c4113dSnw141292       fprintf(stderr,"2nd copy of new key does not match the 1st\n");
807*c5c4113dSnw141292     }else{
808*c5c4113dSnw141292       sqlite_freemem(p->zKey);
809*c5c4113dSnw141292       p->zKey = sqlite_mprintf("%s", azArg[2]);
810*c5c4113dSnw141292       sqlite_rekey(p->db, p->zKey, strlen(p->zKey));
811*c5c4113dSnw141292     }
812*c5c4113dSnw141292   }else
813*c5c4113dSnw141292 #endif
814*c5c4113dSnw141292 
815*c5c4113dSnw141292   if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){
816*c5c4113dSnw141292     struct callback_data data;
817*c5c4113dSnw141292     char *zErrMsg = 0;
818*c5c4113dSnw141292     open_db(p);
819*c5c4113dSnw141292     memcpy(&data, p, sizeof(data));
820*c5c4113dSnw141292     data.showHeader = 0;
821*c5c4113dSnw141292     data.mode = MODE_Semi;
822*c5c4113dSnw141292     if( nArg>1 ){
823*c5c4113dSnw141292       extern int sqliteStrICmp(const char*,const char*);
824*c5c4113dSnw141292       if( sqliteStrICmp(azArg[1],"sqlite_master")==0 ){
825*c5c4113dSnw141292         char *new_argv[2], *new_colv[2];
826*c5c4113dSnw141292         new_argv[0] = "CREATE TABLE sqlite_master (\n"
827*c5c4113dSnw141292                       "  type text,\n"
828*c5c4113dSnw141292                       "  name text,\n"
829*c5c4113dSnw141292                       "  tbl_name text,\n"
830*c5c4113dSnw141292                       "  rootpage integer,\n"
831*c5c4113dSnw141292                       "  sql text\n"
832*c5c4113dSnw141292                       ")";
833*c5c4113dSnw141292         new_argv[1] = 0;
834*c5c4113dSnw141292         new_colv[0] = "sql";
835*c5c4113dSnw141292         new_colv[1] = 0;
836*c5c4113dSnw141292         callback(&data, 1, new_argv, new_colv);
837*c5c4113dSnw141292       }else if( sqliteStrICmp(azArg[1],"sqlite_temp_master")==0 ){
838*c5c4113dSnw141292         char *new_argv[2], *new_colv[2];
839*c5c4113dSnw141292         new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n"
840*c5c4113dSnw141292                       "  type text,\n"
841*c5c4113dSnw141292                       "  name text,\n"
842*c5c4113dSnw141292                       "  tbl_name text,\n"
843*c5c4113dSnw141292                       "  rootpage integer,\n"
844*c5c4113dSnw141292                       "  sql text\n"
845*c5c4113dSnw141292                       ")";
846*c5c4113dSnw141292         new_argv[1] = 0;
847*c5c4113dSnw141292         new_colv[0] = "sql";
848*c5c4113dSnw141292         new_colv[1] = 0;
849*c5c4113dSnw141292         callback(&data, 1, new_argv, new_colv);
850*c5c4113dSnw141292       }else{
851*c5c4113dSnw141292         sqlite_exec_printf(p->db,
852*c5c4113dSnw141292           "SELECT sql FROM "
853*c5c4113dSnw141292           "  (SELECT * FROM sqlite_master UNION ALL"
854*c5c4113dSnw141292           "   SELECT * FROM sqlite_temp_master) "
855*c5c4113dSnw141292           "WHERE tbl_name LIKE '%q' AND type!='meta' AND sql NOTNULL "
856*c5c4113dSnw141292           "ORDER BY substr(type,2,1), name",
857*c5c4113dSnw141292           callback, &data, &zErrMsg, azArg[1]);
858*c5c4113dSnw141292       }
859*c5c4113dSnw141292     }else{
860*c5c4113dSnw141292       sqlite_exec(p->db,
861*c5c4113dSnw141292          "SELECT sql FROM "
862*c5c4113dSnw141292          "  (SELECT * FROM sqlite_master UNION ALL"
863*c5c4113dSnw141292          "   SELECT * FROM sqlite_temp_master) "
864*c5c4113dSnw141292          "WHERE type!='meta' AND sql NOTNULL "
865*c5c4113dSnw141292          "ORDER BY substr(type,2,1), name",
866*c5c4113dSnw141292          callback, &data, &zErrMsg
867*c5c4113dSnw141292       );
868*c5c4113dSnw141292     }
869*c5c4113dSnw141292     if( zErrMsg ){
870*c5c4113dSnw141292       fprintf(stderr,"Error: %s\n", zErrMsg);
871*c5c4113dSnw141292       sqlite_freemem(zErrMsg);
872*c5c4113dSnw141292     }
873*c5c4113dSnw141292   }else
874*c5c4113dSnw141292 
875*c5c4113dSnw141292   if( c=='s' && strncmp(azArg[0], "separator", n)==0 && nArg==2 ){
876*c5c4113dSnw141292     sprintf(p->separator, "%.*s", (int)ArraySize(p->separator)-1, azArg[1]);
877*c5c4113dSnw141292   }else
878*c5c4113dSnw141292 
879*c5c4113dSnw141292   if( c=='s' && strncmp(azArg[0], "show", n)==0){
880*c5c4113dSnw141292     int i;
881*c5c4113dSnw141292     fprintf(p->out,"%9.9s: %s\n","echo", p->echoOn ? "on" : "off");
882*c5c4113dSnw141292     fprintf(p->out,"%9.9s: %s\n","explain", p->explainPrev.valid ? "on" :"off");
883*c5c4113dSnw141292     fprintf(p->out,"%9.9s: %s\n","headers", p->showHeader ? "on" : "off");
884*c5c4113dSnw141292     fprintf(p->out,"%9.9s: %s\n","mode", modeDescr[p->mode]);
885*c5c4113dSnw141292     fprintf(p->out,"%9.9s: %s\n","nullvalue", p->nullvalue);
886*c5c4113dSnw141292     fprintf(p->out,"%9.9s: %s\n","output",
887*c5c4113dSnw141292                                  strlen(p->outfile) ? p->outfile : "stdout");
888*c5c4113dSnw141292     fprintf(p->out,"%9.9s: %s\n","separator", p->separator);
889*c5c4113dSnw141292     fprintf(p->out,"%9.9s: ","width");
890*c5c4113dSnw141292     for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) {
891*c5c4113dSnw141292         fprintf(p->out,"%d ",p->colWidth[i]);
892*c5c4113dSnw141292     }
893*c5c4113dSnw141292     fprintf(p->out,"\n\n");
894*c5c4113dSnw141292   }else
895*c5c4113dSnw141292 
896*c5c4113dSnw141292   if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 ){
897*c5c4113dSnw141292     char **azResult;
898*c5c4113dSnw141292     int nRow, rc;
899*c5c4113dSnw141292     char *zErrMsg;
900*c5c4113dSnw141292     open_db(p);
901*c5c4113dSnw141292     if( nArg==1 ){
902*c5c4113dSnw141292       rc = sqlite_get_table(p->db,
903*c5c4113dSnw141292         "SELECT name FROM sqlite_master "
904*c5c4113dSnw141292         "WHERE type IN ('table','view') "
905*c5c4113dSnw141292         "UNION ALL "
906*c5c4113dSnw141292         "SELECT name FROM sqlite_temp_master "
907*c5c4113dSnw141292         "WHERE type IN ('table','view') "
908*c5c4113dSnw141292         "ORDER BY 1",
909*c5c4113dSnw141292         &azResult, &nRow, 0, &zErrMsg
910*c5c4113dSnw141292       );
911*c5c4113dSnw141292     }else{
912*c5c4113dSnw141292       rc = sqlite_get_table_printf(p->db,
913*c5c4113dSnw141292         "SELECT name FROM sqlite_master "
914*c5c4113dSnw141292         "WHERE type IN ('table','view') AND name LIKE '%%%q%%' "
915*c5c4113dSnw141292         "UNION ALL "
916*c5c4113dSnw141292         "SELECT name FROM sqlite_temp_master "
917*c5c4113dSnw141292         "WHERE type IN ('table','view') AND name LIKE '%%%q%%' "
918*c5c4113dSnw141292         "ORDER BY 1",
919*c5c4113dSnw141292         &azResult, &nRow, 0, &zErrMsg, azArg[1], azArg[1]
920*c5c4113dSnw141292       );
921*c5c4113dSnw141292     }
922*c5c4113dSnw141292     if( zErrMsg ){
923*c5c4113dSnw141292       fprintf(stderr,"Error: %s\n", zErrMsg);
924*c5c4113dSnw141292       sqlite_freemem(zErrMsg);
925*c5c4113dSnw141292     }
926*c5c4113dSnw141292     if( rc==SQLITE_OK ){
927*c5c4113dSnw141292       int len, maxlen = 0;
928*c5c4113dSnw141292       int i, j;
929*c5c4113dSnw141292       int nPrintCol, nPrintRow;
930*c5c4113dSnw141292       for(i=1; i<=nRow; i++){
931*c5c4113dSnw141292         if( azResult[i]==0 ) continue;
932*c5c4113dSnw141292         len = strlen(azResult[i]);
933*c5c4113dSnw141292         if( len>maxlen ) maxlen = len;
934*c5c4113dSnw141292       }
935*c5c4113dSnw141292       nPrintCol = 80/(maxlen+2);
936*c5c4113dSnw141292       if( nPrintCol<1 ) nPrintCol = 1;
937*c5c4113dSnw141292       nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
938*c5c4113dSnw141292       for(i=0; i<nPrintRow; i++){
939*c5c4113dSnw141292         for(j=i+1; j<=nRow; j+=nPrintRow){
940*c5c4113dSnw141292           char *zSp = j<=nPrintRow ? "" : "  ";
941*c5c4113dSnw141292           printf("%s%-*s", zSp, maxlen, azResult[j] ? azResult[j] : "");
942*c5c4113dSnw141292         }
943*c5c4113dSnw141292         printf("\n");
944*c5c4113dSnw141292       }
945*c5c4113dSnw141292     }
946*c5c4113dSnw141292     sqlite_free_table(azResult);
947*c5c4113dSnw141292   }else
948*c5c4113dSnw141292 
949*c5c4113dSnw141292   if( c=='t' && n>1 && strncmp(azArg[0], "timeout", n)==0 && nArg>=2 ){
950*c5c4113dSnw141292     open_db(p);
951*c5c4113dSnw141292     sqlite_busy_timeout(p->db, atoi(azArg[1]));
952*c5c4113dSnw141292   }else
953*c5c4113dSnw141292 
954*c5c4113dSnw141292   if( c=='w' && strncmp(azArg[0], "width", n)==0 ){
955*c5c4113dSnw141292     int j;
956*c5c4113dSnw141292     for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){
957*c5c4113dSnw141292       p->colWidth[j-1] = atoi(azArg[j]);
958*c5c4113dSnw141292     }
959*c5c4113dSnw141292   }else
960*c5c4113dSnw141292 
961*c5c4113dSnw141292   {
962*c5c4113dSnw141292     fprintf(stderr, "unknown command or invalid arguments: "
963*c5c4113dSnw141292       " \"%s\". Enter \".help\" for help\n", azArg[0]);
964*c5c4113dSnw141292   }
965*c5c4113dSnw141292 
966*c5c4113dSnw141292   return rc;
967*c5c4113dSnw141292 }
968*c5c4113dSnw141292 
969*c5c4113dSnw141292 /*
970*c5c4113dSnw141292 ** Return TRUE if the last non-whitespace character in z[] is a semicolon.
971*c5c4113dSnw141292 ** z[] is N characters long.
972*c5c4113dSnw141292 */
_ends_with_semicolon(const char * z,int N)973*c5c4113dSnw141292 static int _ends_with_semicolon(const char *z, int N){
974*c5c4113dSnw141292   while( N>0 && isspace(z[N-1]) ){ N--; }
975*c5c4113dSnw141292   return N>0 && z[N-1]==';';
976*c5c4113dSnw141292 }
977*c5c4113dSnw141292 
978*c5c4113dSnw141292 /*
979*c5c4113dSnw141292 ** Test to see if a line consists entirely of whitespace.
980*c5c4113dSnw141292 */
_all_whitespace(const char * z)981*c5c4113dSnw141292 static int _all_whitespace(const char *z){
982*c5c4113dSnw141292   for(; *z; z++){
983*c5c4113dSnw141292     if( isspace(*z) ) continue;
984*c5c4113dSnw141292     if( *z=='/' && z[1]=='*' ){
985*c5c4113dSnw141292       z += 2;
986*c5c4113dSnw141292       while( *z && (*z!='*' || z[1]!='/') ){ z++; }
987*c5c4113dSnw141292       if( *z==0 ) return 0;
988*c5c4113dSnw141292       z++;
989*c5c4113dSnw141292       continue;
990*c5c4113dSnw141292     }
991*c5c4113dSnw141292     if( *z=='-' && z[1]=='-' ){
992*c5c4113dSnw141292       z += 2;
993*c5c4113dSnw141292       while( *z && *z!='\n' ){ z++; }
994*c5c4113dSnw141292       if( *z==0 ) return 1;
995*c5c4113dSnw141292       continue;
996*c5c4113dSnw141292     }
997*c5c4113dSnw141292     return 0;
998*c5c4113dSnw141292   }
999*c5c4113dSnw141292   return 1;
1000*c5c4113dSnw141292 }
1001*c5c4113dSnw141292 
1002*c5c4113dSnw141292 /*
1003*c5c4113dSnw141292 ** Return TRUE if the line typed in is an SQL command terminator other
1004*c5c4113dSnw141292 ** than a semi-colon.  The SQL Server style "go" command is understood
1005*c5c4113dSnw141292 ** as is the Oracle "/".
1006*c5c4113dSnw141292 */
_is_command_terminator(const char * zLine)1007*c5c4113dSnw141292 static int _is_command_terminator(const char *zLine){
1008*c5c4113dSnw141292   extern int sqliteStrNICmp(const char*,const char*,int);
1009*c5c4113dSnw141292   while( isspace(*zLine) ){ zLine++; };
1010*c5c4113dSnw141292   if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ) return 1;  /* Oracle */
1011*c5c4113dSnw141292   if( sqliteStrNICmp(zLine,"go",2)==0 && _all_whitespace(&zLine[2]) ){
1012*c5c4113dSnw141292     return 1;  /* SQL Server */
1013*c5c4113dSnw141292   }
1014*c5c4113dSnw141292   return 0;
1015*c5c4113dSnw141292 }
1016*c5c4113dSnw141292 
1017*c5c4113dSnw141292 /*
1018*c5c4113dSnw141292 ** Read input from *in and process it.  If *in==0 then input
1019*c5c4113dSnw141292 ** is interactive - the user is typing it it.  Otherwise, input
1020*c5c4113dSnw141292 ** is coming from a file or device.  A prompt is issued and history
1021*c5c4113dSnw141292 ** is saved only if input is interactive.  An interrupt signal will
1022*c5c4113dSnw141292 ** cause this routine to exit immediately, unless input is interactive.
1023*c5c4113dSnw141292 */
process_input(struct callback_data * p,FILE * in)1024*c5c4113dSnw141292 static void process_input(struct callback_data *p, FILE *in){
1025*c5c4113dSnw141292   char *zLine;
1026*c5c4113dSnw141292   char *zSql = 0;
1027*c5c4113dSnw141292   int nSql = 0;
1028*c5c4113dSnw141292   char *zErrMsg;
1029*c5c4113dSnw141292   int rc;
1030*c5c4113dSnw141292   while( fflush(p->out), (zLine = one_input_line(zSql, in))!=0 ){
1031*c5c4113dSnw141292     if( seenInterrupt ){
1032*c5c4113dSnw141292       if( in!=0 ) break;
1033*c5c4113dSnw141292       seenInterrupt = 0;
1034*c5c4113dSnw141292     }
1035*c5c4113dSnw141292     if( p->echoOn ) printf("%s\n", zLine);
1036*c5c4113dSnw141292     if( (zSql==0 || zSql[0]==0) && _all_whitespace(zLine) ) continue;
1037*c5c4113dSnw141292     if( zLine && zLine[0]=='.' && nSql==0 ){
1038*c5c4113dSnw141292       int rc = do_meta_command(zLine, p);
1039*c5c4113dSnw141292       free(zLine);
1040*c5c4113dSnw141292       if( rc ) break;
1041*c5c4113dSnw141292       continue;
1042*c5c4113dSnw141292     }
1043*c5c4113dSnw141292     if( _is_command_terminator(zLine) ){
1044*c5c4113dSnw141292       strcpy(zLine,";");
1045*c5c4113dSnw141292     }
1046*c5c4113dSnw141292     if( zSql==0 ){
1047*c5c4113dSnw141292       int i;
1048*c5c4113dSnw141292       for(i=0; zLine[i] && isspace(zLine[i]); i++){}
1049*c5c4113dSnw141292       if( zLine[i]!=0 ){
1050*c5c4113dSnw141292         nSql = strlen(zLine);
1051*c5c4113dSnw141292         zSql = malloc( nSql+1 );
1052*c5c4113dSnw141292         strcpy(zSql, zLine);
1053*c5c4113dSnw141292       }
1054*c5c4113dSnw141292     }else{
1055*c5c4113dSnw141292       int len = strlen(zLine);
1056*c5c4113dSnw141292       zSql = realloc( zSql, nSql + len + 2 );
1057*c5c4113dSnw141292       if( zSql==0 ){
1058*c5c4113dSnw141292         fprintf(stderr,"%s: out of memory!\n", Argv0);
1059*c5c4113dSnw141292         exit(1);
1060*c5c4113dSnw141292       }
1061*c5c4113dSnw141292       strcpy(&zSql[nSql++], "\n");
1062*c5c4113dSnw141292       strcpy(&zSql[nSql], zLine);
1063*c5c4113dSnw141292       nSql += len;
1064*c5c4113dSnw141292     }
1065*c5c4113dSnw141292     free(zLine);
1066*c5c4113dSnw141292     if( zSql && _ends_with_semicolon(zSql, nSql) && sqlite_complete(zSql) ){
1067*c5c4113dSnw141292       p->cnt = 0;
1068*c5c4113dSnw141292       open_db(p);
1069*c5c4113dSnw141292       rc = sqlite_exec(p->db, zSql, callback, p, &zErrMsg);
1070*c5c4113dSnw141292       if( rc || zErrMsg ){
1071*c5c4113dSnw141292         if( in!=0 && !p->echoOn ) printf("%s\n",zSql);
1072*c5c4113dSnw141292         if( zErrMsg!=0 ){
1073*c5c4113dSnw141292           printf("SQL error: %s\n", zErrMsg);
1074*c5c4113dSnw141292           sqlite_freemem(zErrMsg);
1075*c5c4113dSnw141292           zErrMsg = 0;
1076*c5c4113dSnw141292         }else{
1077*c5c4113dSnw141292           printf("SQL error: %s\n", sqlite_error_string(rc));
1078*c5c4113dSnw141292         }
1079*c5c4113dSnw141292       }
1080*c5c4113dSnw141292       free(zSql);
1081*c5c4113dSnw141292       zSql = 0;
1082*c5c4113dSnw141292       nSql = 0;
1083*c5c4113dSnw141292     }
1084*c5c4113dSnw141292   }
1085*c5c4113dSnw141292   if( zSql ){
1086*c5c4113dSnw141292     if( !_all_whitespace(zSql) ) printf("Incomplete SQL: %s\n", zSql);
1087*c5c4113dSnw141292     free(zSql);
1088*c5c4113dSnw141292   }
1089*c5c4113dSnw141292 }
1090*c5c4113dSnw141292 
1091*c5c4113dSnw141292 /*
1092*c5c4113dSnw141292 ** Return a pathname which is the user's home directory.  A
1093*c5c4113dSnw141292 ** 0 return indicates an error of some kind.  Space to hold the
1094*c5c4113dSnw141292 ** resulting string is obtained from malloc().  The calling
1095*c5c4113dSnw141292 ** function should free the result.
1096*c5c4113dSnw141292 */
find_home_dir(void)1097*c5c4113dSnw141292 static char *find_home_dir(void){
1098*c5c4113dSnw141292   char *home_dir = NULL;
1099*c5c4113dSnw141292 
1100*c5c4113dSnw141292 #if !defined(_WIN32) && !defined(WIN32) && !defined(__MACOS__)
1101*c5c4113dSnw141292   struct passwd *pwent;
1102*c5c4113dSnw141292   uid_t uid = getuid();
1103*c5c4113dSnw141292   if( (pwent=getpwuid(uid)) != NULL) {
1104*c5c4113dSnw141292     home_dir = pwent->pw_dir;
1105*c5c4113dSnw141292   }
1106*c5c4113dSnw141292 #endif
1107*c5c4113dSnw141292 
1108*c5c4113dSnw141292 #ifdef __MACOS__
1109*c5c4113dSnw141292   char home_path[_MAX_PATH+1];
1110*c5c4113dSnw141292   home_dir = getcwd(home_path, _MAX_PATH);
1111*c5c4113dSnw141292 #endif
1112*c5c4113dSnw141292 
1113*c5c4113dSnw141292   if (!home_dir) {
1114*c5c4113dSnw141292     home_dir = getenv("HOME");
1115*c5c4113dSnw141292     if (!home_dir) {
1116*c5c4113dSnw141292       home_dir = getenv("HOMEPATH"); /* Windows? */
1117*c5c4113dSnw141292     }
1118*c5c4113dSnw141292   }
1119*c5c4113dSnw141292 
1120*c5c4113dSnw141292 #if defined(_WIN32) || defined(WIN32)
1121*c5c4113dSnw141292   if (!home_dir) {
1122*c5c4113dSnw141292     home_dir = "c:";
1123*c5c4113dSnw141292   }
1124*c5c4113dSnw141292 #endif
1125*c5c4113dSnw141292 
1126*c5c4113dSnw141292   if( home_dir ){
1127*c5c4113dSnw141292     char *z = malloc( strlen(home_dir)+1 );
1128*c5c4113dSnw141292     if( z ) strcpy(z, home_dir);
1129*c5c4113dSnw141292     home_dir = z;
1130*c5c4113dSnw141292   }
1131*c5c4113dSnw141292 
1132*c5c4113dSnw141292   return home_dir;
1133*c5c4113dSnw141292 }
1134*c5c4113dSnw141292 
1135*c5c4113dSnw141292 /*
1136*c5c4113dSnw141292 ** Read input from the file given by sqliterc_override.  Or if that
1137*c5c4113dSnw141292 ** parameter is NULL, take input from ~/.sqliterc
1138*c5c4113dSnw141292 */
process_sqliterc(struct callback_data * p,const char * sqliterc_override)1139*c5c4113dSnw141292 static void process_sqliterc(
1140*c5c4113dSnw141292   struct callback_data *p,        /* Configuration data */
1141*c5c4113dSnw141292   const char *sqliterc_override   /* Name of config file. NULL to use default */
1142*c5c4113dSnw141292 ){
1143*c5c4113dSnw141292   char *home_dir = NULL;
1144*c5c4113dSnw141292   const char *sqliterc = sqliterc_override;
1145*c5c4113dSnw141292   char *zBuf;
1146*c5c4113dSnw141292   FILE *in = NULL;
1147*c5c4113dSnw141292 
1148*c5c4113dSnw141292   if (sqliterc == NULL) {
1149*c5c4113dSnw141292     home_dir = find_home_dir();
1150*c5c4113dSnw141292     if( home_dir==0 ){
1151*c5c4113dSnw141292       fprintf(stderr,"%s: cannot locate your home directory!\n", Argv0);
1152*c5c4113dSnw141292       return;
1153*c5c4113dSnw141292     }
1154*c5c4113dSnw141292     zBuf = malloc(strlen(home_dir) + 15);
1155*c5c4113dSnw141292     if( zBuf==0 ){
1156*c5c4113dSnw141292       fprintf(stderr,"%s: out of memory!\n", Argv0);
1157*c5c4113dSnw141292       exit(1);
1158*c5c4113dSnw141292     }
1159*c5c4113dSnw141292     sprintf(zBuf,"%s/.sqliterc",home_dir);
1160*c5c4113dSnw141292     free(home_dir);
1161*c5c4113dSnw141292     sqliterc = (const char*)zBuf;
1162*c5c4113dSnw141292   }
1163*c5c4113dSnw141292   in = fopen(sqliterc,"rb");
1164*c5c4113dSnw141292   if( in ){
1165*c5c4113dSnw141292     if( isatty(fileno(stdout)) ){
1166*c5c4113dSnw141292       printf("Loading resources from %s\n",sqliterc);
1167*c5c4113dSnw141292     }
1168*c5c4113dSnw141292     process_input(p,in);
1169*c5c4113dSnw141292     fclose(in);
1170*c5c4113dSnw141292   }
1171*c5c4113dSnw141292   return;
1172*c5c4113dSnw141292 }
1173*c5c4113dSnw141292 
1174*c5c4113dSnw141292 /*
1175*c5c4113dSnw141292 ** Show available command line options
1176*c5c4113dSnw141292 */
1177*c5c4113dSnw141292 static const char zOptions[] =
1178*c5c4113dSnw141292   "   -init filename       read/process named file\n"
1179*c5c4113dSnw141292   "   -echo                print commands before execution\n"
1180*c5c4113dSnw141292   "   -[no]header          turn headers on or off\n"
1181*c5c4113dSnw141292   "   -column              set output mode to 'column'\n"
1182*c5c4113dSnw141292   "   -html                set output mode to HTML\n"
1183*c5c4113dSnw141292 #ifdef SQLITE_HAS_CODEC
1184*c5c4113dSnw141292   "   -key KEY             encryption key\n"
1185*c5c4113dSnw141292 #endif
1186*c5c4113dSnw141292   "   -line                set output mode to 'line'\n"
1187*c5c4113dSnw141292   "   -list                set output mode to 'list'\n"
1188*c5c4113dSnw141292   "   -separator 'x'       set output field separator (|)\n"
1189*c5c4113dSnw141292   "   -nullvalue 'text'    set text string for NULL values\n"
1190*c5c4113dSnw141292   "   -version             show SQLite version\n"
1191*c5c4113dSnw141292   "   -help                show this text, also show dot-commands\n"
1192*c5c4113dSnw141292 ;
usage(int showDetail)1193*c5c4113dSnw141292 static void usage(int showDetail){
1194*c5c4113dSnw141292   fprintf(stderr, "Usage: %s [OPTIONS] FILENAME [SQL]\n", Argv0);
1195*c5c4113dSnw141292   if( showDetail ){
1196*c5c4113dSnw141292     fprintf(stderr, "Options are:\n%s", zOptions);
1197*c5c4113dSnw141292   }else{
1198*c5c4113dSnw141292     fprintf(stderr, "Use the -help option for additional information\n");
1199*c5c4113dSnw141292   }
1200*c5c4113dSnw141292   exit(1);
1201*c5c4113dSnw141292 }
1202*c5c4113dSnw141292 
1203*c5c4113dSnw141292 /*
1204*c5c4113dSnw141292 ** Initialize the state information in data
1205*c5c4113dSnw141292 */
main_init(struct callback_data * data)1206*c5c4113dSnw141292 void main_init(struct callback_data *data) {
1207*c5c4113dSnw141292   memset(data, 0, sizeof(*data));
1208*c5c4113dSnw141292   data->mode = MODE_List;
1209*c5c4113dSnw141292   strcpy(data->separator,"|");
1210*c5c4113dSnw141292   data->showHeader = 0;
1211*c5c4113dSnw141292   strcpy(mainPrompt,"sqlite> ");
1212*c5c4113dSnw141292   strcpy(continuePrompt,"   ...> ");
1213*c5c4113dSnw141292 }
1214*c5c4113dSnw141292 
main(int argc,char ** argv)1215*c5c4113dSnw141292 int main(int argc, char **argv){
1216*c5c4113dSnw141292   char *zErrMsg = 0;
1217*c5c4113dSnw141292   struct callback_data data;
1218*c5c4113dSnw141292   const char *zInitFile = 0;
1219*c5c4113dSnw141292   char *zFirstCmd = 0;
1220*c5c4113dSnw141292   int i;
1221*c5c4113dSnw141292   extern int sqliteOsFileExists(const char*);
1222*c5c4113dSnw141292 
1223*c5c4113dSnw141292   sqlite_temp_directory = "/etc/svc/volatile";		/* SUNW addition */
1224*c5c4113dSnw141292 
1225*c5c4113dSnw141292 #ifdef __MACOS__
1226*c5c4113dSnw141292   argc = ccommand(&argv);
1227*c5c4113dSnw141292 #endif
1228*c5c4113dSnw141292 
1229*c5c4113dSnw141292   Argv0 = argv[0];
1230*c5c4113dSnw141292   main_init(&data);
1231*c5c4113dSnw141292 
1232*c5c4113dSnw141292   /* Make sure we have a valid signal handler early, before anything
1233*c5c4113dSnw141292   ** else is done.
1234*c5c4113dSnw141292   */
1235*c5c4113dSnw141292 #ifdef SIGINT
1236*c5c4113dSnw141292   signal(SIGINT, interrupt_handler);
1237*c5c4113dSnw141292 #endif
1238*c5c4113dSnw141292 
1239*c5c4113dSnw141292   /* Do an initial pass through the command-line argument to locate
1240*c5c4113dSnw141292   ** the name of the database file, the name of the initialization file,
1241*c5c4113dSnw141292   ** and the first command to execute.
1242*c5c4113dSnw141292   */
1243*c5c4113dSnw141292   for(i=1; i<argc-1; i++){
1244*c5c4113dSnw141292     if( argv[i][0]!='-' ) break;
1245*c5c4113dSnw141292     if( strcmp(argv[i],"-separator")==0 || strcmp(argv[i],"-nullvalue")==0 ){
1246*c5c4113dSnw141292       i++;
1247*c5c4113dSnw141292     }else if( strcmp(argv[i],"-init")==0 ){
1248*c5c4113dSnw141292       i++;
1249*c5c4113dSnw141292       zInitFile = argv[i];
1250*c5c4113dSnw141292     }else if( strcmp(argv[i],"-key")==0 ){
1251*c5c4113dSnw141292       i++;
1252*c5c4113dSnw141292       data.zKey = sqlite_mprintf("%s",argv[i]);
1253*c5c4113dSnw141292     }
1254*c5c4113dSnw141292   }
1255*c5c4113dSnw141292   if( i<argc ){
1256*c5c4113dSnw141292     data.zDbFilename = argv[i++];
1257*c5c4113dSnw141292   }else{
1258*c5c4113dSnw141292     data.zDbFilename = ":memory:";
1259*c5c4113dSnw141292   }
1260*c5c4113dSnw141292   if( i<argc ){
1261*c5c4113dSnw141292     zFirstCmd = argv[i++];
1262*c5c4113dSnw141292   }
1263*c5c4113dSnw141292   data.out = stdout;
1264*c5c4113dSnw141292 
1265*c5c4113dSnw141292   /* Go ahead and open the database file if it already exists.  If the
1266*c5c4113dSnw141292   ** file does not exist, delay opening it.  This prevents empty database
1267*c5c4113dSnw141292   ** files from being created if a user mistypes the database name argument
1268*c5c4113dSnw141292   ** to the sqlite command-line tool.
1269*c5c4113dSnw141292   */
1270*c5c4113dSnw141292   if( sqliteOsFileExists(data.zDbFilename) ){
1271*c5c4113dSnw141292     open_db(&data);
1272*c5c4113dSnw141292   }
1273*c5c4113dSnw141292 
1274*c5c4113dSnw141292   /* Process the initialization file if there is one.  If no -init option
1275*c5c4113dSnw141292   ** is given on the command line, look for a file named ~/.sqliterc and
1276*c5c4113dSnw141292   ** try to process it.
1277*c5c4113dSnw141292   */
1278*c5c4113dSnw141292   process_sqliterc(&data,zInitFile);
1279*c5c4113dSnw141292 
1280*c5c4113dSnw141292   /* Make a second pass through the command-line argument and set
1281*c5c4113dSnw141292   ** options.  This second pass is delayed until after the initialization
1282*c5c4113dSnw141292   ** file is processed so that the command-line arguments will override
1283*c5c4113dSnw141292   ** settings in the initialization file.
1284*c5c4113dSnw141292   */
1285*c5c4113dSnw141292   for(i=1; i<argc && argv[i][0]=='-'; i++){
1286*c5c4113dSnw141292     char *z = argv[i];
1287*c5c4113dSnw141292     if( strcmp(z,"-init")==0 || strcmp(z,"-key")==0 ){
1288*c5c4113dSnw141292       i++;
1289*c5c4113dSnw141292     }else if( strcmp(z,"-html")==0 ){
1290*c5c4113dSnw141292       data.mode = MODE_Html;
1291*c5c4113dSnw141292     }else if( strcmp(z,"-list")==0 ){
1292*c5c4113dSnw141292       data.mode = MODE_List;
1293*c5c4113dSnw141292     }else if( strcmp(z,"-line")==0 ){
1294*c5c4113dSnw141292       data.mode = MODE_Line;
1295*c5c4113dSnw141292     }else if( strcmp(z,"-column")==0 ){
1296*c5c4113dSnw141292       data.mode = MODE_Column;
1297*c5c4113dSnw141292     }else if( strcmp(z,"-separator")==0 ){
1298*c5c4113dSnw141292       i++;
1299*c5c4113dSnw141292       sprintf(data.separator,"%.*s",(int)sizeof(data.separator)-1,argv[i]);
1300*c5c4113dSnw141292     }else if( strcmp(z,"-nullvalue")==0 ){
1301*c5c4113dSnw141292       i++;
1302*c5c4113dSnw141292       sprintf(data.nullvalue,"%.*s",(int)sizeof(data.nullvalue)-1,argv[i]);
1303*c5c4113dSnw141292     }else if( strcmp(z,"-header")==0 ){
1304*c5c4113dSnw141292       data.showHeader = 1;
1305*c5c4113dSnw141292     }else if( strcmp(z,"-noheader")==0 ){
1306*c5c4113dSnw141292       data.showHeader = 0;
1307*c5c4113dSnw141292     }else if( strcmp(z,"-echo")==0 ){
1308*c5c4113dSnw141292       data.echoOn = 1;
1309*c5c4113dSnw141292     }else if( strcmp(z,"-version")==0 ){
1310*c5c4113dSnw141292       printf("%s\n", sqlite_version);
1311*c5c4113dSnw141292       return 1;
1312*c5c4113dSnw141292     }else if( strcmp(z,"-help")==0 ){
1313*c5c4113dSnw141292       usage(1);
1314*c5c4113dSnw141292     }else{
1315*c5c4113dSnw141292       fprintf(stderr,"%s: unknown option: %s\n", Argv0, z);
1316*c5c4113dSnw141292       fprintf(stderr,"Use -help for a list of options.\n");
1317*c5c4113dSnw141292       return 1;
1318*c5c4113dSnw141292     }
1319*c5c4113dSnw141292   }
1320*c5c4113dSnw141292 
1321*c5c4113dSnw141292   if( zFirstCmd ){
1322*c5c4113dSnw141292     /* Run just the command that follows the database name
1323*c5c4113dSnw141292     */
1324*c5c4113dSnw141292     if( zFirstCmd[0]=='.' ){
1325*c5c4113dSnw141292       do_meta_command(zFirstCmd, &data);
1326*c5c4113dSnw141292       exit(0);
1327*c5c4113dSnw141292     }else{
1328*c5c4113dSnw141292       int rc;
1329*c5c4113dSnw141292       open_db(&data);
1330*c5c4113dSnw141292       rc = sqlite_exec(data.db, zFirstCmd, callback, &data, &zErrMsg);
1331*c5c4113dSnw141292       if( rc!=0 && zErrMsg!=0 ){
1332*c5c4113dSnw141292         fprintf(stderr,"SQL error: %s\n", zErrMsg);
1333*c5c4113dSnw141292         exit(1);
1334*c5c4113dSnw141292       }
1335*c5c4113dSnw141292     }
1336*c5c4113dSnw141292   }else{
1337*c5c4113dSnw141292     /* Run commands received from standard input
1338*c5c4113dSnw141292     */
1339*c5c4113dSnw141292     if( isatty(fileno(stdout)) && isatty(fileno(stdin)) ){
1340*c5c4113dSnw141292       char *zHome;
1341*c5c4113dSnw141292       char *zHistory = 0;
1342*c5c4113dSnw141292       printf(
1343*c5c4113dSnw141292         "SQLite version %s\n"
1344*c5c4113dSnw141292         "Enter \".help\" for instructions\n",
1345*c5c4113dSnw141292         sqlite_version
1346*c5c4113dSnw141292       );
1347*c5c4113dSnw141292       zHome = find_home_dir();
1348*c5c4113dSnw141292       if( zHome && (zHistory = malloc(strlen(zHome)+20))!=0 ){
1349*c5c4113dSnw141292         sprintf(zHistory,"%s/.sqlite_history", zHome);
1350*c5c4113dSnw141292       }
1351*c5c4113dSnw141292       if( zHistory ) read_history(zHistory);
1352*c5c4113dSnw141292       process_input(&data, 0);
1353*c5c4113dSnw141292       if( zHistory ){
1354*c5c4113dSnw141292         stifle_history(100);
1355*c5c4113dSnw141292         write_history(zHistory);
1356*c5c4113dSnw141292       }
1357*c5c4113dSnw141292     }else{
1358*c5c4113dSnw141292       process_input(&data, stdin);
1359*c5c4113dSnw141292     }
1360*c5c4113dSnw141292   }
1361*c5c4113dSnw141292   set_table_name(&data, 0);
1362*c5c4113dSnw141292   if( db ) sqlite_close(db);
1363*c5c4113dSnw141292   return 0;
1364*c5c4113dSnw141292 }
1365