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,"<");
268*c5c4113dSnw141292 }else if( z[i]=='&' ){
269*c5c4113dSnw141292 fprintf(out,"&");
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