Skip to content
Projects
Groups
Snippets
Help
Loading...
Help
Contribute to GitLab
Sign in / Register
Toggle navigation
M
Magisk
Project
Project
Details
Activity
Cycle Analytics
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Charts
Issues
0
Issues
0
List
Board
Labels
Milestones
Merge Requests
0
Merge Requests
0
CI / CD
CI / CD
Pipelines
Jobs
Schedules
Charts
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Charts
Create a new issue
Jobs
Commits
Issue Boards
Open sidebar
Administrator
Magisk
Commits
17e395c2
Commit
17e395c2
authored
Mar 15, 2017
by
topjohnwu
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
Cleanup and hide debug msg
parent
d50c1f39
Show whitespace changes
Inline
Side-by-side
Showing
3 changed files
with
2 additions
and
3610 deletions
+2
-3610
shell.c
sqlite3/shell.c
+0
-3163
sqlite3ext.h
sqlite3/sqlite3ext.h
+0
-447
su.c
su.c
+2
-0
No files found.
sqlite3/shell.c
deleted
100644 → 0
View file @
d50c1f39
/*
** 2001 September 15
**
** The author disclaims copyright to this source code. In place of
** a legal notice, here is a blessing:
**
** May you do good and not evil.
** May you find forgiveness for yourself and forgive others.
** May you share freely, never taking more than you give.
**
*************************************************************************
** This file contains code to implement the "sqlite" command line
** utility for accessing SQLite databases.
*/
#if (defined(_WIN32) || defined(WIN32)) && !defined(_CRT_SECURE_NO_WARNINGS)
/* This needs to come before any includes for MSVC compiler */
#define _CRT_SECURE_NO_WARNINGS
#endif
/*
** Enable large-file support for fopen() and friends on unix.
*/
#ifndef SQLITE_DISABLE_LFS
# define _LARGE_FILE 1
# ifndef _FILE_OFFSET_BITS
# define _FILE_OFFSET_BITS 64
# endif
# define _LARGEFILE_SOURCE 1
#endif
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <assert.h>
#include "sqlite3.h"
#include <ctype.h>
#include <stdarg.h>
#if !defined(_WIN32) && !defined(WIN32)
# include <signal.h>
# if !defined(__RTP__) && !defined(_WRS_KERNEL)
# include <pwd.h>
# endif
# include <unistd.h>
# include <sys/types.h>
#endif
#ifdef HAVE_EDITLINE
# include <editline/editline.h>
#endif
#if defined(HAVE_READLINE) && HAVE_READLINE==1
# include <readline/readline.h>
# include <readline/history.h>
#endif
#if !defined(HAVE_EDITLINE) && (!defined(HAVE_READLINE) || HAVE_READLINE!=1)
# define readline(p) local_getline(p,stdin,0)
# define add_history(X)
# define read_history(X)
# define write_history(X)
# define stifle_history(X)
#endif
#if defined(_WIN32) || defined(WIN32)
# include <io.h>
#define isatty(h) _isatty(h)
#define access(f,m) _access((f),(m))
#undef popen
#define popen(a,b) _popen((a),(b))
#undef pclose
#define pclose(x) _pclose(x)
#else
/* Make sure isatty() has a prototype.
*/
extern
int
isatty
(
int
);
#endif
#if defined(_WIN32_WCE)
/* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty()
* thus we always assume that we have a console. That can be
* overridden with the -batch command line option.
*/
#define isatty(x) 1
#endif
/* True if the timer is enabled */
static
int
enableTimer
=
0
;
/* ctype macros that work with signed characters */
#define IsSpace(X) isspace((unsigned char)X)
#define IsDigit(X) isdigit((unsigned char)X)
#define ToLower(X) (char)tolower((unsigned char)X)
#if !defined(_WIN32) && !defined(WIN32) && !defined(_WRS_KERNEL)
#include <sys/time.h>
#include <sys/resource.h>
/* Saved resource information for the beginning of an operation */
static
struct
rusage
sBegin
;
/*
** Begin timing an operation
*/
static
void
beginTimer
(
void
){
if
(
enableTimer
){
getrusage
(
RUSAGE_SELF
,
&
sBegin
);
}
}
/* Return the difference of two time_structs in seconds */
static
double
timeDiff
(
struct
timeval
*
pStart
,
struct
timeval
*
pEnd
){
return
(
pEnd
->
tv_usec
-
pStart
->
tv_usec
)
*
0
.
000001
+
(
double
)(
pEnd
->
tv_sec
-
pStart
->
tv_sec
);
}
/*
** Print the timing results.
*/
static
void
endTimer
(
void
){
if
(
enableTimer
){
struct
rusage
sEnd
;
getrusage
(
RUSAGE_SELF
,
&
sEnd
);
printf
(
"CPU Time: user %f sys %f
\n
"
,
timeDiff
(
&
sBegin
.
ru_utime
,
&
sEnd
.
ru_utime
),
timeDiff
(
&
sBegin
.
ru_stime
,
&
sEnd
.
ru_stime
));
}
}
#define BEGIN_TIMER beginTimer()
#define END_TIMER endTimer()
#define HAS_TIMER 1
#elif (defined(_WIN32) || defined(WIN32))
#include <windows.h>
/* Saved resource information for the beginning of an operation */
static
HANDLE
hProcess
;
static
FILETIME
ftKernelBegin
;
static
FILETIME
ftUserBegin
;
typedef
BOOL
(
WINAPI
*
GETPROCTIMES
)(
HANDLE
,
LPFILETIME
,
LPFILETIME
,
LPFILETIME
,
LPFILETIME
);
static
GETPROCTIMES
getProcessTimesAddr
=
NULL
;
/*
** Check to see if we have timer support. Return 1 if necessary
** support found (or found previously).
*/
static
int
hasTimer
(
void
){
if
(
getProcessTimesAddr
){
return
1
;
}
else
{
/* GetProcessTimes() isn't supported in WIN95 and some other Windows versions.
** See if the version we are running on has it, and if it does, save off
** a pointer to it and the current process handle.
*/
hProcess
=
GetCurrentProcess
();
if
(
hProcess
){
HINSTANCE
hinstLib
=
LoadLibrary
(
TEXT
(
"Kernel32.dll"
));
if
(
NULL
!=
hinstLib
){
getProcessTimesAddr
=
(
GETPROCTIMES
)
GetProcAddress
(
hinstLib
,
"GetProcessTimes"
);
if
(
NULL
!=
getProcessTimesAddr
){
return
1
;
}
FreeLibrary
(
hinstLib
);
}
}
}
return
0
;
}
/*
** Begin timing an operation
*/
static
void
beginTimer
(
void
){
if
(
enableTimer
&&
getProcessTimesAddr
){
FILETIME
ftCreation
,
ftExit
;
getProcessTimesAddr
(
hProcess
,
&
ftCreation
,
&
ftExit
,
&
ftKernelBegin
,
&
ftUserBegin
);
}
}
/* Return the difference of two FILETIME structs in seconds */
static
double
timeDiff
(
FILETIME
*
pStart
,
FILETIME
*
pEnd
){
sqlite_int64
i64Start
=
*
((
sqlite_int64
*
)
pStart
);
sqlite_int64
i64End
=
*
((
sqlite_int64
*
)
pEnd
);
return
(
double
)
((
i64End
-
i64Start
)
/
10000000
.
0
);
}
/*
** Print the timing results.
*/
static
void
endTimer
(
void
){
if
(
enableTimer
&&
getProcessTimesAddr
){
FILETIME
ftCreation
,
ftExit
,
ftKernelEnd
,
ftUserEnd
;
getProcessTimesAddr
(
hProcess
,
&
ftCreation
,
&
ftExit
,
&
ftKernelEnd
,
&
ftUserEnd
);
printf
(
"CPU Time: user %f sys %f
\n
"
,
timeDiff
(
&
ftUserBegin
,
&
ftUserEnd
),
timeDiff
(
&
ftKernelBegin
,
&
ftKernelEnd
));
}
}
#define BEGIN_TIMER beginTimer()
#define END_TIMER endTimer()
#define HAS_TIMER hasTimer()
#else
#define BEGIN_TIMER
#define END_TIMER
#define HAS_TIMER 0
#endif
/*
** Used to prevent warnings about unused parameters
*/
#define UNUSED_PARAMETER(x) (void)(x)
/*
** If the following flag is set, then command execution stops
** at an error if we are not interactive.
*/
static
int
bail_on_error
=
0
;
/*
** Threat stdin as an interactive input if the following variable
** is true. Otherwise, assume stdin is connected to a file or pipe.
*/
static
int
stdin_is_interactive
=
1
;
/*
** The following is the open SQLite database. We make a pointer
** to this database a static variable so that it can be accessed
** by the SIGINT handler to interrupt database processing.
*/
static
sqlite3
*
db
=
0
;
/*
** True if an interrupt (Control-C) has been received.
*/
static
volatile
int
seenInterrupt
=
0
;
/*
** This is the name of our program. It is set in main(), used
** in a number of other places, mostly for error messages.
*/
static
char
*
Argv0
;
/*
** Prompt strings. Initialized in main. Settable with
** .prompt main continue
*/
static
char
mainPrompt
[
20
];
/* First line prompt. default: "sqlite> "*/
static
char
continuePrompt
[
20
];
/* Continuation prompt. default: " ...> " */
/*
** Write I/O traces to the following stream.
*/
#ifdef SQLITE_ENABLE_IOTRACE
static
FILE
*
iotrace
=
0
;
#endif
/*
** This routine works like printf in that its first argument is a
** format string and subsequent arguments are values to be substituted
** in place of % fields. The result of formatting this string
** is written to iotrace.
*/
#ifdef SQLITE_ENABLE_IOTRACE
static
void
iotracePrintf
(
const
char
*
zFormat
,
...){
va_list
ap
;
char
*
z
;
if
(
iotrace
==
0
)
return
;
va_start
(
ap
,
zFormat
);
z
=
sqlite3_vmprintf
(
zFormat
,
ap
);
va_end
(
ap
);
fprintf
(
iotrace
,
"%s"
,
z
);
sqlite3_free
(
z
);
}
#endif
/*
** Determines if a string is a number of not.
*/
static
int
isNumber
(
const
char
*
z
,
int
*
realnum
){
if
(
*
z
==
'-'
||
*
z
==
'+'
)
z
++
;
if
(
!
IsDigit
(
*
z
)
){
return
0
;
}
z
++
;
if
(
realnum
)
*
realnum
=
0
;
while
(
IsDigit
(
*
z
)
){
z
++
;
}
if
(
*
z
==
'.'
){
z
++
;
if
(
!
IsDigit
(
*
z
)
)
return
0
;
while
(
IsDigit
(
*
z
)
){
z
++
;
}
if
(
realnum
)
*
realnum
=
1
;
}
if
(
*
z
==
'e'
||
*
z
==
'E'
){
z
++
;
if
(
*
z
==
'+'
||
*
z
==
'-'
)
z
++
;
if
(
!
IsDigit
(
*
z
)
)
return
0
;
while
(
IsDigit
(
*
z
)
){
z
++
;
}
if
(
realnum
)
*
realnum
=
1
;
}
return
*
z
==
0
;
}
/*
** A global char* and an SQL function to access its current value
** from within an SQL statement. This program used to use the
** sqlite_exec_printf() API to substitue a string into an SQL statement.
** The correct way to do this with sqlite3 is to use the bind API, but
** since the shell is built around the callback paradigm it would be a lot
** of work. Instead just use this hack, which is quite harmless.
*/
static
const
char
*
zShellStatic
=
0
;
static
void
shellstaticFunc
(
sqlite3_context
*
context
,
int
argc
,
sqlite3_value
**
argv
){
assert
(
0
==
argc
);
assert
(
zShellStatic
);
UNUSED_PARAMETER
(
argc
);
UNUSED_PARAMETER
(
argv
);
sqlite3_result_text
(
context
,
zShellStatic
,
-
1
,
SQLITE_STATIC
);
}
/*
** This routine reads a line of text from FILE in, stores
** the text in memory obtained from malloc() and returns a pointer
** to the text. NULL is returned at end of file, or if malloc()
** fails.
**
** The interface is like "readline" but no command-line editing
** is done.
*/
static
char
*
local_getline
(
char
*
zPrompt
,
FILE
*
in
,
int
csvFlag
){
char
*
zLine
;
int
nLine
;
int
n
;
int
inQuote
=
0
;
if
(
zPrompt
&&
*
zPrompt
){
printf
(
"%s"
,
zPrompt
);
fflush
(
stdout
);
}
nLine
=
100
;
zLine
=
malloc
(
nLine
);
if
(
zLine
==
0
)
return
0
;
n
=
0
;
while
(
1
){
if
(
n
+
100
>
nLine
){
nLine
=
nLine
*
2
+
100
;
zLine
=
realloc
(
zLine
,
nLine
);
if
(
zLine
==
0
)
return
0
;
}
if
(
fgets
(
&
zLine
[
n
],
nLine
-
n
,
in
)
==
0
){
if
(
n
==
0
){
free
(
zLine
);
return
0
;
}
zLine
[
n
]
=
0
;
break
;
}
while
(
zLine
[
n
]
){
if
(
zLine
[
n
]
==
'"'
)
inQuote
=
!
inQuote
;
n
++
;
}
if
(
n
>
0
&&
zLine
[
n
-
1
]
==
'\n'
&&
(
!
inQuote
||
!
csvFlag
)
){
n
--
;
if
(
n
>
0
&&
zLine
[
n
-
1
]
==
'\r'
)
n
--
;
zLine
[
n
]
=
0
;
break
;
}
}
zLine
=
realloc
(
zLine
,
n
+
1
);
return
zLine
;
}
/*
** Retrieve a single line of input text.
**
** zPrior is a string of prior text retrieved. If not the empty
** string, then issue a continuation prompt.
*/
static
char
*
one_input_line
(
const
char
*
zPrior
,
FILE
*
in
){
char
*
zPrompt
;
char
*
zResult
;
if
(
in
!=
0
){
return
local_getline
(
0
,
in
,
0
);
}
if
(
zPrior
&&
zPrior
[
0
]
){
zPrompt
=
continuePrompt
;
}
else
{
zPrompt
=
mainPrompt
;
}
zResult
=
readline
(
zPrompt
);
#if defined(HAVE_READLINE) && HAVE_READLINE==1
if
(
zResult
&&
*
zResult
)
add_history
(
zResult
);
#endif
return
zResult
;
}
struct
previous_mode_data
{
int
valid
;
/* Is there legit data in here? */
int
mode
;
int
showHeader
;
int
colWidth
[
100
];
};
/*
** An pointer to an instance of this structure is passed from
** the main program to the callback. This is used to communicate
** state and mode information.
*/
struct
callback_data
{
sqlite3
*
db
;
/* The database */
int
echoOn
;
/* True to echo input commands */
int
statsOn
;
/* True to display memory stats before each finalize */
int
cnt
;
/* Number of records displayed so far */
FILE
*
out
;
/* Write results here */
FILE
*
traceOut
;
/* Output for sqlite3_trace() */
int
nErr
;
/* Number of errors seen */
int
mode
;
/* An output mode setting */
int
writableSchema
;
/* True if PRAGMA writable_schema=ON */
int
showHeader
;
/* True to show column names in List or Column mode */
char
*
zDestTable
;
/* Name of destination table when MODE_Insert */
char
separator
[
20
];
/* Separator character for MODE_List */
int
colWidth
[
100
];
/* Requested width of each column when in column mode*/
int
actualWidth
[
100
];
/* Actual width of each column */
char
nullvalue
[
20
];
/* The text to print when a NULL comes back from
** the database */
struct
previous_mode_data
explainPrev
;
/* Holds the mode information just before
** .explain ON */
char
outfile
[
FILENAME_MAX
];
/* Filename for *out */
const
char
*
zDbFilename
;
/* name of the database file */
const
char
*
zVfs
;
/* Name of VFS to use */
sqlite3_stmt
*
pStmt
;
/* Current statement if any. */
FILE
*
pLog
;
/* Write log output here */
};
/*
** These are the allowed modes.
*/
#define MODE_Line 0
/* One column per line. Blank line between records */
#define MODE_Column 1
/* One record per line in neat columns */
#define MODE_List 2
/* One record per line with a separator */
#define MODE_Semi 3
/* Same as MODE_List but append ";" to each line */
#define MODE_Html 4
/* Generate an XHTML table */
#define MODE_Insert 5
/* Generate SQL "insert" statements */
#define MODE_Tcl 6
/* Generate ANSI-C or TCL quoted elements */
#define MODE_Csv 7
/* Quote strings, numbers are plain */
#define MODE_Explain 8
/* Like MODE_Column, but do not truncate data */
static
const
char
*
modeDescr
[]
=
{
"line"
,
"column"
,
"list"
,
"semi"
,
"html"
,
"insert"
,
"tcl"
,
"csv"
,
"explain"
,
};
/*
** Number of elements in an array
*/
#define ArraySize(X) (int)(sizeof(X)/sizeof(X[0]))
/*
** Compute a string length that is limited to what can be stored in
** lower 30 bits of a 32-bit signed integer.
*/
static
int
strlen30
(
const
char
*
z
){
const
char
*
z2
=
z
;
while
(
*
z2
){
z2
++
;
}
return
0x3fffffff
&
(
int
)(
z2
-
z
);
}
/*
** A callback for the sqlite3_log() interface.
*/
static
void
shellLog
(
void
*
pArg
,
int
iErrCode
,
const
char
*
zMsg
){
struct
callback_data
*
p
=
(
struct
callback_data
*
)
pArg
;
if
(
p
->
pLog
==
0
)
return
;
fprintf
(
p
->
pLog
,
"(%d) %s
\n
"
,
iErrCode
,
zMsg
);
fflush
(
p
->
pLog
);
}
/*
** Output the given string as a hex-encoded blob (eg. X'1234' )
*/
static
void
output_hex_blob
(
FILE
*
out
,
const
void
*
pBlob
,
int
nBlob
){
int
i
;
char
*
zBlob
=
(
char
*
)
pBlob
;
fprintf
(
out
,
"X'"
);
for
(
i
=
0
;
i
<
nBlob
;
i
++
){
fprintf
(
out
,
"%02x"
,
zBlob
[
i
]
&
0xff
);
}
fprintf
(
out
,
"'"
);
}
/*
** Output the given string as a quoted string using SQL quoting conventions.
*/
static
void
output_quoted_string
(
FILE
*
out
,
const
char
*
z
){
int
i
;
int
nSingle
=
0
;
for
(
i
=
0
;
z
[
i
];
i
++
){
if
(
z
[
i
]
==
'\''
)
nSingle
++
;
}
if
(
nSingle
==
0
){
fprintf
(
out
,
"'%s'"
,
z
);
}
else
{
fprintf
(
out
,
"'"
);
while
(
*
z
){
for
(
i
=
0
;
z
[
i
]
&&
z
[
i
]
!=
'\''
;
i
++
){}
if
(
i
==
0
){
fprintf
(
out
,
"''"
);
z
++
;
}
else
if
(
z
[
i
]
==
'\''
){
fprintf
(
out
,
"%.*s''"
,
i
,
z
);
z
+=
i
+
1
;
}
else
{
fprintf
(
out
,
"%s"
,
z
);
break
;
}
}
fprintf
(
out
,
"'"
);
}
}
/*
** Output the given string as a quoted according to C or TCL quoting rules.
*/
static
void
output_c_string
(
FILE
*
out
,
const
char
*
z
){
unsigned
int
c
;
fputc
(
'"'
,
out
);
while
(
(
c
=
*
(
z
++
))
!=
0
){
if
(
c
==
'\\'
){
fputc
(
c
,
out
);
fputc
(
c
,
out
);
}
else
if
(
c
==
'"'
){
fputc
(
'\\'
,
out
);
fputc
(
'"'
,
out
);
}
else
if
(
c
==
'\t'
){
fputc
(
'\\'
,
out
);
fputc
(
't'
,
out
);
}
else
if
(
c
==
'\n'
){
fputc
(
'\\'
,
out
);
fputc
(
'n'
,
out
);
}
else
if
(
c
==
'\r'
){
fputc
(
'\\'
,
out
);
fputc
(
'r'
,
out
);
}
else
if
(
!
isprint
(
c
)
){
fprintf
(
out
,
"
\\
%03o"
,
c
&
0xff
);
}
else
{
fputc
(
c
,
out
);
}
}
fputc
(
'"'
,
out
);
}
/*
** Output the given string with characters that are special to
** HTML escaped.
*/
static
void
output_html_string
(
FILE
*
out
,
const
char
*
z
){
int
i
;
while
(
*
z
){
for
(
i
=
0
;
z
[
i
]
&&
z
[
i
]
!=
'<'
&&
z
[
i
]
!=
'&'
&&
z
[
i
]
!=
'>'
&&
z
[
i
]
!=
'\"'
&&
z
[
i
]
!=
'\''
;
i
++
){}
if
(
i
>
0
){
fprintf
(
out
,
"%.*s"
,
i
,
z
);
}
if
(
z
[
i
]
==
'<'
){
fprintf
(
out
,
"<"
);
}
else
if
(
z
[
i
]
==
'&'
){
fprintf
(
out
,
"&"
);
}
else
if
(
z
[
i
]
==
'>'
){
fprintf
(
out
,
">"
);
}
else
if
(
z
[
i
]
==
'\"'
){
fprintf
(
out
,
"""
);
}
else
if
(
z
[
i
]
==
'\''
){
fprintf
(
out
,
"'"
);
}
else
{
break
;
}
z
+=
i
+
1
;
}
}
/*
** If a field contains any character identified by a 1 in the following
** array, then the string must be quoted for CSV.
*/
static
const
char
needCsvQuote
[]
=
{
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
0
,
1
,
0
,
0
,
0
,
0
,
1
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
1
,
};
/*
** Output a single term of CSV. Actually, p->separator is used for
** the separator, which may or may not be a comma. p->nullvalue is
** the null value. Strings are quoted if necessary.
*/
static
void
output_csv
(
struct
callback_data
*
p
,
const
char
*
z
,
int
bSep
){
FILE
*
out
=
p
->
out
;
if
(
z
==
0
){
fprintf
(
out
,
"%s"
,
p
->
nullvalue
);
}
else
{
int
i
;
int
nSep
=
strlen30
(
p
->
separator
);
for
(
i
=
0
;
z
[
i
];
i
++
){
if
(
needCsvQuote
[((
unsigned
char
*
)
z
)[
i
]]
||
(
z
[
i
]
==
p
->
separator
[
0
]
&&
(
nSep
==
1
||
memcmp
(
z
,
p
->
separator
,
nSep
)
==
0
))
){
i
=
0
;
break
;
}
}
if
(
i
==
0
){
putc
(
'"'
,
out
);
for
(
i
=
0
;
z
[
i
];
i
++
){
if
(
z
[
i
]
==
'"'
)
putc
(
'"'
,
out
);
putc
(
z
[
i
],
out
);
}
putc
(
'"'
,
out
);
}
else
{
fprintf
(
out
,
"%s"
,
z
);
}
}
if
(
bSep
){
fprintf
(
p
->
out
,
"%s"
,
p
->
separator
);
}
}
#ifdef SIGINT
/*
** This routine runs when the user presses Ctrl-C
*/
static
void
interrupt_handler
(
int
NotUsed
){
UNUSED_PARAMETER
(
NotUsed
);
seenInterrupt
=
1
;
if
(
db
)
sqlite3_interrupt
(
db
);
}
#endif
/*
** This is the callback routine that the shell
** invokes for each row of a query result.
*/
static
int
shell_callback
(
void
*
pArg
,
int
nArg
,
char
**
azArg
,
char
**
azCol
,
int
*
aiType
){
int
i
;
struct
callback_data
*
p
=
(
struct
callback_data
*
)
pArg
;
switch
(
p
->
mode
){
case
MODE_Line
:
{
int
w
=
5
;
if
(
azArg
==
0
)
break
;
for
(
i
=
0
;
i
<
nArg
;
i
++
){
int
len
=
strlen30
(
azCol
[
i
]
?
azCol
[
i
]
:
""
);
if
(
len
>
w
)
w
=
len
;
}
if
(
p
->
cnt
++>
0
)
fprintf
(
p
->
out
,
"
\n
"
);
for
(
i
=
0
;
i
<
nArg
;
i
++
){
fprintf
(
p
->
out
,
"%*s = %s
\n
"
,
w
,
azCol
[
i
],
azArg
[
i
]
?
azArg
[
i
]
:
p
->
nullvalue
);
}
break
;
}
case
MODE_Explain
:
case
MODE_Column
:
{
if
(
p
->
cnt
++==
0
){
for
(
i
=
0
;
i
<
nArg
;
i
++
){
int
w
,
n
;
if
(
i
<
ArraySize
(
p
->
colWidth
)
){
w
=
p
->
colWidth
[
i
];
}
else
{
w
=
0
;
}
if
(
w
==
0
){
w
=
strlen30
(
azCol
[
i
]
?
azCol
[
i
]
:
""
);
if
(
w
<
10
)
w
=
10
;
n
=
strlen30
(
azArg
&&
azArg
[
i
]
?
azArg
[
i
]
:
p
->
nullvalue
);
if
(
w
<
n
)
w
=
n
;
}
if
(
i
<
ArraySize
(
p
->
actualWidth
)
){
p
->
actualWidth
[
i
]
=
w
;
}
if
(
p
->
showHeader
){
if
(
w
<
0
){
fprintf
(
p
->
out
,
"%*.*s%s"
,
-
w
,
-
w
,
azCol
[
i
],
i
==
nArg
-
1
?
"
\n
"
:
" "
);
}
else
{
fprintf
(
p
->
out
,
"%-*.*s%s"
,
w
,
w
,
azCol
[
i
],
i
==
nArg
-
1
?
"
\n
"
:
" "
);
}
}
}
if
(
p
->
showHeader
){
for
(
i
=
0
;
i
<
nArg
;
i
++
){
int
w
;
if
(
i
<
ArraySize
(
p
->
actualWidth
)
){
w
=
p
->
actualWidth
[
i
];
if
(
w
<
0
)
w
=
-
w
;
}
else
{
w
=
10
;
}
fprintf
(
p
->
out
,
"%-*.*s%s"
,
w
,
w
,
"-----------------------------------"
"----------------------------------------------------------"
,
i
==
nArg
-
1
?
"
\n
"
:
" "
);
}
}
}
if
(
azArg
==
0
)
break
;
for
(
i
=
0
;
i
<
nArg
;
i
++
){
int
w
;
if
(
i
<
ArraySize
(
p
->
actualWidth
)
){
w
=
p
->
actualWidth
[
i
];
}
else
{
w
=
10
;
}
if
(
p
->
mode
==
MODE_Explain
&&
azArg
[
i
]
&&
strlen30
(
azArg
[
i
])
>
w
){
w
=
strlen30
(
azArg
[
i
]);
}
if
(
w
<
0
){
fprintf
(
p
->
out
,
"%*.*s%s"
,
-
w
,
-
w
,
azArg
[
i
]
?
azArg
[
i
]
:
p
->
nullvalue
,
i
==
nArg
-
1
?
"
\n
"
:
" "
);
}
else
{
fprintf
(
p
->
out
,
"%-*.*s%s"
,
w
,
w
,
azArg
[
i
]
?
azArg
[
i
]
:
p
->
nullvalue
,
i
==
nArg
-
1
?
"
\n
"
:
" "
);
}
}
break
;
}
case
MODE_Semi
:
case
MODE_List
:
{
if
(
p
->
cnt
++==
0
&&
p
->
showHeader
){
for
(
i
=
0
;
i
<
nArg
;
i
++
){
fprintf
(
p
->
out
,
"%s%s"
,
azCol
[
i
],
i
==
nArg
-
1
?
"
\n
"
:
p
->
separator
);
}
}
if
(
azArg
==
0
)
break
;
for
(
i
=
0
;
i
<
nArg
;
i
++
){
char
*
z
=
azArg
[
i
];
if
(
z
==
0
)
z
=
p
->
nullvalue
;
fprintf
(
p
->
out
,
"%s"
,
z
);
if
(
i
<
nArg
-
1
){
fprintf
(
p
->
out
,
"%s"
,
p
->
separator
);
}
else
if
(
p
->
mode
==
MODE_Semi
){
fprintf
(
p
->
out
,
";
\n
"
);
}
else
{
fprintf
(
p
->
out
,
"
\n
"
);
}
}
break
;
}
case
MODE_Html
:
{
if
(
p
->
cnt
++==
0
&&
p
->
showHeader
){
fprintf
(
p
->
out
,
"<TR>"
);
for
(
i
=
0
;
i
<
nArg
;
i
++
){
fprintf
(
p
->
out
,
"<TH>"
);
output_html_string
(
p
->
out
,
azCol
[
i
]);
fprintf
(
p
->
out
,
"</TH>
\n
"
);
}
fprintf
(
p
->
out
,
"</TR>
\n
"
);
}
if
(
azArg
==
0
)
break
;
fprintf
(
p
->
out
,
"<TR>"
);
for
(
i
=
0
;
i
<
nArg
;
i
++
){
fprintf
(
p
->
out
,
"<TD>"
);
output_html_string
(
p
->
out
,
azArg
[
i
]
?
azArg
[
i
]
:
p
->
nullvalue
);
fprintf
(
p
->
out
,
"</TD>
\n
"
);
}
fprintf
(
p
->
out
,
"</TR>
\n
"
);
break
;
}
case
MODE_Tcl
:
{
if
(
p
->
cnt
++==
0
&&
p
->
showHeader
){
for
(
i
=
0
;
i
<
nArg
;
i
++
){
output_c_string
(
p
->
out
,
azCol
[
i
]
?
azCol
[
i
]
:
""
);
if
(
i
<
nArg
-
1
)
fprintf
(
p
->
out
,
"%s"
,
p
->
separator
);
}
fprintf
(
p
->
out
,
"
\n
"
);
}
if
(
azArg
==
0
)
break
;
for
(
i
=
0
;
i
<
nArg
;
i
++
){
output_c_string
(
p
->
out
,
azArg
[
i
]
?
azArg
[
i
]
:
p
->
nullvalue
);
if
(
i
<
nArg
-
1
)
fprintf
(
p
->
out
,
"%s"
,
p
->
separator
);
}
fprintf
(
p
->
out
,
"
\n
"
);
break
;
}
case
MODE_Csv
:
{
if
(
p
->
cnt
++==
0
&&
p
->
showHeader
){
for
(
i
=
0
;
i
<
nArg
;
i
++
){
output_csv
(
p
,
azCol
[
i
]
?
azCol
[
i
]
:
""
,
i
<
nArg
-
1
);
}
fprintf
(
p
->
out
,
"
\n
"
);
}
if
(
azArg
==
0
)
break
;
for
(
i
=
0
;
i
<
nArg
;
i
++
){
output_csv
(
p
,
azArg
[
i
],
i
<
nArg
-
1
);
}
fprintf
(
p
->
out
,
"
\n
"
);
break
;
}
case
MODE_Insert
:
{
p
->
cnt
++
;
if
(
azArg
==
0
)
break
;
fprintf
(
p
->
out
,
"INSERT INTO %s VALUES("
,
p
->
zDestTable
);
for
(
i
=
0
;
i
<
nArg
;
i
++
){
char
*
zSep
=
i
>
0
?
","
:
""
;
if
(
(
azArg
[
i
]
==
0
)
||
(
aiType
&&
aiType
[
i
]
==
SQLITE_NULL
)
){
fprintf
(
p
->
out
,
"%sNULL"
,
zSep
);
}
else
if
(
aiType
&&
aiType
[
i
]
==
SQLITE_TEXT
){
if
(
zSep
[
0
]
)
fprintf
(
p
->
out
,
"%s"
,
zSep
);
output_quoted_string
(
p
->
out
,
azArg
[
i
]);
}
else
if
(
aiType
&&
(
aiType
[
i
]
==
SQLITE_INTEGER
||
aiType
[
i
]
==
SQLITE_FLOAT
)
){
fprintf
(
p
->
out
,
"%s%s"
,
zSep
,
azArg
[
i
]);
}
else
if
(
aiType
&&
aiType
[
i
]
==
SQLITE_BLOB
&&
p
->
pStmt
){
const
void
*
pBlob
=
sqlite3_column_blob
(
p
->
pStmt
,
i
);
int
nBlob
=
sqlite3_column_bytes
(
p
->
pStmt
,
i
);
if
(
zSep
[
0
]
)
fprintf
(
p
->
out
,
"%s"
,
zSep
);
output_hex_blob
(
p
->
out
,
pBlob
,
nBlob
);
}
else
if
(
isNumber
(
azArg
[
i
],
0
)
){
fprintf
(
p
->
out
,
"%s%s"
,
zSep
,
azArg
[
i
]);
}
else
{
if
(
zSep
[
0
]
)
fprintf
(
p
->
out
,
"%s"
,
zSep
);
output_quoted_string
(
p
->
out
,
azArg
[
i
]);
}
}
fprintf
(
p
->
out
,
");
\n
"
);
break
;
}
}
return
0
;
}
/*
** This is the callback routine that the SQLite library
** invokes for each row of a query result.
*/
static
int
callback
(
void
*
pArg
,
int
nArg
,
char
**
azArg
,
char
**
azCol
){
/* since we don't have type info, call the shell_callback with a NULL value */
return
shell_callback
(
pArg
,
nArg
,
azArg
,
azCol
,
NULL
);
}
/*
** Set the destination table field of the callback_data structure to
** the name of the table given. Escape any quote characters in the
** table name.
*/
static
void
set_table_name
(
struct
callback_data
*
p
,
const
char
*
zName
){
int
i
,
n
;
int
needQuote
;
char
*
z
;
if
(
p
->
zDestTable
){
free
(
p
->
zDestTable
);
p
->
zDestTable
=
0
;
}
if
(
zName
==
0
)
return
;
needQuote
=
!
isalpha
((
unsigned
char
)
*
zName
)
&&
*
zName
!=
'_'
;
for
(
i
=
n
=
0
;
zName
[
i
];
i
++
,
n
++
){
if
(
!
isalnum
((
unsigned
char
)
zName
[
i
])
&&
zName
[
i
]
!=
'_'
){
needQuote
=
1
;
if
(
zName
[
i
]
==
'\''
)
n
++
;
}
}
if
(
needQuote
)
n
+=
2
;
z
=
p
->
zDestTable
=
malloc
(
n
+
1
);
if
(
z
==
0
){
fprintf
(
stderr
,
"Error: out of memory
\n
"
);
exit
(
1
);
}
n
=
0
;
if
(
needQuote
)
z
[
n
++
]
=
'\''
;
for
(
i
=
0
;
zName
[
i
];
i
++
){
z
[
n
++
]
=
zName
[
i
];
if
(
zName
[
i
]
==
'\''
)
z
[
n
++
]
=
'\''
;
}
if
(
needQuote
)
z
[
n
++
]
=
'\''
;
z
[
n
]
=
0
;
}
/* zIn is either a pointer to a NULL-terminated string in memory obtained
** from malloc(), or a NULL pointer. The string pointed to by zAppend is
** added to zIn, and the result returned in memory obtained from malloc().
** zIn, if it was not NULL, is freed.
**
** If the third argument, quote, is not '\0', then it is used as a
** quote character for zAppend.
*/
static
char
*
appendText
(
char
*
zIn
,
char
const
*
zAppend
,
char
quote
){
int
len
;
int
i
;
int
nAppend
=
strlen30
(
zAppend
);
int
nIn
=
(
zIn
?
strlen30
(
zIn
)
:
0
);
len
=
nAppend
+
nIn
+
1
;
if
(
quote
){
len
+=
2
;
for
(
i
=
0
;
i
<
nAppend
;
i
++
){
if
(
zAppend
[
i
]
==
quote
)
len
++
;
}
}
zIn
=
(
char
*
)
realloc
(
zIn
,
len
);
if
(
!
zIn
){
return
0
;
}
if
(
quote
){
char
*
zCsr
=
&
zIn
[
nIn
];
*
zCsr
++
=
quote
;
for
(
i
=
0
;
i
<
nAppend
;
i
++
){
*
zCsr
++
=
zAppend
[
i
];
if
(
zAppend
[
i
]
==
quote
)
*
zCsr
++
=
quote
;
}
*
zCsr
++
=
quote
;
*
zCsr
++
=
'\0'
;
assert
(
(
zCsr
-
zIn
)
==
len
);
}
else
{
memcpy
(
&
zIn
[
nIn
],
zAppend
,
nAppend
);
zIn
[
len
-
1
]
=
'\0'
;
}
return
zIn
;
}
/*
** Execute a query statement that will generate SQL output. Print
** the result columns, comma-separated, on a line and then add a
** semicolon terminator to the end of that line.
**
** If the number of columns is 1 and that column contains text "--"
** then write the semicolon on a separate line. That way, if a
** "--" comment occurs at the end of the statement, the comment
** won't consume the semicolon terminator.
*/
static
int
run_table_dump_query
(
struct
callback_data
*
p
,
/* Query context */
const
char
*
zSelect
,
/* SELECT statement to extract content */
const
char
*
zFirstRow
/* Print before first row, if not NULL */
){
sqlite3_stmt
*
pSelect
;
int
rc
;
int
nResult
;
int
i
;
const
char
*
z
;
rc
=
sqlite3_prepare
(
p
->
db
,
zSelect
,
-
1
,
&
pSelect
,
0
);
if
(
rc
!=
SQLITE_OK
||
!
pSelect
){
fprintf
(
p
->
out
,
"/**** ERROR: (%d) %s *****/
\n
"
,
rc
,
sqlite3_errmsg
(
p
->
db
));
p
->
nErr
++
;
return
rc
;
}
rc
=
sqlite3_step
(
pSelect
);
nResult
=
sqlite3_column_count
(
pSelect
);
while
(
rc
==
SQLITE_ROW
){
if
(
zFirstRow
){
fprintf
(
p
->
out
,
"%s"
,
zFirstRow
);
zFirstRow
=
0
;
}
z
=
(
const
char
*
)
sqlite3_column_text
(
pSelect
,
0
);
fprintf
(
p
->
out
,
"%s"
,
z
);
for
(
i
=
1
;
i
<
nResult
;
i
++
){
fprintf
(
p
->
out
,
",%s"
,
sqlite3_column_text
(
pSelect
,
i
));
}
if
(
z
==
0
)
z
=
""
;
while
(
z
[
0
]
&&
(
z
[
0
]
!=
'-'
||
z
[
1
]
!=
'-'
)
)
z
++
;
if
(
z
[
0
]
){
fprintf
(
p
->
out
,
"
\n
;
\n
"
);
}
else
{
fprintf
(
p
->
out
,
";
\n
"
);
}
rc
=
sqlite3_step
(
pSelect
);
}
rc
=
sqlite3_finalize
(
pSelect
);
if
(
rc
!=
SQLITE_OK
){
fprintf
(
p
->
out
,
"/**** ERROR: (%d) %s *****/
\n
"
,
rc
,
sqlite3_errmsg
(
p
->
db
));
p
->
nErr
++
;
}
return
rc
;
}
/*
** Allocate space and save off current error string.
*/
static
char
*
save_err_msg
(
sqlite3
*
db
/* Database to query */
){
int
nErrMsg
=
1
+
strlen30
(
sqlite3_errmsg
(
db
));
char
*
zErrMsg
=
sqlite3_malloc
(
nErrMsg
);
if
(
zErrMsg
){
memcpy
(
zErrMsg
,
sqlite3_errmsg
(
db
),
nErrMsg
);
}
return
zErrMsg
;
}
/*
** Display memory stats.
*/
static
int
display_stats
(
sqlite3
*
db
,
/* Database to query */
struct
callback_data
*
pArg
,
/* Pointer to struct callback_data */
int
bReset
/* True to reset the stats */
){
int
iCur
;
int
iHiwtr
;
if
(
pArg
&&
pArg
->
out
){
iHiwtr
=
iCur
=
-
1
;
sqlite3_status
(
SQLITE_STATUS_MEMORY_USED
,
&
iCur
,
&
iHiwtr
,
bReset
);
fprintf
(
pArg
->
out
,
"Memory Used: %d (max %d) bytes
\n
"
,
iCur
,
iHiwtr
);
iHiwtr
=
iCur
=
-
1
;
sqlite3_status
(
SQLITE_STATUS_MALLOC_COUNT
,
&
iCur
,
&
iHiwtr
,
bReset
);
fprintf
(
pArg
->
out
,
"Number of Outstanding Allocations: %d (max %d)
\n
"
,
iCur
,
iHiwtr
);
/*
** Not currently used by the CLI.
** iHiwtr = iCur = -1;
** sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset);
** fprintf(pArg->out, "Number of Pcache Pages Used: %d (max %d) pages\n", iCur, iHiwtr);
*/
iHiwtr
=
iCur
=
-
1
;
sqlite3_status
(
SQLITE_STATUS_PAGECACHE_OVERFLOW
,
&
iCur
,
&
iHiwtr
,
bReset
);
fprintf
(
pArg
->
out
,
"Number of Pcache Overflow Bytes: %d (max %d) bytes
\n
"
,
iCur
,
iHiwtr
);
/*
** Not currently used by the CLI.
** iHiwtr = iCur = -1;
** sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset);
** fprintf(pArg->out, "Number of Scratch Allocations Used: %d (max %d)\n", iCur, iHiwtr);
*/
iHiwtr
=
iCur
=
-
1
;
sqlite3_status
(
SQLITE_STATUS_SCRATCH_OVERFLOW
,
&
iCur
,
&
iHiwtr
,
bReset
);
fprintf
(
pArg
->
out
,
"Number of Scratch Overflow Bytes: %d (max %d) bytes
\n
"
,
iCur
,
iHiwtr
);
iHiwtr
=
iCur
=
-
1
;
sqlite3_status
(
SQLITE_STATUS_MALLOC_SIZE
,
&
iCur
,
&
iHiwtr
,
bReset
);
fprintf
(
pArg
->
out
,
"Largest Allocation: %d bytes
\n
"
,
iHiwtr
);
iHiwtr
=
iCur
=
-
1
;
sqlite3_status
(
SQLITE_STATUS_PAGECACHE_SIZE
,
&
iCur
,
&
iHiwtr
,
bReset
);
fprintf
(
pArg
->
out
,
"Largest Pcache Allocation: %d bytes
\n
"
,
iHiwtr
);
iHiwtr
=
iCur
=
-
1
;
sqlite3_status
(
SQLITE_STATUS_SCRATCH_SIZE
,
&
iCur
,
&
iHiwtr
,
bReset
);
fprintf
(
pArg
->
out
,
"Largest Scratch Allocation: %d bytes
\n
"
,
iHiwtr
);
#ifdef YYTRACKMAXSTACKDEPTH
iHiwtr
=
iCur
=
-
1
;
sqlite3_status
(
SQLITE_STATUS_PARSER_STACK
,
&
iCur
,
&
iHiwtr
,
bReset
);
fprintf
(
pArg
->
out
,
"Deepest Parser Stack: %d (max %d)
\n
"
,
iCur
,
iHiwtr
);
#endif
}
if
(
pArg
&&
pArg
->
out
&&
db
){
iHiwtr
=
iCur
=
-
1
;
sqlite3_db_status
(
db
,
SQLITE_DBSTATUS_LOOKASIDE_USED
,
&
iCur
,
&
iHiwtr
,
bReset
);
fprintf
(
pArg
->
out
,
"Lookaside Slots Used: %d (max %d)
\n
"
,
iCur
,
iHiwtr
);
sqlite3_db_status
(
db
,
SQLITE_DBSTATUS_LOOKASIDE_HIT
,
&
iCur
,
&
iHiwtr
,
bReset
);
fprintf
(
pArg
->
out
,
"Successful lookaside attempts: %d
\n
"
,
iHiwtr
);
sqlite3_db_status
(
db
,
SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE
,
&
iCur
,
&
iHiwtr
,
bReset
);
fprintf
(
pArg
->
out
,
"Lookaside failures due to size: %d
\n
"
,
iHiwtr
);
sqlite3_db_status
(
db
,
SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL
,
&
iCur
,
&
iHiwtr
,
bReset
);
fprintf
(
pArg
->
out
,
"Lookaside failures due to OOM: %d
\n
"
,
iHiwtr
);
iHiwtr
=
iCur
=
-
1
;
sqlite3_db_status
(
db
,
SQLITE_DBSTATUS_CACHE_USED
,
&
iCur
,
&
iHiwtr
,
bReset
);
fprintf
(
pArg
->
out
,
"Pager Heap Usage: %d bytes
\n
"
,
iCur
);
iHiwtr
=
iCur
=
-
1
;
sqlite3_db_status
(
db
,
SQLITE_DBSTATUS_CACHE_HIT
,
&
iCur
,
&
iHiwtr
,
1
);
fprintf
(
pArg
->
out
,
"Page cache hits: %d
\n
"
,
iCur
);
iHiwtr
=
iCur
=
-
1
;
sqlite3_db_status
(
db
,
SQLITE_DBSTATUS_CACHE_MISS
,
&
iCur
,
&
iHiwtr
,
1
);
fprintf
(
pArg
->
out
,
"Page cache misses: %d
\n
"
,
iCur
);
iHiwtr
=
iCur
=
-
1
;
sqlite3_db_status
(
db
,
SQLITE_DBSTATUS_CACHE_WRITE
,
&
iCur
,
&
iHiwtr
,
1
);
fprintf
(
pArg
->
out
,
"Page cache writes: %d
\n
"
,
iCur
);
iHiwtr
=
iCur
=
-
1
;
sqlite3_db_status
(
db
,
SQLITE_DBSTATUS_SCHEMA_USED
,
&
iCur
,
&
iHiwtr
,
bReset
);
fprintf
(
pArg
->
out
,
"Schema Heap Usage: %d bytes
\n
"
,
iCur
);
iHiwtr
=
iCur
=
-
1
;
sqlite3_db_status
(
db
,
SQLITE_DBSTATUS_STMT_USED
,
&
iCur
,
&
iHiwtr
,
bReset
);
fprintf
(
pArg
->
out
,
"Statement Heap/Lookaside Usage: %d bytes
\n
"
,
iCur
);
}
if
(
pArg
&&
pArg
->
out
&&
db
&&
pArg
->
pStmt
){
iCur
=
sqlite3_stmt_status
(
pArg
->
pStmt
,
SQLITE_STMTSTATUS_FULLSCAN_STEP
,
bReset
);
fprintf
(
pArg
->
out
,
"Fullscan Steps: %d
\n
"
,
iCur
);
iCur
=
sqlite3_stmt_status
(
pArg
->
pStmt
,
SQLITE_STMTSTATUS_SORT
,
bReset
);
fprintf
(
pArg
->
out
,
"Sort Operations: %d
\n
"
,
iCur
);
iCur
=
sqlite3_stmt_status
(
pArg
->
pStmt
,
SQLITE_STMTSTATUS_AUTOINDEX
,
bReset
);
fprintf
(
pArg
->
out
,
"Autoindex Inserts: %d
\n
"
,
iCur
);
}
return
0
;
}
/*
** Execute a statement or set of statements. Print
** any result rows/columns depending on the current mode
** set via the supplied callback.
**
** This is very similar to SQLite's built-in sqlite3_exec()
** function except it takes a slightly different callback
** and callback data argument.
*/
static
int
shell_exec
(
sqlite3
*
db
,
/* An open database */
const
char
*
zSql
,
/* SQL to be evaluated */
int
(
*
xCallback
)(
void
*
,
int
,
char
**
,
char
**
,
int
*
),
/* Callback function */
/* (not the same as sqlite3_exec) */
struct
callback_data
*
pArg
,
/* Pointer to struct callback_data */
char
**
pzErrMsg
/* Error msg written here */
){
sqlite3_stmt
*
pStmt
=
NULL
;
/* Statement to execute. */
int
rc
=
SQLITE_OK
;
/* Return Code */
int
rc2
;
const
char
*
zLeftover
;
/* Tail of unprocessed SQL */
if
(
pzErrMsg
){
*
pzErrMsg
=
NULL
;
}
while
(
zSql
[
0
]
&&
(
SQLITE_OK
==
rc
)
){
rc
=
sqlite3_prepare_v2
(
db
,
zSql
,
-
1
,
&
pStmt
,
&
zLeftover
);
if
(
SQLITE_OK
!=
rc
){
if
(
pzErrMsg
){
*
pzErrMsg
=
save_err_msg
(
db
);
}
}
else
{
if
(
!
pStmt
){
/* this happens for a comment or white-space */
zSql
=
zLeftover
;
while
(
IsSpace
(
zSql
[
0
])
)
zSql
++
;
continue
;
}
/* save off the prepared statment handle and reset row count */
if
(
pArg
){
pArg
->
pStmt
=
pStmt
;
pArg
->
cnt
=
0
;
}
/* echo the sql statement if echo on */
if
(
pArg
&&
pArg
->
echoOn
){
const
char
*
zStmtSql
=
sqlite3_sql
(
pStmt
);
fprintf
(
pArg
->
out
,
"%s
\n
"
,
zStmtSql
?
zStmtSql
:
zSql
);
}
/* Output TESTCTRL_EXPLAIN text of requested */
if
(
pArg
&&
pArg
->
mode
==
MODE_Explain
){
const
char
*
zExplain
=
0
;
sqlite3_test_control
(
SQLITE_TESTCTRL_EXPLAIN_STMT
,
pStmt
,
&
zExplain
);
if
(
zExplain
&&
zExplain
[
0
]
){
fprintf
(
pArg
->
out
,
"%s"
,
zExplain
);
}
}
/* perform the first step. this will tell us if we
** have a result set or not and how wide it is.
*/
rc
=
sqlite3_step
(
pStmt
);
/* if we have a result set... */
if
(
SQLITE_ROW
==
rc
){
/* if we have a callback... */
if
(
xCallback
){
/* allocate space for col name ptr, value ptr, and type */
int
nCol
=
sqlite3_column_count
(
pStmt
);
void
*
pData
=
sqlite3_malloc
(
3
*
nCol
*
sizeof
(
const
char
*
)
+
1
);
if
(
!
pData
){
rc
=
SQLITE_NOMEM
;
}
else
{
char
**
azCols
=
(
char
**
)
pData
;
/* Names of result columns */
char
**
azVals
=
&
azCols
[
nCol
];
/* Results */
int
*
aiTypes
=
(
int
*
)
&
azVals
[
nCol
];
/* Result types */
int
i
;
assert
(
sizeof
(
int
)
<=
sizeof
(
char
*
));
/* save off ptrs to column names */
for
(
i
=
0
;
i
<
nCol
;
i
++
){
azCols
[
i
]
=
(
char
*
)
sqlite3_column_name
(
pStmt
,
i
);
}
do
{
/* extract the data and data types */
for
(
i
=
0
;
i
<
nCol
;
i
++
){
azVals
[
i
]
=
(
char
*
)
sqlite3_column_text
(
pStmt
,
i
);
aiTypes
[
i
]
=
sqlite3_column_type
(
pStmt
,
i
);
if
(
!
azVals
[
i
]
&&
(
aiTypes
[
i
]
!=
SQLITE_NULL
)
){
rc
=
SQLITE_NOMEM
;
break
;
/* from for */
}
}
/* end for */
/* if data and types extracted successfully... */
if
(
SQLITE_ROW
==
rc
){
/* call the supplied callback with the result row data */
if
(
xCallback
(
pArg
,
nCol
,
azVals
,
azCols
,
aiTypes
)
){
rc
=
SQLITE_ABORT
;
}
else
{
rc
=
sqlite3_step
(
pStmt
);
}
}
}
while
(
SQLITE_ROW
==
rc
);
sqlite3_free
(
pData
);
}
}
else
{
do
{
rc
=
sqlite3_step
(
pStmt
);
}
while
(
rc
==
SQLITE_ROW
);
}
}
/* print usage stats if stats on */
if
(
pArg
&&
pArg
->
statsOn
){
display_stats
(
db
,
pArg
,
0
);
}
/* Finalize the statement just executed. If this fails, save a
** copy of the error message. Otherwise, set zSql to point to the
** next statement to execute. */
rc2
=
sqlite3_finalize
(
pStmt
);
if
(
rc
!=
SQLITE_NOMEM
)
rc
=
rc2
;
if
(
rc
==
SQLITE_OK
){
zSql
=
zLeftover
;
while
(
IsSpace
(
zSql
[
0
])
)
zSql
++
;
}
else
if
(
pzErrMsg
){
*
pzErrMsg
=
save_err_msg
(
db
);
}
/* clear saved stmt handle */
if
(
pArg
){
pArg
->
pStmt
=
NULL
;
}
}
}
/* end while */
return
rc
;
}
/*
** This is a different callback routine used for dumping the database.
** Each row received by this callback consists of a table name,
** the table type ("index" or "table") and SQL to create the table.
** This routine should print text sufficient to recreate the table.
*/
static
int
dump_callback
(
void
*
pArg
,
int
nArg
,
char
**
azArg
,
char
**
azCol
){
int
rc
;
const
char
*
zTable
;
const
char
*
zType
;
const
char
*
zSql
;
const
char
*
zPrepStmt
=
0
;
struct
callback_data
*
p
=
(
struct
callback_data
*
)
pArg
;
UNUSED_PARAMETER
(
azCol
);
if
(
nArg
!=
3
)
return
1
;
zTable
=
azArg
[
0
];
zType
=
azArg
[
1
];
zSql
=
azArg
[
2
];
if
(
strcmp
(
zTable
,
"sqlite_sequence"
)
==
0
){
zPrepStmt
=
"DELETE FROM sqlite_sequence;
\n
"
;
}
else
if
(
strcmp
(
zTable
,
"sqlite_stat1"
)
==
0
){
fprintf
(
p
->
out
,
"ANALYZE sqlite_master;
\n
"
);
}
else
if
(
strncmp
(
zTable
,
"sqlite_"
,
7
)
==
0
){
return
0
;
}
else
if
(
strncmp
(
zSql
,
"CREATE VIRTUAL TABLE"
,
20
)
==
0
){
char
*
zIns
;
if
(
!
p
->
writableSchema
){
fprintf
(
p
->
out
,
"PRAGMA writable_schema=ON;
\n
"
);
p
->
writableSchema
=
1
;
}
zIns
=
sqlite3_mprintf
(
"INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
"VALUES('table','%q','%q',0,'%q');"
,
zTable
,
zTable
,
zSql
);
fprintf
(
p
->
out
,
"%s
\n
"
,
zIns
);
sqlite3_free
(
zIns
);
return
0
;
}
else
{
fprintf
(
p
->
out
,
"%s;
\n
"
,
zSql
);
}
if
(
strcmp
(
zType
,
"table"
)
==
0
){
sqlite3_stmt
*
pTableInfo
=
0
;
char
*
zSelect
=
0
;
char
*
zTableInfo
=
0
;
char
*
zTmp
=
0
;
int
nRow
=
0
;
zTableInfo
=
appendText
(
zTableInfo
,
"PRAGMA table_info("
,
0
);
zTableInfo
=
appendText
(
zTableInfo
,
zTable
,
'"'
);
zTableInfo
=
appendText
(
zTableInfo
,
");"
,
0
);
rc
=
sqlite3_prepare
(
p
->
db
,
zTableInfo
,
-
1
,
&
pTableInfo
,
0
);
free
(
zTableInfo
);
if
(
rc
!=
SQLITE_OK
||
!
pTableInfo
){
return
1
;
}
zSelect
=
appendText
(
zSelect
,
"SELECT 'INSERT INTO ' || "
,
0
);
/* Always quote the table name, even if it appears to be pure ascii,
** in case it is a keyword. Ex: INSERT INTO "table" ... */
zTmp
=
appendText
(
zTmp
,
zTable
,
'"'
);
if
(
zTmp
){
zSelect
=
appendText
(
zSelect
,
zTmp
,
'\''
);
free
(
zTmp
);
}
zSelect
=
appendText
(
zSelect
,
" || ' VALUES(' || "
,
0
);
rc
=
sqlite3_step
(
pTableInfo
);
while
(
rc
==
SQLITE_ROW
){
const
char
*
zText
=
(
const
char
*
)
sqlite3_column_text
(
pTableInfo
,
1
);
zSelect
=
appendText
(
zSelect
,
"quote("
,
0
);
zSelect
=
appendText
(
zSelect
,
zText
,
'"'
);
rc
=
sqlite3_step
(
pTableInfo
);
if
(
rc
==
SQLITE_ROW
){
zSelect
=
appendText
(
zSelect
,
"), "
,
0
);
}
else
{
zSelect
=
appendText
(
zSelect
,
") "
,
0
);
}
nRow
++
;
}
rc
=
sqlite3_finalize
(
pTableInfo
);
if
(
rc
!=
SQLITE_OK
||
nRow
==
0
){
free
(
zSelect
);
return
1
;
}
zSelect
=
appendText
(
zSelect
,
"|| ')' FROM "
,
0
);
zSelect
=
appendText
(
zSelect
,
zTable
,
'"'
);
rc
=
run_table_dump_query
(
p
,
zSelect
,
zPrepStmt
);
if
(
rc
==
SQLITE_CORRUPT
){
zSelect
=
appendText
(
zSelect
,
" ORDER BY rowid DESC"
,
0
);
run_table_dump_query
(
p
,
zSelect
,
0
);
}
free
(
zSelect
);
}
return
0
;
}
/*
** Run zQuery. Use dump_callback() as the callback routine so that
** the contents of the query are output as SQL statements.
**
** If we get a SQLITE_CORRUPT error, rerun the query after appending
** "ORDER BY rowid DESC" to the end.
*/
static
int
run_schema_dump_query
(
struct
callback_data
*
p
,
const
char
*
zQuery
){
int
rc
;
char
*
zErr
=
0
;
rc
=
sqlite3_exec
(
p
->
db
,
zQuery
,
dump_callback
,
p
,
&
zErr
);
if
(
rc
==
SQLITE_CORRUPT
){
char
*
zQ2
;
int
len
=
strlen30
(
zQuery
);
fprintf
(
p
->
out
,
"/****** CORRUPTION ERROR *******/
\n
"
);
if
(
zErr
){
fprintf
(
p
->
out
,
"/****** %s ******/
\n
"
,
zErr
);
sqlite3_free
(
zErr
);
zErr
=
0
;
}
zQ2
=
malloc
(
len
+
100
);
if
(
zQ2
==
0
)
return
rc
;
sqlite3_snprintf
(
len
+
100
,
zQ2
,
"%s ORDER BY rowid DESC"
,
zQuery
);
rc
=
sqlite3_exec
(
p
->
db
,
zQ2
,
dump_callback
,
p
,
&
zErr
);
if
(
rc
){
fprintf
(
p
->
out
,
"/****** ERROR: %s ******/
\n
"
,
zErr
);
}
else
{
rc
=
SQLITE_CORRUPT
;
}
sqlite3_free
(
zErr
);
free
(
zQ2
);
}
return
rc
;
}
/*
** Text of a help message
*/
static
char
zHelp
[]
=
".backup ?DB? FILE Backup DB (default
\"
main
\"
) to FILE
\n
"
".bail ON|OFF Stop after hitting an error. Default OFF
\n
"
".databases List names and files of attached databases
\n
"
".dump ?TABLE? ... Dump the database in an SQL text format
\n
"
" If TABLE specified, only dump tables matching
\n
"
" LIKE pattern TABLE.
\n
"
".echo ON|OFF Turn command echo on or off
\n
"
".exit Exit this program
\n
"
".explain ?ON|OFF? Turn output mode suitable for EXPLAIN on or off.
\n
"
" With no args, it turns EXPLAIN on.
\n
"
".header(s) ON|OFF Turn display of headers on or off
\n
"
".help Show this message
\n
"
".import FILE TABLE Import data from FILE into TABLE
\n
"
".indices ?TABLE? Show names of all indices
\n
"
" If TABLE specified, only show indices for tables
\n
"
" matching LIKE pattern TABLE.
\n
"
#ifdef SQLITE_ENABLE_IOTRACE
".iotrace FILE Enable I/O diagnostic logging to FILE
\n
"
#endif
#ifndef SQLITE_OMIT_LOAD_EXTENSION
".load FILE ?ENTRY? Load an extension library
\n
"
#endif
".log FILE|off Turn logging on or off. FILE can be stderr/stdout
\n
"
".mode MODE ?TABLE? Set output mode where MODE is one of:
\n
"
" csv Comma-separated values
\n
"
" column Left-aligned columns. (See .width)
\n
"
" html HTML <table> code
\n
"
" insert SQL insert statements for TABLE
\n
"
" line One value per line
\n
"
" list Values delimited by .separator string
\n
"
" tabs Tab-separated values
\n
"
" tcl TCL list elements
\n
"
".nullvalue STRING Use STRING in place of NULL values
\n
"
".output FILENAME Send output to FILENAME
\n
"
".output stdout Send output to the screen
\n
"
".print STRING... Print literal STRING
\n
"
".prompt MAIN CONTINUE Replace the standard prompts
\n
"
".quit Exit this program
\n
"
".read FILENAME Execute SQL in FILENAME
\n
"
".restore ?DB? FILE Restore content of DB (default
\"
main
\"
) from FILE
\n
"
".schema ?TABLE? Show the CREATE statements
\n
"
" If TABLE specified, only show tables matching
\n
"
" LIKE pattern TABLE.
\n
"
".separator STRING Change separator used by output mode and .import
\n
"
".show Show the current values for various settings
\n
"
".stats ON|OFF Turn stats on or off
\n
"
".tables ?TABLE? List names of tables
\n
"
" If TABLE specified, only list tables matching
\n
"
" LIKE pattern TABLE.
\n
"
".timeout MS Try opening locked tables for MS milliseconds
\n
"
".trace FILE|off Output each SQL statement as it is run
\n
"
".vfsname ?AUX? Print the name of the VFS stack
\n
"
".width NUM1 NUM2 ... Set column widths for
\"
column
\"
mode
\n
"
;
static
char
zTimerHelp
[]
=
".timer ON|OFF Turn the CPU timer measurement on or off
\n
"
;
/* Forward reference */
static
int
process_input
(
struct
callback_data
*
p
,
FILE
*
in
);
/*
** Make sure the database is open. If it is not, then open it. If
** the database fails to open, print an error message and exit.
*/
static
void
open_db
(
struct
callback_data
*
p
){
if
(
p
->
db
==
0
){
sqlite3_initialize
();
sqlite3_open
(
p
->
zDbFilename
,
&
p
->
db
);
db
=
p
->
db
;
if
(
db
&&
sqlite3_errcode
(
db
)
==
SQLITE_OK
){
sqlite3_create_function
(
db
,
"shellstatic"
,
0
,
SQLITE_UTF8
,
0
,
shellstaticFunc
,
0
,
0
);
}
if
(
db
==
0
||
SQLITE_OK
!=
sqlite3_errcode
(
db
)
){
fprintf
(
stderr
,
"Error: unable to open database
\"
%s
\"
: %s
\n
"
,
p
->
zDbFilename
,
sqlite3_errmsg
(
db
));
exit
(
1
);
}
#ifndef SQLITE_OMIT_LOAD_EXTENSION
sqlite3_enable_load_extension
(
p
->
db
,
1
);
#endif
}
}
/*
** Do C-language style dequoting.
**
** \t -> tab
** \n -> newline
** \r -> carriage return
** \NNN -> ascii character NNN in octal
** \\ -> backslash
*/
static
void
resolve_backslashes
(
char
*
z
){
int
i
,
j
;
char
c
;
for
(
i
=
j
=
0
;
(
c
=
z
[
i
])
!=
0
;
i
++
,
j
++
){
if
(
c
==
'\\'
){
c
=
z
[
++
i
];
if
(
c
==
'n'
){
c
=
'\n'
;
}
else
if
(
c
==
't'
){
c
=
'\t'
;
}
else
if
(
c
==
'r'
){
c
=
'\r'
;
}
else
if
(
c
>=
'0'
&&
c
<=
'7'
){
c
-=
'0'
;
if
(
z
[
i
+
1
]
>=
'0'
&&
z
[
i
+
1
]
<=
'7'
){
i
++
;
c
=
(
c
<<
3
)
+
z
[
i
]
-
'0'
;
if
(
z
[
i
+
1
]
>=
'0'
&&
z
[
i
+
1
]
<=
'7'
){
i
++
;
c
=
(
c
<<
3
)
+
z
[
i
]
-
'0'
;
}
}
}
}
z
[
j
]
=
c
;
}
z
[
j
]
=
0
;
}
/*
** Interpret zArg as a boolean value. Return either 0 or 1.
*/
static
int
booleanValue
(
char
*
zArg
){
int
val
=
atoi
(
zArg
);
int
j
;
for
(
j
=
0
;
zArg
[
j
];
j
++
){
zArg
[
j
]
=
ToLower
(
zArg
[
j
]);
}
if
(
strcmp
(
zArg
,
"on"
)
==
0
){
val
=
1
;
}
else
if
(
strcmp
(
zArg
,
"yes"
)
==
0
){
val
=
1
;
}
return
val
;
}
/*
** Close an output file, assuming it is not stderr or stdout
*/
static
void
output_file_close
(
FILE
*
f
){
if
(
f
&&
f
!=
stdout
&&
f
!=
stderr
)
fclose
(
f
);
}
/*
** Try to open an output file. The names "stdout" and "stderr" are
** recognized and do the right thing. NULL is returned if the output
** filename is "off".
*/
static
FILE
*
output_file_open
(
const
char
*
zFile
){
FILE
*
f
;
if
(
strcmp
(
zFile
,
"stdout"
)
==
0
){
f
=
stdout
;
}
else
if
(
strcmp
(
zFile
,
"stderr"
)
==
0
){
f
=
stderr
;
}
else
if
(
strcmp
(
zFile
,
"off"
)
==
0
){
f
=
0
;
}
else
{
f
=
fopen
(
zFile
,
"wb"
);
if
(
f
==
0
){
fprintf
(
stderr
,
"Error: cannot open
\"
%s
\"\n
"
,
zFile
);
}
}
return
f
;
}
/*
** A routine for handling output from sqlite3_trace().
*/
static
void
sql_trace_callback
(
void
*
pArg
,
const
char
*
z
){
FILE
*
f
=
(
FILE
*
)
pArg
;
if
(
f
)
fprintf
(
f
,
"%s
\n
"
,
z
);
}
/*
** A no-op routine that runs with the ".breakpoint" doc-command. This is
** a useful spot to set a debugger breakpoint.
*/
static
void
test_breakpoint
(
void
){
static
int
nCall
=
0
;
nCall
++
;
}
/*
** If an input line begins with "." then invoke this routine to
** process that line.
**
** Return 1 on error, 2 to exit, and 0 otherwise.
*/
static
int
do_meta_command
(
char
*
zLine
,
struct
callback_data
*
p
){
int
i
=
1
;
int
nArg
=
0
;
int
n
,
c
;
int
rc
=
0
;
char
*
azArg
[
50
];
/* Parse the input line into tokens.
*/
while
(
zLine
[
i
]
&&
nArg
<
ArraySize
(
azArg
)
){
while
(
IsSpace
(
zLine
[
i
])
){
i
++
;
}
if
(
zLine
[
i
]
==
0
)
break
;
if
(
zLine
[
i
]
==
'\''
||
zLine
[
i
]
==
'"'
){
int
delim
=
zLine
[
i
++
];
azArg
[
nArg
++
]
=
&
zLine
[
i
];
while
(
zLine
[
i
]
&&
zLine
[
i
]
!=
delim
){
i
++
;
}
if
(
zLine
[
i
]
==
delim
){
zLine
[
i
++
]
=
0
;
}
if
(
delim
==
'"'
)
resolve_backslashes
(
azArg
[
nArg
-
1
]);
}
else
{
azArg
[
nArg
++
]
=
&
zLine
[
i
];
while
(
zLine
[
i
]
&&
!
IsSpace
(
zLine
[
i
])
){
i
++
;
}
if
(
zLine
[
i
]
)
zLine
[
i
++
]
=
0
;
resolve_backslashes
(
azArg
[
nArg
-
1
]);
}
}
/* Process the input line.
*/
if
(
nArg
==
0
)
return
0
;
/* no tokens, no error */
n
=
strlen30
(
azArg
[
0
]);
c
=
azArg
[
0
][
0
];
if
(
c
==
'b'
&&
n
>=
3
&&
strncmp
(
azArg
[
0
],
"backup"
,
n
)
==
0
&&
nArg
>
1
&&
nArg
<
4
){
const
char
*
zDestFile
;
const
char
*
zDb
;
sqlite3
*
pDest
;
sqlite3_backup
*
pBackup
;
if
(
nArg
==
2
){
zDestFile
=
azArg
[
1
];
zDb
=
"main"
;
}
else
{
zDestFile
=
azArg
[
2
];
zDb
=
azArg
[
1
];
}
rc
=
sqlite3_open
(
zDestFile
,
&
pDest
);
if
(
rc
!=
SQLITE_OK
){
fprintf
(
stderr
,
"Error: cannot open
\"
%s
\"\n
"
,
zDestFile
);
sqlite3_close
(
pDest
);
return
1
;
}
open_db
(
p
);
pBackup
=
sqlite3_backup_init
(
pDest
,
"main"
,
p
->
db
,
zDb
);
if
(
pBackup
==
0
){
fprintf
(
stderr
,
"Error: %s
\n
"
,
sqlite3_errmsg
(
pDest
));
sqlite3_close
(
pDest
);
return
1
;
}
while
(
(
rc
=
sqlite3_backup_step
(
pBackup
,
100
))
==
SQLITE_OK
){}
sqlite3_backup_finish
(
pBackup
);
if
(
rc
==
SQLITE_DONE
){
rc
=
0
;
}
else
{
fprintf
(
stderr
,
"Error: %s
\n
"
,
sqlite3_errmsg
(
pDest
));
rc
=
1
;
}
sqlite3_close
(
pDest
);
}
else
if
(
c
==
'b'
&&
n
>=
3
&&
strncmp
(
azArg
[
0
],
"bail"
,
n
)
==
0
&&
nArg
>
1
&&
nArg
<
3
){
bail_on_error
=
booleanValue
(
azArg
[
1
]);
}
else
/* The undocumented ".breakpoint" command causes a call to the no-op
** routine named test_breakpoint().
*/
if
(
c
==
'b'
&&
n
>=
3
&&
strncmp
(
azArg
[
0
],
"breakpoint"
,
n
)
==
0
){
test_breakpoint
();
}
else
if
(
c
==
'd'
&&
n
>
1
&&
strncmp
(
azArg
[
0
],
"databases"
,
n
)
==
0
&&
nArg
==
1
){
struct
callback_data
data
;
char
*
zErrMsg
=
0
;
open_db
(
p
);
memcpy
(
&
data
,
p
,
sizeof
(
data
));
data
.
showHeader
=
1
;
data
.
mode
=
MODE_Column
;
data
.
colWidth
[
0
]
=
3
;
data
.
colWidth
[
1
]
=
15
;
data
.
colWidth
[
2
]
=
58
;
data
.
cnt
=
0
;
sqlite3_exec
(
p
->
db
,
"PRAGMA database_list; "
,
callback
,
&
data
,
&
zErrMsg
);
if
(
zErrMsg
){
fprintf
(
stderr
,
"Error: %s
\n
"
,
zErrMsg
);
sqlite3_free
(
zErrMsg
);
rc
=
1
;
}
}
else
if
(
c
==
'd'
&&
strncmp
(
azArg
[
0
],
"dump"
,
n
)
==
0
&&
nArg
<
3
){
open_db
(
p
);
/* When playing back a "dump", the content might appear in an order
** which causes immediate foreign key constraints to be violated.
** So disable foreign-key constraint enforcement to prevent problems. */
fprintf
(
p
->
out
,
"PRAGMA foreign_keys=OFF;
\n
"
);
fprintf
(
p
->
out
,
"BEGIN TRANSACTION;
\n
"
);
p
->
writableSchema
=
0
;
sqlite3_exec
(
p
->
db
,
"SAVEPOINT dump; PRAGMA writable_schema=ON"
,
0
,
0
,
0
);
p
->
nErr
=
0
;
if
(
nArg
==
1
){
run_schema_dump_query
(
p
,
"SELECT name, type, sql FROM sqlite_master "
"WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
);
run_schema_dump_query
(
p
,
"SELECT name, type, sql FROM sqlite_master "
"WHERE name=='sqlite_sequence'"
);
run_table_dump_query
(
p
,
"SELECT sql FROM sqlite_master "
"WHERE sql NOT NULL AND type IN ('index','trigger','view')"
,
0
);
}
else
{
int
i
;
for
(
i
=
1
;
i
<
nArg
;
i
++
){
zShellStatic
=
azArg
[
i
];
run_schema_dump_query
(
p
,
"SELECT name, type, sql FROM sqlite_master "
"WHERE tbl_name LIKE shellstatic() AND type=='table'"
" AND sql NOT NULL"
);
run_table_dump_query
(
p
,
"SELECT sql FROM sqlite_master "
"WHERE sql NOT NULL"
" AND type IN ('index','trigger','view')"
" AND tbl_name LIKE shellstatic()"
,
0
);
zShellStatic
=
0
;
}
}
if
(
p
->
writableSchema
){
fprintf
(
p
->
out
,
"PRAGMA writable_schema=OFF;
\n
"
);
p
->
writableSchema
=
0
;
}
sqlite3_exec
(
p
->
db
,
"PRAGMA writable_schema=OFF;"
,
0
,
0
,
0
);
sqlite3_exec
(
p
->
db
,
"RELEASE dump;"
,
0
,
0
,
0
);
fprintf
(
p
->
out
,
p
->
nErr
?
"ROLLBACK; -- due to errors
\n
"
:
"COMMIT;
\n
"
);
}
else
if
(
c
==
'e'
&&
strncmp
(
azArg
[
0
],
"echo"
,
n
)
==
0
&&
nArg
>
1
&&
nArg
<
3
){
p
->
echoOn
=
booleanValue
(
azArg
[
1
]);
}
else
if
(
c
==
'e'
&&
strncmp
(
azArg
[
0
],
"exit"
,
n
)
==
0
&&
nArg
==
1
){
rc
=
2
;
}
else
if
(
c
==
'e'
&&
strncmp
(
azArg
[
0
],
"explain"
,
n
)
==
0
&&
nArg
<
3
){
int
val
=
nArg
>=
2
?
booleanValue
(
azArg
[
1
])
:
1
;
if
(
val
==
1
)
{
if
(
!
p
->
explainPrev
.
valid
)
{
p
->
explainPrev
.
valid
=
1
;
p
->
explainPrev
.
mode
=
p
->
mode
;
p
->
explainPrev
.
showHeader
=
p
->
showHeader
;
memcpy
(
p
->
explainPrev
.
colWidth
,
p
->
colWidth
,
sizeof
(
p
->
colWidth
));
}
/* We could put this code under the !p->explainValid
** condition so that it does not execute if we are already in
** explain mode. However, always executing it allows us an easy
** was to reset to explain mode in case the user previously
** did an .explain followed by a .width, .mode or .header
** command.
*/
p
->
mode
=
MODE_Explain
;
p
->
showHeader
=
1
;
memset
(
p
->
colWidth
,
0
,
ArraySize
(
p
->
colWidth
));
p
->
colWidth
[
0
]
=
4
;
/* addr */
p
->
colWidth
[
1
]
=
13
;
/* opcode */
p
->
colWidth
[
2
]
=
4
;
/* P1 */
p
->
colWidth
[
3
]
=
4
;
/* P2 */
p
->
colWidth
[
4
]
=
4
;
/* P3 */
p
->
colWidth
[
5
]
=
13
;
/* P4 */
p
->
colWidth
[
6
]
=
2
;
/* P5 */
p
->
colWidth
[
7
]
=
13
;
/* Comment */
}
else
if
(
p
->
explainPrev
.
valid
)
{
p
->
explainPrev
.
valid
=
0
;
p
->
mode
=
p
->
explainPrev
.
mode
;
p
->
showHeader
=
p
->
explainPrev
.
showHeader
;
memcpy
(
p
->
colWidth
,
p
->
explainPrev
.
colWidth
,
sizeof
(
p
->
colWidth
));
}
}
else
if
(
c
==
'h'
&&
(
strncmp
(
azArg
[
0
],
"header"
,
n
)
==
0
||
strncmp
(
azArg
[
0
],
"headers"
,
n
)
==
0
)
&&
nArg
>
1
&&
nArg
<
3
){
p
->
showHeader
=
booleanValue
(
azArg
[
1
]);
}
else
if
(
c
==
'h'
&&
strncmp
(
azArg
[
0
],
"help"
,
n
)
==
0
){
fprintf
(
stderr
,
"%s"
,
zHelp
);
if
(
HAS_TIMER
){
fprintf
(
stderr
,
"%s"
,
zTimerHelp
);
}
}
else
if
(
c
==
'i'
&&
strncmp
(
azArg
[
0
],
"import"
,
n
)
==
0
&&
nArg
==
3
){
char
*
zTable
=
azArg
[
2
];
/* Insert data into this table */
char
*
zFile
=
azArg
[
1
];
/* The file from which to extract data */
sqlite3_stmt
*
pStmt
=
NULL
;
/* A statement */
int
nCol
;
/* Number of columns in the table */
int
nByte
;
/* Number of bytes in an SQL string */
int
i
,
j
;
/* Loop counters */
int
nSep
;
/* Number of bytes in p->separator[] */
char
*
zSql
;
/* An SQL statement */
char
*
zLine
;
/* A single line of input from the file */
char
**
azCol
;
/* zLine[] broken up into columns */
char
*
zCommit
;
/* How to commit changes */
FILE
*
in
;
/* The input file */
int
lineno
=
0
;
/* Line number of input file */
open_db
(
p
);
nSep
=
strlen30
(
p
->
separator
);
if
(
nSep
==
0
){
fprintf
(
stderr
,
"Error: non-null separator required for import
\n
"
);
return
1
;
}
zSql
=
sqlite3_mprintf
(
"SELECT * FROM %s"
,
zTable
);
if
(
zSql
==
0
){
fprintf
(
stderr
,
"Error: out of memory
\n
"
);
return
1
;
}
nByte
=
strlen30
(
zSql
);
rc
=
sqlite3_prepare
(
p
->
db
,
zSql
,
-
1
,
&
pStmt
,
0
);
sqlite3_free
(
zSql
);
if
(
rc
){
if
(
pStmt
)
sqlite3_finalize
(
pStmt
);
fprintf
(
stderr
,
"Error: %s
\n
"
,
sqlite3_errmsg
(
db
));
return
1
;
}
nCol
=
sqlite3_column_count
(
pStmt
);
sqlite3_finalize
(
pStmt
);
pStmt
=
0
;
if
(
nCol
==
0
)
return
0
;
/* no columns, no error */
zSql
=
malloc
(
nByte
+
20
+
nCol
*
2
);
if
(
zSql
==
0
){
fprintf
(
stderr
,
"Error: out of memory
\n
"
);
return
1
;
}
sqlite3_snprintf
(
nByte
+
20
,
zSql
,
"INSERT INTO %s VALUES(?"
,
zTable
);
j
=
strlen30
(
zSql
);
for
(
i
=
1
;
i
<
nCol
;
i
++
){
zSql
[
j
++
]
=
','
;
zSql
[
j
++
]
=
'?'
;
}
zSql
[
j
++
]
=
')'
;
zSql
[
j
]
=
0
;
rc
=
sqlite3_prepare
(
p
->
db
,
zSql
,
-
1
,
&
pStmt
,
0
);
free
(
zSql
);
if
(
rc
){
fprintf
(
stderr
,
"Error: %s
\n
"
,
sqlite3_errmsg
(
db
));
if
(
pStmt
)
sqlite3_finalize
(
pStmt
);
return
1
;
}
in
=
fopen
(
zFile
,
"rb"
);
if
(
in
==
0
){
fprintf
(
stderr
,
"Error: cannot open
\"
%s
\"\n
"
,
zFile
);
sqlite3_finalize
(
pStmt
);
return
1
;
}
azCol
=
malloc
(
sizeof
(
azCol
[
0
])
*
(
nCol
+
1
)
);
if
(
azCol
==
0
){
fprintf
(
stderr
,
"Error: out of memory
\n
"
);
fclose
(
in
);
sqlite3_finalize
(
pStmt
);
return
1
;
}
sqlite3_exec
(
p
->
db
,
"BEGIN"
,
0
,
0
,
0
);
zCommit
=
"COMMIT"
;
while
(
(
zLine
=
local_getline
(
0
,
in
,
1
))
!=
0
){
char
*
z
,
c
;
int
inQuote
=
0
;
lineno
++
;
azCol
[
0
]
=
zLine
;
for
(
i
=
0
,
z
=
zLine
;
(
c
=
*
z
)
!=
0
;
z
++
){
if
(
c
==
'"'
)
inQuote
=
!
inQuote
;
if
(
c
==
'\n'
)
lineno
++
;
if
(
!
inQuote
&&
c
==
p
->
separator
[
0
]
&&
strncmp
(
z
,
p
->
separator
,
nSep
)
==
0
){
*
z
=
0
;
i
++
;
if
(
i
<
nCol
){
azCol
[
i
]
=
&
z
[
nSep
];
z
+=
nSep
-
1
;
}
}
}
/* end for */
*
z
=
0
;
if
(
i
+
1
!=
nCol
){
fprintf
(
stderr
,
"Error: %s line %d: expected %d columns of data but found %d
\n
"
,
zFile
,
lineno
,
nCol
,
i
+
1
);
zCommit
=
"ROLLBACK"
;
free
(
zLine
);
rc
=
1
;
break
;
/* from while */
}
for
(
i
=
0
;
i
<
nCol
;
i
++
){
if
(
azCol
[
i
][
0
]
==
'"'
){
int
k
;
for
(
z
=
azCol
[
i
],
j
=
1
,
k
=
0
;
z
[
j
];
j
++
){
if
(
z
[
j
]
==
'"'
){
j
++
;
if
(
z
[
j
]
==
0
)
break
;
}
z
[
k
++
]
=
z
[
j
];
}
z
[
k
]
=
0
;
}
sqlite3_bind_text
(
pStmt
,
i
+
1
,
azCol
[
i
],
-
1
,
SQLITE_STATIC
);
}
sqlite3_step
(
pStmt
);
rc
=
sqlite3_reset
(
pStmt
);
free
(
zLine
);
if
(
rc
!=
SQLITE_OK
){
fprintf
(
stderr
,
"Error: %s
\n
"
,
sqlite3_errmsg
(
db
));
zCommit
=
"ROLLBACK"
;
rc
=
1
;
break
;
/* from while */
}
}
/* end while */
free
(
azCol
);
fclose
(
in
);
sqlite3_finalize
(
pStmt
);
sqlite3_exec
(
p
->
db
,
zCommit
,
0
,
0
,
0
);
}
else
if
(
c
==
'i'
&&
strncmp
(
azArg
[
0
],
"indices"
,
n
)
==
0
&&
nArg
<
3
){
struct
callback_data
data
;
char
*
zErrMsg
=
0
;
open_db
(
p
);
memcpy
(
&
data
,
p
,
sizeof
(
data
));
data
.
showHeader
=
0
;
data
.
mode
=
MODE_List
;
if
(
nArg
==
1
){
rc
=
sqlite3_exec
(
p
->
db
,
"SELECT name FROM sqlite_master "
"WHERE type='index' AND name NOT LIKE 'sqlite_%' "
"UNION ALL "
"SELECT name FROM sqlite_temp_master "
"WHERE type='index' "
"ORDER BY 1"
,
callback
,
&
data
,
&
zErrMsg
);
}
else
{
zShellStatic
=
azArg
[
1
];
rc
=
sqlite3_exec
(
p
->
db
,
"SELECT name FROM sqlite_master "
"WHERE type='index' AND tbl_name LIKE shellstatic() "
"UNION ALL "
"SELECT name FROM sqlite_temp_master "
"WHERE type='index' AND tbl_name LIKE shellstatic() "
"ORDER BY 1"
,
callback
,
&
data
,
&
zErrMsg
);
zShellStatic
=
0
;
}
if
(
zErrMsg
){
fprintf
(
stderr
,
"Error: %s
\n
"
,
zErrMsg
);
sqlite3_free
(
zErrMsg
);
rc
=
1
;
}
else
if
(
rc
!=
SQLITE_OK
){
fprintf
(
stderr
,
"Error: querying sqlite_master and sqlite_temp_master
\n
"
);
rc
=
1
;
}
}
else
#ifdef SQLITE_ENABLE_IOTRACE
if
(
c
==
'i'
&&
strncmp
(
azArg
[
0
],
"iotrace"
,
n
)
==
0
){
extern
void
(
*
sqlite3IoTrace
)(
const
char
*
,
...);
if
(
iotrace
&&
iotrace
!=
stdout
)
fclose
(
iotrace
);
iotrace
=
0
;
if
(
nArg
<
2
){
sqlite3IoTrace
=
0
;
}
else
if
(
strcmp
(
azArg
[
1
],
"-"
)
==
0
){
sqlite3IoTrace
=
iotracePrintf
;
iotrace
=
stdout
;
}
else
{
iotrace
=
fopen
(
azArg
[
1
],
"w"
);
if
(
iotrace
==
0
){
fprintf
(
stderr
,
"Error: cannot open
\"
%s
\"\n
"
,
azArg
[
1
]);
sqlite3IoTrace
=
0
;
rc
=
1
;
}
else
{
sqlite3IoTrace
=
iotracePrintf
;
}
}
}
else
#endif
#ifndef SQLITE_OMIT_LOAD_EXTENSION
if
(
c
==
'l'
&&
strncmp
(
azArg
[
0
],
"load"
,
n
)
==
0
&&
nArg
>=
2
){
const
char
*
zFile
,
*
zProc
;
char
*
zErrMsg
=
0
;
zFile
=
azArg
[
1
];
zProc
=
nArg
>=
3
?
azArg
[
2
]
:
0
;
open_db
(
p
);
rc
=
sqlite3_load_extension
(
p
->
db
,
zFile
,
zProc
,
&
zErrMsg
);
if
(
rc
!=
SQLITE_OK
){
fprintf
(
stderr
,
"Error: %s
\n
"
,
zErrMsg
);
sqlite3_free
(
zErrMsg
);
rc
=
1
;
}
}
else
#endif
if
(
c
==
'l'
&&
strncmp
(
azArg
[
0
],
"log"
,
n
)
==
0
&&
nArg
>=
2
){
const
char
*
zFile
=
azArg
[
1
];
output_file_close
(
p
->
pLog
);
p
->
pLog
=
output_file_open
(
zFile
);
}
else
if
(
c
==
'm'
&&
strncmp
(
azArg
[
0
],
"mode"
,
n
)
==
0
&&
nArg
==
2
){
int
n2
=
strlen30
(
azArg
[
1
]);
if
(
(
n2
==
4
&&
strncmp
(
azArg
[
1
],
"line"
,
n2
)
==
0
)
||
(
n2
==
5
&&
strncmp
(
azArg
[
1
],
"lines"
,
n2
)
==
0
)
){
p
->
mode
=
MODE_Line
;
}
else
if
(
(
n2
==
6
&&
strncmp
(
azArg
[
1
],
"column"
,
n2
)
==
0
)
||
(
n2
==
7
&&
strncmp
(
azArg
[
1
],
"columns"
,
n2
)
==
0
)
){
p
->
mode
=
MODE_Column
;
}
else
if
(
n2
==
4
&&
strncmp
(
azArg
[
1
],
"list"
,
n2
)
==
0
){
p
->
mode
=
MODE_List
;
}
else
if
(
n2
==
4
&&
strncmp
(
azArg
[
1
],
"html"
,
n2
)
==
0
){
p
->
mode
=
MODE_Html
;
}
else
if
(
n2
==
3
&&
strncmp
(
azArg
[
1
],
"tcl"
,
n2
)
==
0
){
p
->
mode
=
MODE_Tcl
;
sqlite3_snprintf
(
sizeof
(
p
->
separator
),
p
->
separator
,
" "
);
}
else
if
(
n2
==
3
&&
strncmp
(
azArg
[
1
],
"csv"
,
n2
)
==
0
){
p
->
mode
=
MODE_Csv
;
sqlite3_snprintf
(
sizeof
(
p
->
separator
),
p
->
separator
,
","
);
}
else
if
(
n2
==
4
&&
strncmp
(
azArg
[
1
],
"tabs"
,
n2
)
==
0
){
p
->
mode
=
MODE_List
;
sqlite3_snprintf
(
sizeof
(
p
->
separator
),
p
->
separator
,
"
\t
"
);
}
else
if
(
n2
==
6
&&
strncmp
(
azArg
[
1
],
"insert"
,
n2
)
==
0
){
p
->
mode
=
MODE_Insert
;
set_table_name
(
p
,
"table"
);
}
else
{
fprintf
(
stderr
,
"Error: mode should be one of: "
"column csv html insert line list tabs tcl
\n
"
);
rc
=
1
;
}
}
else
if
(
c
==
'm'
&&
strncmp
(
azArg
[
0
],
"mode"
,
n
)
==
0
&&
nArg
==
3
){
int
n2
=
strlen30
(
azArg
[
1
]);
if
(
n2
==
6
&&
strncmp
(
azArg
[
1
],
"insert"
,
n2
)
==
0
){
p
->
mode
=
MODE_Insert
;
set_table_name
(
p
,
azArg
[
2
]);
}
else
{
fprintf
(
stderr
,
"Error: invalid arguments: "
"
\"
%s
\"
. Enter
\"
.help
\"
for help
\n
"
,
azArg
[
2
]);
rc
=
1
;
}
}
else
if
(
c
==
'n'
&&
strncmp
(
azArg
[
0
],
"nullvalue"
,
n
)
==
0
&&
nArg
==
2
)
{
sqlite3_snprintf
(
sizeof
(
p
->
nullvalue
),
p
->
nullvalue
,
"%.*s"
,
(
int
)
ArraySize
(
p
->
nullvalue
)
-
1
,
azArg
[
1
]);
}
else
if
(
c
==
'o'
&&
strncmp
(
azArg
[
0
],
"output"
,
n
)
==
0
&&
nArg
==
2
){
if
(
p
->
outfile
[
0
]
==
'|'
){
pclose
(
p
->
out
);
}
else
{
output_file_close
(
p
->
out
);
}
p
->
outfile
[
0
]
=
0
;
if
(
azArg
[
1
][
0
]
==
'|'
){
p
->
out
=
popen
(
&
azArg
[
1
][
1
],
"w"
);
if
(
p
->
out
==
0
){
fprintf
(
stderr
,
"Error: cannot open pipe
\"
%s
\"\n
"
,
&
azArg
[
1
][
1
]);
p
->
out
=
stdout
;
rc
=
1
;
}
else
{
sqlite3_snprintf
(
sizeof
(
p
->
outfile
),
p
->
outfile
,
"%s"
,
azArg
[
1
]);
}
}
else
{
p
->
out
=
output_file_open
(
azArg
[
1
]);
if
(
p
->
out
==
0
){
if
(
strcmp
(
azArg
[
1
],
"off"
)
!=
0
){
fprintf
(
stderr
,
"Error: cannot write to
\"
%s
\"\n
"
,
azArg
[
1
]);
}
p
->
out
=
stdout
;
rc
=
1
;
}
else
{
sqlite3_snprintf
(
sizeof
(
p
->
outfile
),
p
->
outfile
,
"%s"
,
azArg
[
1
]);
}
}
}
else
if
(
c
==
'p'
&&
n
>=
3
&&
strncmp
(
azArg
[
0
],
"print"
,
n
)
==
0
){
int
i
;
for
(
i
=
1
;
i
<
nArg
;
i
++
){
if
(
i
>
1
)
fprintf
(
p
->
out
,
" "
);
fprintf
(
p
->
out
,
"%s"
,
azArg
[
i
]);
}
fprintf
(
p
->
out
,
"
\n
"
);
}
else
if
(
c
==
'p'
&&
strncmp
(
azArg
[
0
],
"prompt"
,
n
)
==
0
&&
(
nArg
==
2
||
nArg
==
3
)){
if
(
nArg
>=
2
)
{
strncpy
(
mainPrompt
,
azArg
[
1
],(
int
)
ArraySize
(
mainPrompt
)
-
1
);
}
if
(
nArg
>=
3
)
{
strncpy
(
continuePrompt
,
azArg
[
2
],(
int
)
ArraySize
(
continuePrompt
)
-
1
);
}
}
else
if
(
c
==
'q'
&&
strncmp
(
azArg
[
0
],
"quit"
,
n
)
==
0
&&
nArg
==
1
){
rc
=
2
;
}
else
if
(
c
==
'r'
&&
n
>=
3
&&
strncmp
(
azArg
[
0
],
"read"
,
n
)
==
0
&&
nArg
==
2
){
FILE
*
alt
=
fopen
(
azArg
[
1
],
"rb"
);
if
(
alt
==
0
){
fprintf
(
stderr
,
"Error: cannot open
\"
%s
\"\n
"
,
azArg
[
1
]);
rc
=
1
;
}
else
{
rc
=
process_input
(
p
,
alt
);
fclose
(
alt
);
}
}
else
if
(
c
==
'r'
&&
n
>=
3
&&
strncmp
(
azArg
[
0
],
"restore"
,
n
)
==
0
&&
nArg
>
1
&&
nArg
<
4
){
const
char
*
zSrcFile
;
const
char
*
zDb
;
sqlite3
*
pSrc
;
sqlite3_backup
*
pBackup
;
int
nTimeout
=
0
;
if
(
nArg
==
2
){
zSrcFile
=
azArg
[
1
];
zDb
=
"main"
;
}
else
{
zSrcFile
=
azArg
[
2
];
zDb
=
azArg
[
1
];
}
rc
=
sqlite3_open
(
zSrcFile
,
&
pSrc
);
if
(
rc
!=
SQLITE_OK
){
fprintf
(
stderr
,
"Error: cannot open
\"
%s
\"\n
"
,
zSrcFile
);
sqlite3_close
(
pSrc
);
return
1
;
}
open_db
(
p
);
pBackup
=
sqlite3_backup_init
(
p
->
db
,
zDb
,
pSrc
,
"main"
);
if
(
pBackup
==
0
){
fprintf
(
stderr
,
"Error: %s
\n
"
,
sqlite3_errmsg
(
p
->
db
));
sqlite3_close
(
pSrc
);
return
1
;
}
while
(
(
rc
=
sqlite3_backup_step
(
pBackup
,
100
))
==
SQLITE_OK
||
rc
==
SQLITE_BUSY
){
if
(
rc
==
SQLITE_BUSY
){
if
(
nTimeout
++
>=
3
)
break
;
sqlite3_sleep
(
100
);
}
}
sqlite3_backup_finish
(
pBackup
);
if
(
rc
==
SQLITE_DONE
){
rc
=
0
;
}
else
if
(
rc
==
SQLITE_BUSY
||
rc
==
SQLITE_LOCKED
){
fprintf
(
stderr
,
"Error: source database is busy
\n
"
);
rc
=
1
;
}
else
{
fprintf
(
stderr
,
"Error: %s
\n
"
,
sqlite3_errmsg
(
p
->
db
));
rc
=
1
;
}
sqlite3_close
(
pSrc
);
}
else
if
(
c
==
's'
&&
strncmp
(
azArg
[
0
],
"schema"
,
n
)
==
0
&&
nArg
<
3
){
struct
callback_data
data
;
char
*
zErrMsg
=
0
;
open_db
(
p
);
memcpy
(
&
data
,
p
,
sizeof
(
data
));
data
.
showHeader
=
0
;
data
.
mode
=
MODE_Semi
;
if
(
nArg
>
1
){
int
i
;
for
(
i
=
0
;
azArg
[
1
][
i
];
i
++
)
azArg
[
1
][
i
]
=
ToLower
(
azArg
[
1
][
i
]);
if
(
strcmp
(
azArg
[
1
],
"sqlite_master"
)
==
0
){
char
*
new_argv
[
2
],
*
new_colv
[
2
];
new_argv
[
0
]
=
"CREATE TABLE sqlite_master (
\n
"
" type text,
\n
"
" name text,
\n
"
" tbl_name text,
\n
"
" rootpage integer,
\n
"
" sql text
\n
"
")"
;
new_argv
[
1
]
=
0
;
new_colv
[
0
]
=
"sql"
;
new_colv
[
1
]
=
0
;
callback
(
&
data
,
1
,
new_argv
,
new_colv
);
rc
=
SQLITE_OK
;
}
else
if
(
strcmp
(
azArg
[
1
],
"sqlite_temp_master"
)
==
0
){
char
*
new_argv
[
2
],
*
new_colv
[
2
];
new_argv
[
0
]
=
"CREATE TEMP TABLE sqlite_temp_master (
\n
"
" type text,
\n
"
" name text,
\n
"
" tbl_name text,
\n
"
" rootpage integer,
\n
"
" sql text
\n
"
")"
;
new_argv
[
1
]
=
0
;
new_colv
[
0
]
=
"sql"
;
new_colv
[
1
]
=
0
;
callback
(
&
data
,
1
,
new_argv
,
new_colv
);
rc
=
SQLITE_OK
;
}
else
{
zShellStatic
=
azArg
[
1
];
rc
=
sqlite3_exec
(
p
->
db
,
"SELECT sql FROM "
" (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
" FROM sqlite_master UNION ALL"
" SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
"WHERE lower(tbl_name) LIKE shellstatic()"
" AND type!='meta' AND sql NOTNULL "
"ORDER BY substr(type,2,1), "
" CASE type WHEN 'view' THEN rowid ELSE name END"
,
callback
,
&
data
,
&
zErrMsg
);
zShellStatic
=
0
;
}
}
else
{
rc
=
sqlite3_exec
(
p
->
db
,
"SELECT sql FROM "
" (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
" FROM sqlite_master UNION ALL"
" SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
"WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%'"
"ORDER BY substr(type,2,1),"
" CASE type WHEN 'view' THEN rowid ELSE name END"
,
callback
,
&
data
,
&
zErrMsg
);
}
if
(
zErrMsg
){
fprintf
(
stderr
,
"Error: %s
\n
"
,
zErrMsg
);
sqlite3_free
(
zErrMsg
);
rc
=
1
;
}
else
if
(
rc
!=
SQLITE_OK
){
fprintf
(
stderr
,
"Error: querying schema information
\n
"
);
rc
=
1
;
}
else
{
rc
=
0
;
}
}
else
if
(
c
==
's'
&&
strncmp
(
azArg
[
0
],
"separator"
,
n
)
==
0
&&
nArg
==
2
){
sqlite3_snprintf
(
sizeof
(
p
->
separator
),
p
->
separator
,
"%.*s"
,
(
int
)
sizeof
(
p
->
separator
)
-
1
,
azArg
[
1
]);
}
else
if
(
c
==
's'
&&
strncmp
(
azArg
[
0
],
"show"
,
n
)
==
0
&&
nArg
==
1
){
int
i
;
fprintf
(
p
->
out
,
"%9.9s: %s
\n
"
,
"echo"
,
p
->
echoOn
?
"on"
:
"off"
);
fprintf
(
p
->
out
,
"%9.9s: %s
\n
"
,
"explain"
,
p
->
explainPrev
.
valid
?
"on"
:
"off"
);
fprintf
(
p
->
out
,
"%9.9s: %s
\n
"
,
"headers"
,
p
->
showHeader
?
"on"
:
"off"
);
fprintf
(
p
->
out
,
"%9.9s: %s
\n
"
,
"mode"
,
modeDescr
[
p
->
mode
]);
fprintf
(
p
->
out
,
"%9.9s: "
,
"nullvalue"
);
output_c_string
(
p
->
out
,
p
->
nullvalue
);
fprintf
(
p
->
out
,
"
\n
"
);
fprintf
(
p
->
out
,
"%9.9s: %s
\n
"
,
"output"
,
strlen30
(
p
->
outfile
)
?
p
->
outfile
:
"stdout"
);
fprintf
(
p
->
out
,
"%9.9s: "
,
"separator"
);
output_c_string
(
p
->
out
,
p
->
separator
);
fprintf
(
p
->
out
,
"
\n
"
);
fprintf
(
p
->
out
,
"%9.9s: %s
\n
"
,
"stats"
,
p
->
statsOn
?
"on"
:
"off"
);
fprintf
(
p
->
out
,
"%9.9s: "
,
"width"
);
for
(
i
=
0
;
i
<
(
int
)
ArraySize
(
p
->
colWidth
)
&&
p
->
colWidth
[
i
]
!=
0
;
i
++
)
{
fprintf
(
p
->
out
,
"%d "
,
p
->
colWidth
[
i
]);
}
fprintf
(
p
->
out
,
"
\n
"
);
}
else
if
(
c
==
's'
&&
strncmp
(
azArg
[
0
],
"stats"
,
n
)
==
0
&&
nArg
>
1
&&
nArg
<
3
){
p
->
statsOn
=
booleanValue
(
azArg
[
1
]);
}
else
if
(
c
==
't'
&&
n
>
1
&&
strncmp
(
azArg
[
0
],
"tables"
,
n
)
==
0
&&
nArg
<
3
){
sqlite3_stmt
*
pStmt
;
char
**
azResult
;
int
nRow
,
nAlloc
;
char
*
zSql
=
0
;
int
ii
;
open_db
(
p
);
rc
=
sqlite3_prepare_v2
(
p
->
db
,
"PRAGMA database_list"
,
-
1
,
&
pStmt
,
0
);
if
(
rc
)
return
rc
;
zSql
=
sqlite3_mprintf
(
"SELECT name FROM sqlite_master"
" WHERE type IN ('table','view')"
" AND name NOT LIKE 'sqlite_%%'"
" AND name LIKE ?1"
);
while
(
sqlite3_step
(
pStmt
)
==
SQLITE_ROW
){
const
char
*
zDbName
=
(
const
char
*
)
sqlite3_column_text
(
pStmt
,
1
);
if
(
zDbName
==
0
||
strcmp
(
zDbName
,
"main"
)
==
0
)
continue
;
if
(
strcmp
(
zDbName
,
"temp"
)
==
0
){
zSql
=
sqlite3_mprintf
(
"%z UNION ALL "
"SELECT 'temp.' || name FROM sqlite_temp_master"
" WHERE type IN ('table','view')"
" AND name NOT LIKE 'sqlite_%%'"
" AND name LIKE ?1"
,
zSql
);
}
else
{
zSql
=
sqlite3_mprintf
(
"%z UNION ALL "
"SELECT '%q.' || name FROM
\"
%w
\"
.sqlite_master"
" WHERE type IN ('table','view')"
" AND name NOT LIKE 'sqlite_%%'"
" AND name LIKE ?1"
,
zSql
,
zDbName
,
zDbName
);
}
}
sqlite3_finalize
(
pStmt
);
zSql
=
sqlite3_mprintf
(
"%z ORDER BY 1"
,
zSql
);
rc
=
sqlite3_prepare_v2
(
p
->
db
,
zSql
,
-
1
,
&
pStmt
,
0
);
sqlite3_free
(
zSql
);
if
(
rc
)
return
rc
;
nRow
=
nAlloc
=
0
;
azResult
=
0
;
if
(
nArg
>
1
){
sqlite3_bind_text
(
pStmt
,
1
,
azArg
[
1
],
-
1
,
SQLITE_TRANSIENT
);
}
else
{
sqlite3_bind_text
(
pStmt
,
1
,
"%"
,
-
1
,
SQLITE_STATIC
);
}
while
(
sqlite3_step
(
pStmt
)
==
SQLITE_ROW
){
if
(
nRow
>=
nAlloc
){
char
**
azNew
;
int
n
=
nAlloc
*
2
+
10
;
azNew
=
sqlite3_realloc
(
azResult
,
sizeof
(
azResult
[
0
])
*
n
);
if
(
azNew
==
0
){
fprintf
(
stderr
,
"Error: out of memory
\n
"
);
break
;
}
nAlloc
=
n
;
azResult
=
azNew
;
}
azResult
[
nRow
]
=
sqlite3_mprintf
(
"%s"
,
sqlite3_column_text
(
pStmt
,
0
));
if
(
azResult
[
nRow
]
)
nRow
++
;
}
sqlite3_finalize
(
pStmt
);
if
(
nRow
>
0
){
int
len
,
maxlen
=
0
;
int
i
,
j
;
int
nPrintCol
,
nPrintRow
;
for
(
i
=
0
;
i
<
nRow
;
i
++
){
len
=
strlen30
(
azResult
[
i
]);
if
(
len
>
maxlen
)
maxlen
=
len
;
}
nPrintCol
=
80
/
(
maxlen
+
2
);
if
(
nPrintCol
<
1
)
nPrintCol
=
1
;
nPrintRow
=
(
nRow
+
nPrintCol
-
1
)
/
nPrintCol
;
for
(
i
=
0
;
i
<
nPrintRow
;
i
++
){
for
(
j
=
i
;
j
<
nRow
;
j
+=
nPrintRow
){
char
*
zSp
=
j
<
nPrintRow
?
""
:
" "
;
printf
(
"%s%-*s"
,
zSp
,
maxlen
,
azResult
[
j
]
?
azResult
[
j
]
:
""
);
}
printf
(
"
\n
"
);
}
}
for
(
ii
=
0
;
ii
<
nRow
;
ii
++
)
sqlite3_free
(
azResult
[
ii
]);
sqlite3_free
(
azResult
);
}
else
if
(
c
==
't'
&&
n
>=
8
&&
strncmp
(
azArg
[
0
],
"testctrl"
,
n
)
==
0
&&
nArg
>=
2
){
static
const
struct
{
const
char
*
zCtrlName
;
/* Name of a test-control option */
int
ctrlCode
;
/* Integer code for that option */
}
aCtrl
[]
=
{
{
"prng_save"
,
SQLITE_TESTCTRL_PRNG_SAVE
},
{
"prng_restore"
,
SQLITE_TESTCTRL_PRNG_RESTORE
},
{
"prng_reset"
,
SQLITE_TESTCTRL_PRNG_RESET
},
{
"bitvec_test"
,
SQLITE_TESTCTRL_BITVEC_TEST
},
{
"fault_install"
,
SQLITE_TESTCTRL_FAULT_INSTALL
},
{
"benign_malloc_hooks"
,
SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS
},
{
"pending_byte"
,
SQLITE_TESTCTRL_PENDING_BYTE
},
{
"assert"
,
SQLITE_TESTCTRL_ASSERT
},
{
"always"
,
SQLITE_TESTCTRL_ALWAYS
},
{
"reserve"
,
SQLITE_TESTCTRL_RESERVE
},
{
"optimizations"
,
SQLITE_TESTCTRL_OPTIMIZATIONS
},
{
"iskeyword"
,
SQLITE_TESTCTRL_ISKEYWORD
},
{
"scratchmalloc"
,
SQLITE_TESTCTRL_SCRATCHMALLOC
},
};
int
testctrl
=
-
1
;
int
rc
=
0
;
int
i
,
n
;
open_db
(
p
);
/* convert testctrl text option to value. allow any unique prefix
** of the option name, or a numerical value. */
n
=
strlen30
(
azArg
[
1
]);
for
(
i
=
0
;
i
<
(
int
)(
sizeof
(
aCtrl
)
/
sizeof
(
aCtrl
[
0
]));
i
++
){
if
(
strncmp
(
azArg
[
1
],
aCtrl
[
i
].
zCtrlName
,
n
)
==
0
){
if
(
testctrl
<
0
){
testctrl
=
aCtrl
[
i
].
ctrlCode
;
}
else
{
fprintf
(
stderr
,
"ambiguous option name:
\"
%s
\"\n
"
,
azArg
[
1
]);
testctrl
=
-
1
;
break
;
}
}
}
if
(
testctrl
<
0
)
testctrl
=
atoi
(
azArg
[
1
]);
if
(
(
testctrl
<
SQLITE_TESTCTRL_FIRST
)
||
(
testctrl
>
SQLITE_TESTCTRL_LAST
)
){
fprintf
(
stderr
,
"Error: invalid testctrl option: %s
\n
"
,
azArg
[
1
]);
}
else
{
switch
(
testctrl
){
/* sqlite3_test_control(int, db, int) */
case
SQLITE_TESTCTRL_OPTIMIZATIONS
:
case
SQLITE_TESTCTRL_RESERVE
:
if
(
nArg
==
3
){
int
opt
=
(
int
)
strtol
(
azArg
[
2
],
0
,
0
);
rc
=
sqlite3_test_control
(
testctrl
,
p
->
db
,
opt
);
printf
(
"%d (0x%08x)
\n
"
,
rc
,
rc
);
}
else
{
fprintf
(
stderr
,
"Error: testctrl %s takes a single int option
\n
"
,
azArg
[
1
]);
}
break
;
/* sqlite3_test_control(int) */
case
SQLITE_TESTCTRL_PRNG_SAVE
:
case
SQLITE_TESTCTRL_PRNG_RESTORE
:
case
SQLITE_TESTCTRL_PRNG_RESET
:
if
(
nArg
==
2
){
rc
=
sqlite3_test_control
(
testctrl
);
printf
(
"%d (0x%08x)
\n
"
,
rc
,
rc
);
}
else
{
fprintf
(
stderr
,
"Error: testctrl %s takes no options
\n
"
,
azArg
[
1
]);
}
break
;
/* sqlite3_test_control(int, uint) */
case
SQLITE_TESTCTRL_PENDING_BYTE
:
if
(
nArg
==
3
){
unsigned
int
opt
=
(
unsigned
int
)
atoi
(
azArg
[
2
]);
rc
=
sqlite3_test_control
(
testctrl
,
opt
);
printf
(
"%d (0x%08x)
\n
"
,
rc
,
rc
);
}
else
{
fprintf
(
stderr
,
"Error: testctrl %s takes a single unsigned"
" int option
\n
"
,
azArg
[
1
]);
}
break
;
/* sqlite3_test_control(int, int) */
case
SQLITE_TESTCTRL_ASSERT
:
case
SQLITE_TESTCTRL_ALWAYS
:
if
(
nArg
==
3
){
int
opt
=
atoi
(
azArg
[
2
]);
rc
=
sqlite3_test_control
(
testctrl
,
opt
);
printf
(
"%d (0x%08x)
\n
"
,
rc
,
rc
);
}
else
{
fprintf
(
stderr
,
"Error: testctrl %s takes a single int option
\n
"
,
azArg
[
1
]);
}
break
;
/* sqlite3_test_control(int, char *) */
#ifdef SQLITE_N_KEYWORD
case
SQLITE_TESTCTRL_ISKEYWORD
:
if
(
nArg
==
3
){
const
char
*
opt
=
azArg
[
2
];
rc
=
sqlite3_test_control
(
testctrl
,
opt
);
printf
(
"%d (0x%08x)
\n
"
,
rc
,
rc
);
}
else
{
fprintf
(
stderr
,
"Error: testctrl %s takes a single char * option
\n
"
,
azArg
[
1
]);
}
break
;
#endif
case
SQLITE_TESTCTRL_BITVEC_TEST
:
case
SQLITE_TESTCTRL_FAULT_INSTALL
:
case
SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS
:
case
SQLITE_TESTCTRL_SCRATCHMALLOC
:
default
:
fprintf
(
stderr
,
"Error: CLI support for testctrl %s not implemented
\n
"
,
azArg
[
1
]);
break
;
}
}
}
else
if
(
c
==
't'
&&
n
>
4
&&
strncmp
(
azArg
[
0
],
"timeout"
,
n
)
==
0
&&
nArg
==
2
){
open_db
(
p
);
sqlite3_busy_timeout
(
p
->
db
,
atoi
(
azArg
[
1
]));
}
else
if
(
HAS_TIMER
&&
c
==
't'
&&
n
>=
5
&&
strncmp
(
azArg
[
0
],
"timer"
,
n
)
==
0
&&
nArg
==
2
){
enableTimer
=
booleanValue
(
azArg
[
1
]);
}
else
if
(
c
==
't'
&&
strncmp
(
azArg
[
0
],
"trace"
,
n
)
==
0
&&
nArg
>
1
){
open_db
(
p
);
output_file_close
(
p
->
traceOut
);
p
->
traceOut
=
output_file_open
(
azArg
[
1
]);
#if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)
if
(
p
->
traceOut
==
0
){
sqlite3_trace
(
p
->
db
,
0
,
0
);
}
else
{
sqlite3_trace
(
p
->
db
,
sql_trace_callback
,
p
->
traceOut
);
}
#endif
}
else
if
(
c
==
'v'
&&
strncmp
(
azArg
[
0
],
"version"
,
n
)
==
0
){
printf
(
"SQLite %s %s
\n
"
/*extra-version-info*/
,
sqlite3_libversion
(),
sqlite3_sourceid
());
}
else
if
(
c
==
'v'
&&
strncmp
(
azArg
[
0
],
"vfsname"
,
n
)
==
0
){
const
char
*
zDbName
=
nArg
==
2
?
azArg
[
1
]
:
"main"
;
char
*
zVfsName
=
0
;
if
(
p
->
db
){
sqlite3_file_control
(
p
->
db
,
zDbName
,
SQLITE_FCNTL_VFSNAME
,
&
zVfsName
);
if
(
zVfsName
){
printf
(
"%s
\n
"
,
zVfsName
);
sqlite3_free
(
zVfsName
);
}
}
}
else
#if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
if
(
c
==
'w'
&&
strncmp
(
azArg
[
0
],
"wheretrace"
,
n
)
==
0
){
extern
int
sqlite3WhereTrace
;
sqlite3WhereTrace
=
atoi
(
azArg
[
1
]);
}
else
#endif
if
(
c
==
'w'
&&
strncmp
(
azArg
[
0
],
"width"
,
n
)
==
0
&&
nArg
>
1
){
int
j
;
assert
(
nArg
<=
ArraySize
(
azArg
)
);
for
(
j
=
1
;
j
<
nArg
&&
j
<
ArraySize
(
p
->
colWidth
);
j
++
){
p
->
colWidth
[
j
-
1
]
=
atoi
(
azArg
[
j
]);
}
}
else
{
fprintf
(
stderr
,
"Error: unknown command or invalid arguments: "
"
\"
%s
\"
. Enter
\"
.help
\"
for help
\n
"
,
azArg
[
0
]);
rc
=
1
;
}
return
rc
;
}
/*
** Return TRUE if a semicolon occurs anywhere in the first N characters
** of string z[].
*/
static
int
_contains_semicolon
(
const
char
*
z
,
int
N
){
int
i
;
for
(
i
=
0
;
i
<
N
;
i
++
){
if
(
z
[
i
]
==
';'
)
return
1
;
}
return
0
;
}
/*
** Test to see if a line consists entirely of whitespace.
*/
static
int
_all_whitespace
(
const
char
*
z
){
for
(;
*
z
;
z
++
){
if
(
IsSpace
(
z
[
0
])
)
continue
;
if
(
*
z
==
'/'
&&
z
[
1
]
==
'*'
){
z
+=
2
;
while
(
*
z
&&
(
*
z
!=
'*'
||
z
[
1
]
!=
'/'
)
){
z
++
;
}
if
(
*
z
==
0
)
return
0
;
z
++
;
continue
;
}
if
(
*
z
==
'-'
&&
z
[
1
]
==
'-'
){
z
+=
2
;
while
(
*
z
&&
*
z
!=
'\n'
){
z
++
;
}
if
(
*
z
==
0
)
return
1
;
continue
;
}
return
0
;
}
return
1
;
}
/*
** Return TRUE if the line typed in is an SQL command terminator other
** than a semi-colon. The SQL Server style "go" command is understood
** as is the Oracle "/".
*/
static
int
_is_command_terminator
(
const
char
*
zLine
){
while
(
IsSpace
(
zLine
[
0
])
){
zLine
++
;
};
if
(
zLine
[
0
]
==
'/'
&&
_all_whitespace
(
&
zLine
[
1
])
){
return
1
;
/* Oracle */
}
if
(
ToLower
(
zLine
[
0
])
==
'g'
&&
ToLower
(
zLine
[
1
])
==
'o'
&&
_all_whitespace
(
&
zLine
[
2
])
){
return
1
;
/* SQL Server */
}
return
0
;
}
/*
** Return true if zSql is a complete SQL statement. Return false if it
** ends in the middle of a string literal or C-style comment.
*/
static
int
_is_complete
(
char
*
zSql
,
int
nSql
){
int
rc
;
if
(
zSql
==
0
)
return
1
;
zSql
[
nSql
]
=
';'
;
zSql
[
nSql
+
1
]
=
0
;
rc
=
sqlite3_complete
(
zSql
);
zSql
[
nSql
]
=
0
;
return
rc
;
}
/*
** Read input from *in and process it. If *in==0 then input
** is interactive - the user is typing it it. Otherwise, input
** is coming from a file or device. A prompt is issued and history
** is saved only if input is interactive. An interrupt signal will
** cause this routine to exit immediately, unless input is interactive.
**
** Return the number of errors.
*/
static
int
process_input
(
struct
callback_data
*
p
,
FILE
*
in
){
char
*
zLine
=
0
;
char
*
zSql
=
0
;
int
nSql
=
0
;
int
nSqlPrior
=
0
;
char
*
zErrMsg
;
int
rc
;
int
errCnt
=
0
;
int
lineno
=
0
;
int
startline
=
0
;
while
(
errCnt
==
0
||
!
bail_on_error
||
(
in
==
0
&&
stdin_is_interactive
)
){
fflush
(
p
->
out
);
free
(
zLine
);
zLine
=
one_input_line
(
zSql
,
in
);
if
(
zLine
==
0
){
/* End of input */
if
(
stdin_is_interactive
)
printf
(
"
\n
"
);
break
;
}
if
(
seenInterrupt
){
if
(
in
!=
0
)
break
;
seenInterrupt
=
0
;
}
lineno
++
;
if
(
(
zSql
==
0
||
zSql
[
0
]
==
0
)
&&
_all_whitespace
(
zLine
)
)
continue
;
if
(
zLine
&&
zLine
[
0
]
==
'.'
&&
nSql
==
0
){
if
(
p
->
echoOn
)
printf
(
"%s
\n
"
,
zLine
);
rc
=
do_meta_command
(
zLine
,
p
);
if
(
rc
==
2
){
/* exit requested */
break
;
}
else
if
(
rc
){
errCnt
++
;
}
continue
;
}
if
(
_is_command_terminator
(
zLine
)
&&
_is_complete
(
zSql
,
nSql
)
){
memcpy
(
zLine
,
";"
,
2
);
}
nSqlPrior
=
nSql
;
if
(
zSql
==
0
){
int
i
;
for
(
i
=
0
;
zLine
[
i
]
&&
IsSpace
(
zLine
[
i
]);
i
++
){}
if
(
zLine
[
i
]
!=
0
){
nSql
=
strlen30
(
zLine
);
zSql
=
malloc
(
nSql
+
3
);
if
(
zSql
==
0
){
fprintf
(
stderr
,
"Error: out of memory
\n
"
);
exit
(
1
);
}
memcpy
(
zSql
,
zLine
,
nSql
+
1
);
startline
=
lineno
;
}
}
else
{
int
len
=
strlen30
(
zLine
);
zSql
=
realloc
(
zSql
,
nSql
+
len
+
4
);
if
(
zSql
==
0
){
fprintf
(
stderr
,
"Error: out of memory
\n
"
);
exit
(
1
);
}
zSql
[
nSql
++
]
=
'\n'
;
memcpy
(
&
zSql
[
nSql
],
zLine
,
len
+
1
);
nSql
+=
len
;
}
if
(
zSql
&&
_contains_semicolon
(
&
zSql
[
nSqlPrior
],
nSql
-
nSqlPrior
)
&&
sqlite3_complete
(
zSql
)
){
p
->
cnt
=
0
;
open_db
(
p
);
BEGIN_TIMER
;
rc
=
shell_exec
(
p
->
db
,
zSql
,
shell_callback
,
p
,
&
zErrMsg
);
END_TIMER
;
if
(
rc
||
zErrMsg
){
char
zPrefix
[
100
];
if
(
in
!=
0
||
!
stdin_is_interactive
){
sqlite3_snprintf
(
sizeof
(
zPrefix
),
zPrefix
,
"Error: near line %d:"
,
startline
);
}
else
{
sqlite3_snprintf
(
sizeof
(
zPrefix
),
zPrefix
,
"Error:"
);
}
if
(
zErrMsg
!=
0
){
fprintf
(
stderr
,
"%s %s
\n
"
,
zPrefix
,
zErrMsg
);
sqlite3_free
(
zErrMsg
);
zErrMsg
=
0
;
}
else
{
fprintf
(
stderr
,
"%s %s
\n
"
,
zPrefix
,
sqlite3_errmsg
(
p
->
db
));
}
errCnt
++
;
}
free
(
zSql
);
zSql
=
0
;
nSql
=
0
;
}
}
if
(
zSql
){
if
(
!
_all_whitespace
(
zSql
)
){
fprintf
(
stderr
,
"Error: incomplete SQL: %s
\n
"
,
zSql
);
}
free
(
zSql
);
}
free
(
zLine
);
return
errCnt
>
0
;
}
/*
** Return a pathname which is the user's home directory. A
** 0 return indicates an error of some kind.
*/
static
char
*
find_home_dir
(
void
){
static
char
*
home_dir
=
NULL
;
if
(
home_dir
)
return
home_dir
;
#if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) && !defined(__RTP__) && !defined(_WRS_KERNEL)
{
struct
passwd
*
pwent
;
uid_t
uid
=
getuid
();
if
(
(
pwent
=
getpwuid
(
uid
))
!=
NULL
)
{
home_dir
=
pwent
->
pw_dir
;
}
}
#endif
#if defined(_WIN32_WCE)
/* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
*/
home_dir
=
"/"
;
#else
#if defined(_WIN32) || defined(WIN32)
if
(
!
home_dir
)
{
home_dir
=
getenv
(
"USERPROFILE"
);
}
#endif
if
(
!
home_dir
)
{
home_dir
=
getenv
(
"HOME"
);
}
#if defined(_WIN32) || defined(WIN32)
if
(
!
home_dir
)
{
char
*
zDrive
,
*
zPath
;
int
n
;
zDrive
=
getenv
(
"HOMEDRIVE"
);
zPath
=
getenv
(
"HOMEPATH"
);
if
(
zDrive
&&
zPath
){
n
=
strlen30
(
zDrive
)
+
strlen30
(
zPath
)
+
1
;
home_dir
=
malloc
(
n
);
if
(
home_dir
==
0
)
return
0
;
sqlite3_snprintf
(
n
,
home_dir
,
"%s%s"
,
zDrive
,
zPath
);
return
home_dir
;
}
home_dir
=
"c:
\\
"
;
}
#endif
#endif
/* !_WIN32_WCE */
if
(
home_dir
){
int
n
=
strlen30
(
home_dir
)
+
1
;
char
*
z
=
malloc
(
n
);
if
(
z
)
memcpy
(
z
,
home_dir
,
n
);
home_dir
=
z
;
}
return
home_dir
;
}
/*
** Read input from the file given by sqliterc_override. Or if that
** parameter is NULL, take input from ~/.sqliterc
**
** Returns the number of errors.
*/
static
int
process_sqliterc
(
struct
callback_data
*
p
,
/* Configuration data */
const
char
*
sqliterc_override
/* Name of config file. NULL to use default */
){
char
*
home_dir
=
NULL
;
const
char
*
sqliterc
=
sqliterc_override
;
char
*
zBuf
=
0
;
FILE
*
in
=
NULL
;
int
rc
=
0
;
if
(
sqliterc
==
NULL
)
{
home_dir
=
find_home_dir
();
if
(
home_dir
==
0
){
#if !defined(__RTP__) && !defined(_WRS_KERNEL)
fprintf
(
stderr
,
"%s: Error: cannot locate your home directory
\n
"
,
Argv0
);
#endif
return
1
;
}
sqlite3_initialize
();
zBuf
=
sqlite3_mprintf
(
"%s/.sqliterc"
,
home_dir
);
sqliterc
=
zBuf
;
}
in
=
fopen
(
sqliterc
,
"rb"
);
if
(
in
){
if
(
stdin_is_interactive
){
fprintf
(
stderr
,
"-- Loading resources from %s
\n
"
,
sqliterc
);
}
rc
=
process_input
(
p
,
in
);
fclose
(
in
);
}
sqlite3_free
(
zBuf
);
return
rc
;
}
/*
** Show available command line options
*/
static
const
char
zOptions
[]
=
" -bail stop after hitting an error
\n
"
" -batch force batch I/O
\n
"
" -column set output mode to 'column'
\n
"
" -cmd COMMAND run
\"
COMMAND
\"
before reading stdin
\n
"
" -csv set output mode to 'csv'
\n
"
" -echo print commands before execution
\n
"
" -init FILENAME read/process named file
\n
"
" -[no]header turn headers on or off
\n
"
#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
" -heap SIZE Size of heap for memsys3 or memsys5
\n
"
#endif
" -help show this message
\n
"
" -html set output mode to HTML
\n
"
" -interactive force interactive I/O
\n
"
" -line set output mode to 'line'
\n
"
" -list set output mode to 'list'
\n
"
#ifdef SQLITE_ENABLE_MULTIPLEX
" -multiplex enable the multiplexor VFS
\n
"
#endif
" -nullvalue TEXT set text string for NULL values. Default ''
\n
"
" -separator SEP set output field separator. Default: '|'
\n
"
" -stats print memory stats before each finalize
\n
"
" -version show SQLite version
\n
"
" -vfs NAME use NAME as the default VFS
\n
"
#ifdef SQLITE_ENABLE_VFSTRACE
" -vfstrace enable tracing of all VFS calls
\n
"
#endif
;
static
void
usage
(
int
showDetail
){
fprintf
(
stderr
,
"Usage: %s [OPTIONS] FILENAME [SQL]
\n
"
"FILENAME is the name of an SQLite database. A new database is created
\n
"
"if the file does not previously exist.
\n
"
,
Argv0
);
if
(
showDetail
){
fprintf
(
stderr
,
"OPTIONS include:
\n
%s"
,
zOptions
);
}
else
{
fprintf
(
stderr
,
"Use the -help option for additional information
\n
"
);
}
exit
(
1
);
}
/*
** Initialize the state information in data
*/
static
void
main_init
(
struct
callback_data
*
data
)
{
memset
(
data
,
0
,
sizeof
(
*
data
));
data
->
mode
=
MODE_List
;
memcpy
(
data
->
separator
,
"|"
,
2
);
data
->
showHeader
=
0
;
sqlite3_config
(
SQLITE_CONFIG_URI
,
1
);
sqlite3_config
(
SQLITE_CONFIG_LOG
,
shellLog
,
data
);
sqlite3_snprintf
(
sizeof
(
mainPrompt
),
mainPrompt
,
"sqlite> "
);
sqlite3_snprintf
(
sizeof
(
continuePrompt
),
continuePrompt
,
" ...> "
);
sqlite3_config
(
SQLITE_CONFIG_SINGLETHREAD
);
}
/*
** Get the argument to an --option. Throw an error and die if no argument
** is available.
*/
static
char
*
cmdline_option_value
(
int
argc
,
char
**
argv
,
int
i
){
if
(
i
==
argc
){
fprintf
(
stderr
,
"%s: Error: missing argument to %s
\n
"
,
argv
[
0
],
argv
[
argc
-
1
]);
exit
(
1
);
}
return
argv
[
i
];
}
int
main
(
int
argc
,
char
**
argv
){
char
*
zErrMsg
=
0
;
struct
callback_data
data
;
const
char
*
zInitFile
=
0
;
char
*
zFirstCmd
=
0
;
int
i
;
int
rc
=
0
;
if
(
strcmp
(
sqlite3_sourceid
(),
SQLITE_SOURCE_ID
)
!=
0
){
fprintf
(
stderr
,
"SQLite header and source version mismatch
\n
%s
\n
%s
\n
"
,
sqlite3_sourceid
(),
SQLITE_SOURCE_ID
);
exit
(
1
);
}
Argv0
=
argv
[
0
];
main_init
(
&
data
);
stdin_is_interactive
=
isatty
(
0
);
/* Make sure we have a valid signal handler early, before anything
** else is done.
*/
#ifdef SIGINT
signal
(
SIGINT
,
interrupt_handler
);
#endif
/* Do an initial pass through the command-line argument to locate
** the name of the database file, the name of the initialization file,
** the size of the alternative malloc heap,
** and the first command to execute.
*/
for
(
i
=
1
;
i
<
argc
;
i
++
){
char
*
z
;
z
=
argv
[
i
];
if
(
z
[
0
]
!=
'-'
){
if
(
data
.
zDbFilename
==
0
){
data
.
zDbFilename
=
z
;
continue
;
}
if
(
zFirstCmd
==
0
){
zFirstCmd
=
z
;
continue
;
}
fprintf
(
stderr
,
"%s: Error: too many options:
\"
%s
\"\n
"
,
Argv0
,
argv
[
i
]);
fprintf
(
stderr
,
"Use -help for a list of options.
\n
"
);
return
1
;
}
if
(
z
[
1
]
==
'-'
)
z
++
;
if
(
strcmp
(
z
,
"-separator"
)
==
0
||
strcmp
(
z
,
"-nullvalue"
)
==
0
||
strcmp
(
z
,
"-cmd"
)
==
0
){
(
void
)
cmdline_option_value
(
argc
,
argv
,
++
i
);
}
else
if
(
strcmp
(
z
,
"-init"
)
==
0
){
zInitFile
=
cmdline_option_value
(
argc
,
argv
,
++
i
);
}
else
if
(
strcmp
(
z
,
"-batch"
)
==
0
){
/* Need to check for batch mode here to so we can avoid printing
** informational messages (like from process_sqliterc) before
** we do the actual processing of arguments later in a second pass.
*/
stdin_is_interactive
=
0
;
}
else
if
(
strcmp
(
z
,
"-heap"
)
==
0
){
#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
int
j
,
c
;
const
char
*
zSize
;
sqlite3_int64
szHeap
;
zSize
=
cmdline_option_value
(
argc
,
argv
,
++
i
);
szHeap
=
atoi
(
zSize
);
for
(
j
=
0
;
(
c
=
zSize
[
j
])
!=
0
;
j
++
){
if
(
c
==
'M'
){
szHeap
*=
1000000
;
break
;
}
if
(
c
==
'K'
){
szHeap
*=
1000
;
break
;
}
if
(
c
==
'G'
){
szHeap
*=
1000000000
;
break
;
}
}
if
(
szHeap
>
0x7fff0000
)
szHeap
=
0x7fff0000
;
sqlite3_config
(
SQLITE_CONFIG_HEAP
,
malloc
((
int
)
szHeap
),
(
int
)
szHeap
,
64
);
#endif
#ifdef SQLITE_ENABLE_VFSTRACE
}
else
if
(
strcmp
(
z
,
"-vfstrace"
)
==
0
){
extern
int
vfstrace_register
(
const
char
*
zTraceName
,
const
char
*
zOldVfsName
,
int
(
*
xOut
)(
const
char
*
,
void
*
),
void
*
pOutArg
,
int
makeDefault
);
vfstrace_register
(
"trace"
,
0
,(
int
(
*
)(
const
char
*
,
void
*
))
fputs
,
stderr
,
1
);
#endif
#ifdef SQLITE_ENABLE_MULTIPLEX
}
else
if
(
strcmp
(
z
,
"-multiplex"
)
==
0
){
extern
int
sqlite3_multiple_initialize
(
const
char
*
,
int
);
sqlite3_multiplex_initialize
(
0
,
1
);
#endif
}
else
if
(
strcmp
(
z
,
"-vfs"
)
==
0
){
sqlite3_vfs
*
pVfs
=
sqlite3_vfs_find
(
cmdline_option_value
(
argc
,
argv
,
++
i
));
if
(
pVfs
){
sqlite3_vfs_register
(
pVfs
,
1
);
}
else
{
fprintf
(
stderr
,
"no such VFS:
\"
%s
\"\n
"
,
argv
[
i
]);
exit
(
1
);
}
}
}
if
(
data
.
zDbFilename
==
0
){
#ifndef SQLITE_OMIT_MEMORYDB
data
.
zDbFilename
=
":memory:"
;
#else
fprintf
(
stderr
,
"%s: Error: no database filename specified
\n
"
,
Argv0
);
return
1
;
#endif
}
data
.
out
=
stdout
;
/* Go ahead and open the database file if it already exists. If the
** file does not exist, delay opening it. This prevents empty database
** files from being created if a user mistypes the database name argument
** to the sqlite command-line tool.
*/
if
(
access
(
data
.
zDbFilename
,
0
)
==
0
){
open_db
(
&
data
);
}
/* Process the initialization file if there is one. If no -init option
** is given on the command line, look for a file named ~/.sqliterc and
** try to process it.
*/
rc
=
process_sqliterc
(
&
data
,
zInitFile
);
if
(
rc
>
0
){
return
rc
;
}
/* Make a second pass through the command-line argument and set
** options. This second pass is delayed until after the initialization
** file is processed so that the command-line arguments will override
** settings in the initialization file.
*/
for
(
i
=
1
;
i
<
argc
;
i
++
){
char
*
z
=
argv
[
i
];
if
(
z
[
0
]
!=
'-'
)
continue
;
if
(
z
[
1
]
==
'-'
){
z
++
;
}
if
(
strcmp
(
z
,
"-init"
)
==
0
){
i
++
;
}
else
if
(
strcmp
(
z
,
"-html"
)
==
0
){
data
.
mode
=
MODE_Html
;
}
else
if
(
strcmp
(
z
,
"-list"
)
==
0
){
data
.
mode
=
MODE_List
;
}
else
if
(
strcmp
(
z
,
"-line"
)
==
0
){
data
.
mode
=
MODE_Line
;
}
else
if
(
strcmp
(
z
,
"-column"
)
==
0
){
data
.
mode
=
MODE_Column
;
}
else
if
(
strcmp
(
z
,
"-csv"
)
==
0
){
data
.
mode
=
MODE_Csv
;
memcpy
(
data
.
separator
,
","
,
2
);
}
else
if
(
strcmp
(
z
,
"-separator"
)
==
0
){
sqlite3_snprintf
(
sizeof
(
data
.
separator
),
data
.
separator
,
"%s"
,
cmdline_option_value
(
argc
,
argv
,
++
i
));
}
else
if
(
strcmp
(
z
,
"-nullvalue"
)
==
0
){
sqlite3_snprintf
(
sizeof
(
data
.
nullvalue
),
data
.
nullvalue
,
"%s"
,
cmdline_option_value
(
argc
,
argv
,
++
i
));
}
else
if
(
strcmp
(
z
,
"-header"
)
==
0
){
data
.
showHeader
=
1
;
}
else
if
(
strcmp
(
z
,
"-noheader"
)
==
0
){
data
.
showHeader
=
0
;
}
else
if
(
strcmp
(
z
,
"-echo"
)
==
0
){
data
.
echoOn
=
1
;
}
else
if
(
strcmp
(
z
,
"-stats"
)
==
0
){
data
.
statsOn
=
1
;
}
else
if
(
strcmp
(
z
,
"-bail"
)
==
0
){
bail_on_error
=
1
;
}
else
if
(
strcmp
(
z
,
"-version"
)
==
0
){
printf
(
"%s %s
\n
"
,
sqlite3_libversion
(),
sqlite3_sourceid
());
return
0
;
}
else
if
(
strcmp
(
z
,
"-interactive"
)
==
0
){
stdin_is_interactive
=
1
;
}
else
if
(
strcmp
(
z
,
"-batch"
)
==
0
){
stdin_is_interactive
=
0
;
}
else
if
(
strcmp
(
z
,
"-heap"
)
==
0
){
i
++
;
}
else
if
(
strcmp
(
z
,
"-vfs"
)
==
0
){
i
++
;
#ifdef SQLITE_ENABLE_VFSTRACE
}
else
if
(
strcmp
(
z
,
"-vfstrace"
)
==
0
){
i
++
;
#endif
#ifdef SQLITE_ENABLE_MULTIPLEX
}
else
if
(
strcmp
(
z
,
"-multiplex"
)
==
0
){
i
++
;
#endif
}
else
if
(
strcmp
(
z
,
"-help"
)
==
0
){
usage
(
1
);
}
else
if
(
strcmp
(
z
,
"-cmd"
)
==
0
){
if
(
i
==
argc
-
1
)
break
;
z
=
cmdline_option_value
(
argc
,
argv
,
++
i
);
if
(
z
[
0
]
==
'.'
){
rc
=
do_meta_command
(
z
,
&
data
);
if
(
rc
&&
bail_on_error
)
return
rc
;
}
else
{
open_db
(
&
data
);
rc
=
shell_exec
(
data
.
db
,
z
,
shell_callback
,
&
data
,
&
zErrMsg
);
if
(
zErrMsg
!=
0
){
fprintf
(
stderr
,
"Error: %s
\n
"
,
zErrMsg
);
if
(
bail_on_error
)
return
rc
!=
0
?
rc
:
1
;
}
else
if
(
rc
!=
0
){
fprintf
(
stderr
,
"Error: unable to process SQL
\"
%s
\"\n
"
,
z
);
if
(
bail_on_error
)
return
rc
;
}
}
}
else
{
fprintf
(
stderr
,
"%s: Error: unknown option: %s
\n
"
,
Argv0
,
z
);
fprintf
(
stderr
,
"Use -help for a list of options.
\n
"
);
return
1
;
}
}
if
(
zFirstCmd
){
/* Run just the command that follows the database name
*/
if
(
zFirstCmd
[
0
]
==
'.'
){
rc
=
do_meta_command
(
zFirstCmd
,
&
data
);
}
else
{
open_db
(
&
data
);
rc
=
shell_exec
(
data
.
db
,
zFirstCmd
,
shell_callback
,
&
data
,
&
zErrMsg
);
if
(
zErrMsg
!=
0
){
fprintf
(
stderr
,
"Error: %s
\n
"
,
zErrMsg
);
return
rc
!=
0
?
rc
:
1
;
}
else
if
(
rc
!=
0
){
fprintf
(
stderr
,
"Error: unable to process SQL
\"
%s
\"\n
"
,
zFirstCmd
);
return
rc
;
}
}
}
else
{
/* Run commands received from standard input
*/
if
(
stdin_is_interactive
){
char
*
zHome
;
char
*
zHistory
=
0
;
int
nHistory
;
printf
(
"SQLite version %s %.19s
\n
"
/*extra-version-info*/
"Enter
\"
.help
\"
for instructions
\n
"
"Enter SQL statements terminated with a
\"
;
\"\n
"
,
sqlite3_libversion
(),
sqlite3_sourceid
()
);
zHome
=
find_home_dir
();
if
(
zHome
){
nHistory
=
strlen30
(
zHome
)
+
20
;
if
(
(
zHistory
=
malloc
(
nHistory
))
!=
0
){
sqlite3_snprintf
(
nHistory
,
zHistory
,
"%s/.sqlite_history"
,
zHome
);
}
}
#if defined(HAVE_READLINE) && HAVE_READLINE==1
if
(
zHistory
)
read_history
(
zHistory
);
#endif
rc
=
process_input
(
&
data
,
0
);
if
(
zHistory
){
stifle_history
(
100
);
write_history
(
zHistory
);
free
(
zHistory
);
}
}
else
{
rc
=
process_input
(
&
data
,
stdin
);
}
}
set_table_name
(
&
data
,
0
);
if
(
data
.
db
){
sqlite3_close
(
data
.
db
);
}
return
rc
;
}
sqlite3/sqlite3ext.h
deleted
100644 → 0
View file @
d50c1f39
/*
** 2006 June 7
**
** The author disclaims copyright to this source code. In place of
** a legal notice, here is a blessing:
**
** May you do good and not evil.
** May you find forgiveness for yourself and forgive others.
** May you share freely, never taking more than you give.
**
*************************************************************************
** This header file defines the SQLite interface for use by
** shared libraries that want to be imported as extensions into
** an SQLite instance. Shared libraries that intend to be loaded
** as extensions by SQLite should #include this file instead of
** sqlite3.h.
*/
#ifndef _SQLITE3EXT_H_
#define _SQLITE3EXT_H_
#include "sqlite3.h"
typedef
struct
sqlite3_api_routines
sqlite3_api_routines
;
/*
** The following structure holds pointers to all of the SQLite API
** routines.
**
** WARNING: In order to maintain backwards compatibility, add new
** interfaces to the end of this structure only. If you insert new
** interfaces in the middle of this structure, then older different
** versions of SQLite will not be able to load each others' shared
** libraries!
*/
struct
sqlite3_api_routines
{
void
*
(
*
aggregate_context
)(
sqlite3_context
*
,
int
nBytes
);
int
(
*
aggregate_count
)(
sqlite3_context
*
);
int
(
*
bind_blob
)(
sqlite3_stmt
*
,
int
,
const
void
*
,
int
n
,
void
(
*
)(
void
*
));
int
(
*
bind_double
)(
sqlite3_stmt
*
,
int
,
double
);
int
(
*
bind_int
)(
sqlite3_stmt
*
,
int
,
int
);
int
(
*
bind_int64
)(
sqlite3_stmt
*
,
int
,
sqlite_int64
);
int
(
*
bind_null
)(
sqlite3_stmt
*
,
int
);
int
(
*
bind_parameter_count
)(
sqlite3_stmt
*
);
int
(
*
bind_parameter_index
)(
sqlite3_stmt
*
,
const
char
*
zName
);
const
char
*
(
*
bind_parameter_name
)(
sqlite3_stmt
*
,
int
);
int
(
*
bind_text
)(
sqlite3_stmt
*
,
int
,
const
char
*
,
int
n
,
void
(
*
)(
void
*
));
int
(
*
bind_text16
)(
sqlite3_stmt
*
,
int
,
const
void
*
,
int
,
void
(
*
)(
void
*
));
int
(
*
bind_value
)(
sqlite3_stmt
*
,
int
,
const
sqlite3_value
*
);
int
(
*
busy_handler
)(
sqlite3
*
,
int
(
*
)(
void
*
,
int
),
void
*
);
int
(
*
busy_timeout
)(
sqlite3
*
,
int
ms
);
int
(
*
changes
)(
sqlite3
*
);
int
(
*
close
)(
sqlite3
*
);
int
(
*
collation_needed
)(
sqlite3
*
,
void
*
,
void
(
*
)(
void
*
,
sqlite3
*
,
int
eTextRep
,
const
char
*
));
int
(
*
collation_needed16
)(
sqlite3
*
,
void
*
,
void
(
*
)(
void
*
,
sqlite3
*
,
int
eTextRep
,
const
void
*
));
const
void
*
(
*
column_blob
)(
sqlite3_stmt
*
,
int
iCol
);
int
(
*
column_bytes
)(
sqlite3_stmt
*
,
int
iCol
);
int
(
*
column_bytes16
)(
sqlite3_stmt
*
,
int
iCol
);
int
(
*
column_count
)(
sqlite3_stmt
*
pStmt
);
const
char
*
(
*
column_database_name
)(
sqlite3_stmt
*
,
int
);
const
void
*
(
*
column_database_name16
)(
sqlite3_stmt
*
,
int
);
const
char
*
(
*
column_decltype
)(
sqlite3_stmt
*
,
int
i
);
const
void
*
(
*
column_decltype16
)(
sqlite3_stmt
*
,
int
);
double
(
*
column_double
)(
sqlite3_stmt
*
,
int
iCol
);
int
(
*
column_int
)(
sqlite3_stmt
*
,
int
iCol
);
sqlite_int64
(
*
column_int64
)(
sqlite3_stmt
*
,
int
iCol
);
const
char
*
(
*
column_name
)(
sqlite3_stmt
*
,
int
);
const
void
*
(
*
column_name16
)(
sqlite3_stmt
*
,
int
);
const
char
*
(
*
column_origin_name
)(
sqlite3_stmt
*
,
int
);
const
void
*
(
*
column_origin_name16
)(
sqlite3_stmt
*
,
int
);
const
char
*
(
*
column_table_name
)(
sqlite3_stmt
*
,
int
);
const
void
*
(
*
column_table_name16
)(
sqlite3_stmt
*
,
int
);
const
unsigned
char
*
(
*
column_text
)(
sqlite3_stmt
*
,
int
iCol
);
const
void
*
(
*
column_text16
)(
sqlite3_stmt
*
,
int
iCol
);
int
(
*
column_type
)(
sqlite3_stmt
*
,
int
iCol
);
sqlite3_value
*
(
*
column_value
)(
sqlite3_stmt
*
,
int
iCol
);
void
*
(
*
commit_hook
)(
sqlite3
*
,
int
(
*
)(
void
*
),
void
*
);
int
(
*
complete
)(
const
char
*
sql
);
int
(
*
complete16
)(
const
void
*
sql
);
int
(
*
create_collation
)(
sqlite3
*
,
const
char
*
,
int
,
void
*
,
int
(
*
)(
void
*
,
int
,
const
void
*
,
int
,
const
void
*
));
int
(
*
create_collation16
)(
sqlite3
*
,
const
void
*
,
int
,
void
*
,
int
(
*
)(
void
*
,
int
,
const
void
*
,
int
,
const
void
*
));
int
(
*
create_function
)(
sqlite3
*
,
const
char
*
,
int
,
int
,
void
*
,
void
(
*
xFunc
)(
sqlite3_context
*
,
int
,
sqlite3_value
**
),
void
(
*
xStep
)(
sqlite3_context
*
,
int
,
sqlite3_value
**
),
void
(
*
xFinal
)(
sqlite3_context
*
));
int
(
*
create_function16
)(
sqlite3
*
,
const
void
*
,
int
,
int
,
void
*
,
void
(
*
xFunc
)(
sqlite3_context
*
,
int
,
sqlite3_value
**
),
void
(
*
xStep
)(
sqlite3_context
*
,
int
,
sqlite3_value
**
),
void
(
*
xFinal
)(
sqlite3_context
*
));
int
(
*
create_module
)(
sqlite3
*
,
const
char
*
,
const
sqlite3_module
*
,
void
*
);
int
(
*
data_count
)(
sqlite3_stmt
*
pStmt
);
sqlite3
*
(
*
db_handle
)(
sqlite3_stmt
*
);
int
(
*
declare_vtab
)(
sqlite3
*
,
const
char
*
);
int
(
*
enable_shared_cache
)(
int
);
int
(
*
errcode
)(
sqlite3
*
db
);
const
char
*
(
*
errmsg
)(
sqlite3
*
);
const
void
*
(
*
errmsg16
)(
sqlite3
*
);
int
(
*
exec
)(
sqlite3
*
,
const
char
*
,
sqlite3_callback
,
void
*
,
char
**
);
int
(
*
expired
)(
sqlite3_stmt
*
);
int
(
*
finalize
)(
sqlite3_stmt
*
pStmt
);
void
(
*
free
)(
void
*
);
void
(
*
free_table
)(
char
**
result
);
int
(
*
get_autocommit
)(
sqlite3
*
);
void
*
(
*
get_auxdata
)(
sqlite3_context
*
,
int
);
int
(
*
get_table
)(
sqlite3
*
,
const
char
*
,
char
***
,
int
*
,
int
*
,
char
**
);
int
(
*
global_recover
)(
void
);
void
(
*
interruptx
)(
sqlite3
*
);
sqlite_int64
(
*
last_insert_rowid
)(
sqlite3
*
);
const
char
*
(
*
libversion
)(
void
);
int
(
*
libversion_number
)(
void
);
void
*
(
*
malloc
)(
int
);
char
*
(
*
mprintf
)(
const
char
*
,...);
int
(
*
open
)(
const
char
*
,
sqlite3
**
);
int
(
*
open16
)(
const
void
*
,
sqlite3
**
);
int
(
*
prepare
)(
sqlite3
*
,
const
char
*
,
int
,
sqlite3_stmt
**
,
const
char
**
);
int
(
*
prepare16
)(
sqlite3
*
,
const
void
*
,
int
,
sqlite3_stmt
**
,
const
void
**
);
void
*
(
*
profile
)(
sqlite3
*
,
void
(
*
)(
void
*
,
const
char
*
,
sqlite_uint64
),
void
*
);
void
(
*
progress_handler
)(
sqlite3
*
,
int
,
int
(
*
)(
void
*
),
void
*
);
void
*
(
*
realloc
)(
void
*
,
int
);
int
(
*
reset
)(
sqlite3_stmt
*
pStmt
);
void
(
*
result_blob
)(
sqlite3_context
*
,
const
void
*
,
int
,
void
(
*
)(
void
*
));
void
(
*
result_double
)(
sqlite3_context
*
,
double
);
void
(
*
result_error
)(
sqlite3_context
*
,
const
char
*
,
int
);
void
(
*
result_error16
)(
sqlite3_context
*
,
const
void
*
,
int
);
void
(
*
result_int
)(
sqlite3_context
*
,
int
);
void
(
*
result_int64
)(
sqlite3_context
*
,
sqlite_int64
);
void
(
*
result_null
)(
sqlite3_context
*
);
void
(
*
result_text
)(
sqlite3_context
*
,
const
char
*
,
int
,
void
(
*
)(
void
*
));
void
(
*
result_text16
)(
sqlite3_context
*
,
const
void
*
,
int
,
void
(
*
)(
void
*
));
void
(
*
result_text16be
)(
sqlite3_context
*
,
const
void
*
,
int
,
void
(
*
)(
void
*
));
void
(
*
result_text16le
)(
sqlite3_context
*
,
const
void
*
,
int
,
void
(
*
)(
void
*
));
void
(
*
result_value
)(
sqlite3_context
*
,
sqlite3_value
*
);
void
*
(
*
rollback_hook
)(
sqlite3
*
,
void
(
*
)(
void
*
),
void
*
);
int
(
*
set_authorizer
)(
sqlite3
*
,
int
(
*
)(
void
*
,
int
,
const
char
*
,
const
char
*
,
const
char
*
,
const
char
*
),
void
*
);
void
(
*
set_auxdata
)(
sqlite3_context
*
,
int
,
void
*
,
void
(
*
)(
void
*
));
char
*
(
*
snprintf
)(
int
,
char
*
,
const
char
*
,...);
int
(
*
step
)(
sqlite3_stmt
*
);
int
(
*
table_column_metadata
)(
sqlite3
*
,
const
char
*
,
const
char
*
,
const
char
*
,
char
const
**
,
char
const
**
,
int
*
,
int
*
,
int
*
);
void
(
*
thread_cleanup
)(
void
);
int
(
*
total_changes
)(
sqlite3
*
);
void
*
(
*
trace
)(
sqlite3
*
,
void
(
*
xTrace
)(
void
*
,
const
char
*
),
void
*
);
int
(
*
transfer_bindings
)(
sqlite3_stmt
*
,
sqlite3_stmt
*
);
void
*
(
*
update_hook
)(
sqlite3
*
,
void
(
*
)(
void
*
,
int
,
char
const
*
,
char
const
*
,
sqlite_int64
),
void
*
);
void
*
(
*
user_data
)(
sqlite3_context
*
);
const
void
*
(
*
value_blob
)(
sqlite3_value
*
);
int
(
*
value_bytes
)(
sqlite3_value
*
);
int
(
*
value_bytes16
)(
sqlite3_value
*
);
double
(
*
value_double
)(
sqlite3_value
*
);
int
(
*
value_int
)(
sqlite3_value
*
);
sqlite_int64
(
*
value_int64
)(
sqlite3_value
*
);
int
(
*
value_numeric_type
)(
sqlite3_value
*
);
const
unsigned
char
*
(
*
value_text
)(
sqlite3_value
*
);
const
void
*
(
*
value_text16
)(
sqlite3_value
*
);
const
void
*
(
*
value_text16be
)(
sqlite3_value
*
);
const
void
*
(
*
value_text16le
)(
sqlite3_value
*
);
int
(
*
value_type
)(
sqlite3_value
*
);
char
*
(
*
vmprintf
)(
const
char
*
,
va_list
);
/* Added ??? */
int
(
*
overload_function
)(
sqlite3
*
,
const
char
*
zFuncName
,
int
nArg
);
/* Added by 3.3.13 */
int
(
*
prepare_v2
)(
sqlite3
*
,
const
char
*
,
int
,
sqlite3_stmt
**
,
const
char
**
);
int
(
*
prepare16_v2
)(
sqlite3
*
,
const
void
*
,
int
,
sqlite3_stmt
**
,
const
void
**
);
int
(
*
clear_bindings
)(
sqlite3_stmt
*
);
/* Added by 3.4.1 */
int
(
*
create_module_v2
)(
sqlite3
*
,
const
char
*
,
const
sqlite3_module
*
,
void
*
,
void
(
*
xDestroy
)(
void
*
));
/* Added by 3.5.0 */
int
(
*
bind_zeroblob
)(
sqlite3_stmt
*
,
int
,
int
);
int
(
*
blob_bytes
)(
sqlite3_blob
*
);
int
(
*
blob_close
)(
sqlite3_blob
*
);
int
(
*
blob_open
)(
sqlite3
*
,
const
char
*
,
const
char
*
,
const
char
*
,
sqlite3_int64
,
int
,
sqlite3_blob
**
);
int
(
*
blob_read
)(
sqlite3_blob
*
,
void
*
,
int
,
int
);
int
(
*
blob_write
)(
sqlite3_blob
*
,
const
void
*
,
int
,
int
);
int
(
*
create_collation_v2
)(
sqlite3
*
,
const
char
*
,
int
,
void
*
,
int
(
*
)(
void
*
,
int
,
const
void
*
,
int
,
const
void
*
),
void
(
*
)(
void
*
));
int
(
*
file_control
)(
sqlite3
*
,
const
char
*
,
int
,
void
*
);
sqlite3_int64
(
*
memory_highwater
)(
int
);
sqlite3_int64
(
*
memory_used
)(
void
);
sqlite3_mutex
*
(
*
mutex_alloc
)(
int
);
void
(
*
mutex_enter
)(
sqlite3_mutex
*
);
void
(
*
mutex_free
)(
sqlite3_mutex
*
);
void
(
*
mutex_leave
)(
sqlite3_mutex
*
);
int
(
*
mutex_try
)(
sqlite3_mutex
*
);
int
(
*
open_v2
)(
const
char
*
,
sqlite3
**
,
int
,
const
char
*
);
int
(
*
release_memory
)(
int
);
void
(
*
result_error_nomem
)(
sqlite3_context
*
);
void
(
*
result_error_toobig
)(
sqlite3_context
*
);
int
(
*
sleep
)(
int
);
void
(
*
soft_heap_limit
)(
int
);
sqlite3_vfs
*
(
*
vfs_find
)(
const
char
*
);
int
(
*
vfs_register
)(
sqlite3_vfs
*
,
int
);
int
(
*
vfs_unregister
)(
sqlite3_vfs
*
);
int
(
*
xthreadsafe
)(
void
);
void
(
*
result_zeroblob
)(
sqlite3_context
*
,
int
);
void
(
*
result_error_code
)(
sqlite3_context
*
,
int
);
int
(
*
test_control
)(
int
,
...);
void
(
*
randomness
)(
int
,
void
*
);
sqlite3
*
(
*
context_db_handle
)(
sqlite3_context
*
);
int
(
*
extended_result_codes
)(
sqlite3
*
,
int
);
int
(
*
limit
)(
sqlite3
*
,
int
,
int
);
sqlite3_stmt
*
(
*
next_stmt
)(
sqlite3
*
,
sqlite3_stmt
*
);
const
char
*
(
*
sql
)(
sqlite3_stmt
*
);
int
(
*
status
)(
int
,
int
*
,
int
*
,
int
);
int
(
*
backup_finish
)(
sqlite3_backup
*
);
sqlite3_backup
*
(
*
backup_init
)(
sqlite3
*
,
const
char
*
,
sqlite3
*
,
const
char
*
);
int
(
*
backup_pagecount
)(
sqlite3_backup
*
);
int
(
*
backup_remaining
)(
sqlite3_backup
*
);
int
(
*
backup_step
)(
sqlite3_backup
*
,
int
);
const
char
*
(
*
compileoption_get
)(
int
);
int
(
*
compileoption_used
)(
const
char
*
);
int
(
*
create_function_v2
)(
sqlite3
*
,
const
char
*
,
int
,
int
,
void
*
,
void
(
*
xFunc
)(
sqlite3_context
*
,
int
,
sqlite3_value
**
),
void
(
*
xStep
)(
sqlite3_context
*
,
int
,
sqlite3_value
**
),
void
(
*
xFinal
)(
sqlite3_context
*
),
void
(
*
xDestroy
)(
void
*
));
int
(
*
db_config
)(
sqlite3
*
,
int
,...);
sqlite3_mutex
*
(
*
db_mutex
)(
sqlite3
*
);
int
(
*
db_status
)(
sqlite3
*
,
int
,
int
*
,
int
*
,
int
);
int
(
*
extended_errcode
)(
sqlite3
*
);
void
(
*
log
)(
int
,
const
char
*
,...);
sqlite3_int64
(
*
soft_heap_limit64
)(
sqlite3_int64
);
const
char
*
(
*
sourceid
)(
void
);
int
(
*
stmt_status
)(
sqlite3_stmt
*
,
int
,
int
);
int
(
*
strnicmp
)(
const
char
*
,
const
char
*
,
int
);
int
(
*
unlock_notify
)(
sqlite3
*
,
void
(
*
)(
void
**
,
int
),
void
*
);
int
(
*
wal_autocheckpoint
)(
sqlite3
*
,
int
);
int
(
*
wal_checkpoint
)(
sqlite3
*
,
const
char
*
);
void
*
(
*
wal_hook
)(
sqlite3
*
,
int
(
*
)(
void
*
,
sqlite3
*
,
const
char
*
,
int
),
void
*
);
int
(
*
blob_reopen
)(
sqlite3_blob
*
,
sqlite3_int64
);
int
(
*
vtab_config
)(
sqlite3
*
,
int
op
,...);
int
(
*
vtab_on_conflict
)(
sqlite3
*
);
};
/*
** The following macros redefine the API routines so that they are
** redirected throught the global sqlite3_api structure.
**
** This header file is also used by the loadext.c source file
** (part of the main SQLite library - not an extension) so that
** it can get access to the sqlite3_api_routines structure
** definition. But the main library does not want to redefine
** the API. So the redefinition macros are only valid if the
** SQLITE_CORE macros is undefined.
*/
#ifndef SQLITE_CORE
#define sqlite3_aggregate_context sqlite3_api->aggregate_context
#ifndef SQLITE_OMIT_DEPRECATED
#define sqlite3_aggregate_count sqlite3_api->aggregate_count
#endif
#define sqlite3_bind_blob sqlite3_api->bind_blob
#define sqlite3_bind_double sqlite3_api->bind_double
#define sqlite3_bind_int sqlite3_api->bind_int
#define sqlite3_bind_int64 sqlite3_api->bind_int64
#define sqlite3_bind_null sqlite3_api->bind_null
#define sqlite3_bind_parameter_count sqlite3_api->bind_parameter_count
#define sqlite3_bind_parameter_index sqlite3_api->bind_parameter_index
#define sqlite3_bind_parameter_name sqlite3_api->bind_parameter_name
#define sqlite3_bind_text sqlite3_api->bind_text
#define sqlite3_bind_text16 sqlite3_api->bind_text16
#define sqlite3_bind_value sqlite3_api->bind_value
#define sqlite3_busy_handler sqlite3_api->busy_handler
#define sqlite3_busy_timeout sqlite3_api->busy_timeout
#define sqlite3_changes sqlite3_api->changes
#define sqlite3_close sqlite3_api->close
#define sqlite3_collation_needed sqlite3_api->collation_needed
#define sqlite3_collation_needed16 sqlite3_api->collation_needed16
#define sqlite3_column_blob sqlite3_api->column_blob
#define sqlite3_column_bytes sqlite3_api->column_bytes
#define sqlite3_column_bytes16 sqlite3_api->column_bytes16
#define sqlite3_column_count sqlite3_api->column_count
#define sqlite3_column_database_name sqlite3_api->column_database_name
#define sqlite3_column_database_name16 sqlite3_api->column_database_name16
#define sqlite3_column_decltype sqlite3_api->column_decltype
#define sqlite3_column_decltype16 sqlite3_api->column_decltype16
#define sqlite3_column_double sqlite3_api->column_double
#define sqlite3_column_int sqlite3_api->column_int
#define sqlite3_column_int64 sqlite3_api->column_int64
#define sqlite3_column_name sqlite3_api->column_name
#define sqlite3_column_name16 sqlite3_api->column_name16
#define sqlite3_column_origin_name sqlite3_api->column_origin_name
#define sqlite3_column_origin_name16 sqlite3_api->column_origin_name16
#define sqlite3_column_table_name sqlite3_api->column_table_name
#define sqlite3_column_table_name16 sqlite3_api->column_table_name16
#define sqlite3_column_text sqlite3_api->column_text
#define sqlite3_column_text16 sqlite3_api->column_text16
#define sqlite3_column_type sqlite3_api->column_type
#define sqlite3_column_value sqlite3_api->column_value
#define sqlite3_commit_hook sqlite3_api->commit_hook
#define sqlite3_complete sqlite3_api->complete
#define sqlite3_complete16 sqlite3_api->complete16
#define sqlite3_create_collation sqlite3_api->create_collation
#define sqlite3_create_collation16 sqlite3_api->create_collation16
#define sqlite3_create_function sqlite3_api->create_function
#define sqlite3_create_function16 sqlite3_api->create_function16
#define sqlite3_create_module sqlite3_api->create_module
#define sqlite3_create_module_v2 sqlite3_api->create_module_v2
#define sqlite3_data_count sqlite3_api->data_count
#define sqlite3_db_handle sqlite3_api->db_handle
#define sqlite3_declare_vtab sqlite3_api->declare_vtab
#define sqlite3_enable_shared_cache sqlite3_api->enable_shared_cache
#define sqlite3_errcode sqlite3_api->errcode
#define sqlite3_errmsg sqlite3_api->errmsg
#define sqlite3_errmsg16 sqlite3_api->errmsg16
#define sqlite3_exec sqlite3_api->exec
#ifndef SQLITE_OMIT_DEPRECATED
#define sqlite3_expired sqlite3_api->expired
#endif
#define sqlite3_finalize sqlite3_api->finalize
#define sqlite3_free sqlite3_api->free
#define sqlite3_free_table sqlite3_api->free_table
#define sqlite3_get_autocommit sqlite3_api->get_autocommit
#define sqlite3_get_auxdata sqlite3_api->get_auxdata
#define sqlite3_get_table sqlite3_api->get_table
#ifndef SQLITE_OMIT_DEPRECATED
#define sqlite3_global_recover sqlite3_api->global_recover
#endif
#define sqlite3_interrupt sqlite3_api->interruptx
#define sqlite3_last_insert_rowid sqlite3_api->last_insert_rowid
#define sqlite3_libversion sqlite3_api->libversion
#define sqlite3_libversion_number sqlite3_api->libversion_number
#define sqlite3_malloc sqlite3_api->malloc
#define sqlite3_mprintf sqlite3_api->mprintf
#define sqlite3_open sqlite3_api->open
#define sqlite3_open16 sqlite3_api->open16
#define sqlite3_prepare sqlite3_api->prepare
#define sqlite3_prepare16 sqlite3_api->prepare16
#define sqlite3_prepare_v2 sqlite3_api->prepare_v2
#define sqlite3_prepare16_v2 sqlite3_api->prepare16_v2
#define sqlite3_profile sqlite3_api->profile
#define sqlite3_progress_handler sqlite3_api->progress_handler
#define sqlite3_realloc sqlite3_api->realloc
#define sqlite3_reset sqlite3_api->reset
#define sqlite3_result_blob sqlite3_api->result_blob
#define sqlite3_result_double sqlite3_api->result_double
#define sqlite3_result_error sqlite3_api->result_error
#define sqlite3_result_error16 sqlite3_api->result_error16
#define sqlite3_result_int sqlite3_api->result_int
#define sqlite3_result_int64 sqlite3_api->result_int64
#define sqlite3_result_null sqlite3_api->result_null
#define sqlite3_result_text sqlite3_api->result_text
#define sqlite3_result_text16 sqlite3_api->result_text16
#define sqlite3_result_text16be sqlite3_api->result_text16be
#define sqlite3_result_text16le sqlite3_api->result_text16le
#define sqlite3_result_value sqlite3_api->result_value
#define sqlite3_rollback_hook sqlite3_api->rollback_hook
#define sqlite3_set_authorizer sqlite3_api->set_authorizer
#define sqlite3_set_auxdata sqlite3_api->set_auxdata
#define sqlite3_snprintf sqlite3_api->snprintf
#define sqlite3_step sqlite3_api->step
#define sqlite3_table_column_metadata sqlite3_api->table_column_metadata
#define sqlite3_thread_cleanup sqlite3_api->thread_cleanup
#define sqlite3_total_changes sqlite3_api->total_changes
#define sqlite3_trace sqlite3_api->trace
#ifndef SQLITE_OMIT_DEPRECATED
#define sqlite3_transfer_bindings sqlite3_api->transfer_bindings
#endif
#define sqlite3_update_hook sqlite3_api->update_hook
#define sqlite3_user_data sqlite3_api->user_data
#define sqlite3_value_blob sqlite3_api->value_blob
#define sqlite3_value_bytes sqlite3_api->value_bytes
#define sqlite3_value_bytes16 sqlite3_api->value_bytes16
#define sqlite3_value_double sqlite3_api->value_double
#define sqlite3_value_int sqlite3_api->value_int
#define sqlite3_value_int64 sqlite3_api->value_int64
#define sqlite3_value_numeric_type sqlite3_api->value_numeric_type
#define sqlite3_value_text sqlite3_api->value_text
#define sqlite3_value_text16 sqlite3_api->value_text16
#define sqlite3_value_text16be sqlite3_api->value_text16be
#define sqlite3_value_text16le sqlite3_api->value_text16le
#define sqlite3_value_type sqlite3_api->value_type
#define sqlite3_vmprintf sqlite3_api->vmprintf
#define sqlite3_overload_function sqlite3_api->overload_function
#define sqlite3_prepare_v2 sqlite3_api->prepare_v2
#define sqlite3_prepare16_v2 sqlite3_api->prepare16_v2
#define sqlite3_clear_bindings sqlite3_api->clear_bindings
#define sqlite3_bind_zeroblob sqlite3_api->bind_zeroblob
#define sqlite3_blob_bytes sqlite3_api->blob_bytes
#define sqlite3_blob_close sqlite3_api->blob_close
#define sqlite3_blob_open sqlite3_api->blob_open
#define sqlite3_blob_read sqlite3_api->blob_read
#define sqlite3_blob_write sqlite3_api->blob_write
#define sqlite3_create_collation_v2 sqlite3_api->create_collation_v2
#define sqlite3_file_control sqlite3_api->file_control
#define sqlite3_memory_highwater sqlite3_api->memory_highwater
#define sqlite3_memory_used sqlite3_api->memory_used
#define sqlite3_mutex_alloc sqlite3_api->mutex_alloc
#define sqlite3_mutex_enter sqlite3_api->mutex_enter
#define sqlite3_mutex_free sqlite3_api->mutex_free
#define sqlite3_mutex_leave sqlite3_api->mutex_leave
#define sqlite3_mutex_try sqlite3_api->mutex_try
#define sqlite3_open_v2 sqlite3_api->open_v2
#define sqlite3_release_memory sqlite3_api->release_memory
#define sqlite3_result_error_nomem sqlite3_api->result_error_nomem
#define sqlite3_result_error_toobig sqlite3_api->result_error_toobig
#define sqlite3_sleep sqlite3_api->sleep
#define sqlite3_soft_heap_limit sqlite3_api->soft_heap_limit
#define sqlite3_vfs_find sqlite3_api->vfs_find
#define sqlite3_vfs_register sqlite3_api->vfs_register
#define sqlite3_vfs_unregister sqlite3_api->vfs_unregister
#define sqlite3_threadsafe sqlite3_api->xthreadsafe
#define sqlite3_result_zeroblob sqlite3_api->result_zeroblob
#define sqlite3_result_error_code sqlite3_api->result_error_code
#define sqlite3_test_control sqlite3_api->test_control
#define sqlite3_randomness sqlite3_api->randomness
#define sqlite3_context_db_handle sqlite3_api->context_db_handle
#define sqlite3_extended_result_codes sqlite3_api->extended_result_codes
#define sqlite3_limit sqlite3_api->limit
#define sqlite3_next_stmt sqlite3_api->next_stmt
#define sqlite3_sql sqlite3_api->sql
#define sqlite3_status sqlite3_api->status
#define sqlite3_backup_finish sqlite3_api->backup_finish
#define sqlite3_backup_init sqlite3_api->backup_init
#define sqlite3_backup_pagecount sqlite3_api->backup_pagecount
#define sqlite3_backup_remaining sqlite3_api->backup_remaining
#define sqlite3_backup_step sqlite3_api->backup_step
#define sqlite3_compileoption_get sqlite3_api->compileoption_get
#define sqlite3_compileoption_used sqlite3_api->compileoption_used
#define sqlite3_create_function_v2 sqlite3_api->create_function_v2
#define sqlite3_db_config sqlite3_api->db_config
#define sqlite3_db_mutex sqlite3_api->db_mutex
#define sqlite3_db_status sqlite3_api->db_status
#define sqlite3_extended_errcode sqlite3_api->extended_errcode
#define sqlite3_log sqlite3_api->log
#define sqlite3_soft_heap_limit64 sqlite3_api->soft_heap_limit64
#define sqlite3_sourceid sqlite3_api->sourceid
#define sqlite3_stmt_status sqlite3_api->stmt_status
#define sqlite3_strnicmp sqlite3_api->strnicmp
#define sqlite3_unlock_notify sqlite3_api->unlock_notify
#define sqlite3_wal_autocheckpoint sqlite3_api->wal_autocheckpoint
#define sqlite3_wal_checkpoint sqlite3_api->wal_checkpoint
#define sqlite3_wal_hook sqlite3_api->wal_hook
#define sqlite3_blob_reopen sqlite3_api->blob_reopen
#define sqlite3_vtab_config sqlite3_api->vtab_config
#define sqlite3_vtab_on_conflict sqlite3_api->vtab_on_conflict
#endif
/* SQLITE_CORE */
#define SQLITE_EXTENSION_INIT1 const sqlite3_api_routines *sqlite3_api = 0;
#define SQLITE_EXTENSION_INIT2(v) sqlite3_api = v;
#endif
/* _SQLITE3EXT_H_ */
su.c
View file @
17e395c2
...
@@ -125,6 +125,7 @@ void exec_logw(const char* fmt, ...) {
...
@@ -125,6 +125,7 @@ void exec_logw(const char* fmt, ...) {
}
}
void
exec_logd
(
const
char
*
fmt
,
...)
{
void
exec_logd
(
const
char
*
fmt
,
...)
{
#ifdef DEBUG
va_list
args
;
va_list
args
;
char
logline
[
PATH_MAX
];
char
logline
[
PATH_MAX
];
...
@@ -132,6 +133,7 @@ void exec_logd(const char* fmt, ...) {
...
@@ -132,6 +133,7 @@ void exec_logd(const char* fmt, ...) {
vsnprintf
(
logline
,
PATH_MAX
,
fmt
,
args
);
vsnprintf
(
logline
,
PATH_MAX
,
fmt
,
args
);
va_end
(
args
);
va_end
(
args
);
exec_log
(
"d"
,
logline
);
exec_log
(
"d"
,
logline
);
#endif
}
}
static
int
from_init
(
struct
su_initiator
*
from
)
{
static
int
from_init
(
struct
su_initiator
*
from
)
{
...
...
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment