shell.c File Reference

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <assert.h>
#include <math.h>
#include "sqlite3.h"
#include <ctype.h>
#include <stdarg.h>
#include <signal.h>
#include <pwd.h>
#include <unistd.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <memory.h>
#include <limits.h>
#include <fcntl.h>
#include <utime.h>
#include <time.h>
#include <errno.h>

Include dependency graph for shell.c:

Go to the source code of this file.

Data Structures
struct	DynaPrompt
struct	ShellText
struct	SHA3Context
struct	SHA1Context
struct	Decimal
struct	Percentile
struct	PercentileFunc
struct	SequenceSpec
struct	series_cursor
struct	ReStateSet
struct	ReInput
struct	ReCompiled
struct	FsdirLevel
struct	fsdir_cursor
struct	fsdir_tab
struct	completion_vtab
struct	completion_cursor
struct	ApndFile
struct	IdxConstraint
struct	IdxScan
struct	IdxColumn
struct	IdxTable
struct	IdxWrite
struct	IdxStatement
struct	IdxHashEntry
struct	IdxHash
struct	sqlite3expert
struct	ExpertVtab
struct	ExpertCsr
struct	IdxSampleCtx
struct	IdxRemCtx
struct	IdxRemCtx::IdxRemSlot
struct	sqlite3_intck
struct	Stmtrand
struct	vfstrace_info
struct	vfstrace_file
struct	ExpertInfo
struct	EQPGraphRow
struct	EQPGraph
struct	ColModeOpts
struct	ShellState
struct	ShellState::AuxDb
struct	ImportCtx
union	SHA3Context.u

Macros
#define	SHELL_STRINGIFY_(f)
#define	SHELL_STRINGIFY(f)
#define	SQLITE_OS_WINRT   0
#define	_LARGE_FILE   1
#define	_FILE_OFFSET_BITS   64
#define	_LARGEFILE_SOURCE   1
#define	GETPID   getpid
#define	shell_read_history(X)
#define	shell_write_history(X)
#define	shell_stifle_history(X)
#define	SHELL_USE_LOCAL_GETLINE   1
#define	deliberate_fall_through
#define	IsSpace(X)
#define	IsDigit(X)
#define	ToLower(X)
#define	IsAlnum(X)
#define	IsAlpha(X)
#define	_SQLITE3_STDIO_H_   1
#define	sqlite3_fopen   fopen
#define	sqlite3_popen   popen
#define	sqlite3_fgets   fgets
#define	sqlite3_fputs   fputs
#define	sqlite3_fprintf   fprintf
#define	sqlite3_fsetmode(F, X)
#define	SQLITE_INTERNAL_LINKAGE   static
#define	eputz(z)
#define	sputz(fp, z)
#define	BEGIN_TIMER   beginTimer()
#define	END_TIMER(X)
#define	HAS_TIMER   1
#define	UNUSED_PARAMETER(x)
#define	ArraySize(X)
#define	PROMPT_LEN_MAX   128
#define	CONTINUATION_PROMPT   dynamicContinuePrompt()
#define	CONTINUE_PROMPT_RESET    do {setLexemeOpen(&dynPrompt,0,0); trackParenLevel(&dynPrompt,0);} while(0)
#define	CONTINUE_PROMPT_AWAITS(p, s)
#define	CONTINUE_PROMPT_AWAITC(p, c)
#define	CONTINUE_PAREN_INCR(p, n)
#define	CONTINUE_PROMPT_PSTATE   (&dynPrompt)
#define	SCAN_TRACKER_REFTYPE   t_DynaPromptRef
#define	STAT_CHR_SRC(mode)
#define	SQLITE_EXTENSION_INIT1
#define	SQLITE_EXTENSION_INIT2(X)
#define	SHA3_BYTEORDER   0
#define	a00   (p->u.s[0])
#define	a01   (p->u.s[1])
#define	a02   (p->u.s[2])
#define	a03   (p->u.s[3])
#define	a04   (p->u.s[4])
#define	a10   (p->u.s[5])
#define	a11   (p->u.s[6])
#define	a12   (p->u.s[7])
#define	a13   (p->u.s[8])
#define	a14   (p->u.s[9])
#define	a20   (p->u.s[10])
#define	a21   (p->u.s[11])
#define	a22   (p->u.s[12])
#define	a23   (p->u.s[13])
#define	a24   (p->u.s[14])
#define	a30   (p->u.s[15])
#define	a31   (p->u.s[16])
#define	a32   (p->u.s[17])
#define	a33   (p->u.s[18])
#define	a34   (p->u.s[19])
#define	a40   (p->u.s[20])
#define	a41   (p->u.s[21])
#define	a42   (p->u.s[22])
#define	a43   (p->u.s[23])
#define	a44   (p->u.s[24])
#define	ROL64(a, x)
#define	SHA_ROT(x, l, r)
#define	rol(x, k)
#define	ror(x, k)
#define	blk0le(i)
#define	blk0be(i)
#define	blk(i)
#define	Rl0(v, w, x, y, z, i)
#define	Rb0(v, w, x, y, z, i)
#define	R1(v, w, x, y, z, i)
#define	R2(v, w, x, y, z, i)
#define	R3(v, w, x, y, z, i)
#define	R4(v, w, x, y, z, i)
#define	a   qq[0]
#define	b   qq[1]
#define	c   qq[2]
#define	d   qq[3]
#define	e   qq[4]
#define	SWAP_DOUBLE(X, Y)
#define	sqlite3_base_init   sqlite3_base64_init
#define	PC   0x80 /* pad character */
#define	WS   0x81 /* whitespace */
#define	ND   0x82 /* Not above or digit-value */
#define	PAD_CHAR   '='
#define	U8_TYPEDEF
#define	BX_DV_PROTO(c)
#define	IS_BX_DIGIT(bdp)
#define	IS_BX_WS(bdp)
#define	IS_BX_PAD(bdp)
#define	BX_NUMERAL(dv)
#define	B64_DARK_MAX   72
#define	BASE64_INIT(db)
#define	BASE64_EXPOSE(db, pzErr)
#define	sqlite3_base_init   sqlite3_base85_init
#define	OMIT_BASE85_CHECKER
#define	B85_CLASS(c)
#define	B85_DNOS(c)
#define	IS_B85(c)
#define	B85_DARK_MAX   80
#define	base85Numeral(dn)
#define	BASE85_INIT(db)
#define	BASE85_EXPOSE(db, pzErr)
#define	SERIES_COLUMN_ROWID   (-1)
#define	SERIES_COLUMN_VALUE   0
#define	SERIES_COLUMN_START   1
#define	SERIES_COLUMN_STOP   2
#define	SERIES_COLUMN_STEP   3
#define	LARGEST_INT64   (0xffffffff|(((sqlite3_int64)0x7fffffff)<<32))
#define	LARGEST_UINT64   (0xffffffff|(((sqlite3_uint64)0xffffffff)<<32))
#define	SMALLEST_INT64   (((sqlite3_int64)-1) - LARGEST_INT64)
#define	SQLITE_SERIES_CONSTRAINT_VERIFY   0
#define	re_match   sqlite3re_match
#define	re_compile   sqlite3re_compile
#define	re_free   sqlite3re_free
#define	RE_EOF   0 /* End of input */
#define	RE_START   0xfffffff /* Start of input - larger than an UTF-8 */
#define	RE_OP_MATCH   1 /* Match the one character in the argument */
#define	RE_OP_ANY   2 /* Match any one character. (Implements ".") */
#define	RE_OP_ANYSTAR   3 /* Special optimized version of .* */
#define	RE_OP_FORK   4 /* Continue to both next and opcode at iArg */
#define	RE_OP_GOTO   5 /* Jump to opcode at iArg */
#define	RE_OP_ACCEPT   6 /* Halt and indicate a successful match */
#define	RE_OP_CC_INC   7 /* Beginning of a [...] character class */
#define	RE_OP_CC_EXC   8 /* Beginning of a [^...] character class */
#define	RE_OP_CC_VALUE   9 /* Single value in a character class */
#define	RE_OP_CC_RANGE   10 /* Range of values in a character class */
#define	RE_OP_WORD   11 /* Perl word character [A-Za-z0-9_] */
#define	RE_OP_NOTWORD   12 /* Not a perl word character */
#define	RE_OP_DIGIT   13 /* digit: [0-9] */
#define	RE_OP_NOTDIGIT   14 /* Not a digit */
#define	RE_OP_SPACE   15 /* space: [ \t\n\r\v\f] */
#define	RE_OP_NOTSPACE   16 /* Not a digit */
#define	RE_OP_BOUNDARY   17 /* Boundary between word and non-word */
#define	RE_OP_ATSTART   18 /* Currently at the start of the string */
#define	STRUCT_STAT   struct stat
#define	FSDIR_SCHEMA   "(name,mode,mtime,data,path HIDDEN,dir HIDDEN)"
#define	FSDIR_COLUMN_NAME   0 /* Name of the file */
#define	FSDIR_COLUMN_MODE   1 /* Access mode */
#define	FSDIR_COLUMN_MTIME   2 /* Last modification time */
#define	FSDIR_COLUMN_DATA   3 /* File content */
#define	FSDIR_COLUMN_PATH   4 /* Path to top of search */
#define	FSDIR_COLUMN_DIR   5 /* Path is relative to this directory */
#define	COMPLETION_FIRST_PHASE   1
#define	COMPLETION_KEYWORDS   1
#define	COMPLETION_PRAGMAS   2
#define	COMPLETION_FUNCTIONS   3
#define	COMPLETION_COLLATIONS   4
#define	COMPLETION_INDEXES   5
#define	COMPLETION_TRIGGERS   6
#define	COMPLETION_DATABASES   7
#define	COMPLETION_TABLES   8 /* Also VIEWs and TRIGGERs */
#define	COMPLETION_COLUMNS   9
#define	COMPLETION_MODULES   10
#define	COMPLETION_EOF   11
#define	COMPLETION_COLUMN_CANDIDATE   0 /* Suggested completion of the input */
#define	COMPLETION_COLUMN_PREFIX   1 /* Prefix of the word to be completed */
#define	COMPLETION_COLUMN_WHOLELINE   2 /* Entire line seen so far */
#define	COMPLETION_COLUMN_PHASE   3 /* ePhase - used for debugging only */
#define	APND_MARK_PREFIX   "Start-Of-SQLite3-"
#define	APND_MARK_PREFIX_SZ   17
#define	APND_MARK_FOS_SZ   8
#define	APND_MARK_SIZE   (APND_MARK_PREFIX_SZ+APND_MARK_FOS_SZ)
#define	APND_MAX_SIZE   (0x40000000)
#define	APND_ROUNDUP   4096
#define	APND_ALIGN_MASK   ((sqlite3_int64)(APND_ROUNDUP-1))
#define	APND_START_ROUNDUP(fsz)
#define	ORIGVFS(p)
#define	ORIGFILE(p)
#define	SQLITEEXPERT_H   1
#define	EXPERT_CONFIG_SAMPLE   1 /* int */
#define	EXPERT_REPORT_SQL   1
#define	EXPERT_REPORT_INDEXES   2
#define	EXPERT_REPORT_PLAN   3
#define	EXPERT_REPORT_CANDIDATES   4
#define	ALWAYS(X)
#define	NEVER(X)
#define	STRLEN   (int)strlen
#define	UNIQUE_TABLE_NAME   "t592690916721053953805701627921227776"
#define	IDX_HASH_SIZE   1023
#define	_SQLITE_INTCK_H
#define	STMTRAND_KEY   (-4418371)
#define	VTR_CLOSE   0x00000001
#define	VTR_READ   0x00000002
#define	VTR_WRITE   0x00000004
#define	VTR_TRUNC   0x00000008
#define	VTR_SYNC   0x00000010
#define	VTR_FSIZE   0x00000020
#define	VTR_LOCK   0x00000040
#define	VTR_UNLOCK   0x00000080
#define	VTR_CRL   0x00000100
#define	VTR_FCTRL   0x00000200
#define	VTR_SECSZ   0x00000400
#define	VTR_DEVCHAR   0x00000800
#define	VTR_SHMLOCK   0x00001000
#define	VTR_SHMMAP   0x00002000
#define	VTR_SHMBAR   0x00004000
#define	VTR_SHMUNMAP   0x00008000
#define	VTR_OPEN   0x00010000
#define	VTR_DELETE   0x00020000
#define	VTR_ACCESS   0x00040000
#define	VTR_FULLPATH   0x00080000
#define	VTR_DLOPEN   0x00100000
#define	VTR_DLERR   0x00200000
#define	VTR_DLSYM   0x00400000
#define	VTR_DLCLOSE   0x00800000
#define	VTR_RAND   0x01000000
#define	VTR_SLEEP   0x02000000
#define	VTR_CURTIME   0x04000000
#define	VTR_LASTERR   0x08000000
#define	VTR_FETCH   0x10000000 /* Also coverse xUnfetch */
#define	SQLITE_SHELL_HAVE_RECOVER   0
#define	ColModeOpts_default   { 60, 0, 0 }
#define	ColModeOpts_default_qbox   { 60, 1, 0 }
#define	AUTOEQP_off   0 /* Automatic EXPLAIN QUERY PLAN is off */
#define	AUTOEQP_on   1 /* Automatic EQP is on */
#define	AUTOEQP_trigger   2 /* On and also show plans for triggers */
#define	AUTOEQP_full   3 /* Show full EXPLAIN */
#define	SHELL_OPEN_UNSPEC   0 /* No open-mode specified */
#define	SHELL_OPEN_NORMAL   1 /* Normal database file */
#define	SHELL_OPEN_APPENDVFS   2 /* Use appendvfs */
#define	SHELL_OPEN_ZIPFILE   3 /* Use the zipfile virtual table */
#define	SHELL_OPEN_READONLY   4 /* Open a normal database read-only */
#define	SHELL_OPEN_DESERIALIZE   5 /* Open using sqlite3_deserialize() */
#define	SHELL_OPEN_HEXDB   6 /* Use "dbtotxt" output as data source */
#define	SHELL_TRACE_PLAIN   0 /* Show input SQL text */
#define	SHELL_TRACE_EXPANDED   1 /* Show expanded SQL text */
#define	SHELL_TRACE_NORMALIZED   2 /* Show normalized SQL text */
#define	SHELL_PROGRESS_QUIET   0x01 /* Omit announcing every progress callback */
#define	SHELL_PROGRESS_RESET
#define	SHELL_PROGRESS_ONCE   0x04 /* Cancel the --limit after firing once */
#define	SHELL_ESC_ASCII   0 /* Substitute ^Y for X where Y=X+0x40 */
#define	SHELL_ESC_SYMBOL   1 /* Substitute U+2400 graphics */
#define	SHELL_ESC_OFF   2 /* Send characters verbatim */
#define	SHFLG_Pagecache   0x00000001 /* The --pagecache option is used */
#define	SHFLG_Lookaside   0x00000002 /* Lookaside memory is used */
#define	SHFLG_Backslash   0x00000004 /* The --backslash option is used */
#define	SHFLG_PreserveRowid   0x00000008 /* .dump preserves rowid values */
#define	SHFLG_Newlines   0x00000010 /* .dump --newline flag */
#define	SHFLG_CountChanges   0x00000020 /* .changes setting */
#define	SHFLG_Echo   0x00000040 /* .echo on/off, or --echo setting */
#define	SHFLG_HeaderSet   0x00000080 /* showHeader has been specified */
#define	SHFLG_DumpDataOnly   0x00000100 /* .dump show data only */
#define	SHFLG_DumpNoSys   0x00000200 /* .dump omits system tables */
#define	SHFLG_TestingMode   0x00000400 /* allow unsafe testing features */
#define	ShellHasFlag(P, X)
#define	ShellSetFlag(P, X)
#define	ShellClearFlag(P, X)
#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_Quote   6 /* Quote values as for SQL */
#define	MODE_Tcl   7 /* Generate ANSI-C or TCL quoted elements */
#define	MODE_Csv   8 /* Quote strings, numbers are plain */
#define	MODE_Explain   9 /* Like MODE_Column, but do not truncate data */
#define	MODE_Ascii   10 /* Use ASCII unit and record separators (0x1F/0x1E) */
#define	MODE_Pretty   11 /* Pretty-print schemas */
#define	MODE_EQP   12 /* Converts EXPLAIN QUERY PLAN output into a graph */
#define	MODE_Json   13 /* Output JSON */
#define	MODE_Markdown   14 /* Markdown formatting */
#define	MODE_Table   15 /* MySQL-style table formatting */
#define	MODE_Box   16 /* Unicode box-drawing characters */
#define	MODE_Count   17 /* Output only a count of the rows of output */
#define	MODE_Off   18 /* No query output shown */
#define	MODE_ScanExp   19 /* Like MODE_Explain, but for ".scanstats vm" */
#define	MODE_Www   20 /* Full web-page output */
#define	SEP_Column   "|"
#define	SEP_Row   "\n"
#define	SEP_Tab   "\t"
#define	SEP_Space   " "
#define	SEP_Comma   ","
#define	SEP_CrLf   "\r\n"
#define	SEP_Unit   "\x1F"
#define	SEP_Record   "\x1E"
#define	MAX_INPUT_NESTING   25
#define	BOX_24   "\342\224\200" /* U+2500 --- */
#define	BOX_13   "\342\224\202" /* U+2502 | */
#define	BOX_23   "\342\224\214" /* U+250c ,- */
#define	BOX_34   "\342\224\220" /* U+2510 -, */
#define	BOX_12   "\342\224\224" /* U+2514 '- */
#define	BOX_14   "\342\224\230" /* U+2518 -' */
#define	BOX_123   "\342\224\234" /* U+251c |- */
#define	BOX_134   "\342\224\244" /* U+2524 -| */
#define	BOX_234   "\342\224\254" /* U+252c -,- */
#define	BOX_124   "\342\224\264" /* U+2534 -'- */
#define	BOX_1234   "\342\224\274" /* U+253c -|- */
#define	session_close_all(X, Y)
#define	OPEN_DB_KEEPALIVE   0x001 /* Return after error if true */
#define	OPEN_DB_ZIPFILE   0x002 /* Open as ZIP if name matches *.zip */
#define	AUTOCOLUMN_SEP   "_"
#define	CTIMEOPT_VAL_(opt)
#define	CTIMEOPT_VAL(opt)
#define	CHAR_BIT   8
#define	QSS_SETV(qss, newst)
#define	QSS_INPLAIN(qss)
#define	QSS_PLAINWHITE(qss)
#define	QSS_PLAINDARK(qss)
#define	QSS_SEMITERM(qss)
#define	SQLITE_SHELL_IS_UTF8   (1)

Typedefs
typedef unsigned int	u32
typedef unsigned short int	u16
typedef sqlite3_int64	i64
typedef sqlite3_uint64	u64
typedef unsigned char	u8
typedef struct DynaPrompt *	t_DynaPromptRef
typedef struct ShellText	ShellText
typedef struct SHA3Context	SHA3Context
typedef struct SHA1Context	SHA1Context
typedef struct Decimal	Decimal
typedef struct Percentile	Percentile
typedef struct PercentileFunc	PercentileFunc
typedef struct SequenceSpec	SequenceSpec
typedef struct series_cursor	series_cursor
typedef unsigned short	ReStateNumber
typedef struct ReStateSet	ReStateSet
typedef struct ReInput	ReInput
typedef struct ReCompiled	ReCompiled
typedef struct fsdir_cursor	fsdir_cursor
typedef struct FsdirLevel	FsdirLevel
typedef struct fsdir_tab	fsdir_tab
typedef struct completion_vtab	completion_vtab
typedef struct completion_cursor	completion_cursor
typedef struct sqlite3_vfs	ApndVfs
typedef struct ApndFile	ApndFile
typedef struct sqlite3expert	sqlite3expert
typedef struct IdxColumn	IdxColumn
typedef struct IdxConstraint	IdxConstraint
typedef struct IdxScan	IdxScan
typedef struct IdxStatement	IdxStatement
typedef struct IdxTable	IdxTable
typedef struct IdxWrite	IdxWrite
typedef struct IdxHashEntry	IdxHashEntry
typedef struct IdxHash	IdxHash
typedef struct ExpertVtab	ExpertVtab
typedef struct ExpertCsr	ExpertCsr
typedef struct sqlite3_intck	sqlite3_intck
typedef struct Stmtrand	Stmtrand
typedef struct vfstrace_info	vfstrace_info
typedef struct vfstrace_file	vfstrace_file
typedef struct ExpertInfo	ExpertInfo
typedef struct EQPGraphRow	EQPGraphRow
typedef struct EQPGraph	EQPGraph
typedef struct ColModeOpts	ColModeOpts
typedef struct ShellState	ShellState
typedef struct ImportCtx	ImportCtx

Enumerations
enum	QuickScanState { QSS_HasDark = 1<< 8 , QSS_EndingSemi = 2<< 8 , QSS_CharMask = (1<< 8 )-1 , QSS_ScanMask = 3<< 8 , QSS_Start = 0 }

Functions
int	isatty (int)
FILE *	popen (const char *, const char *)
int	pclose (FILE *)
static int	cli_strcmp (const char *a, const char *b)
static int	cli_strncmp (const char *a, const char *b, size_t n)
static sqlite3_int64	timeOfDay (void)
static void	beginTimer (void)
static double	timeDiff (struct timeval *pStart, struct timeval *pEnd)
static void	endTimer (FILE *out)
static char *	shell_strncpy (char *dest, const char *src, size_t n)
static void	shell_strcpy (char *dest, const char *src)
static void	trackParenLevel (struct DynaPrompt *p, int ni)
static void	setLexemeOpen (struct DynaPrompt *p, char *s, char c)
static char *	dynamicContinuePrompt (void)
static void	shell_out_of_memory (void)
static void	shell_check_oom (const void *p)
int	cli_wcwidth (int c)
static int	decodeUtf8 (const unsigned char *z, int *pU)
static int	isVt100 (const unsigned char *z)
static void	utf8_width_print (FILE *out, int w, const char *zUtf)
static int	isNumber (const char *z, int *realnum)
static int	strlen30 (const char *z)
static int	strlenChar (const char *z)
static FILE *	openChrSource (const char *zFile)
static char *	local_getline (char *zLine, FILE *in)
static char *	one_input_line (FILE *in, char *zPrior, int isContinuation)
static int	hexDigitValue (char c)
static sqlite3_int64	integerValue (const char *zArg)
static void	initText (ShellText *p)
static void	freeText (ShellText *p)
static void	appendText (ShellText *p, const char *zAppend, char quote)
static char	quoteChar (const char *zName)
static char *	shellFakeSchema (sqlite3 *db, const char *zSchema, const char *zName)
static void	shellStrtod (sqlite3_context *pCtx, int nVal, sqlite3_value **apVal)
static void	shellDtostr (sqlite3_context *pCtx, int nVal, sqlite3_value **apVal)
static void	shellAddSchemaName (sqlite3_context *pCtx, int nVal, sqlite3_value **apVal)
static void *	memtraceMalloc (int n)
static void	memtraceFree (void *p)
static void *	memtraceRealloc (void *p, int n)
static int	memtraceSize (void *p)
static int	memtraceRoundup (int n)
static int	memtraceInit (void *p)
static void	memtraceShutdown (void *p)
int	sqlite3MemTraceActivate (FILE *out)
int	sqlite3MemTraceDeactivate (void)
static int	pcachetraceInit (void *pArg)
static void	pcachetraceShutdown (void *pArg)
static sqlite3_pcache *	pcachetraceCreate (int szPage, int szExtra, int bPurge)
static void	pcachetraceCachesize (sqlite3_pcache *p, int nCachesize)
static int	pcachetracePagecount (sqlite3_pcache *p)
static sqlite3_pcache_page *	pcachetraceFetch (sqlite3_pcache *p, unsigned key, int crFg)
static void	pcachetraceUnpin (sqlite3_pcache *p, sqlite3_pcache_page *pPg, int bDiscard)
static void	pcachetraceRekey (sqlite3_pcache *p, sqlite3_pcache_page *pPg, unsigned oldKey, unsigned newKey)
static void	pcachetraceTruncate (sqlite3_pcache *p, unsigned n)
static void	pcachetraceDestroy (sqlite3_pcache *p)
static void	pcachetraceShrink (sqlite3_pcache *p)
int	sqlite3PcacheTraceActivate (FILE *out)
int	sqlite3PcacheTraceDeactivate (void)
static void	KeccakF1600Step (SHA3Context *p)
static void	SHA3Init (SHA3Context *p, int iSize)
static void	SHA3Update (SHA3Context *p, const unsigned char *aData, unsigned int nData)
static unsigned char *	SHA3Final (SHA3Context *p)
static void	sha3Func (sqlite3_context *context, int argc, sqlite3_value **argv)
static void	sha3_step_vformat (SHA3Context *p, const char *zFormat,...)
static void	sha3UpdateFromValue (SHA3Context *p, sqlite3_value *pVal)
static void	sha3QueryFunc (sqlite3_context *context, int argc, sqlite3_value **argv)
static void	sha3AggStep (sqlite3_context *context, int argc, sqlite3_value **argv)
static void	sha3AggFinal (sqlite3_context *context)
int	sqlite3_shathree_init (sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi)
static void	SHA1Transform (unsigned int state[5], const unsigned char buffer[64])
static void	hash_init (SHA1Context *p)
static void	hash_step (SHA1Context *p, const unsigned char *data, unsigned int len)
static void	hash_step_vformat (SHA1Context *p, const char *zFormat,...)
static void	hash_finish (SHA1Context *p, char *zOut, int bAsBinary)
static void	sha1Func (sqlite3_context *context, int argc, sqlite3_value **argv)
static void	sha1QueryFunc (sqlite3_context *context, int argc, sqlite3_value **argv)
int	sqlite3_sha_init (sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi)
static int	uintCollFunc (void *notUsed, int nKey1, const void *pKey1, int nKey2, const void *pKey2)
int	sqlite3_uint_init (sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi)
static void	decimal_clear (Decimal *p)
static void	decimal_free (Decimal *p)
static Decimal *	decimalNewFromText (const char *zIn, int n)
static Decimal *	decimalFromDouble (double)
static Decimal *	decimal_new (sqlite3_context *pCtx, sqlite3_value *pIn, int bTextOnly)
static void	decimal_result (sqlite3_context *pCtx, Decimal *p)
static void	decimal_result_sci (sqlite3_context *pCtx, Decimal *p)
static int	decimal_cmp (const Decimal *pA, const Decimal *pB)
static void	decimalCmpFunc (sqlite3_context *context, int argc, sqlite3_value **argv)
static void	decimal_expand (Decimal *p, int nDigit, int nFrac)
static void	decimal_add (Decimal *pA, Decimal *pB)
static void	decimalMul (Decimal *pA, Decimal *pB)
static Decimal *	decimalPow2 (int N)
static void	decimalFunc (sqlite3_context *context, int argc, sqlite3_value **argv)
static int	decimalCollFunc (void *notUsed, int nKey1, const void *pKey1, int nKey2, const void *pKey2)
static void	decimalAddFunc (sqlite3_context *context, int argc, sqlite3_value **argv)
static void	decimalSubFunc (sqlite3_context *context, int argc, sqlite3_value **argv)
static void	decimalSumStep (sqlite3_context *context, int argc, sqlite3_value **argv)
static void	decimalSumInverse (sqlite3_context *context, int argc, sqlite3_value **argv)
static void	decimalSumValue (sqlite3_context *context)
static void	decimalSumFinalize (sqlite3_context *context)
static void	decimalMulFunc (sqlite3_context *context, int argc, sqlite3_value **argv)
static void	decimalPow2Func (sqlite3_context *context, int argc, sqlite3_value **argv)
int	sqlite3_decimal_init (sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi)
static int	percentIsInfinity (double r)
static int	percentSameValue (double a, double b)
static int	percentBinarySearch (Percentile *p, double y, int bExact)
static void	percentError (sqlite3_context *pCtx, const char *zFormat,...)
static void	percentStep (sqlite3_context *pCtx, int argc, sqlite3_value **argv)
static void	percentSort (double *a, unsigned int n)
static void	percentInverse (sqlite3_context *pCtx, int argc, sqlite3_value **argv)
static void	percentCompute (sqlite3_context *pCtx, int bIsFinal)
static void	percentFinal (sqlite3_context *pCtx)
static void	percentValue (sqlite3_context *pCtx)
int	sqlite3_percentile_init (sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi)
static char *	toBase64 (u8 *pIn, int nbIn, char *pOut)
static char *	skipNonB64 (char *s, int nc)
static u8 *	fromBase64 (char *pIn, int ncIn, u8 *pOut)
static void	base64 (sqlite3_context *context, int na, sqlite3_value *av[])
int	sqlite3_base64_init (sqlite3 *db, char **pzErr, const sqlite3_api_routines *pApi)
static char *	skipNonB85 (char *s, int nc)
static char *	putcs (char *pc, char *s)
static char *	toBase85 (u8 *pIn, int nbIn, char *pOut, char *pSep)
static u8 *	fromBase85 (char *pIn, int ncIn, u8 *pOut)
static void	base85 (sqlite3_context *context, int na, sqlite3_value *av[])
int	sqlite3_base85_init (sqlite3 *db, char **pzErr, const sqlite3_api_routines *pApi)
static void	ieee754func (sqlite3_context *context, int argc, sqlite3_value **argv)
static void	ieee754func_from_blob (sqlite3_context *context, int argc, sqlite3_value **argv)
static void	ieee754func_to_blob (sqlite3_context *context, int argc, sqlite3_value **argv)
static void	ieee754inc (sqlite3_context *context, int argc, sqlite3_value **argv)
int	sqlite3_ieee_init (sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi)
static sqlite3_int64	genSeqMember (sqlite3_int64 smBase, sqlite3_int64 smStep, sqlite3_uint64 ix)
static void	setupSequence (SequenceSpec *pss)
static int	progressSequence (SequenceSpec *pss)
static int	seriesConnect (sqlite3 *db, void *pUnused, int argcUnused, const char *const *argvUnused, sqlite3_vtab **ppVtab, char **pzErrUnused)
static int	seriesDisconnect (sqlite3_vtab *pVtab)
static int	seriesOpen (sqlite3_vtab *pUnused, sqlite3_vtab_cursor **ppCursor)
static int	seriesClose (sqlite3_vtab_cursor *cur)
static int	seriesNext (sqlite3_vtab_cursor *cur)
static int	seriesColumn (sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i)
static int	seriesRowid (sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid)
static int	seriesEof (sqlite3_vtab_cursor *cur)
static int	seriesFilter (sqlite3_vtab_cursor *pVtabCursor, int idxNum, const char *idxStrUnused, int argc, sqlite3_value **argv)
static int	seriesBestIndex (sqlite3_vtab *pVTab, sqlite3_index_info *pIdxInfo)
int	sqlite3_series_init (sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi)
static void	re_add_state (ReStateSet *pSet, int newState)
static unsigned	re_next_char (ReInput *p)
static unsigned	re_next_char_nocase (ReInput *p)
static int	re_word_char (int c)
static int	re_digit_char (int c)
static int	re_space_char (int c)
static int	sqlite3re_match (ReCompiled *pRe, const unsigned char *zIn, int nIn)
static int	re_resize (ReCompiled *p, int N)
static int	re_insert (ReCompiled *p, int iBefore, int op, int arg)
static int	re_append (ReCompiled *p, int op, int arg)
static void	re_copy (ReCompiled *p, int iStart, int N)
static int	re_hex (int c, int *pV)
static unsigned	re_esc_char (ReCompiled *p)
static const char *	re_subcompile_string (ReCompiled *)
static unsigned char	rePeek (ReCompiled *p)
static const char *	re_subcompile_re (ReCompiled *p)
static void	sqlite3re_free (void *p)
static const char *	sqlite3re_compile (ReCompiled **ppRe, const char *zIn, int noCase)
static void	re_sql_func (sqlite3_context *context, int argc, sqlite3_value **argv)
int	sqlite3_regexp_init (sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi)
static void	readFileContents (sqlite3_context *ctx, const char *zName)
static void	readfileFunc (sqlite3_context *context, int argc, sqlite3_value **argv)
static void	ctxErrorMsg (sqlite3_context *ctx, const char *zFmt,...)
static int	fileStat (const char *zPath, struct stat *pStatBuf)
static int	fileLinkStat (const char *zPath, struct stat *pStatBuf)
static int	makeDirectory (const char *zFile)
static int	writeFile (sqlite3_context *pCtx, const char *zFile, sqlite3_value *pData, mode_t mode, sqlite3_int64 mtime)
static void	writefileFunc (sqlite3_context *context, int argc, sqlite3_value **argv)
static void	lsModeFunc (sqlite3_context *context, int argc, sqlite3_value **argv)
static int	fsdirConnect (sqlite3 *db, void *pAux, int argc, const char *const *argv, sqlite3_vtab **ppVtab, char **pzErr)
static int	fsdirDisconnect (sqlite3_vtab *pVtab)
static int	fsdirOpen (sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor)
static void	fsdirResetCursor (fsdir_cursor *pCur)
static int	fsdirClose (sqlite3_vtab_cursor *cur)
static void	fsdirSetErrmsg (fsdir_cursor *pCur, const char *zFmt,...)
static int	fsdirNext (sqlite3_vtab_cursor *cur)
static int	fsdirColumn (sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i)
static int	fsdirRowid (sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid)
static int	fsdirEof (sqlite3_vtab_cursor *cur)
static int	fsdirFilter (sqlite3_vtab_cursor *cur, int idxNum, const char *idxStr, int argc, sqlite3_value **argv)
static int	fsdirBestIndex (sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo)
static int	fsdirRegister (sqlite3 *db)
int	sqlite3_fileio_init (sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi)
static int	completionConnect (sqlite3 *db, void *pAux, int argc, const char *const *argv, sqlite3_vtab **ppVtab, char **pzErr)
static int	completionDisconnect (sqlite3_vtab *pVtab)
static int	completionOpen (sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor)
static void	completionCursorReset (completion_cursor *pCur)
static int	completionClose (sqlite3_vtab_cursor *cur)
static int	completionNext (sqlite3_vtab_cursor *cur)
static int	completionColumn (sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i)
static int	completionRowid (sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid)
static int	completionEof (sqlite3_vtab_cursor *cur)
static int	completionFilter (sqlite3_vtab_cursor *pVtabCursor, int idxNum, const char *idxStr, int argc, sqlite3_value **argv)
static int	completionBestIndex (sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo)
int	sqlite3CompletionVtabInit (sqlite3 *db)
int	sqlite3_completion_init (sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi)
static int	apndClose (sqlite3_file *)
static int	apndRead (sqlite3_file *, void *, int iAmt, sqlite3_int64 iOfst)
static int	apndWrite (sqlite3_file *, const void *, int iAmt, sqlite3_int64 iOfst)
static int	apndTruncate (sqlite3_file *, sqlite3_int64 size)
static int	apndSync (sqlite3_file *, int flags)
static int	apndFileSize (sqlite3_file *, sqlite3_int64 *pSize)
static int	apndLock (sqlite3_file *, int)
static int	apndUnlock (sqlite3_file *, int)
static int	apndCheckReservedLock (sqlite3_file *, int *pResOut)
static int	apndFileControl (sqlite3_file *, int op, void *pArg)
static int	apndSectorSize (sqlite3_file *)
static int	apndDeviceCharacteristics (sqlite3_file *)
static int	apndShmMap (sqlite3_file *, int iPg, int pgsz, int, void volatile **)
static int	apndShmLock (sqlite3_file *, int offset, int n, int flags)
static void	apndShmBarrier (sqlite3_file *)
static int	apndShmUnmap (sqlite3_file *, int deleteFlag)
static int	apndFetch (sqlite3_file *, sqlite3_int64 iOfst, int iAmt, void **pp)
static int	apndUnfetch (sqlite3_file *, sqlite3_int64 iOfst, void *p)
static int	apndOpen (sqlite3_vfs *, const char *, sqlite3_file *, int, int *)
static int	apndDelete (sqlite3_vfs *, const char *zName, int syncDir)
static int	apndAccess (sqlite3_vfs *, const char *zName, int flags, int *)
static int	apndFullPathname (sqlite3_vfs *, const char *zName, int, char *zOut)
static void *	apndDlOpen (sqlite3_vfs *, const char *zFilename)
static void	apndDlError (sqlite3_vfs *, int nByte, char *zErrMsg)
static void	apndDlClose (sqlite3_vfs *, void *)
static int	apndRandomness (sqlite3_vfs *, int nByte, char *zOut)
static int	apndSleep (sqlite3_vfs *, int microseconds)
static int	apndCurrentTime (sqlite3_vfs *, double *)
static int	apndGetLastError (sqlite3_vfs *, int, char *)
static int	apndCurrentTimeInt64 (sqlite3_vfs *, sqlite3_int64 *)
static int	apndSetSystemCall (sqlite3_vfs *, const char *, sqlite3_syscall_ptr)
static sqlite3_syscall_ptr	apndGetSystemCall (sqlite3_vfs *, const char *z)
static const char *	apndNextSystemCall (sqlite3_vfs *, const char *zName)
static int	apndWriteMark (ApndFile *paf, sqlite3_file *pFile, sqlite_int64 iWriteEnd)
static sqlite3_int64	apndReadMark (sqlite3_int64 sz, sqlite3_file *pFile)
static int	apndIsAppendvfsDatabase (sqlite3_int64 sz, sqlite3_file *pFile)
static int	apndIsOrdinaryDatabaseFile (sqlite3_int64 sz, sqlite3_file *pFile)
int	sqlite3_appendvfs_init (sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi)
sqlite3expert *	sqlite3_expert_new (sqlite3 *db, char **pzErr)
int	sqlite3_expert_config (sqlite3expert *p, int op,...)
int	sqlite3_expert_sql (sqlite3expert *p, const char *zSql, char **pzErr)
int	sqlite3_expert_analyze (sqlite3expert *p, char **pzErr)
int	sqlite3_expert_count (sqlite3expert *)
const char *	sqlite3_expert_report (sqlite3expert *, int iStmt, int eReport)
void	sqlite3_expert_destroy (sqlite3expert *)
static void *	idxMalloc (int *pRc, int nByte)
static void	idxHashInit (IdxHash *pHash)
static void	idxHashClear (IdxHash *pHash)
static int	idxHashString (const char *z, int n)
static int	idxHashAdd (int *pRc, IdxHash *pHash, const char *zKey, const char *zVal)
static IdxHashEntry *	idxHashFind (IdxHash *pHash, const char *zKey, int nKey)
static const char *	idxHashSearch (IdxHash *pHash, const char *zKey, int nKey)
static IdxConstraint *	idxNewConstraint (int *pRc, const char *zColl)
static void	idxDatabaseError (sqlite3 *db, char **pzErrmsg)
static int	idxPrepareStmt (sqlite3 *db, sqlite3_stmt **ppStmt, char **pzErrmsg, const char *zSql)
static int	idxPrintfPrepareStmt (sqlite3 *db, sqlite3_stmt **ppStmt, char **pzErrmsg, const char *zFmt,...)
static char *	expertDequote (const char *zIn)
static int	expertConnect (sqlite3 *db, void *pAux, int argc, const char *const *argv, sqlite3_vtab **ppVtab, char **pzErr)
static int	expertDisconnect (sqlite3_vtab *pVtab)
static int	expertBestIndex (sqlite3_vtab *pVtab, sqlite3_index_info *pIdxInfo)
static int	expertUpdate (sqlite3_vtab *pVtab, int nData, sqlite3_value **azData, sqlite_int64 *pRowid)
static int	expertOpen (sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor)
static int	expertClose (sqlite3_vtab_cursor *cur)
static int	expertEof (sqlite3_vtab_cursor *cur)
static int	expertNext (sqlite3_vtab_cursor *cur)
static int	expertRowid (sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid)
static int	expertColumn (sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i)
static int	expertFilter (sqlite3_vtab_cursor *cur, int idxNum, const char *idxStr, int argc, sqlite3_value **argv)
static int	idxRegisterVtab (sqlite3expert *p)
static void	idxFinalize (int *pRc, sqlite3_stmt *pStmt)
static int	idxGetTableInfo (sqlite3 *db, const char *zTab, IdxTable **ppOut, char **pzErrmsg)
static char *	idxAppendText (int *pRc, char *zIn, const char *zFmt,...)
static int	idxIdentifierRequiresQuotes (const char *zId)
static char *	idxAppendColDefn (int *pRc, char *zIn, IdxTable *pTab, IdxConstraint *pCons)
static int	idxFindCompatible (int *pRc, sqlite3 *dbm, IdxScan *pScan, IdxConstraint *pEq, IdxConstraint *pTail)
static int	countNonzeros (void *pCount, int nc, char *azResults[], char *azColumns[])
static int	idxCreateFromCons (sqlite3expert *p, IdxScan *pScan, IdxConstraint *pEq, IdxConstraint *pTail)
static int	idxFindConstraint (IdxConstraint *pList, IdxConstraint *p)
static int	idxCreateFromWhere (sqlite3expert *p, IdxScan *pScan, IdxConstraint *pTail)
static int	idxCreateCandidates (sqlite3expert *p)
static void	idxConstraintFree (IdxConstraint *pConstraint)
static void	idxScanFree (IdxScan *pScan, IdxScan *pLast)
static void	idxStatementFree (IdxStatement *pStatement, IdxStatement *pLast)
static void	idxTableFree (IdxTable *pTab)
static void	idxWriteFree (IdxWrite *pTab)
static int	idxFindIndexes (sqlite3expert *p, char **pzErr)
static int	idxAuthCallback (void *pCtx, int eOp, const char *z3, const char *z4, const char *zDb, const char *zTrigger)
static int	idxProcessOneTrigger (sqlite3expert *p, IdxWrite *pWrite, char **pzErr)
static int	idxProcessTriggers (sqlite3expert *p, char **pzErr)
static int	expertDbContainsObject (sqlite3 *db, const char *zTab, int *pbContains)
static int	expertSchemaSql (sqlite3 *db, const char *zSql, char **pzErr)
static int	idxCreateVtabSchema (sqlite3expert *p, char **pzErrmsg)
static void	idxSampleFunc (sqlite3_context *pCtx, int argc, sqlite3_value **argv)
static void	idxRemFunc (sqlite3_context *pCtx, int argc, sqlite3_value **argv)
static int	idxLargestIndex (sqlite3 *db, int *pnMax, char **pzErr)
static int	idxPopulateOneStat1 (sqlite3expert *p, sqlite3_stmt *pIndexXInfo, sqlite3_stmt *pWriteStat, const char *zTab, const char *zIdx, char **pzErr)
static int	idxBuildSampleTable (sqlite3expert *p, const char *zTab)
static int	idxPopulateStat1 (sqlite3expert *p, char **pzErr)
int	dummyCompare (void *up1, int up2, const void *up3, int up4, const void *up5)
void	useDummyCS (void *up1, sqlite3 *db, int etr, const char *zName)
void	dummyUDF (sqlite3_context *up1, int up2, sqlite3_value **up3)
void	dummyUDFvalue (sqlite3_context *up1)
int	registerUDFs (sqlite3 *dbSrc, sqlite3 *dbDst)
int	sqlite3_intck_open (sqlite3 *db, const char *zDb, sqlite3_intck **ppOut)
void	sqlite3_intck_close (sqlite3_intck *pCk)
int	sqlite3_intck_step (sqlite3_intck *pCk)
const char *	sqlite3_intck_message (sqlite3_intck *pCk)
int	sqlite3_intck_unlock (sqlite3_intck *pCk)
int	sqlite3_intck_error (sqlite3_intck *pCk, const char **pzErr)
const char *	sqlite3_intck_test_sql (sqlite3_intck *pCk, const char *zObj)
static void	intckSaveErrmsg (sqlite3_intck *p)
static sqlite3_stmt *	intckPrepare (sqlite3_intck *p, const char *zSql)
static sqlite3_stmt *	intckPrepareFmt (sqlite3_intck *p, const char *zFmt,...)
static void	intckFinalize (sqlite3_intck *p, sqlite3_stmt *pStmt)
static int	intckStep (sqlite3_intck *p, sqlite3_stmt *pStmt)
static void	intckExec (sqlite3_intck *p, const char *zSql)
static char *	intckMprintf (sqlite3_intck *p, const char *zFmt,...)
static void	intckSaveKey (sqlite3_intck *p)
static void	intckFindObject (sqlite3_intck *p)
static int	intckGetToken (const char *z)
static int	intckIsSpace (char c)
static const char *	intckParseCreateIndex (const char *z, int iCol, int *pnByte)
static void	intckParseCreateIndexFunc (sqlite3_context *pCtx, int nVal, sqlite3_value **apVal)
static int	intckGetAutoIndex (sqlite3_intck *p)
static int	intckIsIndex (sqlite3_intck *p, const char *zObj)
static char *	intckCheckObjectSql (sqlite3_intck *p, const char *zObj, const char *zPrev, int *pnKeyVal)
static void	stmtrandFunc (sqlite3_context *context, int argc, sqlite3_value **argv)
int	sqlite3_stmtrand_init (sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi)
static int	vfstraceClose (sqlite3_file *)
static int	vfstraceRead (sqlite3_file *, void *, int iAmt, sqlite3_int64 iOfst)
static int	vfstraceWrite (sqlite3_file *, const void *, int iAmt, sqlite3_int64)
static int	vfstraceTruncate (sqlite3_file *, sqlite3_int64 size)
static int	vfstraceSync (sqlite3_file *, int flags)
static int	vfstraceFileSize (sqlite3_file *, sqlite3_int64 *pSize)
static int	vfstraceLock (sqlite3_file *, int)
static int	vfstraceUnlock (sqlite3_file *, int)
static int	vfstraceCheckReservedLock (sqlite3_file *, int *)
static int	vfstraceFileControl (sqlite3_file *, int op, void *pArg)
static int	vfstraceSectorSize (sqlite3_file *)
static int	vfstraceDeviceCharacteristics (sqlite3_file *)
static int	vfstraceShmLock (sqlite3_file *, int, int, int)
static int	vfstraceShmMap (sqlite3_file *, int, int, int, void volatile **)
static void	vfstraceShmBarrier (sqlite3_file *)
static int	vfstraceShmUnmap (sqlite3_file *, int)
static int	vfstraceOpen (sqlite3_vfs *, const char *, sqlite3_file *, int, int *)
static int	vfstraceDelete (sqlite3_vfs *, const char *zName, int syncDir)
static int	vfstraceAccess (sqlite3_vfs *, const char *zName, int flags, int *)
static int	vfstraceFullPathname (sqlite3_vfs *, const char *zName, int, char *)
static void *	vfstraceDlOpen (sqlite3_vfs *, const char *zFilename)
static void	vfstraceDlError (sqlite3_vfs *, int nByte, char *zErrMsg)
static void	vfstraceDlClose (sqlite3_vfs *, void *)
static int	vfstraceRandomness (sqlite3_vfs *, int nByte, char *zOut)
static int	vfstraceSleep (sqlite3_vfs *, int microseconds)
static int	vfstraceCurrentTime (sqlite3_vfs *, double *)
static int	vfstraceGetLastError (sqlite3_vfs *, int, char *)
static int	vfstraceCurrentTimeInt64 (sqlite3_vfs *, sqlite3_int64 *)
static int	vfstraceSetSystemCall (sqlite3_vfs *, const char *, sqlite3_syscall_ptr)
static sqlite3_syscall_ptr	vfstraceGetSystemCall (sqlite3_vfs *, const char *)
static const char *	vfstraceNextSystemCall (sqlite3_vfs *, const char *zName)
static const char *	fileTail (const char *z)
static void	vfstrace_printf (vfstrace_info *pInfo, const char *zFormat,...)
static const char *	vfstrace_errcode_name (int rc)
static void	vfstrace_print_errcode (vfstrace_info *pInfo, const char *zFormat, int rc)
static void	strappend (char *z, int *pI, const char *zAppend)
static void	vfstraceOnOff (vfstrace_info *pInfo, unsigned int mMask)
static const char *	lockName (int eLock)
static int	vfstraceFetch (sqlite3_file *pFile, i64 iOff, int nAmt, void **pptr)
static int	vfstraceUnfetch (sqlite3_file *pFile, i64 iOff, void *ptr)
int	vfstrace_register (const char *zTraceName, const char *zOldVfsName, int(*xOut)(const char *, void *), void *pOutArg, int makeDefault)
void	vfstrace_unregister (const char *zTraceName)
static void	shellLog (void *pArg, int iErrCode, const char *zMsg)
static void	shellPutsFunc (sqlite3_context *pCtx, int nVal, sqlite3_value **apVal)
static void	failIfSafeMode (ShellState *p, const char *zErrMsg,...)
static void	editFunc (sqlite3_context *context, int argc, sqlite3_value **argv)
static void	outputModePush (ShellState *p)
static void	outputModePop (ShellState *p)
static void	setCrlfMode (ShellState *p)
static void	output_hex_blob (FILE *out, const void *pBlob, int nBlob)
static void	output_quoted_string (ShellState *p, const char *zInX)
static void	output_quoted_escaped_string (ShellState *p, const char *z)
static const char *	anyOfInStr (const char *s, const char *zAny, size_t ns)
const char *	zSkipValidUtf8 (const char *z, int nAccept, long ccm)
static void	output_c_string (FILE *out, const char *z)
static void	output_json_string (FILE *out, const char *z, i64 n)
static const char *	escapeOutput (ShellState *p, const char *zInX, char **ppFree)
static void	output_html_string (FILE *out, const char *z)
static void	output_csv (ShellState *p, const char *z, int bSep)
static void	interrupt_handler (int NotUsed)
static int	safeModeAuth (void *pClientData, int op, const char *zA1, const char *zA2, const char *zA3, const char *zA4)
static int	shellAuth (void *pClientData, int op, const char *zA1, const char *zA2, const char *zA3, const char *zA4)
static void	printSchemaLine (FILE *out, const char *z, const char *zTail)
static void	printSchemaLineN (FILE *out, char *z, int n, const char *zTail)
static int	wsToEol (const char *z)
static void	eqp_append (ShellState *p, int iEqpId, int p2, const char *zText)
static void	eqp_reset (ShellState *p)
static EQPGraphRow *	eqp_next_row (ShellState *p, int iEqpId, EQPGraphRow *pOld)
static void	eqp_render_level (ShellState *p, int iEqpId)
static void	eqp_render (ShellState *p, i64 nCycle)
static int	progress_handler (void *pClientData)
static void	print_dashes (FILE *out, int N)
static void	print_row_separator (ShellState *p, int nArg, const char *zSep)
static int	shell_callback (void *pArg, int nArg, char **azArg, char **azCol, int *aiType)
static int	callback (void *pArg, int nArg, char **azArg, char **azCol)
static int	captureOutputCallback (void *pArg, int nArg, char **azArg, char **az)
static void	createSelftestTable (ShellState *p)
static void	set_table_name (ShellState *p, const char *zName)
static char *	shell_error_context (const char *zSql, sqlite3 *db)
static int	run_table_dump_query (ShellState *p, const char *zSelect)
static char *	save_err_msg (sqlite3 *db, const char *zPhase, int rc, const char *zSql)
static void	displayStatLine (FILE *out, char *zLabel, char *zFormat, int iStatusCtrl, int bReset)
static int	display_stats (sqlite3 *db, ShellState *pArg, int bReset)
static int	str_in_array (const char *zStr, const char **azArray)
static void	explain_data_prepare (ShellState *p, sqlite3_stmt *pSql)
static void	explain_data_delete (ShellState *p)
static void	exec_prepared_stmt (ShellState *, sqlite3_stmt *)
static void	display_scanstats (sqlite3 *db, ShellState *pArg)
static void	disable_debug_trace_modes (void)
static void	restore_debug_trace_modes (void)
static void	bind_table_init (ShellState *p)
static void	bind_prepared_stmt (ShellState *pArg, sqlite3_stmt *pStmt)
static void	print_box_line (FILE *out, int N)
static void	print_box_row_separator (ShellState *p, int nArg, const char *zSep1, const char *zSep2, const char *zSep3)
static char *	translateForDisplayAndDup (ShellState *p, const unsigned char *z, const unsigned char **pzTail, int mxWidth, u8 bWordWrap)
static int	needUnistr (const unsigned char *z)
static char *	quoted_column (sqlite3_stmt *pStmt, int i)
static void	exec_prepared_stmt_columnar (ShellState *p, sqlite3_stmt *pStmt)
static int	expertHandleSQL (ShellState *pState, const char *zSql, char **pzErr)
static int	expertFinish (ShellState *pState, int bCancel, char **pzErr)
static int	expertDotCommand (ShellState *pState, char **azArg, int nArg)
static int	shell_exec (ShellState *pArg, const char *zSql, char **pzErrMsg)
static void	freeColumnList (char **azCol)
static char **	tableColumnList (ShellState *p, const char *zTab)
static void	toggleSelectOrder (sqlite3 *db)
static int	dump_callback (void *pArg, int nArg, char **azArg, char **azNotUsed)
static int	run_schema_dump_query (ShellState *p, const char *zQuery)
static int	showHelp (FILE *out, const char *zPattern)
static int	process_input (ShellState *p)
static char *	readFile (const char *zName, int *pnByte)
int	deduceDatabaseType (const char *zName, int dfltZip)
static unsigned char *	readHexDb (ShellState *p, int *pnData)
static void	shellUSleepFunc (sqlite3_context *context, int argcUnused, sqlite3_value **argv)
static void	shellModuleSchema (sqlite3_context *pCtx, int nVal, sqlite3_value **apVal)
static void	open_db (ShellState *p, int openFlags)
void	close_db (sqlite3 *db)
static void	resolve_backslashes (char *z)
static int	booleanValue (const char *zArg)
static void	setOrClearFlag (ShellState *p, unsigned mFlag, const char *zArg)
static void	output_file_close (FILE *f)
static FILE *	output_file_open (const char *zFile)
static int	sql_trace_callback (unsigned mType, void *pArg, void *pP, void *pX)
static void	test_breakpoint (void)
static void	import_cleanup (ImportCtx *p)
static void	import_append_char (ImportCtx *p, int c)
static char *	csv_read_one_field (ImportCtx *p)
static char *	ascii_read_one_field (ImportCtx *p)
static void	tryToCloneData (ShellState *p, sqlite3 *newDb, const char *zTable)
static void	tryToCloneSchema (ShellState *p, sqlite3 *newDb, const char *zWhere, void(*xForEach)(ShellState *, sqlite3 *, const char *))
static void	tryToClone (ShellState *p, const char *zNewDb)
static void	output_redir (ShellState *p, FILE *pfNew)
static void	output_reset (ShellState *p)
static int	db_int (sqlite3 *db, const char *zSql,...)
static int	shell_dbtotxt_command (ShellState *p, int nArg, char **azArg)
static void	shellEmitError (const char *zErr)
static int	shellDatabaseError (sqlite3 *db)
static int	testcase_glob (const char *zGlob, const char *z)
static int	optionMatch (const char *zStr, const char *zOpt)
int	shellDeleteFile (const char *zFilename)
static void	clearTempFile (ShellState *p)
static void	newTempFile (ShellState *p, const char *zSuffix)
static void	shellFkeyCollateClause (sqlite3_context *pCtx, int nVal, sqlite3_value **apVal)
static int	lintFkeyIndexes (ShellState *pState, char **azArg, int nArg)
static int	lintDotCommand (ShellState *pState, char **azArg, int nArg)
static void	shellPrepare (sqlite3 *db, int *pRc, const char *zSql, sqlite3_stmt **ppStmt)
static void	shellPreparePrintf (sqlite3 *db, int *pRc, sqlite3_stmt **ppStmt, const char *zFmt,...)
static void	shellFinalize (int *pRc, sqlite3_stmt *pStmt)
void	shellReset (int *pRc, sqlite3_stmt *pStmt)
static int	intckDatabaseCmd (ShellState *pState, i64 nStepPerUnlock)
static void	rc_err_oom_die (int rc)
static char *	zAutoColumn (const char *zColNew, sqlite3 **pDb, char **pzRenamed)
static int	outputDumpWarning (ShellState *p, const char *zLike)
static int	faultsim_callback (int iArg)
static int	do_meta_command (char *zLine, ShellState *p)
static QuickScanState	quickscan (char *zLine, QuickScanState qss, t_DynaPromptRef pst)
static int	line_is_command_terminator (char *zLine)
static int	line_is_complete (char *zSql, int nSql)
static int	doAutoDetectRestore (ShellState *p, const char *zSql)
static int	runOneSqlLine (ShellState *p, char *zSql, FILE *in, int startline)
static void	echo_group_input (ShellState *p, const char *zDo)
static char *	find_home_dir (int clearFlag)
static char *	find_xdg_config (void)
static void	process_sqliterc (ShellState *p, const char *sqliterc_override)
static void	usage (int showDetail)
static void	verify_uninitialized (void)
static void	main_init (ShellState *data)
static void	printBold (const char *zText)
static char *	cmdline_option_value (int argc, char **argv, int i)
static void	sayAbnormalExit (void)
static int	vfstraceOut (const char *z, void *pArg)
int	main (int argc, char **argv)

Variables
static int	enableTimer = 0
static struct rusage	sBegin
static sqlite3_int64	iBegin
static int	bail_on_error = 0
static int	stdin_is_interactive = 1
static int	stdout_is_console = 1
static sqlite3 *	globalDb = 0
static volatile int	seenInterrupt = 0
static char *	Argv0
static char	mainPrompt [128]
static char	continuePrompt [128]
static struct DynaPrompt	dynPrompt = { {0}, {0}, 0, 0 }
struct {
unsigned char	w
int	iFirst
}	aUWidth []
static sqlite3_mem_methods	memtraceBase
static FILE *	memtraceOut
static sqlite3_mem_methods	ersaztMethods
static sqlite3_pcache_methods2	pcacheBase
static FILE *	pcachetraceOut
static sqlite3_pcache_methods2	ersaztPcacheMethods
static const PercentileFunc	aPercentFunc []
static const u8	b64DigitValues [128]
static const char	b64Numerals [64+1] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
static u8	b85_cOffset [] = { 0, '#', 0, '*'-4, 0 }
static sqlite3_module	seriesModule
static sqlite3_module	completionModule
static void(*)(void)	apndDlSym (sqlite3_vfs *pVfs, void *p, const char *zSym)
static sqlite3_vfs	apnd_vfs
static const sqlite3_io_methods	apnd_io_methods
static const char	apvfsSqliteHdr [] = "SQLite format 3"
static void(*)(void)	vfstraceDlSym (sqlite3_vfs *, void *, const char *zSymbol)
static const char *	shell_EscModeNames [] = { "ascii", "symbol", "off" }
static const char *	modeDescr []
static const char	needCsvQuote []
static unsigned int	savedSelectTrace
static unsigned int	savedWhereTrace
static const char *	azHelp []
static const char *	zCOL_DB = ":memory:"
struct {
int	iId
int	iErr
int	iCnt
int	iInterval
int	eVerbose
int	nHit
int	nRepeat
int	nSkip
}	faultsim_state = {-1, 0, 0, 0, 0, 0, 0, 0}
static const char	zOptions []

---

Data Structure Documentation

DynaPrompt

struct DynaPrompt

Data Fields
char	acAwait[2]
char	dynamicPrompt[128]
int	inParenLevel
char *	zScannerAwaits

ShellText

struct ShellText

Data Fields
int	n
int	nAlloc
char *	z

SHA3Context

struct SHA3Context

Data Fields
unsigned	iSize
unsigned	ixMask
unsigned	nLoaded
unsigned	nRate
union SHA3Context.u	u

SHA1Context

struct SHA1Context

Data Fields
unsigned char	buffer[64]
unsigned int	count[2]
unsigned int	state[5]

Decimal

struct Decimal

Data Fields
signed char *	a
char	isInit
char	isNull
int	nDigit
int	nFrac
char	oom
char	sign

Percentile

struct Percentile

Data Fields
double *	a
char	bKeepSorted
char	bPctValid
char	bSorted
unsigned	nAlloc
unsigned	nUsed
double	rPct

PercentileFunc

struct PercentileFunc

Data Fields
char	bDiscrete
char	mxFrac
char	nArg
const char *	zName

SequenceSpec

struct SequenceSpec

Data Fields
sqlite3_int64	iBase
sqlite3_int64	iOBase
sqlite3_int64	iOTerm
u8	isNotEOF
u8	isReversing
sqlite3_int64	iStep
sqlite3_int64	iTerm
sqlite3_int64	iValueNow
sqlite3_uint64	uSeqIndexMax
sqlite3_uint64	uSeqIndexNow

series_cursor

struct series_cursor

Collaboration diagram for series_cursor:

Data Fields
sqlite3_vtab_cursor	base
SequenceSpec	ss

ReStateSet

struct ReStateSet

Data Fields
ReStateNumber *	aState
unsigned	nState

ReInput

struct ReInput

Data Fields
int	i
int	mx
const unsigned char *	z

ReCompiled

struct ReCompiled

Collaboration diagram for ReCompiled:

Data Fields
int *	aArg
char *	aOp
unsigned	nAlloc
int	nInit
unsigned	nState
ReInput	sIn
unsigned(*)(ReInput *)	xNextChar
const char *	zErr
unsigned char	zInit[12]

FsdirLevel

struct FsdirLevel

Data Fields
DIR *	pDir
char *	zDir

fsdir_cursor

struct fsdir_cursor

Collaboration diagram for fsdir_cursor:

Data Fields
FsdirLevel *	aLvl
sqlite3_vtab_cursor	base
int	iLvl
sqlite3_int64	iRowid
int	nBase
int	nLvl
struct stat	sStat
const char *	zBase
char *	zPath

fsdir_tab

struct fsdir_tab

Collaboration diagram for fsdir_tab:

Data Fields
sqlite3_vtab	base

completion_vtab

struct completion_vtab

Collaboration diagram for completion_vtab:

Data Fields
sqlite3_vtab	base
sqlite3 *	db

completion_cursor

struct completion_cursor

Collaboration diagram for completion_cursor:

Data Fields
sqlite3_vtab_cursor	base
sqlite3 *	db
int	ePhase
sqlite3_int64	iRowid
int	j
int	nLine
int	nPrefix
sqlite3_stmt *	pStmt
int	szRow
const char *	zCurrentRow
char *	zLine
char *	zPrefix

ApndFile

struct ApndFile

Collaboration diagram for ApndFile:

Data Fields
sqlite3_file	base
sqlite3_int64	iMark
sqlite3_int64	iPgOne

IdxConstraint

struct IdxConstraint

Collaboration diagram for IdxConstraint:

Data Fields
int	bDesc
int	bFlag
int	bRange
int	iCol
IdxConstraint *	pLink
IdxConstraint *	pNext
char *	zColl

IdxScan

struct IdxScan

Collaboration diagram for IdxScan:

Data Fields
i64	covering
int	iDb
IdxConstraint *	pEq
IdxScan *	pNextScan
IdxConstraint *	pOrder
IdxConstraint *	pRange
IdxTable *	pTab

IdxColumn

struct IdxColumn

Data Fields
int	iPk
char *	zColl
char *	zName

IdxTable

struct IdxTable

Collaboration diagram for IdxTable:

Data Fields
IdxColumn *	aCol
int	nCol
IdxTable *	pNext
char *	zName

IdxWrite

struct IdxWrite

Collaboration diagram for IdxWrite:

Data Fields
int	eOp
IdxWrite *	pNext
IdxTable *	pTab

IdxStatement

struct IdxStatement

Collaboration diagram for IdxStatement:

Data Fields
int	iId
IdxStatement *	pNext
char *	zEQP
char *	zIdx
char *	zSql

IdxHashEntry

struct IdxHashEntry

Collaboration diagram for IdxHashEntry:

Data Fields
IdxHashEntry *	pHashNext
IdxHashEntry *	pNext
char *	zKey
char *	zVal
char *	zVal2

IdxHash

struct IdxHash

Collaboration diagram for IdxHash:

Data Fields
IdxHashEntry *	aHash[1023]
IdxHashEntry *	pFirst

sqlite3expert

struct sqlite3expert

Collaboration diagram for sqlite3expert:

Data Fields
int	bRun
sqlite3 *	db
sqlite3 *	dbm
sqlite3 *	dbv
IdxHash	hIdx
int	iSample
IdxScan *	pScan
IdxStatement *	pStatement
IdxTable *	pTable
IdxWrite *	pWrite
char **	pzErrmsg
int	rc
char *	zCandidates

ExpertVtab

struct ExpertVtab

Collaboration diagram for ExpertVtab:

Data Fields
sqlite3_vtab	base
sqlite3expert *	pExpert
IdxTable *	pTab

ExpertCsr

struct ExpertCsr

Collaboration diagram for ExpertCsr:

Data Fields
sqlite3_vtab_cursor	base
sqlite3_stmt *	pData

IdxSampleCtx

struct IdxSampleCtx

Data Fields
int	iTarget
double	nRet
double	nRow
double	target

IdxRemCtx

struct IdxRemCtx

Collaboration diagram for IdxRemCtx:

Data Fields
struct IdxRemSlot	aSlot[1]
int	nSlot

IdxRemCtx::IdxRemSlot

struct IdxRemCtx::IdxRemSlot

Data Fields
int	eType
i64	iVal
int	n
int	nByte
double	rVal
char *	z

sqlite3_intck

struct sqlite3_intck

Collaboration diagram for sqlite3_intck:

Data Fields
int	bCorruptSchema
sqlite3 *	db
int	nKeyVal
sqlite3_stmt *	pCheck
int	rc
const char *	zDb
char *	zErr
char *	zKey
char *	zMessage
char *	zObj
char *	zTestSql

Stmtrand

struct Stmtrand

Data Fields
unsigned int	x
unsigned int	y

vfstrace_info

struct vfstrace_info

Collaboration diagram for vfstrace_info:

Data Fields
u8	bOn
unsigned int	mTrace
void *	pOutArg
sqlite3_vfs *	pRootVfs
sqlite3_vfs *	pTraceVfs
int(*)(const char *, void *)	xOut
const char *	zVfsName

vfstrace_file

struct vfstrace_file

Collaboration diagram for vfstrace_file:

Data Fields
sqlite3_file	base
vfstrace_info *	pInfo
sqlite3_file *	pReal
const char *	zFName

ExpertInfo

struct ExpertInfo

Collaboration diagram for ExpertInfo:

Data Fields
int	bVerbose
sqlite3expert *	pExpert

EQPGraphRow

struct EQPGraphRow

Collaboration diagram for EQPGraphRow:

Data Fields
int	iEqpId
int	iParentId
EQPGraphRow *	pNext
char	zText[1]

EQPGraph

struct EQPGraph

Collaboration diagram for EQPGraph:

Data Fields
EQPGraphRow *	pLast
EQPGraphRow *	pRow
char	zPrefix[100]

ColModeOpts

struct ColModeOpts

Data Fields
u8	bQuote
u8	bWordWrap
int	iWrap

ShellState

struct ShellState

Collaboration diagram for ShellState:

Data Fields
struct AuxDb	aAuxDb[5]
int *	actualWidth
int *	aiIndent
u8	autoEQP
u8	autoEQPtest
u8	autoEQPtrace
u8	autoExplain
u8	bSafeMode
u8	bSafeModePersist
int	cMode
ColModeOpts	cmOpts
int	cnt
char	colSeparator[20]
char	colSepPrior[20]
int *	colWidth
u8	crlfMode
sqlite3 *	db
u8	doXdgOpen
u8	eEscMode
u8	eRestoreState
u8	eTraceType
ExpertInfo	expert
unsigned	flgProgress
int	iIndent
FILE *	in
int	inputNesting
int	lineno
unsigned	mEqpLines
int	mode
int	modePrior
unsigned	mxProgress
int	nCheck
u8	nEqpLevel
int	nErr
int	nIndent
int	normalMode
unsigned	nProgress
char	nullValue[20]
int	nWidth
int	openFlags
u8	openMode
FILE *	out
int	outCount
char	outfile[FILENAME_MAX]
struct AuxDb *	pAuxDb[5]
FILE *	pLog
unsigned	priorShFlgs
sqlite3_stmt *	pStmt
char	rowSeparator[20]
char	rowSepPrior[20]
u8	scanstatsOn
EQPGraph	sGraph
unsigned	shellFlgs
int	showHeader
unsigned	statsOn
sqlite3_int64	szMax
FILE *	traceOut
int	writableSchema
char *	zDestTable
char *	zNonce
char *	zTempFile
char	zTestcase[30]

ShellState::AuxDb

struct ShellState::AuxDb

Collaboration diagram for ShellState::AuxDb:

Data Fields
sqlite3 *	db
const char *	zDbFilename
char *	zFreeOnClose

ImportCtx

struct ImportCtx

Data Fields
int	bNotFirst
int	cColSep
int	cRowSep
int	cTerm
FILE *	in
int	n
int	nAlloc
int	nErr
int	nLine
int	nRow
int(*)(FILE *)	xCloser
char *	z
const char *	zFile

SHA3Context.u

union SHA3Context.u

Data Fields
u64	s[25]
unsigned char	x[1600]

Macro Definition Documentation

_FILE_OFFSET_BITS

#define _FILE_OFFSET_BITS   64

_LARGE_FILE

#define _LARGE_FILE   1

_LARGEFILE_SOURCE

#define _LARGEFILE_SOURCE   1

_SQLITE3_STDIO_H_

#define _SQLITE3_STDIO_H_   1

_SQLITE_INTCK_H

#define _SQLITE_INTCK_H

a

#define a   qq[0]

Referenced by accessPayload(), apndGetLastError(), apndReadMark(), apndWriteMark(), cli_strcmp(), cli_strncmp(), convertCompoundSelectToSubquery(), decimal_result_sci(), decimalFromDouble(), exprINAffinity(), ieee754func(), ieee754func_to_blob(), jsonBlobAppendNode(), lsModeFunc(), main(), noopValueFunc(), parserSyntaxError(), pcacheSortDirtyList(), percentSameValue(), percentSort(), percentStep(), quoted_column(), readHexDb(), selectExpander(), SHA1Transform(), sqlite3DefaultRowEst(), sqlite3GetVarint(), sqlite3LogEstAdd(), sqlite3PagerClose(), sqlite3StrIHash(), sqlite3SubqueryColumnTypes(), utf8_width_print(), vfstraceFileControl(), walChecksumBytes(), and whereRangeScanEst().

a00

#define a00   (p->u.s[0])

Referenced by KeccakF1600Step().

a01

#define a01   (p->u.s[1])

Referenced by KeccakF1600Step().

a02

#define a02   (p->u.s[2])

Referenced by KeccakF1600Step().

a03

#define a03   (p->u.s[3])

Referenced by KeccakF1600Step().

a04

#define a04   (p->u.s[4])

Referenced by KeccakF1600Step().

a10

#define a10   (p->u.s[5])

Referenced by KeccakF1600Step().

a11

#define a11   (p->u.s[6])

Referenced by KeccakF1600Step().

a12

#define a12   (p->u.s[7])

Referenced by KeccakF1600Step().

a13

#define a13   (p->u.s[8])

Referenced by KeccakF1600Step().

a14

#define a14   (p->u.s[9])

Referenced by KeccakF1600Step().

a20

#define a20   (p->u.s[10])

Referenced by KeccakF1600Step().

a21

#define a21   (p->u.s[11])

Referenced by KeccakF1600Step().

a22

#define a22   (p->u.s[12])

Referenced by KeccakF1600Step().

a23

#define a23   (p->u.s[13])

Referenced by KeccakF1600Step().

a24

#define a24   (p->u.s[14])

Referenced by KeccakF1600Step().

a30

#define a30   (p->u.s[15])

Referenced by KeccakF1600Step().

a31

#define a31   (p->u.s[16])

Referenced by KeccakF1600Step().

a32

#define a32   (p->u.s[17])

Referenced by KeccakF1600Step().

a33

#define a33   (p->u.s[18])

Referenced by KeccakF1600Step().

a34

#define a34   (p->u.s[19])

Referenced by KeccakF1600Step().

a40

#define a40   (p->u.s[20])

Referenced by KeccakF1600Step().

a41

#define a41   (p->u.s[21])

Referenced by KeccakF1600Step().

a42

#define a42   (p->u.s[22])

Referenced by KeccakF1600Step().

a43

#define a43   (p->u.s[23])

Referenced by KeccakF1600Step().

a44

#define a44   (p->u.s[24])

Referenced by KeccakF1600Step().

ALWAYS

#define ALWAYS

(

X

)

Value:

((X)?1:(assert(0),0))

Referenced by exprAnalyze(), idxCreateVtabSchema(), idxGetTableInfo(), impliesNotNullRow(), jsonArgIsJsonb(), lookupName(), renameColumnElistNames(), renameColumnExprCb(), resolveFromTermToCte(), selectExpander(), sqlite3ColumnsFromExprList(), sqlite3ExpandReturning(), sqlite3ExprCanBeNull(), sqlite3ExprCodeTarget(), sqlite3ExprCompare(), sqlite3ExprListAppendVector(), sqlite3Pragma(), sqlite3Select(), sqlite3SrcListShiftJoinType(), sqlite3VdbeEnter(), sqlite3VdbeLeave(), sqlite3WalUndo(), sqlite3WindowRewrite(), vdbePmaWriterFinish(), whereCheckIfBloomFilterIsUseful(), whereLoopAddBtreeIndex(), whereRangeScanEst(), and xferOptimization().

APND_ALIGN_MASK

#define APND_ALIGN_MASK   ((sqlite3_int64)(APND_ROUNDUP-1))

APND_MARK_FOS_SZ

#define APND_MARK_FOS_SZ   8

Referenced by apndReadMark(), and apndWriteMark().

APND_MARK_PREFIX

#define APND_MARK_PREFIX   "Start-Of-SQLite3-"

Referenced by apndReadMark(), and apndWriteMark().

APND_MARK_PREFIX_SZ

#define APND_MARK_PREFIX_SZ   17

Referenced by apndReadMark(), and apndWriteMark().

APND_MARK_SIZE

#define APND_MARK_SIZE   (APND_MARK_PREFIX_SZ+APND_MARK_FOS_SZ)

Referenced by apndIsAppendvfsDatabase(), apndOpen(), apndReadMark(), apndTruncate(), and apndWriteMark().

APND_MAX_SIZE

#define APND_MAX_SIZE   (0x40000000)

Referenced by apndWrite().

APND_ROUNDUP

#define APND_ROUNDUP   4096

APND_START_ROUNDUP

#define APND_START_ROUNDUP

(

fsz

)

Value:

(((fsz)+APND_ALIGN_MASK) & ~APND_ALIGN_MASK)

Referenced by apndOpen().

ArraySize

#define ArraySize

(

X

)

Value:

(int)(sizeof(X)/sizeof(X[0]))

Referenced by createMask(), createTableStmt(), do_meta_command(), insertCell(), insertCellFast(), integerValue(), main(), printSchemaLine(), safeModeAuth(), shell_callback(), shellAddSchemaName(), showHelp(), and whereShortCut().

AUTOCOLUMN_SEP

#define AUTOCOLUMN_SEP   "_"

Referenced by zAutoColumn().

AUTOEQP_full

#define AUTOEQP_full   3 /* Show full EXPLAIN */

Referenced by do_meta_command(), main(), and shell_exec().

AUTOEQP_off

#define AUTOEQP_off   0 /* Automatic EXPLAIN QUERY PLAN is off */

AUTOEQP_on

#define AUTOEQP_on   1 /* Automatic EQP is on */

Referenced by do_meta_command(), and main().

AUTOEQP_trigger

#define AUTOEQP_trigger   2 /* On and also show plans for triggers */

Referenced by do_meta_command(), and shell_exec().

b

#define b   qq[1]

Referenced by apndGetLastError(), balance_nonroot(), balance_quick(), cli_strcmp(), cli_strncmp(), exprAnalyzeOrTerm(), main(), parserSyntaxError(), percentSameValue(), SHA1Transform(), sqlite3BtreeCopyFile(), sqlite3BtreeSecureDelete(), sqlite3GetVarint(), sqlite3LogEstAdd(), sqlite3Pragma(), sqlite3StrIHash(), sqlite3WhereBegin(), and whereLoopAddBtree().

B64_DARK_MAX

#define B64_DARK_MAX   72

Referenced by base64(), and toBase64().

B85_CLASS

#define B85_CLASS

(

c

)

Value:

(((c)>='#')+((c)>'&')+((c)>='*')+((c)>'z'))

B85_DARK_MAX

#define B85_DARK_MAX   80

Referenced by toBase85().

B85_DNOS

#define B85_DNOS

(

c

)

Value:

b85_cOffset[B85_CLASS(c)]

Referenced by fromBase85().

BASE64_EXPOSE

#define BASE64_EXPOSE	(		db,
			pzErr )

Value:

/* Not needed, ..._init() does this. */

BASE64_INIT

#define BASE64_INIT

(

db

)

Value:

sqlite3_base64_init(db, 0, 0)

BASE85_EXPOSE

#define BASE85_EXPOSE	(		db,
			pzErr )

Value:

/* Not needed, ..._init() does this. */

BASE85_INIT

#define BASE85_INIT

(

db

)

Value:

sqlite3_base85_init(db, 0, 0)

base85Numeral

#define base85Numeral

(

dn

)

Value:

  ((char)(((dn) < 4)? (char)((dn) + '#') : (char)((dn) - 4 + '*')))

# define base85Numeral( dn )\
  ((char)(((dn) < 4)? (char)((dn) + '#') : (char)((dn) - 4 + '*')))

Referenced by toBase85().

BEGIN_TIMER

#define BEGIN_TIMER   beginTimer()

Referenced by runOneSqlLine().

blk

#define blk

(

i

)

Value:

    (block[i&15] = rol(block[(i+13)&15]^block[(i+8)&15] \
    ^block[(i+2)&15]^block[i&15],1))

#define blk(i) (block[i&15] = rol(block[(i+13)&15]^block[(i+8)&15] \
    ^block[(i+2)&15]^block[i&15],1))

blk0be

#define blk0be

(

i

)

Value:

block[i]

blk0le

#define blk0le

(

i

)

Value:

    (block[i] = (ror(block[i],8)&0xFF00FF00) \
    |(rol(block[i],8)&0x00FF00FF))

#define blk0le(i) (block[i] = (ror(block[i],8)&0xFF00FF00) \
    |(rol(block[i],8)&0x00FF00FF))

BOX_12

#define BOX_12   "\342\224\224" /* U+2514 '- */

Referenced by exec_prepared_stmt_columnar().

BOX_123

#define BOX_123   "\342\224\234" /* U+251c |- */

Referenced by exec_prepared_stmt_columnar().

BOX_1234

#define BOX_1234   "\342\224\274" /* U+253c -|- */

Referenced by exec_prepared_stmt_columnar().

BOX_124

#define BOX_124   "\342\224\264" /* U+2534 -'- */

Referenced by exec_prepared_stmt_columnar().

BOX_13

#define BOX_13   "\342\224\202" /* U+2502 | */

Referenced by exec_prepared_stmt_columnar().

BOX_134

#define BOX_134   "\342\224\244" /* U+2524 -| */

Referenced by exec_prepared_stmt_columnar().

BOX_14

#define BOX_14   "\342\224\230" /* U+2518 -' */

Referenced by exec_prepared_stmt_columnar().

BOX_23

#define BOX_23   "\342\224\214" /* U+250c ,- */

Referenced by exec_prepared_stmt_columnar().

BOX_234

#define BOX_234   "\342\224\254" /* U+252c -,- */

Referenced by exec_prepared_stmt_columnar().

BOX_24

#define BOX_24   "\342\224\200" /* U+2500 --- */

Referenced by print_box_line().

BOX_34

#define BOX_34   "\342\224\220" /* U+2510 -, */

Referenced by exec_prepared_stmt_columnar().

BX_DV_PROTO

#define BX_DV_PROTO

(

c

)

Value:

  ((((u8)(c))<0x80)? (u8)(b64DigitValues[(u8)(c)]) : 0x80)

#define BX_DV_PROTO(c) \
  ((((u8)(c))<0x80)? (u8)(b64DigitValues[(u8)(c)]) : 0x80)

Referenced by fromBase64(), and skipNonB64().

BX_NUMERAL

#define BX_NUMERAL

(

dv

)

Value:

(b64Numerals[(u8)(dv)])

Referenced by toBase64().

c

#define c   qq[2]

Referenced by ascii_read_one_field(), charFunc(), cli_wcwidth(), codeInteger(), compare2pow63(), csv_read_one_field(), decimalNewFromText(), decodeIntArray(), dekkerMul2(), do_meta_command(), escapeOutput(), exprAnalyze(), fromBase64(), fromBase85(), getToken(), hexDigitValue(), import_append_char(), indexCellCompare(), intckGetToken(), intckIsSpace(), isLikeOrGlob(), journalHdrOffset(), json5Whitespace(), jsonAppendChar(), jsonAppendControlChar(), jsonAppendString(), jsonArgIsJsonb(), jsonBlobAppendOneByte(), jsonbValidityCheck(), jsonGroupInverse(), jsonReturnFromBlob(), jsonTranslateTextToBlob(), needUnistr(), output_c_string(), output_json_string(), output_quoted_string(), pager_delsuper(), parseTimezone(), patternCompare(), putcs(), re_digit_char(), re_esc_char(), re_hex(), re_next_char(), re_next_char_nocase(), re_space_char(), re_subcompile_string(), re_word_char(), resolve_backslashes(), setLexemeOpen(), SHA1Transform(), shell_callback(), shell_dbtotxt_command(), skipNonB64(), skipNonB85(), sqlite3_complete(), sqlite3_str_vappendf(), sqlite3Atoi64(), sqlite3BlobCompare(), sqlite3BtreeIndexMoveto(), sqlite3BtreeTableMoveto(), sqlite3GetInt32(), sqlite3LoadExtension(), sqlite3ParseUri(), sqlite3re_match(), sqlite3Utf16ByteLen(), sqlite3Utf8Read(), sqlite3Utf8ReadLimited(), sqlite3VdbeMemTranslate(), sqlite3VdbeMultiLoad(), sqlite3VdbeReset(), strftimeFunc(), testcase_glob(), translateForDisplayAndDup(), unhexFunc(), utf8_width_print(), and zSkipValidUtf8().

CHAR_BIT

#define CHAR_BIT   8

ColModeOpts_default

#define ColModeOpts_default   { 60, 0, 0 }

Referenced by do_meta_command().

ColModeOpts_default_qbox

#define ColModeOpts_default_qbox   { 60, 1, 0 }

Referenced by do_meta_command().

COMPLETION_COLLATIONS

#define COMPLETION_COLLATIONS   4

COMPLETION_COLUMN_CANDIDATE

#define COMPLETION_COLUMN_CANDIDATE   0 /* Suggested completion of the input */

Referenced by completionColumn().

COMPLETION_COLUMN_PHASE

#define COMPLETION_COLUMN_PHASE   3 /* ePhase - used for debugging only */

Referenced by completionColumn().

COMPLETION_COLUMN_PREFIX

#define COMPLETION_COLUMN_PREFIX   1 /* Prefix of the word to be completed */

Referenced by completionBestIndex(), and completionColumn().

COMPLETION_COLUMN_WHOLELINE

#define COMPLETION_COLUMN_WHOLELINE   2 /* Entire line seen so far */

Referenced by completionBestIndex(), and completionColumn().

COMPLETION_COLUMNS

#define COMPLETION_COLUMNS   9

Referenced by completionNext().

COMPLETION_DATABASES

#define COMPLETION_DATABASES   7

Referenced by completionNext().

COMPLETION_EOF

#define COMPLETION_EOF   11

Referenced by completionEof(), and completionNext().

COMPLETION_FIRST_PHASE

#define COMPLETION_FIRST_PHASE   1

Referenced by completionFilter().

COMPLETION_FUNCTIONS

#define COMPLETION_FUNCTIONS   3

COMPLETION_INDEXES

#define COMPLETION_INDEXES   5

COMPLETION_KEYWORDS

#define COMPLETION_KEYWORDS   1

Referenced by completionNext().

COMPLETION_MODULES

#define COMPLETION_MODULES   10

COMPLETION_PRAGMAS

#define COMPLETION_PRAGMAS   2

COMPLETION_TABLES

#define COMPLETION_TABLES   8 /* Also VIEWs and TRIGGERs */

Referenced by completionNext().

COMPLETION_TRIGGERS

#define COMPLETION_TRIGGERS   6

CONTINUATION_PROMPT

#define CONTINUATION_PROMPT   dynamicContinuePrompt()

Referenced by one_input_line().

CONTINUE_PAREN_INCR

#define CONTINUE_PAREN_INCR	(		p,
			n )

Value:

  if(p && stdin_is_interactive) (trackParenLevel(p,n))

# define CONTINUE_PAREN_INCR(p,n) \
  if(p && stdin_is_interactive) (trackParenLevel(p,n))

Referenced by quickscan().

CONTINUE_PROMPT_AWAITC

#define CONTINUE_PROMPT_AWAITC	(		p,
			c )

Value:

  if(p && stdin_is_interactive) setLexemeOpen(p, 0, c)

# define CONTINUE_PROMPT_AWAITC(p,c) \
  if(p && stdin_is_interactive) setLexemeOpen(p, 0, c)

Referenced by quickscan().

CONTINUE_PROMPT_AWAITS

#define CONTINUE_PROMPT_AWAITS	(		p,
			s )

Value:

  if(p && stdin_is_interactive) setLexemeOpen(p, s, 0)

# define CONTINUE_PROMPT_AWAITS(p,s) \
  if(p && stdin_is_interactive) setLexemeOpen(p, s, 0)

Referenced by quickscan().

CONTINUE_PROMPT_PSTATE

#define CONTINUE_PROMPT_PSTATE   (&dynPrompt)

Referenced by process_input().

CONTINUE_PROMPT_RESET

#define CONTINUE_PROMPT_RESET    do {setLexemeOpen(&dynPrompt,0,0); trackParenLevel(&dynPrompt,0);} while(0)

# define CONTINUE_PROMPT_RESET \
  do {setLexemeOpen(&dynPrompt,0,0); trackParenLevel(&dynPrompt,0);} while(0)

Referenced by process_input().

CTIMEOPT_VAL

#define CTIMEOPT_VAL

(

opt

)

Value:

CTIMEOPT_VAL_(opt)

Referenced by do_meta_command().

CTIMEOPT_VAL_

#define CTIMEOPT_VAL_

(

opt

)

Value:

#opt

d

#define d   qq[3]

Referenced by balance_nonroot(), jsonBlobEdit(), jsonBlobOverwrite(), seriesFilter(), SHA1Transform(), sqlite3AtoF(), sqlite3VdbeRecordUnpack(), and unhexFunc().

deliberate_fall_through

#define deliberate_fall_through

Referenced by exprImpliesNotNull(), exprNodeIsConstant(), fkActionTrigger(), fromBase64(), impliesNotNullRow(), jsonTranslateTextToBlob(), jsonValidFunc(), quickscan(), resolveExprStep(), resolveP2Values(), sqlite3_str_vappendf(), sqlite3ExprCodeTarget(), sqlite3ExprIfFalse(), sqlite3ExprIfTrue(), and sqlite3GenerateConstraintChecks().

e

#define e   qq[4]

Referenced by checkColumnOverlap(), decimalFromDouble(), ieee754func(), SHA1Transform(), sqlite3AtoF(), sqlite3FpDecode(), and sqlite3LogEstToInt().

END_TIMER

#define END_TIMER

(

X

)

Value:

endTimer(X)

Referenced by runOneSqlLine().

eputz

#define eputz

(

z

)

Value:

sqlite3_fputs(z,stderr)

Referenced by do_meta_command(), main(), process_sqliterc(), shell_out_of_memory(), and usage().

EXPERT_CONFIG_SAMPLE

#define EXPERT_CONFIG_SAMPLE   1 /* int */

Referenced by expertDotCommand(), and sqlite3_expert_config().

EXPERT_REPORT_CANDIDATES

#define EXPERT_REPORT_CANDIDATES   4

Referenced by expertFinish(), and sqlite3_expert_report().

EXPERT_REPORT_INDEXES

#define EXPERT_REPORT_INDEXES   2

Referenced by expertFinish(), and sqlite3_expert_report().

EXPERT_REPORT_PLAN

#define EXPERT_REPORT_PLAN   3

Referenced by expertFinish(), and sqlite3_expert_report().

EXPERT_REPORT_SQL

#define EXPERT_REPORT_SQL   1

Referenced by expertFinish(), and sqlite3_expert_report().

FSDIR_COLUMN_DATA

#define FSDIR_COLUMN_DATA   3 /* File content */

Referenced by fsdirColumn().

FSDIR_COLUMN_DIR

#define FSDIR_COLUMN_DIR   5 /* Path is relative to this directory */

Referenced by fsdirBestIndex().

FSDIR_COLUMN_MODE

#define FSDIR_COLUMN_MODE   1 /* Access mode */

Referenced by fsdirColumn().

FSDIR_COLUMN_MTIME

#define FSDIR_COLUMN_MTIME   2 /* Last modification time */

Referenced by fsdirColumn().

FSDIR_COLUMN_NAME

#define FSDIR_COLUMN_NAME   0 /* Name of the file */

Referenced by fsdirColumn().

FSDIR_COLUMN_PATH

#define FSDIR_COLUMN_PATH   4 /* Path to top of search */

Referenced by fsdirBestIndex(), and fsdirColumn().

FSDIR_SCHEMA

#define FSDIR_SCHEMA   "(name,mode,mtime,data,path HIDDEN,dir HIDDEN)"

Referenced by fsdirConnect().

GETPID

#define GETPID   getpid

Referenced by main().

HAS_TIMER

#define HAS_TIMER   1

Referenced by do_meta_command().

IDX_HASH_SIZE

#define IDX_HASH_SIZE   1023

Referenced by idxHashClear(), and idxHashString().

IS_B85

#define IS_B85

(

c

)

Value:

(B85_CLASS(c) & 1)

Referenced by skipNonB85().

IS_BX_DIGIT

#define IS_BX_DIGIT

(

bdp

)

Value:

(((u8)(bdp))<0x80)

Referenced by skipNonB64().

IS_BX_PAD

#define IS_BX_PAD

(

bdp

)

Value:

((bdp)==PC)

IS_BX_WS

#define IS_BX_WS

(

bdp

)

Value:

((bdp)==WS)

IsAlnum

#define IsAlnum

(

X

)

Value:

isalnum((unsigned char)X)

Referenced by completionFilter(), quoteChar(), shell_callback(), and translateForDisplayAndDup().

IsAlpha

#define IsAlpha

(

X

)

Value:

isalpha((unsigned char)X)

Referenced by quoteChar().

IsDigit

#define IsDigit

(

X

)

Value:

isdigit((unsigned char)X)

Referenced by do_meta_command(), integerValue(), isNumber(), and testcase_glob().

IsSpace

#define IsSpace

(

X

)

Value:

isspace((unsigned char)X)

Referenced by decimalNewFromText(), do_meta_command(), line_is_command_terminator(), process_input(), quickscan(), shell_callback(), shell_error_context(), shell_exec(), testcase_glob(), translateForDisplayAndDup(), and wsToEol().

LARGEST_INT64

#define LARGEST_INT64   (0xffffffff|(((sqlite3_int64)0x7fffffff)<<32))

Referenced by randomFunc(), seriesFilter(), sqlite3AddInt64(), sqlite3Atoi64(), sqlite3BtreeIntegrityCheck(), sqlite3SubInt64(), and valueFromExpr().

LARGEST_UINT64

#define LARGEST_UINT64   (0xffffffff|(((sqlite3_uint64)0xffffffff)<<32))

Referenced by sqlite3AtoF().

MAX_INPUT_NESTING

#define MAX_INPUT_NESTING   25

Referenced by process_input().

MODE_Ascii

#define MODE_Ascii   10 /* Use ASCII unit and record separators (0x1F/0x1E) */

Referenced by do_meta_command(), main(), and shell_callback().

MODE_Box

#define MODE_Box   16 /* Unicode box-drawing characters */

Referenced by do_meta_command(), exec_prepared_stmt(), exec_prepared_stmt_columnar(), and main().

MODE_Column

#define MODE_Column   1 /* One record per line in neat columns */

Referenced by do_meta_command(), exec_prepared_stmt(), exec_prepared_stmt_columnar(), and main().

MODE_Count

#define MODE_Count   17 /* Output only a count of the rows of output */

Referenced by do_meta_command(), exec_prepared_stmt(), and shell_callback().

MODE_Csv

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

Referenced by do_meta_command(), main(), and shell_callback().

MODE_EQP

#define MODE_EQP   12 /* Converts EXPLAIN QUERY PLAN output into a graph */

Referenced by shell_callback(), and shell_exec().

MODE_Explain

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

Referenced by do_meta_command(), shell_callback(), and shell_exec().

MODE_Html

#define MODE_Html   4 /* Generate an XHTML table */

Referenced by do_meta_command(), main(), and shell_callback().

MODE_Insert

#define MODE_Insert   5 /* Generate SQL "insert" statements */

Referenced by do_meta_command(), dump_callback(), exec_prepared_stmt(), and shell_callback().

MODE_Json

#define MODE_Json   13 /* Output JSON */

Referenced by do_meta_command(), exec_prepared_stmt(), main(), and shell_callback().

MODE_Line

#define MODE_Line   0 /* One column per line. Blank line between records */

Referenced by do_meta_command(), main(), and shell_callback().

MODE_List

#define MODE_List   2 /* One record per line with a separator */

Referenced by do_meta_command(), main(), main_init(), and shell_callback().

MODE_Markdown

#define MODE_Markdown   14 /* Markdown formatting */

Referenced by do_meta_command(), exec_prepared_stmt(), exec_prepared_stmt_columnar(), and main().

MODE_Off

#define MODE_Off   18 /* No query output shown */

Referenced by do_meta_command(), and shell_callback().

MODE_Pretty

#define MODE_Pretty   11 /* Pretty-print schemas */

Referenced by do_meta_command(), and shell_callback().

MODE_Quote

#define MODE_Quote   6 /* Quote values as for SQL */

Referenced by do_meta_command(), exec_prepared_stmt(), main(), and shell_callback().

MODE_ScanExp

#define MODE_ScanExp   19 /* Like MODE_Explain, but for ".scanstats vm" */

Referenced by display_scanstats(), and shell_callback().

MODE_Semi

#define MODE_Semi   3 /* Same as MODE_List but append ";" to each line */

Referenced by do_meta_command(), and shell_callback().

MODE_Table

#define MODE_Table   15 /* MySQL-style table formatting */

Referenced by do_meta_command(), exec_prepared_stmt(), exec_prepared_stmt_columnar(), and main().

MODE_Tcl

#define MODE_Tcl   7 /* Generate ANSI-C or TCL quoted elements */

Referenced by do_meta_command(), and shell_callback().

MODE_Www

#define MODE_Www   20 /* Full web-page output */

Referenced by do_meta_command(), exec_prepared_stmt(), output_redir(), output_reset(), and shell_callback().

ND

#define ND   0x82 /* Not above or digit-value */

Referenced by fromBase64().

NEVER

#define NEVER

(

X

)

Value:

((X)?(assert(0),1):0)

Referenced by constraintCompatibleWithOuterJoin(), sqlite3ColumnSetExpr(), sqlite3ExprAddFunctionOrderBy(), sqlite3ExprCodeTarget(), whereOmitNoopJoin(), and whereReverseScanOrder().

OMIT_BASE85_CHECKER

#define OMIT_BASE85_CHECKER

OPEN_DB_KEEPALIVE

#define OPEN_DB_KEEPALIVE   0x001 /* Return after error if true */

Referenced by do_meta_command(), and open_db().

OPEN_DB_ZIPFILE

#define OPEN_DB_ZIPFILE   0x002 /* Open as ZIP if name matches *.zip */

Referenced by main(), and open_db().

ORIGFILE

#define ORIGFILE

(

p

)

Value:

((sqlite3_file*)(((ApndFile*)(p))+1))

Referenced by apndCheckReservedLock(), apndClose(), apndDeviceCharacteristics(), apndFetch(), apndFileControl(), apndLock(), apndOpen(), apndRead(), apndSectorSize(), apndShmBarrier(), apndShmLock(), apndShmMap(), apndShmUnmap(), apndSync(), apndTruncate(), apndUnfetch(), apndUnlock(), apndWrite(), and apndWriteMark().

ORIGVFS

#define ORIGVFS

(

p

)

Value:

((sqlite3_vfs*)((p)->pAppData))

Referenced by apndAccess(), apndCurrentTime(), apndCurrentTimeInt64(), apndDelete(), apndDlClose(), apndDlError(), apndDlOpen(), apndFullPathname(), apndGetLastError(), apndGetSystemCall(), apndNextSystemCall(), apndOpen(), apndRandomness(), apndSetSystemCall(), and apndSleep().

PAD_CHAR

#define PAD_CHAR   '='

Referenced by fromBase64(), and toBase64().

PC

#define PC   0x80 /* pad character */

Referenced by fromBase64().

PROMPT_LEN_MAX

#define PROMPT_LEN_MAX   128

Referenced by dynamicContinuePrompt().

QSS_INPLAIN

#define QSS_INPLAIN

(

qss

)

Value:

(((qss)&QSS_CharMask)==QSS_Start)

Referenced by process_input().

QSS_PLAINDARK

#define QSS_PLAINDARK

(

qss

)

Value:

(((qss)&~QSS_EndingSemi)==QSS_HasDark)

QSS_PLAINWHITE

#define QSS_PLAINWHITE

(

qss

)

Value:

(((qss)&~QSS_EndingSemi)==QSS_Start)

Referenced by process_input().

QSS_SEMITERM

#define QSS_SEMITERM

(

qss

)

Value:

(((qss)&~QSS_HasDark)==QSS_EndingSemi)

Referenced by process_input().

QSS_SETV

#define QSS_SETV	(		qss,
			newst )

Value:

((newst) | ((qss) & QSS_ScanMask))

Referenced by quickscan().

R1

#define R1	(		v,
			w,
			x,
			y,
			z,
			i )

Value:

    z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=ror(w,2);

#define R1(v,w,x,y,z,i) \
    z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=ror(w,2);

Referenced by SHA1Transform().

R2

#define R2	(		v,
			w,
			x,
			y,
			z,
			i )

Value:

    z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=ror(w,2);

#define R2(v,w,x,y,z,i) \
    z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=ror(w,2);

Referenced by SHA1Transform().

R3

#define R3	(		v,
			w,
			x,
			y,
			z,
			i )

Value:

    z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=ror(w,2);

#define R3(v,w,x,y,z,i) \
    z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=ror(w,2);

Referenced by SHA1Transform().

R4

#define R4	(		v,
			w,
			x,
			y,
			z,
			i )

Value:

    z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=ror(w,2);

#define R4(v,w,x,y,z,i) \
    z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=ror(w,2);

Referenced by SHA1Transform().

Rb0

#define Rb0	(		v,
			w,
			x,
			y,
			z,
			i )

Value:

    z+=((w&(x^y))^y)+blk0be(i)+0x5A827999+rol(v,5);w=ror(w,2);

#define Rb0(v,w,x,y,z,i) \
    z+=((w&(x^y))^y)+blk0be(i)+0x5A827999+rol(v,5);w=ror(w,2);

Referenced by SHA1Transform().

re_compile

#define re_compile   sqlite3re_compile

Referenced by re_sql_func().

RE_EOF

#define RE_EOF   0 /* End of input */

Referenced by re_subcompile_string(), and sqlite3re_match().

re_free

#define re_free   sqlite3re_free

Referenced by re_sql_func(), and sqlite3re_compile().

re_match

#define re_match   sqlite3re_match

Referenced by re_sql_func().

RE_OP_ACCEPT

#define RE_OP_ACCEPT   6 /* Halt and indicate a successful match */

Referenced by sqlite3re_compile(), and sqlite3re_match().

RE_OP_ANY

#define RE_OP_ANY   2 /* Match any one character. (Implements ".") */

Referenced by re_subcompile_string(), and sqlite3re_match().

RE_OP_ANYSTAR

#define RE_OP_ANYSTAR   3 /* Special optimized version of .* */

Referenced by re_subcompile_string(), sqlite3re_compile(), and sqlite3re_match().

RE_OP_ATSTART

#define RE_OP_ATSTART   18 /* Currently at the start of the string */

Referenced by re_subcompile_string(), and sqlite3re_match().

RE_OP_BOUNDARY

#define RE_OP_BOUNDARY   17 /* Boundary between word and non-word */

Referenced by re_subcompile_string(), and sqlite3re_match().

RE_OP_CC_EXC

#define RE_OP_CC_EXC   8 /* Beginning of a [^...] character class */

Referenced by re_subcompile_string(), and sqlite3re_match().

RE_OP_CC_INC

#define RE_OP_CC_INC   7 /* Beginning of a [...] character class */

Referenced by re_subcompile_string(), and sqlite3re_match().

RE_OP_CC_RANGE

#define RE_OP_CC_RANGE   10 /* Range of values in a character class */

Referenced by re_subcompile_string().

RE_OP_CC_VALUE

#define RE_OP_CC_VALUE   9 /* Single value in a character class */

Referenced by re_subcompile_string(), and sqlite3re_match().

RE_OP_DIGIT

#define RE_OP_DIGIT   13 /* digit: [0-9] */

Referenced by re_subcompile_string(), and sqlite3re_match().

RE_OP_FORK

#define RE_OP_FORK   4 /* Continue to both next and opcode at iArg */

Referenced by re_subcompile_re(), re_subcompile_string(), and sqlite3re_match().

RE_OP_GOTO

#define RE_OP_GOTO   5 /* Jump to opcode at iArg */

Referenced by re_subcompile_re(), re_subcompile_string(), and sqlite3re_match().

RE_OP_MATCH

#define RE_OP_MATCH   1 /* Match the one character in the argument */

Referenced by re_subcompile_string(), sqlite3re_compile(), and sqlite3re_match().

RE_OP_NOTDIGIT

#define RE_OP_NOTDIGIT   14 /* Not a digit */

Referenced by re_subcompile_string(), and sqlite3re_match().

RE_OP_NOTSPACE

#define RE_OP_NOTSPACE   16 /* Not a digit */

Referenced by re_subcompile_string(), and sqlite3re_match().

RE_OP_NOTWORD

#define RE_OP_NOTWORD   12 /* Not a perl word character */

Referenced by re_subcompile_string(), and sqlite3re_match().

RE_OP_SPACE

#define RE_OP_SPACE   15 /* space: [ \t\n\r\v\f] */

Referenced by re_subcompile_string(), and sqlite3re_match().

RE_OP_WORD

#define RE_OP_WORD   11 /* Perl word character [A-Za-z0-9_] */

Referenced by re_subcompile_string(), and sqlite3re_match().

RE_START

#define RE_START   0xfffffff /* Start of input - larger than an UTF-8 */

Referenced by sqlite3re_match().

Rl0

#define Rl0	(		v,
			w,
			x,
			y,
			z,
			i )

Value:

    z+=((w&(x^y))^y)+blk0le(i)+0x5A827999+rol(v,5);w=ror(w,2);

#define Rl0(v,w,x,y,z,i) \
    z+=((w&(x^y))^y)+blk0le(i)+0x5A827999+rol(v,5);w=ror(w,2);

Referenced by SHA1Transform().

rol

#define rol	(		x,
			k )

Value:

SHA_ROT(x,k,32-(k))

ROL64

#define ROL64	(		a,
			x )

Value:

((a<<x)|(a>>(64-x)))

Referenced by KeccakF1600Step().

ror

#define ror	(		x,
			k )

Value:

SHA_ROT(x,32-(k),k)

SCAN_TRACKER_REFTYPE

#define SCAN_TRACKER_REFTYPE   t_DynaPromptRef

Referenced by quickscan().

SEP_Column

#define SEP_Column   "|"

Referenced by do_meta_command(), and main_init().

SEP_Comma

#define SEP_Comma   ","

Referenced by do_meta_command(), and main().

SEP_CrLf

#define SEP_CrLf   "\r\n"

Referenced by do_meta_command().

SEP_Record

#define SEP_Record   "\x1E"

Referenced by do_meta_command(), and main().

SEP_Row

#define SEP_Row   "\n"

Referenced by do_meta_command(), main(), and main_init().

SEP_Space

#define SEP_Space   " "

Referenced by do_meta_command().

SEP_Tab

#define SEP_Tab   "\t"

Referenced by do_meta_command(), and main().

SEP_Unit

#define SEP_Unit   "\x1F"

Referenced by do_meta_command(), and main().

SERIES_COLUMN_ROWID

#define SERIES_COLUMN_ROWID   (-1)

Referenced by seriesBestIndex().

SERIES_COLUMN_START

#define SERIES_COLUMN_START   1

Referenced by seriesBestIndex(), and seriesColumn().

SERIES_COLUMN_STEP

#define SERIES_COLUMN_STEP   3

Referenced by seriesBestIndex(), and seriesColumn().

SERIES_COLUMN_STOP

#define SERIES_COLUMN_STOP   2

Referenced by seriesBestIndex(), and seriesColumn().

SERIES_COLUMN_VALUE

#define SERIES_COLUMN_VALUE   0

Referenced by seriesBestIndex().

session_close_all

#define session_close_all	(		X,
			Y )

Referenced by do_meta_command(), and main().

SHA3_BYTEORDER

#define SHA3_BYTEORDER   0

SHA_ROT

#define SHA_ROT	(		x,
			l,
			r )

Value:

((x) << (l) | (x) >> (r))

SHELL_ESC_ASCII

#define SHELL_ESC_ASCII   0 /* Substitute ^Y for X where Y=X+0x40 */

Referenced by escapeOutput(), and translateForDisplayAndDup().

SHELL_ESC_OFF

#define SHELL_ESC_OFF   2 /* Send characters verbatim */

Referenced by do_meta_command(), escapeOutput(), output_quoted_escaped_string(), output_quoted_string(), and translateForDisplayAndDup().

SHELL_ESC_SYMBOL

#define SHELL_ESC_SYMBOL   1 /* Substitute U+2400 graphics */

Referenced by escapeOutput(), and translateForDisplayAndDup().

SHELL_OPEN_APPENDVFS

#define SHELL_OPEN_APPENDVFS   2 /* Use appendvfs */

Referenced by deduceDatabaseType(), do_meta_command(), main(), and open_db().

SHELL_OPEN_DESERIALIZE

#define SHELL_OPEN_DESERIALIZE   5 /* Open using sqlite3_deserialize() */

Referenced by do_meta_command(), main(), and open_db().

SHELL_OPEN_HEXDB

#define SHELL_OPEN_HEXDB   6 /* Use "dbtotxt" output as data source */

Referenced by do_meta_command(), and open_db().

SHELL_OPEN_NORMAL

#define SHELL_OPEN_NORMAL   1 /* Normal database file */

Referenced by deduceDatabaseType(), and open_db().

SHELL_OPEN_READONLY

#define SHELL_OPEN_READONLY   4 /* Open a normal database read-only */

Referenced by do_meta_command(), main(), and open_db().

SHELL_OPEN_UNSPEC

#define SHELL_OPEN_UNSPEC   0 /* No open-mode specified */

Referenced by deduceDatabaseType(), do_meta_command(), and open_db().

SHELL_OPEN_ZIPFILE

#define SHELL_OPEN_ZIPFILE   3 /* Use the zipfile virtual table */

Referenced by deduceDatabaseType(), do_meta_command(), main(), and open_db().

SHELL_PROGRESS_ONCE

#define SHELL_PROGRESS_ONCE   0x04 /* Cancel the --limit after firing once */

Referenced by do_meta_command(), and progress_handler().

SHELL_PROGRESS_QUIET

#define SHELL_PROGRESS_QUIET   0x01 /* Omit announcing every progress callback */

Referenced by do_meta_command(), and progress_handler().

SHELL_PROGRESS_RESET

#define SHELL_PROGRESS_RESET

Value:

                                   0x02  /* Reset the count when the progress
                                   ** callback limit is reached, and for each
                                   ** top-level SQL statement */

Referenced by do_meta_command(), progress_handler(), and runOneSqlLine().

shell_read_history

#define shell_read_history

(

X

)

Referenced by main().

shell_stifle_history

#define shell_stifle_history

(

X

)

Referenced by main().

SHELL_STRINGIFY

#define SHELL_STRINGIFY

(

f

)

Value:

SHELL_STRINGIFY_(f)

SHELL_STRINGIFY_

#define SHELL_STRINGIFY_

(

f

)

Value:

#f

SHELL_TRACE_EXPANDED

#define SHELL_TRACE_EXPANDED   1 /* Show expanded SQL text */

Referenced by do_meta_command(), and sql_trace_callback().

SHELL_TRACE_NORMALIZED

#define SHELL_TRACE_NORMALIZED   2 /* Show normalized SQL text */

Referenced by do_meta_command(), and sql_trace_callback().

SHELL_TRACE_PLAIN

#define SHELL_TRACE_PLAIN   0 /* Show input SQL text */

Referenced by do_meta_command().

SHELL_USE_LOCAL_GETLINE

#define SHELL_USE_LOCAL_GETLINE   1

shell_write_history

#define shell_write_history

(

X

)

Referenced by main().

ShellClearFlag

#define ShellClearFlag	(		P,
			X )

Value:

((P)->shellFlgs&=(~(X)))

Referenced by do_meta_command(), and setOrClearFlag().

ShellHasFlag

#define ShellHasFlag	(		P,
			X )

Value:

(((P)->shellFlgs & (X))!=0)

Referenced by do_meta_command(), open_db(), runOneSqlLine(), shell_callback(), and tableColumnList().

ShellSetFlag

#define ShellSetFlag	(		P,
			X )

Value:

((P)->shellFlgs|=(X))

Referenced by do_meta_command(), main(), and setOrClearFlag().

SHFLG_Backslash

#define SHFLG_Backslash   0x00000004 /* The --backslash option is used */

Referenced by main(), and runOneSqlLine().

SHFLG_CountChanges

#define SHFLG_CountChanges   0x00000020 /* .changes setting */

Referenced by do_meta_command(), and runOneSqlLine().

SHFLG_DumpDataOnly

#define SHFLG_DumpDataOnly   0x00000100 /* .dump show data only */

Referenced by do_meta_command(), and dump_callback().

SHFLG_DumpNoSys

#define SHFLG_DumpNoSys   0x00000200 /* .dump omits system tables */

Referenced by do_meta_command(), and dump_callback().

SHFLG_Echo

#define SHFLG_Echo   0x00000040 /* .echo on/off, or --echo setting */

Referenced by do_meta_command(), and main().

SHFLG_HeaderSet

#define SHFLG_HeaderSet   0x00000080 /* showHeader has been specified */

Referenced by do_meta_command(), and main().

SHFLG_Lookaside

#define SHFLG_Lookaside   0x00000002 /* Lookaside memory is used */

Referenced by display_stats(), main(), and main_init().

SHFLG_Newlines

#define SHFLG_Newlines   0x00000010 /* .dump --newline flag */

Referenced by do_meta_command(), and shell_callback().

SHFLG_Pagecache

#define SHFLG_Pagecache   0x00000001 /* The --pagecache option is used */

Referenced by display_stats(), and main().

SHFLG_PreserveRowid

#define SHFLG_PreserveRowid   0x00000008 /* .dump preserves rowid values */

Referenced by do_meta_command(), and tableColumnList().

SHFLG_TestingMode

#define SHFLG_TestingMode   0x00000400 /* allow unsafe testing features */

Referenced by do_meta_command(), main(), and open_db().

SMALLEST_INT64

#define SMALLEST_INT64   (((sqlite3_int64)-1) - LARGEST_INT64)

Referenced by absFunc(), codeInteger(), jsonReturnFromBlob(), seriesFilter(), sqlite3_str_vappendf(), sqlite3Atoi64(), sqlite3Int64ToText(), and valueFromExpr().

sputz

#define sputz	(		fp,
			z )

Value:

sqlite3_fputs(z,fp)

Referenced by do_meta_command(), main(), one_input_line(), sql_trace_callback(), tryToCloneSchema(), and verify_uninitialized().

sqlite3_base_init [1/2]

#define sqlite3_base_init   sqlite3_base64_init

Referenced by sqlite3_base64_init(), and sqlite3_base85_init().

sqlite3_base_init [2/2]

#define sqlite3_base_init   sqlite3_base85_init

sqlite3_fgets

#define sqlite3_fgets   fgets

Referenced by local_getline(), main(), and readHexDb().

sqlite3_fopen

#define sqlite3_fopen   fopen

Referenced by deduceDatabaseType(), do_meta_command(), editFunc(), openChrSource(), output_file_open(), process_sqliterc(), readFile(), readFileContents(), readHexDb(), and writeFile().

sqlite3_fprintf

#define sqlite3_fprintf   fprintf

Referenced by booleanValue(), close_db(), cmdline_option_value(), createSelftestTable(), csv_read_one_field(), display_stats(), displayStatLine(), do_meta_command(), dump_callback(), endTimer(), eqp_append(), eqp_render(), eqp_render_level(), exec_prepared_stmt_columnar(), expertDotCommand(), expertFinish(), failIfSafeMode(), faultsim_callback(), intckDatabaseCmd(), lintDotCommand(), lintFkeyIndexes(), main(), open_db(), output_c_string(), output_csv(), output_file_open(), output_hex_blob(), output_html_string(), output_json_string(), output_quoted_string(), output_reset(), print_box_line(), print_dashes(), printSchemaLine(), process_input(), process_sqliterc(), progress_handler(), readFile(), readHexDb(), run_schema_dump_query(), run_table_dump_query(), runOneSqlLine(), shell_callback(), shell_dbtotxt_command(), shellAuth(), shellEmitError(), shellFinalize(), shellLog(), shellPutsFunc(), shellReset(), showHelp(), sql_trace_callback(), tryToClone(), tryToCloneData(), tryToCloneSchema(), usage(), and utf8_width_print().

sqlite3_fputs

#define sqlite3_fputs   fputs

Referenced by do_meta_command(), dump_callback(), eqp_render(), exec_prepared_stmt(), exec_prepared_stmt_columnar(), expertFinish(), lintFkeyIndexes(), main(), open_db(), output_c_string(), output_csv(), output_html_string(), output_json_string(), output_quoted_escaped_string(), output_quoted_string(), output_redir(), output_reset(), outputDumpWarning(), print_box_line(), print_box_row_separator(), print_dashes(), print_row_separator(), process_input(), readFile(), readHexDb(), run_schema_dump_query(), run_table_dump_query(), shell_callback(), shellAuth(), and vfstraceOut().

sqlite3_fsetmode

#define sqlite3_fsetmode	(		F,
			X )

Value:

/*no-op*/

Referenced by output_quoted_escaped_string(), output_quoted_string(), setCrlfMode(), and shell_callback().

sqlite3_popen

#define sqlite3_popen   popen

Referenced by do_meta_command().

SQLITE_EXTENSION_INIT1

#define SQLITE_EXTENSION_INIT1

SQLITE_EXTENSION_INIT2

#define SQLITE_EXTENSION_INIT2

(

X

)

Value:

(void)(X)

Referenced by sqlite3_appendvfs_init(), sqlite3_base64_init(), sqlite3_base85_init(), sqlite3_completion_init(), sqlite3_decimal_init(), sqlite3_fileio_init(), sqlite3_ieee_init(), sqlite3_percentile_init(), sqlite3_regexp_init(), sqlite3_series_init(), sqlite3_sha_init(), sqlite3_shathree_init(), sqlite3_stmtrand_init(), and sqlite3_uint_init().

SQLITE_INTERNAL_LINKAGE

#define SQLITE_INTERNAL_LINKAGE   static

SQLITE_OS_WINRT

#define SQLITE_OS_WINRT   0

SQLITE_SERIES_CONSTRAINT_VERIFY

#define SQLITE_SERIES_CONSTRAINT_VERIFY   0

Referenced by seriesBestIndex().

SQLITE_SHELL_HAVE_RECOVER

#define SQLITE_SHELL_HAVE_RECOVER   0

SQLITE_SHELL_IS_UTF8

#define SQLITE_SHELL_IS_UTF8   (1)

SQLITEEXPERT_H

#define SQLITEEXPERT_H   1

STAT_CHR_SRC

#define STAT_CHR_SRC

(

mode

)

Value:

(S_ISREG(mode)||S_ISFIFO(mode)||S_ISCHR(mode))

Referenced by openChrSource().

STMTRAND_KEY

#define STMTRAND_KEY   (-4418371)

Referenced by stmtrandFunc().

STRLEN

#define STRLEN   (int)strlen

Referenced by expertDequote(), expertSchemaSql(), idxAppendText(), idxFindIndexes(), idxGetTableInfo(), idxHashAdd(), idxHashFind(), idxIdentifierRequiresQuotes(), idxNewConstraint(), idxPopulateOneStat1(), and sqlite3_expert_sql().

STRUCT_STAT

#define STRUCT_STAT   struct stat

Referenced by fileLinkStat(), fileStat(), makeDirectory(), and writeFile().

SWAP_DOUBLE

#define SWAP_DOUBLE	(		X,
			Y )

Value:

{double ttt=(X);(X)=(Y);(Y)=ttt;}

Referenced by percentSort().

ToLower

#define ToLower

(

X

)

Value:

(char)tolower((unsigned char)X)

Referenced by line_is_command_terminator().

U8_TYPEDEF

#define U8_TYPEDEF

UNIQUE_TABLE_NAME

#define UNIQUE_TABLE_NAME   "t592690916721053953805701627921227776"

Referenced by idxBuildSampleTable(), idxPopulateOneStat1(), idxPopulateStat1(), and idxProcessOneTrigger().

UNUSED_PARAMETER

#define UNUSED_PARAMETER

(

x

)

Value:

(void)(x)

Referenced by captureOutputCallback(), decimalAddFunc(), decimalCmpFunc(), decimalCollFunc(), decimalFunc(), decimalMulFunc(), decimalPow2Func(), decimalSubFunc(), decimalSumInverse(), decimalSumStep(), display_scanstats(), dump_callback(), ieee754func_from_blob(), ieee754func_to_blob(), ieee754inc(), interrupt_handler(), safeModeAuth(), setCrlfMode(), shell_dbtotxt_command(), shellAddSchemaName(), shellModuleSchema(), and shellStrtod().

VTR_ACCESS

#define VTR_ACCESS   0x00040000

Referenced by vfstraceAccess(), and vfstraceFileControl().

VTR_CLOSE

#define VTR_CLOSE   0x00000001

Referenced by vfstraceClose(), and vfstraceFileControl().

VTR_CRL

#define VTR_CRL   0x00000100

Referenced by vfstraceCheckReservedLock(), and vfstraceFileControl().

VTR_CURTIME

#define VTR_CURTIME   0x04000000

Referenced by vfstraceCurrentTime(), vfstraceCurrentTimeInt64(), and vfstraceFileControl().

VTR_DELETE

#define VTR_DELETE   0x00020000

Referenced by vfstraceDelete(), and vfstraceFileControl().

VTR_DEVCHAR

#define VTR_DEVCHAR   0x00000800

Referenced by vfstraceDeviceCharacteristics(), and vfstraceFileControl().

VTR_DLCLOSE

#define VTR_DLCLOSE   0x00800000

Referenced by vfstraceDlClose(), and vfstraceFileControl().

VTR_DLERR

#define VTR_DLERR   0x00200000

Referenced by vfstraceDlError(), and vfstraceFileControl().

VTR_DLOPEN

#define VTR_DLOPEN   0x00100000

Referenced by vfstraceDlOpen(), and vfstraceFileControl().

VTR_DLSYM

#define VTR_DLSYM   0x00400000

Referenced by vfstraceFileControl().

VTR_FCTRL

#define VTR_FCTRL   0x00000200

Referenced by vfstraceFileControl().

VTR_FETCH

#define VTR_FETCH   0x10000000 /* Also coverse xUnfetch */

Referenced by vfstraceFetch(), vfstraceFileControl(), and vfstraceUnfetch().

VTR_FSIZE

#define VTR_FSIZE   0x00000020

Referenced by vfstraceFileControl(), and vfstraceFileSize().

VTR_FULLPATH

#define VTR_FULLPATH   0x00080000

Referenced by vfstraceFileControl(), and vfstraceFullPathname().

VTR_LASTERR

#define VTR_LASTERR   0x08000000

Referenced by vfstraceFileControl(), and vfstraceGetLastError().

VTR_LOCK

#define VTR_LOCK   0x00000040

Referenced by vfstraceFileControl(), and vfstraceLock().

VTR_OPEN

#define VTR_OPEN   0x00010000

Referenced by vfstraceFileControl(), and vfstraceOpen().

VTR_RAND

#define VTR_RAND   0x01000000

Referenced by vfstraceFileControl(), and vfstraceRandomness().

VTR_READ

#define VTR_READ   0x00000002

Referenced by vfstraceFileControl(), and vfstraceRead().

VTR_SECSZ

#define VTR_SECSZ   0x00000400

Referenced by vfstraceFileControl(), and vfstraceSectorSize().

VTR_SHMBAR

#define VTR_SHMBAR   0x00004000

Referenced by vfstraceFileControl(), and vfstraceShmBarrier().

VTR_SHMLOCK

#define VTR_SHMLOCK   0x00001000

Referenced by vfstraceFileControl(), and vfstraceShmLock().

VTR_SHMMAP

#define VTR_SHMMAP   0x00002000

Referenced by vfstraceFileControl(), and vfstraceShmMap().

VTR_SHMUNMAP

#define VTR_SHMUNMAP   0x00008000

Referenced by vfstraceFileControl(), and vfstraceShmUnmap().

VTR_SLEEP

#define VTR_SLEEP   0x02000000

Referenced by vfstraceFileControl(), and vfstraceSleep().

VTR_SYNC

#define VTR_SYNC   0x00000010

Referenced by vfstraceFileControl(), and vfstraceSync().

VTR_TRUNC

#define VTR_TRUNC   0x00000008

Referenced by vfstraceFileControl(), and vfstraceTruncate().

VTR_UNLOCK

#define VTR_UNLOCK   0x00000080

Referenced by vfstraceFileControl(), and vfstraceUnlock().

VTR_WRITE

#define VTR_WRITE   0x00000004

Referenced by vfstraceFileControl(), and vfstraceWrite().

WS

#define WS   0x81 /* whitespace */

Referenced by fromBase64().

Typedef Documentation

ApndFile

typedef struct ApndFile ApndFile

ApndVfs

typedef struct sqlite3_vfs ApndVfs

ColModeOpts

typedef struct ColModeOpts ColModeOpts

completion_cursor

typedef struct completion_cursor completion_cursor

completion_vtab

typedef struct completion_vtab completion_vtab

Decimal

typedef struct Decimal Decimal

EQPGraph

typedef struct EQPGraph EQPGraph

EQPGraphRow

typedef struct EQPGraphRow EQPGraphRow

ExpertCsr

typedef struct ExpertCsr ExpertCsr

ExpertInfo

typedef struct ExpertInfo ExpertInfo

ExpertVtab

typedef struct ExpertVtab ExpertVtab

fsdir_cursor

typedef struct fsdir_cursor fsdir_cursor

fsdir_tab

typedef struct fsdir_tab fsdir_tab

FsdirLevel

typedef struct FsdirLevel FsdirLevel

i64

typedef sqlite3_int64 i64

IdxColumn

typedef struct IdxColumn IdxColumn

IdxConstraint

typedef struct IdxConstraint IdxConstraint

IdxHash

typedef struct IdxHash IdxHash

IdxHashEntry

typedef struct IdxHashEntry IdxHashEntry

IdxScan

typedef struct IdxScan IdxScan

IdxStatement

typedef struct IdxStatement IdxStatement

IdxTable

typedef struct IdxTable IdxTable

IdxWrite

typedef struct IdxWrite IdxWrite

ImportCtx

typedef struct ImportCtx ImportCtx

Percentile

typedef struct Percentile Percentile

PercentileFunc

typedef struct PercentileFunc PercentileFunc

ReCompiled

typedef struct ReCompiled ReCompiled

ReInput

typedef struct ReInput ReInput

ReStateNumber

typedef unsigned short ReStateNumber

ReStateSet

typedef struct ReStateSet ReStateSet

SequenceSpec

typedef struct SequenceSpec SequenceSpec

series_cursor

typedef struct series_cursor series_cursor

SHA1Context

typedef struct SHA1Context SHA1Context

SHA3Context

typedef struct SHA3Context SHA3Context

ShellState

typedef struct ShellState ShellState

ShellText

typedef struct ShellText ShellText

sqlite3_intck

typedef struct sqlite3_intck sqlite3_intck

sqlite3expert

typedef struct sqlite3expert sqlite3expert

Stmtrand

typedef struct Stmtrand Stmtrand

t_DynaPromptRef

typedef struct DynaPrompt* t_DynaPromptRef

u16

typedef unsigned short int u16

u32

typedef unsigned int u32

u64

typedef sqlite3_uint64 u64

u8

typedef unsigned char u8

vfstrace_file

typedef struct vfstrace_file vfstrace_file

vfstrace_info

typedef struct vfstrace_info vfstrace_info

Enumeration Type Documentation

QuickScanState

enum QuickScanState

Enumerator
QSS_HasDark	1<< 8
QSS_EndingSemi	2<< 8
QSS_CharMask	(1<< 8 )-1
QSS_ScanMask	3<< 8
QSS_Start	0

             {
  QSS_HasDark = 1<<CHAR_BIT, QSS_EndingSemi = 2<<CHAR_BIT,
  QSS_CharMask = (1<<CHAR_BIT)-1, QSS_ScanMask = 3<<CHAR_BIT,

Function Documentation

anyOfInStr()

const char * anyOfInStr ( const char * s, const char * zAny, size_t ns )

static

                                                                         {
  const char *pcFirst = 0;
  if( ns == ~(size_t)0 ) ns = strlen(s);
  while(*zAny){
    const char *pc = (const char*)memchr(s, *zAny&0xff, ns);
    if( pc ){
      pcFirst = pc;
      ns = pcFirst - s;
    }
    ++zAny;
  }

Referenced by output_c_string(), and output_json_string().

Here is the caller graph for this function:

apndAccess()

int apndAccess ( sqlite3_vfs * pVfs, const char * zName, int flags, int * pResOut )

static

 {
  return ORIGVFS(pVfs)->xAccess(ORIGVFS(pVfs), zPath, flags, pResOut);
}

References ORIGVFS.

apndCheckReservedLock()

int apndCheckReservedLock ( sqlite3_file * pFile, int * pResOut )

static

                                                                   {
  pFile = ORIGFILE(pFile);
  return pFile->pMethods->xCheckReservedLock(pFile, pResOut);
}

References ORIGFILE, sqlite3_file::pMethods, and sqlite3_io_methods::xCheckReservedLock.

apndClose()

int apndClose ( sqlite3_file * pFile )

static

                                         {
  pFile = ORIGFILE(pFile);
  return pFile->pMethods->xClose(pFile);
}

References ORIGFILE, sqlite3_file::pMethods, and sqlite3_io_methods::xClose.

apndCurrentTime()

int apndCurrentTime ( sqlite3_vfs * pVfs, double * pTimeOut )

static

                                                               {
  return ORIGVFS(pVfs)->xCurrentTime(ORIGVFS(pVfs), pTimeOut);
}

References ORIGVFS.

apndCurrentTimeInt64()

int apndCurrentTimeInt64 ( sqlite3_vfs * pVfs, sqlite3_int64 * p )

static

                                                                    {
  return ORIGVFS(pVfs)->xCurrentTimeInt64(ORIGVFS(pVfs), p);
}

References ORIGVFS.

apndDelete()

int apndDelete ( sqlite3_vfs * pVfs, const char * zName, int syncDir )

static

                                                                        {
  return ORIGVFS(pVfs)->xDelete(ORIGVFS(pVfs), zPath, dirSync);
}

References ORIGVFS.

apndDeviceCharacteristics()

int apndDeviceCharacteristics ( sqlite3_file * pFile )

static

                                                         {
  pFile = ORIGFILE(pFile);
  return pFile->pMethods->xDeviceCharacteristics(pFile);
}

References ORIGFILE, sqlite3_file::pMethods, and sqlite3_io_methods::xDeviceCharacteristics.

apndDlClose()

void apndDlClose ( sqlite3_vfs * pVfs, void * pHandle )

static

                                                         {
  ORIGVFS(pVfs)->xDlClose(ORIGVFS(pVfs), pHandle);
}

References ORIGVFS.

apndDlError()

void apndDlError ( sqlite3_vfs * pVfs, int nByte, char * zErrMsg )

static

                                                                    {
  ORIGVFS(pVfs)->xDlError(ORIGVFS(pVfs), nByte, zErrMsg);
}

References ORIGVFS.

apndDlOpen()

void * apndDlOpen ( sqlite3_vfs * pVfs, const char * zFilename )

static

                                                             {
  return ORIGVFS(pVfs)->xDlOpen(ORIGVFS(pVfs), zPath);
}

References ORIGVFS.

apndFetch()

int apndFetch ( sqlite3_file * pFile, sqlite3_int64 iOfst, int iAmt, void ** pp )

static

 {
  ApndFile *p = (ApndFile *)pFile;
  if( p->iMark < 0 || iOfst+iAmt > p->iMark ){
    return SQLITE_IOERR; /* Cannot read what is not yet there. */
  }
  pFile = ORIGFILE(pFile);
  return pFile->pMethods->xFetch(pFile, iOfst+p->iPgOne, iAmt, pp);
}

References ApndFile::iMark, ApndFile::iPgOne, ORIGFILE, sqlite3_file::pMethods, SQLITE_IOERR, and sqlite3_io_methods::xFetch.

apndFileControl()

int apndFileControl ( sqlite3_file * pFile, int op, void * pArg )

static

                                                                   {
  ApndFile *paf = (ApndFile *)pFile;
  int rc;
  pFile = ORIGFILE(pFile);
  if( op==SQLITE_FCNTL_SIZE_HINT ) *(sqlite3_int64*)pArg += paf->iPgOne;
  rc = pFile->pMethods->xFileControl(pFile, op, pArg);
  if( rc==SQLITE_OK && op==SQLITE_FCNTL_VFSNAME ){
    *(char**)pArg = sqlite3_mprintf("apnd(%lld)/%z", paf->iPgOne,*(char**)pArg);
  }
  return rc;
}

References ApndFile::iPgOne, ORIGFILE, sqlite3_file::pMethods, sqlite3_mprintf, SQLITE_FCNTL_SIZE_HINT, SQLITE_FCNTL_VFSNAME, SQLITE_OK, and sqlite3_io_methods::xFileControl.

apndFileSize()

int apndFileSize ( sqlite3_file * pFile, sqlite3_int64 * pSize )

static

                                                                 {
  ApndFile *paf = (ApndFile *)pFile;
  *pSize = ( paf->iMark >= 0 )? (paf->iMark - paf->iPgOne) : 0;
  return SQLITE_OK;
}

References ApndFile::iMark, ApndFile::iPgOne, and SQLITE_OK.

apndFullPathname()

int apndFullPathname ( sqlite3_vfs * pVfs, const char * zName, int nOut, char * zOut )

static

 {
  return ORIGVFS(pVfs)->xFullPathname(ORIGVFS(pVfs),zPath,nOut,zOut);
}

References ORIGVFS.

apndGetLastError()

int apndGetLastError ( sqlite3_vfs * pVfs, int a, char * b )

static

                                                              {
  return ORIGVFS(pVfs)->xGetLastError(ORIGVFS(pVfs), a, b);
}

References a, b, and ORIGVFS.

apndGetSystemCall()

sqlite3_syscall_ptr apndGetSystemCall ( sqlite3_vfs * pVfs, const char * z )

static

 {
  return ORIGVFS(pVfs)->xGetSystemCall(ORIGVFS(pVfs),zName);
}

References ORIGVFS.

apndIsAppendvfsDatabase()

int apndIsAppendvfsDatabase ( sqlite3_int64 sz, sqlite3_file * pFile )

static

                                                                         {
  int rc;
  char zHdr[16];
  sqlite3_int64 iMark = apndReadMark(sz, pFile);
  if( iMark>=0 ){
    /* If file has the correct end-marker, the expected odd size, and the
    ** SQLite DB type marker where the end-marker puts it, then it
    ** is an appendvfs database.
    */
    rc = pFile->pMethods->xRead(pFile, zHdr, sizeof(zHdr), iMark);
    if( SQLITE_OK==rc
     && memcmp(zHdr, apvfsSqliteHdr, sizeof(zHdr))==0
     && (sz & 0x1ff) == APND_MARK_SIZE
     && sz>=512+APND_MARK_SIZE
    ){
      return 1; /* It's an appendvfs database */
    }
  }
  return 0;
}

References APND_MARK_SIZE, apndReadMark(), apvfsSqliteHdr, sqlite3_file::pMethods, SQLITE_OK, and sqlite3_io_methods::xRead.

Referenced by apndIsOrdinaryDatabaseFile().

Here is the call graph for this function:

Here is the caller graph for this function:

apndIsOrdinaryDatabaseFile()

int apndIsOrdinaryDatabaseFile ( sqlite3_int64 sz, sqlite3_file * pFile )

static

                                                                            {
  char zHdr[16];
  if( apndIsAppendvfsDatabase(sz, pFile) /* rule 2 */
   || (sz & 0x1ff) != 0
   || SQLITE_OK!=pFile->pMethods->xRead(pFile, zHdr, sizeof(zHdr), 0)
   || memcmp(zHdr, apvfsSqliteHdr, sizeof(zHdr))!=0
  ){
    return 0;
  }else{
    return 1;
  }
}

References apndIsAppendvfsDatabase(), apvfsSqliteHdr, sqlite3_file::pMethods, SQLITE_OK, and sqlite3_io_methods::xRead.

Referenced by apndOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

apndLock()

int apndLock ( sqlite3_file * pFile, int eLock )

static

                                                   {
  pFile = ORIGFILE(pFile);
  return pFile->pMethods->xLock(pFile, eLock);
}

References ORIGFILE, sqlite3_file::pMethods, and sqlite3_io_methods::xLock.

apndNextSystemCall()

const char * apndNextSystemCall ( sqlite3_vfs * pVfs, const char * zName )

static

                                                                           {
  return ORIGVFS(pVfs)->xNextSystemCall(ORIGVFS(pVfs), zName);
}

References ORIGVFS.

apndOpen()

int apndOpen ( sqlite3_vfs * pApndVfs, const char * zName, sqlite3_file * pFile, int flags, int * pOutFlags )

static

 {
  ApndFile *pApndFile = (ApndFile*)pFile;
  sqlite3_file *pBaseFile = ORIGFILE(pFile);
  sqlite3_vfs *pBaseVfs = ORIGVFS(pApndVfs);
  int rc;
  sqlite3_int64 sz = 0;
  if( (flags & SQLITE_OPEN_MAIN_DB)==0 ){
    /* The appendvfs is not to be used for transient or temporary databases.
    ** Just use the base VFS open to initialize the given file object and
    ** open the underlying file. (Appendvfs is then unused for this file.)
    */
    return pBaseVfs->xOpen(pBaseVfs, zName, pFile, flags, pOutFlags);
  }
  memset(pApndFile, 0, sizeof(ApndFile));
  pFile->pMethods = &apnd_io_methods;
  pApndFile->iMark = -1;    /* Append mark not yet written */
 
  rc = pBaseVfs->xOpen(pBaseVfs, zName, pBaseFile, flags, pOutFlags);
  if( rc==SQLITE_OK ){
    rc = pBaseFile->pMethods->xFileSize(pBaseFile, &sz);
    if( rc ){
      pBaseFile->pMethods->xClose(pBaseFile);
    }
  }
  if( rc ){
    pFile->pMethods = 0;
    return rc;
  }
  if( apndIsOrdinaryDatabaseFile(sz, pBaseFile) ){
    /* The file being opened appears to be just an ordinary DB. Copy
    ** the base dispatch-table so this instance mimics the base VFS. 
    */
    memmove(pApndFile, pBaseFile, pBaseVfs->szOsFile);
    return SQLITE_OK;
  }
  pApndFile->iPgOne = apndReadMark(sz, pFile);
  if( pApndFile->iPgOne>=0 ){
    pApndFile->iMark = sz - APND_MARK_SIZE; /* Append mark found */
    return SQLITE_OK;
  }
  if( (flags & SQLITE_OPEN_CREATE)==0 ){
    pBaseFile->pMethods->xClose(pBaseFile);
    rc = SQLITE_CANTOPEN;
    pFile->pMethods = 0;
  }else{
    /* Round newly added appendvfs location to #define'd page boundary. 
    ** Note that nothing has yet been written to the underlying file.
    ** The append mark will be written along with first content write.
    ** Until then, paf->iMark value indicates it is not yet written.
    */
    pApndFile->iPgOne = APND_START_ROUNDUP(sz);
  }
  return rc;
}

References apnd_io_methods, APND_MARK_SIZE, APND_START_ROUNDUP, apndIsOrdinaryDatabaseFile(), apndReadMark(), ApndFile::iMark, ApndFile::iPgOne, ORIGFILE, ORIGVFS, sqlite3_file::pMethods, SQLITE_CANTOPEN, SQLITE_OK, SQLITE_OPEN_CREATE, SQLITE_OPEN_MAIN_DB, sqlite3_vfs::szOsFile, sqlite3_io_methods::xClose, sqlite3_io_methods::xFileSize, and sqlite3_vfs::xOpen.

Here is the call graph for this function:

apndRandomness()

int apndRandomness ( sqlite3_vfs * pVfs, int nByte, char * zOut )

static

                                                                      {
  return ORIGVFS(pVfs)->xRandomness(ORIGVFS(pVfs), nByte, zBufOut);
}

References ORIGVFS.

apndRead()

int apndRead ( sqlite3_file * pFile, void * zBuf, int iAmt, sqlite3_int64 iOfst )

static

 {
  ApndFile *paf = (ApndFile *)pFile;
  pFile = ORIGFILE(pFile);
  return pFile->pMethods->xRead(pFile, zBuf, iAmt, paf->iPgOne+iOfst);
}

References ApndFile::iPgOne, ORIGFILE, sqlite3_file::pMethods, and sqlite3_io_methods::xRead.

apndReadMark()

sqlite3_int64 apndReadMark ( sqlite3_int64 sz, sqlite3_file * pFile )

static

                                                                        {
  int rc, i;
  sqlite3_int64 iMark;
  int msbs = 8 * (APND_MARK_FOS_SZ-1);
  unsigned char a[APND_MARK_SIZE];
 
  if( APND_MARK_SIZE!=(sz & 0x1ff) ) return -1;
  rc = pFile->pMethods->xRead(pFile, a, APND_MARK_SIZE, sz-APND_MARK_SIZE);
  if( rc ) return -1;
  if( memcmp(a, APND_MARK_PREFIX, APND_MARK_PREFIX_SZ)!=0 ) return -1;
  iMark = ((sqlite3_int64)(a[APND_MARK_PREFIX_SZ] & 0x7f)) << msbs;
  for(i=1; i<8; i++){
    msbs -= 8;
    iMark |= (sqlite3_int64)a[APND_MARK_PREFIX_SZ+i]<<msbs;
  }
  if( iMark > (sz - APND_MARK_SIZE - 512) ) return -1;
  if( iMark & 0x1ff ) return -1;
  return iMark;
}

References a, APND_MARK_FOS_SZ, APND_MARK_PREFIX, APND_MARK_PREFIX_SZ, APND_MARK_SIZE, sqlite3_file::pMethods, and sqlite3_io_methods::xRead.

Referenced by apndIsAppendvfsDatabase(), and apndOpen().

Here is the caller graph for this function:

apndSectorSize()

int apndSectorSize ( sqlite3_file * pFile )

static

                                              {
  pFile = ORIGFILE(pFile);
  return pFile->pMethods->xSectorSize(pFile);
}

References ORIGFILE, sqlite3_file::pMethods, and sqlite3_io_methods::xSectorSize.

apndSetSystemCall()

int apndSetSystemCall ( sqlite3_vfs * pVfs, const char * zName, sqlite3_syscall_ptr pCall )

static

 {
  return ORIGVFS(pVfs)->xSetSystemCall(ORIGVFS(pVfs),zName,pCall);
}

References ORIGVFS.

apndShmBarrier()

void apndShmBarrier ( sqlite3_file * pFile )

static

                                               {
  pFile = ORIGFILE(pFile);
  pFile->pMethods->xShmBarrier(pFile);
}

References ORIGFILE, sqlite3_file::pMethods, and sqlite3_io_methods::xShmBarrier.

apndShmLock()

int apndShmLock ( sqlite3_file * pFile, int offset, int n, int flags )

static

                                                                         {
  pFile = ORIGFILE(pFile);
  return pFile->pMethods->xShmLock(pFile,offset,n,flags);
}

References ORIGFILE, sqlite3_file::pMethods, and sqlite3_io_methods::xShmLock.

apndShmMap()

int apndShmMap ( sqlite3_file * pFile, int iPg, int pgsz, int bExtend, void volatile ** pp )

static

 {
  pFile = ORIGFILE(pFile);
  return pFile->pMethods->xShmMap(pFile,iPg,pgsz,bExtend,pp);
}

References ORIGFILE, sqlite3_file::pMethods, and sqlite3_io_methods::xShmMap.

apndShmUnmap()

int apndShmUnmap ( sqlite3_file * pFile, int deleteFlag )

static

                                                            {
  pFile = ORIGFILE(pFile);
  return pFile->pMethods->xShmUnmap(pFile,deleteFlag);
}

References ORIGFILE, sqlite3_file::pMethods, and sqlite3_io_methods::xShmUnmap.

apndSleep()

int apndSleep ( sqlite3_vfs * pVfs, int microseconds )

static

                                                   {
  return ORIGVFS(pVfs)->xSleep(ORIGVFS(pVfs), nMicro);
}

References ORIGVFS.

apndSync()

int apndSync ( sqlite3_file * pFile, int flags )

static

                                                   {
  pFile = ORIGFILE(pFile);
  return pFile->pMethods->xSync(pFile, flags);
}

References ORIGFILE, sqlite3_file::pMethods, and sqlite3_io_methods::xSync.

apndTruncate()

int apndTruncate ( sqlite3_file * pFile, sqlite3_int64 size )

static

                                                               {
  ApndFile *paf = (ApndFile *)pFile;
  pFile = ORIGFILE(pFile);
  /* The append mark goes out first so truncate failure does not lose it. */
  if( SQLITE_OK!=apndWriteMark(paf, pFile, size) ) return SQLITE_IOERR;
  /* Truncate underlying file just past append mark */
  return pFile->pMethods->xTruncate(pFile, paf->iMark+APND_MARK_SIZE);
}

References APND_MARK_SIZE, apndWriteMark(), ApndFile::iMark, ORIGFILE, sqlite3_file::pMethods, SQLITE_IOERR, SQLITE_OK, and sqlite3_io_methods::xTruncate.

Here is the call graph for this function:

apndUnfetch()

int apndUnfetch ( sqlite3_file * pFile, sqlite3_int64 iOfst, void * p )

static

                                                                             {
  ApndFile *p = (ApndFile *)pFile;
  pFile = ORIGFILE(pFile);
  return pFile->pMethods->xUnfetch(pFile, iOfst+p->iPgOne, pPage);
}

References ApndFile::iPgOne, ORIGFILE, sqlite3_file::pMethods, and sqlite3_io_methods::xUnfetch.

apndUnlock()

int apndUnlock ( sqlite3_file * pFile, int eLock )

static

                                                     {
  pFile = ORIGFILE(pFile);
  return pFile->pMethods->xUnlock(pFile, eLock);
}

References ORIGFILE, sqlite3_file::pMethods, and sqlite3_io_methods::xUnlock.

apndWrite()

int apndWrite ( sqlite3_file * pFile, const void * zBuf, int iAmt, sqlite3_int64 iOfst )

static

 {
  ApndFile *paf = (ApndFile *)pFile;
  sqlite_int64 iWriteEnd = iOfst + iAmt;
  if( iWriteEnd>=APND_MAX_SIZE ) return SQLITE_FULL;
  pFile = ORIGFILE(pFile);
  /* If append-mark is absent or will be overwritten, write it. */
  if( paf->iMark < 0 || paf->iPgOne + iWriteEnd > paf->iMark ){
    int rc = apndWriteMark(paf, pFile, iWriteEnd);
    if( SQLITE_OK!=rc ) return rc;
  }
  return pFile->pMethods->xWrite(pFile, zBuf, iAmt, paf->iPgOne+iOfst);
}

References APND_MAX_SIZE, apndWriteMark(), ApndFile::iMark, ApndFile::iPgOne, ORIGFILE, sqlite3_file::pMethods, SQLITE_FULL, SQLITE_OK, and sqlite3_io_methods::xWrite.

Here is the call graph for this function:

apndWriteMark()

int apndWriteMark ( ApndFile * paf, sqlite3_file * pFile, sqlite_int64 iWriteEnd )

static

 {
  sqlite_int64 iPgOne = paf->iPgOne;
  unsigned char a[APND_MARK_SIZE];
  int i = APND_MARK_FOS_SZ;
  int rc;
  assert(pFile == ORIGFILE(paf));
  memcpy(a, APND_MARK_PREFIX, APND_MARK_PREFIX_SZ);
  while( --i >= 0 ){
    a[APND_MARK_PREFIX_SZ+i] = (unsigned char)(iPgOne & 0xff);
    iPgOne >>= 8;
  }
  iWriteEnd += paf->iPgOne;
  if( SQLITE_OK==(rc = pFile->pMethods->xWrite
                  (pFile, a, APND_MARK_SIZE, iWriteEnd)) ){
    paf->iMark = iWriteEnd;
  }
  return rc;
}

References a, APND_MARK_FOS_SZ, APND_MARK_PREFIX, APND_MARK_PREFIX_SZ, APND_MARK_SIZE, ApndFile::iMark, ApndFile::iPgOne, ORIGFILE, sqlite3_file::pMethods, SQLITE_OK, and sqlite3_io_methods::xWrite.

Referenced by apndTruncate(), and apndWrite().

Here is the caller graph for this function:

appendText()

void appendText ( ShellText * p, const char * zAppend, char quote )

static

                                                                     {
  i64 len;
  i64 i;
  i64 nAppend = strlen30(zAppend);
 
  len = nAppend+p->n+1;
  if( quote ){
    len += 2;
    for(i=0; i<nAppend; i++){
      if( zAppend[i]==quote ) len++;
    }
  }
 
  if( p->z==0 || p->n+len>=p->nAlloc ){
    p->nAlloc = p->nAlloc*2 + len + 20;
    p->z = realloc(p->z, p->nAlloc);
    shell_check_oom(p->z);
  }
 
  if( quote ){
    char *zCsr = p->z+p->n;
    *zCsr++ = quote;
    for(i=0; i<nAppend; i++){
      *zCsr++ = zAppend[i];
      if( zAppend[i]==quote ) *zCsr++ = quote;
    }
    *zCsr++ = quote;
    p->n = (int)(zCsr - p->z);
    *zCsr = '\0';
  }else{
    memcpy(p->z+p->n, zAppend, nAppend);
    p->n += nAppend;
    p->z[p->n] = '\0';
  }
}

References ShellText::n, ShellText::nAlloc, shell_check_oom(), strlen30(), and ShellText::z.

Referenced by captureOutputCallback(), do_meta_command(), dump_callback(), and shellFakeSchema().

Here is the call graph for this function:

Here is the caller graph for this function:

ascii_read_one_field()

char * ascii_read_one_field ( ImportCtx * p )

static

                                                            {
  int c;
  int cSep = (u8)p->cColSep;
  int rSep = (u8)p->cRowSep;
  p->n = 0;
  c = fgetc(p->in);
  if( c==EOF || seenInterrupt ){
    p->cTerm = EOF;
    return 0;
  }
  while( c!=EOF && c!=cSep && c!=rSep ){
    import_append_char(p, c);
    c = fgetc(p->in);
  }
  if( c==rSep ){
    p->nLine++;
  }
  p->cTerm = c;
  if( p->z ) p->z[p->n] = 0;

References c, ImportCtx::cColSep, ImportCtx::cRowSep, ImportCtx::cTerm, import_append_char(), ImportCtx::in, ImportCtx::n, ImportCtx::nLine, seenInterrupt, SQLITE_CDECL, and ImportCtx::z.

Referenced by do_meta_command().

Here is the call graph for this function:

Here is the caller graph for this function:

base64()

void base64 ( sqlite3_context * context, int na, sqlite3_value * av[] )

static

                                                                         {
  int nb, nc, nv = sqlite3_value_bytes(av[0]);
  int nvMax = sqlite3_limit(sqlite3_context_db_handle(context),
                            SQLITE_LIMIT_LENGTH, -1);
  char *cBuf;
  u8 *bBuf;
  assert(na==1);
  switch( sqlite3_value_type(av[0]) ){
  case SQLITE_BLOB:
    nb = nv;
    nc = 4*(nv+2/3); /* quads needed */
    nc += (nc+(B64_DARK_MAX-1))/B64_DARK_MAX + 1; /* LFs and a 0-terminator */
    if( nvMax < nc ){
      sqlite3_result_error(context, "blob expanded to base64 too big", -1);
      return;
    }
    bBuf = (u8*)sqlite3_value_blob(av[0]);
    if( !bBuf ){
      if( SQLITE_NOMEM==sqlite3_errcode(sqlite3_context_db_handle(context)) ){
        goto memFail;
      }
      sqlite3_result_text(context,"",-1,SQLITE_STATIC);
      break;
    }
    cBuf = sqlite3_malloc(nc);
    if( !cBuf ) goto memFail;
    nc = (int)(toBase64(bBuf, nb, cBuf) - cBuf);
    sqlite3_result_text(context, cBuf, nc, sqlite3_free);
    break;
  case SQLITE_TEXT:
    nc = nv;
    nb = 3*((nv+3)/4); /* may overestimate due to LF and padding */
    if( nvMax < nb ){
      sqlite3_result_error(context, "blob from base64 may be too big", -1);
      return;
    }else if( nb<1 ){
      nb = 1;
    }
    cBuf = (char *)sqlite3_value_text(av[0]);
    if( !cBuf ){
      if( SQLITE_NOMEM==sqlite3_errcode(sqlite3_context_db_handle(context)) ){
        goto memFail;
      }
      sqlite3_result_zeroblob(context, 0);
      break;
    }
    bBuf = sqlite3_malloc(nb);
    if( !bBuf ) goto memFail;
    nb = (int)(fromBase64(cBuf, nc, bBuf) - bBuf);
    sqlite3_result_blob(context, bBuf, nb, sqlite3_free);
    break;
  default:
    sqlite3_result_error(context, "base64 accepts only blob or text", -1);
    return;
  }
  return;
 memFail:
  sqlite3_result_error(context, "base64 OOM", -1);
}

References B64_DARK_MAX, fromBase64(), sqlite3_context_db_handle, sqlite3_errcode, sqlite3_free, sqlite3_limit, sqlite3_malloc, sqlite3_result_blob, sqlite3_result_error, sqlite3_result_text, sqlite3_result_zeroblob, sqlite3_value_blob, sqlite3_value_bytes, sqlite3_value_text, sqlite3_value_type, SQLITE_BLOB, SQLITE_LIMIT_LENGTH, SQLITE_NOMEM, SQLITE_STATIC, SQLITE_TEXT, and toBase64().

Referenced by sqlite3_base64_init().

Here is the call graph for this function:

Here is the caller graph for this function:

base85()

void base85 ( sqlite3_context * context, int na, sqlite3_value * av[] )

static

                                                                         {
  int nb, nc, nv = sqlite3_value_bytes(av[0]);
  int nvMax = sqlite3_limit(sqlite3_context_db_handle(context),
                            SQLITE_LIMIT_LENGTH, -1);
  char *cBuf;
  u8 *bBuf;
  assert(na==1);
  switch( sqlite3_value_type(av[0]) ){
  case SQLITE_BLOB:
    nb = nv;
    /*    ulongs    tail   newlines  tailenc+nul*/
    nc = 5*(nv/4) + nv%4 + nv/64+1 + 2;
    if( nvMax < nc ){
      sqlite3_result_error(context, "blob expanded to base85 too big", -1);
      return;
    }
    bBuf = (u8*)sqlite3_value_blob(av[0]);
    if( !bBuf ){
      if( SQLITE_NOMEM==sqlite3_errcode(sqlite3_context_db_handle(context)) ){
        goto memFail;
      }
      sqlite3_result_text(context,"",-1,SQLITE_STATIC);
      break;
    }
    cBuf = sqlite3_malloc(nc);
    if( !cBuf ) goto memFail;
    nc = (int)(toBase85(bBuf, nb, cBuf, "\n") - cBuf);
    sqlite3_result_text(context, cBuf, nc, sqlite3_free);
    break;
  case SQLITE_TEXT:
    nc = nv;
    nb = 4*(nv/5) + nv%5; /* may overestimate */
    if( nvMax < nb ){
      sqlite3_result_error(context, "blob from base85 may be too big", -1);
      return;
    }else if( nb<1 ){
      nb = 1;
    }
    cBuf = (char *)sqlite3_value_text(av[0]);
    if( !cBuf ){
      if( SQLITE_NOMEM==sqlite3_errcode(sqlite3_context_db_handle(context)) ){
        goto memFail;
      }
      sqlite3_result_zeroblob(context, 0);
      break;
    }
    bBuf = sqlite3_malloc(nb);
    if( !bBuf ) goto memFail;
    nb = (int)(fromBase85(cBuf, nc, bBuf) - bBuf);
    sqlite3_result_blob(context, bBuf, nb, sqlite3_free);
    break;
  default:
    sqlite3_result_error(context, "base85 accepts only blob or text.", -1);
    return;
  }
  return;
 memFail:
  sqlite3_result_error(context, "base85 OOM", -1);
}

References fromBase85(), sqlite3_context_db_handle, sqlite3_errcode, sqlite3_free, sqlite3_limit, sqlite3_malloc, sqlite3_result_blob, sqlite3_result_error, sqlite3_result_text, sqlite3_result_zeroblob, sqlite3_value_blob, sqlite3_value_bytes, sqlite3_value_text, sqlite3_value_type, SQLITE_BLOB, SQLITE_LIMIT_LENGTH, SQLITE_NOMEM, SQLITE_STATIC, SQLITE_TEXT, and toBase85().

Referenced by sqlite3_base85_init().

Here is the call graph for this function:

Here is the caller graph for this function:

beginTimer()

void beginTimer ( void )

static

                            {
  if( enableTimer ){
    getrusage(RUSAGE_SELF, &sBegin);
    iBegin = timeOfDay();
  }
}

References enableTimer, iBegin, sBegin, and timeOfDay().

Here is the call graph for this function:

bind_prepared_stmt()

void bind_prepared_stmt ( ShellState * pArg, sqlite3_stmt * pStmt )

static

                                                                     {
  int nVar;
  int i;
  int rc;
  sqlite3_stmt *pQ = 0;
 
  nVar = sqlite3_bind_parameter_count(pStmt);
  if( nVar==0 ) return;  /* Nothing to do */
  if( sqlite3_table_column_metadata(pArg->db, "TEMP", "sqlite_parameters",
                                    "key", 0, 0, 0, 0, 0)!=SQLITE_OK ){
    rc = SQLITE_NOTFOUND;
    pQ = 0;
  }else{
    rc = sqlite3_prepare_v2(pArg->db,
            "SELECT value FROM temp.sqlite_parameters"
            " WHERE key=?1", -1, &pQ, 0);
  }
  for(i=1; i<=nVar; i++){
    char zNum[30];
    const char *zVar = sqlite3_bind_parameter_name(pStmt, i);
    if( zVar==0 ){
      sqlite3_snprintf(sizeof(zNum),zNum,"?%d",i);
      zVar = zNum;
    }
    sqlite3_bind_text(pQ, 1, zVar, -1, SQLITE_STATIC);
    if( rc==SQLITE_OK && pQ && sqlite3_step(pQ)==SQLITE_ROW ){
      sqlite3_bind_value(pStmt, i, sqlite3_column_value(pQ, 0));
#ifdef NAN
    }else if( sqlite3_strlike("_NAN", zVar, 0)==0 ){
      sqlite3_bind_double(pStmt, i, NAN);
#endif
#ifdef INFINITY
    }else if( sqlite3_strlike("_INF", zVar, 0)==0 ){
      sqlite3_bind_double(pStmt, i, INFINITY);
#endif
    }else if( strncmp(zVar, "$int_", 5)==0 ){
      sqlite3_bind_int(pStmt, i, atoi(&zVar[5]));
    }else if( strncmp(zVar, "$text_", 6)==0 ){
      size_t szVar = strlen(zVar);
      char *zBuf = sqlite3_malloc64( szVar-5 );
      if( zBuf ){
        memcpy(zBuf, &zVar[6], szVar-5);
        sqlite3_bind_text64(pStmt, i, zBuf, szVar-6, sqlite3_free, SQLITE_UTF8);
      }
    }else{
      sqlite3_bind_null(pStmt, i);
    }
    sqlite3_reset(pQ);
  }

References ShellState::db, sqlite3_bind_double, sqlite3_bind_int, sqlite3_bind_null, sqlite3_bind_parameter_count, sqlite3_bind_parameter_name, sqlite3_bind_text, sqlite3_bind_text64, sqlite3_bind_value, sqlite3_column_value, sqlite3_finalize, sqlite3_free, sqlite3_malloc64, sqlite3_prepare_v2, sqlite3_reset, sqlite3_snprintf, sqlite3_step, sqlite3_strlike, sqlite3_table_column_metadata, SQLITE_NOTFOUND, SQLITE_OK, SQLITE_ROW, SQLITE_STATIC, and SQLITE_UTF8.

Referenced by do_meta_command(), and shell_exec().

Here is the caller graph for this function:

bind_table_init()

void bind_table_init ( ShellState * p )

static

                                          {
  int wrSchema = 0;
  int defensiveMode = 0;
  sqlite3_db_config(p->db, SQLITE_DBCONFIG_DEFENSIVE, -1, &defensiveMode);
  sqlite3_db_config(p->db, SQLITE_DBCONFIG_DEFENSIVE, 0, 0);
  sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, -1, &wrSchema);
  sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, 1, 0);
  sqlite3_exec(p->db,
    "CREATE TABLE IF NOT EXISTS temp.sqlite_parameters(\n"
    "  key TEXT PRIMARY KEY,\n"
    "  value\n"
    ") WITHOUT ROWID;",
    0, 0, 0);
  sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, wrSchema, 0);

References ShellState::db, sqlite3_db_config, sqlite3_exec, SQLITE_DBCONFIG_DEFENSIVE, and SQLITE_DBCONFIG_WRITABLE_SCHEMA.

Referenced by do_meta_command().

Here is the caller graph for this function:

booleanValue()

int booleanValue ( const char * zArg )

static

                                         {
  int i;
  if( zArg[0]=='0' && zArg[1]=='x' ){
    for(i=2; hexDigitValue(zArg[i])>=0; i++){}
  }else{
    for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
  }
  if( i>0 && zArg[i]==0 ) return (int)(integerValue(zArg) & 0xffffffff);
  if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){
    return 1;
  }
  if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){
    return 0;
  }
  sqlite3_fprintf(stderr,
       "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n", zArg);

References hexDigitValue(), integerValue(), sqlite3_fprintf, and sqlite3_stricmp.

Referenced by do_meta_command(), and setOrClearFlag().

Here is the call graph for this function:

Here is the caller graph for this function:

callback()

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

static

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

References shell_callback().

Referenced by do_meta_command().

Here is the call graph for this function:

Here is the caller graph for this function:

captureOutputCallback()

int captureOutputCallback ( void * pArg, int nArg, char ** azArg, char ** az )

static

                                                                               {
  ShellText *p = (ShellText*)pArg;
  int i;
  UNUSED_PARAMETER(az);
  if( azArg==0 ) return 0;
  if( p->n ) appendText(p, "|", 0);
  for(i=0; i<nArg; i++){
    if( i ) appendText(p, ",", 0);
    if( azArg[i] ) appendText(p, azArg[i], 0);
  }

References appendText(), ShellText::n, and UNUSED_PARAMETER.

Referenced by do_meta_command().

Here is the call graph for this function:

Here is the caller graph for this function:

clearTempFile()

void clearTempFile ( ShellState * p )

static

                                        {
  if( p->zTempFile==0 ) return;
  if( p->doXdgOpen ) return;
  if( shellDeleteFile(p->zTempFile) ) return;
  sqlite3_free(p->zTempFile);

References ShellState::doXdgOpen, shellDeleteFile(), sqlite3_free, and ShellState::zTempFile.

Referenced by do_meta_command(), main(), newTempFile(), and process_input().

Here is the call graph for this function:

Here is the caller graph for this function:

cli_strcmp()

int cli_strcmp ( const char * a, const char * b )

static

                                                   {
  if( a==0 ) a = "";
  if( b==0 ) b = "";
  return strcmp(a,b);
}

References a, and b.

Referenced by do_meta_command(), dump_callback(), main(), optionMatch(), output_file_open(), showHelp(), and str_in_array().

Here is the caller graph for this function:

cli_strncmp()

int cli_strncmp ( const char * a, const char * b, size_t n )

static

                                                              {
  if( a==0 ) a = "";
  if( b==0 ) b = "";
  return strncmp(a,b,n);
}

References a, and b.

Referenced by do_meta_command(), dump_callback(), expertDotCommand(), main(), readHexDb(), runOneSqlLine(), and shellAddSchemaName().

Here is the caller graph for this function:

cli_wcwidth()

int cli_wcwidth

(

int

c

)

                      {
  int iFirst, iLast;
 
  /* Fast path for common characters */
  if( c<=0x300 ) return 1;
 
  /* The general case */
  iFirst = 0;
  iLast = sizeof(aUWidth)/sizeof(aUWidth[0]) - 1;
  while( iFirst<iLast-1 ){
    int iMid = (iFirst+iLast)/2;
    int cMid = aUWidth[iMid].iFirst;
    if( cMid < c ){
      iFirst = iMid;
    }else if( cMid > c ){
      iLast = iMid - 1;
    }else{
      return aUWidth[iMid].w;
    }
  }
  if( aUWidth[iLast].iFirst > c ) return aUWidth[iFirst].w;
  return aUWidth[iLast].w;
}

References aUWidth, and c.

Referenced by translateForDisplayAndDup(), and utf8_width_print().

Here is the caller graph for this function:

close_db()

void close_db

(

sqlite3 *

db

)

                          {
  int rc = sqlite3_close(db);
  if( rc ){
    sqlite3_fprintf(stderr,
        "Error: sqlite3_close() returns %d: %s\n", rc, sqlite3_errmsg(db));

References sqlite3_close, sqlite3_errmsg, and sqlite3_fprintf.

Referenced by do_meta_command(), main(), and tryToClone().

Here is the caller graph for this function:

cmdline_option_value()

char * cmdline_option_value ( int argc, char ** argv, int i )

static

                                                               {
  if( i==argc ){
    sqlite3_fprintf(stderr,
            "%s: Error: missing argument to %s\n", argv[0], argv[argc-1]);
    exit(1);
  }

References sqlite3_fprintf.

Referenced by main().

Here is the caller graph for this function:

completionBestIndex()

int completionBestIndex ( sqlite3_vtab * tab, sqlite3_index_info * pIdxInfo )

static

 {
  int i;                 /* Loop over constraints */
  int idxNum = 0;        /* The query plan bitmask */
  int prefixIdx = -1;    /* Index of the start= constraint, or -1 if none */
  int wholelineIdx = -1; /* Index of the stop= constraint, or -1 if none */
  int nArg = 0;          /* Number of arguments that completeFilter() expects */
  const struct sqlite3_index_constraint *pConstraint;
 
  (void)(tab);    /* Unused parameter */
  pConstraint = pIdxInfo->aConstraint;
  for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){
    if( pConstraint->usable==0 ) continue;
    if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
    switch( pConstraint->iColumn ){
      case COMPLETION_COLUMN_PREFIX:
        prefixIdx = i;
        idxNum |= 1;
        break;
      case COMPLETION_COLUMN_WHOLELINE:
        wholelineIdx = i;
        idxNum |= 2;
        break;
    }
  }
  if( prefixIdx>=0 ){
    pIdxInfo->aConstraintUsage[prefixIdx].argvIndex = ++nArg;
    pIdxInfo->aConstraintUsage[prefixIdx].omit = 1;
  }
  if( wholelineIdx>=0 ){
    pIdxInfo->aConstraintUsage[wholelineIdx].argvIndex = ++nArg;
    pIdxInfo->aConstraintUsage[wholelineIdx].omit = 1;
  }
  pIdxInfo->idxNum = idxNum;
  pIdxInfo->estimatedCost = (double)5000 - 1000*nArg;
  pIdxInfo->estimatedRows = 500 - 100*nArg;
  return SQLITE_OK;
}

References sqlite3_index_info::aConstraint, sqlite3_index_info::aConstraintUsage, sqlite3_index_info::sqlite3_index_constraint_usage::argvIndex, COMPLETION_COLUMN_PREFIX, COMPLETION_COLUMN_WHOLELINE, sqlite3_index_info::estimatedCost, sqlite3_index_info::estimatedRows, sqlite3_index_info::idxNum, sqlite3_index_info::nConstraint, sqlite3_index_info::sqlite3_index_constraint_usage::omit, SQLITE_INDEX_CONSTRAINT_EQ, and SQLITE_OK.

completionClose()

int completionClose ( sqlite3_vtab_cursor * cur )

static

                                                    {
  completionCursorReset((completion_cursor*)cur);
  sqlite3_free(cur);
  return SQLITE_OK;
}

References completionCursorReset(), sqlite3_free, and SQLITE_OK.

Here is the call graph for this function:

completionColumn()

int completionColumn ( sqlite3_vtab_cursor * cur, sqlite3_context * ctx, int i )

static

 {
  completion_cursor *pCur = (completion_cursor*)cur;
  switch( i ){
    case COMPLETION_COLUMN_CANDIDATE: {
      sqlite3_result_text(ctx, pCur->zCurrentRow, pCur->szRow,SQLITE_TRANSIENT);
      break;
    }
    case COMPLETION_COLUMN_PREFIX: {
      sqlite3_result_text(ctx, pCur->zPrefix, -1, SQLITE_TRANSIENT);
      break;
    }
    case COMPLETION_COLUMN_WHOLELINE: {
      sqlite3_result_text(ctx, pCur->zLine, -1, SQLITE_TRANSIENT);
      break;
    }
    case COMPLETION_COLUMN_PHASE: {
      sqlite3_result_int(ctx, pCur->ePhase);
      break;
    }
  }
  return SQLITE_OK;
}

References COMPLETION_COLUMN_CANDIDATE, COMPLETION_COLUMN_PHASE, COMPLETION_COLUMN_PREFIX, COMPLETION_COLUMN_WHOLELINE, completion_cursor::ePhase, sqlite3_result_int, sqlite3_result_text, SQLITE_OK, SQLITE_TRANSIENT, completion_cursor::szRow, completion_cursor::zCurrentRow, completion_cursor::zLine, and completion_cursor::zPrefix.

completionConnect()

int completionConnect ( sqlite3 * db, void * pAux, int argc, const char *const * argv, sqlite3_vtab ** ppVtab, char ** pzErr )

static

 {
  completion_vtab *pNew;
  int rc;
 
  (void)(pAux);    /* Unused parameter */
  (void)(argc);    /* Unused parameter */
  (void)(argv);    /* Unused parameter */
  (void)(pzErr);   /* Unused parameter */
 
/* Column numbers */
#define COMPLETION_COLUMN_CANDIDATE 0  /* Suggested completion of the input */
#define COMPLETION_COLUMN_PREFIX    1  /* Prefix of the word to be completed */
#define COMPLETION_COLUMN_WHOLELINE 2  /* Entire line seen so far */
#define COMPLETION_COLUMN_PHASE     3  /* ePhase - used for debugging only */
 
  sqlite3_vtab_config(db, SQLITE_VTAB_INNOCUOUS);
  rc = sqlite3_declare_vtab(db,
      "CREATE TABLE x("
      "  candidate TEXT,"
      "  prefix TEXT HIDDEN,"
      "  wholeline TEXT HIDDEN,"
      "  phase INT HIDDEN"        /* Used for debugging only */
      ")");
  if( rc==SQLITE_OK ){
    pNew = sqlite3_malloc( sizeof(*pNew) );
    *ppVtab = (sqlite3_vtab*)pNew;
    if( pNew==0 ) return SQLITE_NOMEM;
    memset(pNew, 0, sizeof(*pNew));
    pNew->db = db;
  }
  return rc;
}

References completion_vtab::db, sqlite3_declare_vtab, sqlite3_malloc, sqlite3_vtab_config, SQLITE_NOMEM, SQLITE_OK, and SQLITE_VTAB_INNOCUOUS.

completionCursorReset()

void completionCursorReset ( completion_cursor * pCur )

static

                                                          {
  sqlite3_free(pCur->zPrefix);   pCur->zPrefix = 0;  pCur->nPrefix = 0;
  sqlite3_free(pCur->zLine);     pCur->zLine = 0;    pCur->nLine = 0;
  sqlite3_finalize(pCur->pStmt); pCur->pStmt = 0;
  pCur->j = 0;
}

References completion_cursor::j, completion_cursor::nLine, completion_cursor::nPrefix, completion_cursor::pStmt, sqlite3_finalize, sqlite3_free, completion_cursor::zLine, and completion_cursor::zPrefix.

Referenced by completionClose(), and completionFilter().

Here is the caller graph for this function:

completionDisconnect()

int completionDisconnect ( sqlite3_vtab * pVtab )

static

                                                    {
  sqlite3_free(pVtab);
  return SQLITE_OK;
}

References sqlite3_free, and SQLITE_OK.

completionEof()

int completionEof ( sqlite3_vtab_cursor * cur )

static

                                                  {
  completion_cursor *pCur = (completion_cursor*)cur;
  return pCur->ePhase >= COMPLETION_EOF;
}

References COMPLETION_EOF, and completion_cursor::ePhase.

completionFilter()

int completionFilter ( sqlite3_vtab_cursor * pVtabCursor, int idxNum, const char * idxStr, int argc, sqlite3_value ** argv )

static

 {
  completion_cursor *pCur = (completion_cursor *)pVtabCursor;
  int iArg = 0;
  (void)(idxStr);   /* Unused parameter */
  (void)(argc);     /* Unused parameter */
  completionCursorReset(pCur);
  if( idxNum & 1 ){
    pCur->nPrefix = sqlite3_value_bytes(argv[iArg]);
    if( pCur->nPrefix>0 ){
      pCur->zPrefix = sqlite3_mprintf("%s", sqlite3_value_text(argv[iArg]));
      if( pCur->zPrefix==0 ) return SQLITE_NOMEM;
    }
    iArg = 1;
  }
  if( idxNum & 2 ){
    pCur->nLine = sqlite3_value_bytes(argv[iArg]);
    if( pCur->nLine>0 ){
      pCur->zLine = sqlite3_mprintf("%s", sqlite3_value_text(argv[iArg]));
      if( pCur->zLine==0 ) return SQLITE_NOMEM;
    }
  }
  if( pCur->zLine!=0 && pCur->zPrefix==0 ){
    int i = pCur->nLine;
    while( i>0 && (IsAlnum(pCur->zLine[i-1]) || pCur->zLine[i-1]=='_') ){
      i--;
    }
    pCur->nPrefix = pCur->nLine - i;
    if( pCur->nPrefix>0 ){
      pCur->zPrefix = sqlite3_mprintf("%.*s", pCur->nPrefix, pCur->zLine + i);
      if( pCur->zPrefix==0 ) return SQLITE_NOMEM;
    }
  }
  pCur->iRowid = 0;
  pCur->ePhase = COMPLETION_FIRST_PHASE;
  return completionNext(pVtabCursor);
}

References COMPLETION_FIRST_PHASE, completionCursorReset(), completionNext(), completion_cursor::ePhase, completion_cursor::iRowid, IsAlnum, completion_cursor::nLine, completion_cursor::nPrefix, sqlite3_mprintf, sqlite3_value_bytes, sqlite3_value_text, SQLITE_NOMEM, completion_cursor::zLine, and completion_cursor::zPrefix.

Here is the call graph for this function:

completionNext()

int completionNext ( sqlite3_vtab_cursor * cur )

static

                                                   {
  completion_cursor *pCur = (completion_cursor*)cur;
  int eNextPhase = 0;  /* Next phase to try if current phase reaches end */
  int iCol = -1;       /* If >=0, step pCur->pStmt and use the i-th column */
  pCur->iRowid++;
  while( pCur->ePhase!=COMPLETION_EOF ){
    switch( pCur->ePhase ){
      case COMPLETION_KEYWORDS: {
        if( pCur->j >= sqlite3_keyword_count() ){
          pCur->zCurrentRow = 0;
          pCur->ePhase = COMPLETION_DATABASES;
        }else{
          sqlite3_keyword_name(pCur->j++, &pCur->zCurrentRow, &pCur->szRow);
        }
        iCol = -1;
        break;
      }
      case COMPLETION_DATABASES: {
        if( pCur->pStmt==0 ){
          sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1,
                             &pCur->pStmt, 0);
        }
        iCol = 1;
        eNextPhase = COMPLETION_TABLES;
        break;
      }
      case COMPLETION_TABLES: {
        if( pCur->pStmt==0 ){
          sqlite3_stmt *pS2;
          char *zSql = 0;
          const char *zSep = "";
          sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1, &pS2, 0);
          while( sqlite3_step(pS2)==SQLITE_ROW ){
            const char *zDb = (const char*)sqlite3_column_text(pS2, 1);
            zSql = sqlite3_mprintf(
               "%z%s"
               "SELECT name FROM \"%w\".sqlite_schema",
               zSql, zSep, zDb
            );
            if( zSql==0 ) return SQLITE_NOMEM;
            zSep = " UNION ";
          }
          sqlite3_finalize(pS2);
          sqlite3_prepare_v2(pCur->db, zSql, -1, &pCur->pStmt, 0);
          sqlite3_free(zSql);
        }
        iCol = 0;
        eNextPhase = COMPLETION_COLUMNS;
        break;
      }
      case COMPLETION_COLUMNS: {
        if( pCur->pStmt==0 ){
          sqlite3_stmt *pS2;
          char *zSql = 0;
          const char *zSep = "";
          sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1, &pS2, 0);
          while( sqlite3_step(pS2)==SQLITE_ROW ){
            const char *zDb = (const char*)sqlite3_column_text(pS2, 1);
            zSql = sqlite3_mprintf(
               "%z%s"
               "SELECT pti.name FROM \"%w\".sqlite_schema AS sm"
                       " JOIN pragma_table_xinfo(sm.name,%Q) AS pti"
               " WHERE sm.type='table'",
               zSql, zSep, zDb, zDb
            );
            if( zSql==0 ) return SQLITE_NOMEM;
            zSep = " UNION ";
          }
          sqlite3_finalize(pS2);
          sqlite3_prepare_v2(pCur->db, zSql, -1, &pCur->pStmt, 0);
          sqlite3_free(zSql);
        }
        iCol = 0;
        eNextPhase = COMPLETION_EOF;
        break;
      }
    }
    if( iCol<0 ){
      /* This case is when the phase presets zCurrentRow */
      if( pCur->zCurrentRow==0 ) continue;
    }else{
      if( sqlite3_step(pCur->pStmt)==SQLITE_ROW ){
        /* Extract the next row of content */
        pCur->zCurrentRow = (const char*)sqlite3_column_text(pCur->pStmt, iCol);
        pCur->szRow = sqlite3_column_bytes(pCur->pStmt, iCol);
      }else{
        /* When all rows are finished, advance to the next phase */
        sqlite3_finalize(pCur->pStmt);
        pCur->pStmt = 0;
        pCur->ePhase = eNextPhase;
        continue;
      }
    }
    if( pCur->nPrefix==0 ) break;
    if( pCur->nPrefix<=pCur->szRow
     && sqlite3_strnicmp(pCur->zPrefix, pCur->zCurrentRow, pCur->nPrefix)==0
    ){
      break;
    }
  }
 
  return SQLITE_OK;
}

References COMPLETION_COLUMNS, COMPLETION_DATABASES, COMPLETION_EOF, COMPLETION_KEYWORDS, COMPLETION_TABLES, completion_cursor::db, completion_cursor::ePhase, completion_cursor::iRowid, completion_cursor::j, completion_cursor::nPrefix, completion_cursor::pStmt, sqlite3_column_bytes, sqlite3_column_text, sqlite3_finalize, sqlite3_free, sqlite3_keyword_count, sqlite3_keyword_name, sqlite3_mprintf, sqlite3_prepare_v2, sqlite3_step, sqlite3_strnicmp, SQLITE_NOMEM, SQLITE_OK, SQLITE_ROW, completion_cursor::szRow, completion_cursor::zCurrentRow, and completion_cursor::zPrefix.

Referenced by completionFilter().

Here is the caller graph for this function:

completionOpen()

int completionOpen ( sqlite3_vtab * p, sqlite3_vtab_cursor ** ppCursor )

static

                                                                          {
  completion_cursor *pCur;
  pCur = sqlite3_malloc( sizeof(*pCur) );
  if( pCur==0 ) return SQLITE_NOMEM;
  memset(pCur, 0, sizeof(*pCur));
  pCur->db = ((completion_vtab*)p)->db;
  *ppCursor = &pCur->base;
  return SQLITE_OK;
}

References completion_cursor::base, completion_cursor::db, sqlite3_malloc, SQLITE_NOMEM, and SQLITE_OK.

completionRowid()

int completionRowid ( sqlite3_vtab_cursor * cur, sqlite_int64 * pRowid )

static

                                                                          {
  completion_cursor *pCur = (completion_cursor*)cur;
  *pRowid = pCur->iRowid;
  return SQLITE_OK;
}

References completion_cursor::iRowid, and SQLITE_OK.

countNonzeros()

int countNonzeros ( void * pCount, int nc, char * azResults[], char * azColumns[] )

static

                                                              {
  (void)azColumns;  /* Suppress unused parameter warning */
  if( nc>0 && (azResults[0][0]!='0' || azResults[0][1]!=0) ){
    *((int *)pCount) += 1;
  }
  return 0;
}

Referenced by idxCreateFromCons().

Here is the caller graph for this function:

createSelftestTable()

void createSelftestTable ( ShellState * p )

static

                                              {
  char *zErrMsg = 0;
  sqlite3_exec(p->db,
    "SAVEPOINT selftest_init;\n"
    "CREATE TABLE IF NOT EXISTS selftest(\n"
    "  tno INTEGER PRIMARY KEY,\n"   /* Test number */
    "  op TEXT,\n"                   /* Operator:  memo run */
    "  cmd TEXT,\n"                  /* Command text */
    "  ans TEXT\n"                   /* Desired answer */
    ");"
    "CREATE TEMP TABLE [_shell$self](op,cmd,ans);\n"
    "INSERT INTO [_shell$self](rowid,op,cmd)\n"
    "  VALUES(coalesce((SELECT (max(tno)+100)/10 FROM selftest),10),\n"
    "         'memo','Tests generated by --init');\n"
    "INSERT INTO [_shell$self]\n"
    "  SELECT 'run',\n"
    "    'SELECT hex(sha3_query(''SELECT type,name,tbl_name,sql "
                                 "FROM sqlite_schema ORDER BY 2'',224))',\n"
    "    hex(sha3_query('SELECT type,name,tbl_name,sql "
                          "FROM sqlite_schema ORDER BY 2',224));\n"
    "INSERT INTO [_shell$self]\n"
    "  SELECT 'run',"
    "    'SELECT hex(sha3_query(''SELECT * FROM \"' ||"
    "        printf('%w',name) || '\" NOT INDEXED'',224))',\n"
    "    hex(sha3_query(printf('SELECT * FROM \"%w\" NOT INDEXED',name),224))\n"
    "  FROM (\n"
    "    SELECT name FROM sqlite_schema\n"
    "     WHERE type='table'\n"
    "       AND name<>'selftest'\n"
    "       AND coalesce(rootpage,0)>0\n"
    "  )\n"
    " ORDER BY name;\n"
    "INSERT INTO [_shell$self]\n"
    "  VALUES('run','PRAGMA integrity_check','ok');\n"
    "INSERT INTO selftest(tno,op,cmd,ans)"
    "  SELECT rowid*10,op,cmd,ans FROM [_shell$self];\n"
    "DROP TABLE [_shell$self];"
    ,0,0,&zErrMsg);
  if( zErrMsg ){
    sqlite3_fprintf(stderr, "SELFTEST initialization failure: %s\n", zErrMsg);
    sqlite3_free(zErrMsg);
  }

References ShellState::db, sqlite3_exec, sqlite3_fprintf, and sqlite3_free.

Referenced by do_meta_command().

Here is the caller graph for this function:

csv_read_one_field()

char * csv_read_one_field ( ImportCtx * p )

static

                                                          {
  int c;
  int cSep = (u8)p->cColSep;
  int rSep = (u8)p->cRowSep;
  p->n = 0;
  c = fgetc(p->in);
  if( c==EOF || seenInterrupt ){
    p->cTerm = EOF;
    return 0;
  }
  if( c=='"' ){
    int pc, ppc;
    int startLine = p->nLine;
    int cQuote = c;
    pc = ppc = 0;
    while( 1 ){
      c = fgetc(p->in);
      if( c==rSep ) p->nLine++;
      if( c==cQuote ){
        if( pc==cQuote ){
          pc = 0;
          continue;
        }
      }
      if( (c==cSep && pc==cQuote)
       || (c==rSep && pc==cQuote)
       || (c==rSep && pc=='\r' && ppc==cQuote)
       || (c==EOF && pc==cQuote)
      ){
        do{ p->n--; }while( p->z[p->n]!=cQuote );
        p->cTerm = c;
        break;
      }
      if( pc==cQuote && c!='\r' ){
        sqlite3_fprintf(stderr,"%s:%d: unescaped %c character\n", 
                        p->zFile, p->nLine, cQuote);
      }
      if( c==EOF ){
        sqlite3_fprintf(stderr,"%s:%d: unterminated %c-quoted field\n",
              p->zFile, startLine, cQuote);
        p->cTerm = c;
        break;
      }
      import_append_char(p, c);
      ppc = pc;
      pc = c;
    }
  }else{
    /* If this is the first field being parsed and it begins with the
    ** UTF-8 BOM  (0xEF BB BF) then skip the BOM */
    if( (c&0xff)==0xef && p->bNotFirst==0 ){
      import_append_char(p, c);
      c = fgetc(p->in);
      if( (c&0xff)==0xbb ){
        import_append_char(p, c);
        c = fgetc(p->in);
        if( (c&0xff)==0xbf ){
          p->bNotFirst = 1;
          p->n = 0;
          return csv_read_one_field(p);
        }
      }
    }
    while( c!=EOF && c!=cSep && c!=rSep ){
      import_append_char(p, c);
      c = fgetc(p->in);
    }
    if( c==rSep ){
      p->nLine++;
      if( p->n>0 && p->z[p->n-1]=='\r' ) p->n--;
    }
    p->cTerm = c;
  }
  if( p->z ) p->z[p->n] = 0;
  p->bNotFirst = 1;

References ImportCtx::bNotFirst, c, ImportCtx::cColSep, ImportCtx::cRowSep, csv_read_one_field(), ImportCtx::cTerm, import_append_char(), ImportCtx::in, ImportCtx::n, ImportCtx::nLine, seenInterrupt, sqlite3_fprintf, SQLITE_CDECL, ImportCtx::z, and ImportCtx::zFile.

Referenced by csv_read_one_field(), and do_meta_command().

Here is the call graph for this function:

Here is the caller graph for this function:

ctxErrorMsg()

void ctxErrorMsg ( sqlite3_context * ctx, const char * zFmt, ... )

static

                                                                    {
  char *zMsg = 0;
  va_list ap;
  va_start(ap, zFmt);
  zMsg = sqlite3_vmprintf(zFmt, ap);
  sqlite3_result_error(ctx, zMsg, -1);
  sqlite3_free(zMsg);
  va_end(ap);
}

References sqlite3_free, sqlite3_result_error, and sqlite3_vmprintf.

Referenced by writefileFunc().

Here is the caller graph for this function:

db_int()

int db_int ( sqlite3 * db, const char * zSql, ... )

static

                                                     {
  sqlite3_stmt *pStmt;
  int res = 0;
  char *z;
  va_list ap;
  va_start(ap, zSql);
  z = sqlite3_vmprintf(zSql, ap);
  va_end(ap);
  sqlite3_prepare_v2(db, z, -1, &pStmt, 0);
  if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
    res = sqlite3_column_int(pStmt,0);
  }
  sqlite3_finalize(pStmt);
  sqlite3_free(z);

References sqlite3_column_int, sqlite3_finalize, sqlite3_free, sqlite3_prepare_v2, sqlite3_step, sqlite3_vmprintf, and SQLITE_ROW.

Referenced by do_meta_command(), and zAutoColumn().

Here is the caller graph for this function:

decimal_add()

void decimal_add ( Decimal * pA, Decimal * pB )

static

                                                 {
  int nSig, nFrac, nDigit;
  int i, rc;
  if( pA==0 ){
    return;
  }
  if( pA->oom || pB==0 || pB->oom ){
    pA->oom = 1;
    return;
  }
  if( pA->isNull || pB->isNull ){
    pA->isNull = 1;
    return;
  }
  nSig = pA->nDigit - pA->nFrac;
  if( nSig && pA->a[0]==0 ) nSig--;
  if( nSig<pB->nDigit-pB->nFrac ){
    nSig = pB->nDigit - pB->nFrac;
  }
  nFrac = pA->nFrac;
  if( nFrac<pB->nFrac ) nFrac = pB->nFrac;
  nDigit = nSig + nFrac + 1;
  decimal_expand(pA, nDigit, nFrac);
  decimal_expand(pB, nDigit, nFrac);
  if( pA->oom || pB->oom ){
    pA->oom = 1;
  }else{
    if( pA->sign==pB->sign ){
      int carry = 0;
      for(i=nDigit-1; i>=0; i--){
        int x = pA->a[i] + pB->a[i] + carry;
        if( x>=10 ){
          carry = 1;
          pA->a[i] = x - 10;
        }else{
          carry = 0;
          pA->a[i] = x;
        }
      }
    }else{
      signed char *aA, *aB;
      int borrow = 0;
      rc = memcmp(pA->a, pB->a, nDigit);
      if( rc<0 ){
        aA = pB->a;
        aB = pA->a;
        pA->sign = !pA->sign;
      }else{
        aA = pA->a;
        aB = pB->a;
      }
      for(i=nDigit-1; i>=0; i--){
        int x = aA[i] - aB[i] - borrow;
        if( x<0 ){
          pA->a[i] = x+10;
          borrow = 1;
        }else{
          pA->a[i] = x;
          borrow = 0;
        }
      }
    }
  }
}

References Decimal::a, decimal_expand(), Decimal::isNull, Decimal::nDigit, Decimal::nFrac, Decimal::oom, and Decimal::sign.

Referenced by decimalAddFunc(), decimalSubFunc(), decimalSumInverse(), and decimalSumStep().

Here is the call graph for this function:

Here is the caller graph for this function:

decimal_clear()

void decimal_clear ( Decimal * p )

static

                                     {
  sqlite3_free(p->a);
}

References Decimal::a, and sqlite3_free.

Referenced by decimal_free(), and decimalSumFinalize().

Here is the caller graph for this function:

decimal_cmp()

int decimal_cmp ( const Decimal * pA, const Decimal * pB )

static

                                                            {
  int nASig, nBSig, rc, n;
  if( pA->sign!=pB->sign ){
    return pA->sign ? -1 : +1;
  }
  if( pA->sign ){
    const Decimal *pTemp = pA;
    pA = pB;
    pB = pTemp;
  }
  nASig = pA->nDigit - pA->nFrac;
  nBSig = pB->nDigit - pB->nFrac;
  if( nASig!=nBSig ){
    return nASig - nBSig;
  }
  n = pA->nDigit;
  if( n>pB->nDigit ) n = pB->nDigit;
  rc = memcmp(pA->a, pB->a, n);
  if( rc==0 ){
    rc = pA->nDigit - pB->nDigit;
  }
  return rc;
}

References Decimal::a, Decimal::nDigit, Decimal::nFrac, and Decimal::sign.

Referenced by decimalCmpFunc(), and decimalCollFunc().

Here is the caller graph for this function:

decimal_expand()

void decimal_expand ( Decimal * p, int nDigit, int nFrac )

static

                                                             {
  int nAddSig;
  int nAddFrac;
  if( p==0 ) return;
  nAddFrac = nFrac - p->nFrac;
  nAddSig = (nDigit - p->nDigit) - nAddFrac;
  if( nAddFrac==0 && nAddSig==0 ) return;
  p->a = sqlite3_realloc64(p->a, nDigit+1);
  if( p->a==0 ){
    p->oom = 1;
    return;
  }
  if( nAddSig ){
    memmove(p->a+nAddSig, p->a, p->nDigit);
    memset(p->a, 0, nAddSig);
    p->nDigit += nAddSig;
  }
  if( nAddFrac ){
    memset(p->a+p->nDigit, 0, nAddFrac);
    p->nDigit += nAddFrac;
    p->nFrac += nAddFrac;
  }
}

References Decimal::a, Decimal::nDigit, Decimal::nFrac, Decimal::oom, and sqlite3_realloc64.

Referenced by decimal_add().

Here is the caller graph for this function:

decimal_free()

void decimal_free ( Decimal * p )

static

                                    {
  if( p ){
    decimal_clear(p);
    sqlite3_free(p);
  }
}

References decimal_clear(), and sqlite3_free.

Referenced by decimalAddFunc(), decimalCmpFunc(), decimalCollFunc(), decimalFromDouble(), decimalFunc(), decimalMulFunc(), decimalPow2(), decimalPow2Func(), decimalSubFunc(), decimalSumInverse(), and decimalSumStep().

Here is the call graph for this function:

Here is the caller graph for this function:

decimal_new()

Decimal * decimal_new ( sqlite3_context * pCtx, sqlite3_value * pIn, int bTextOnly )

static

 {
  Decimal *p = 0;
  int eType = sqlite3_value_type(pIn);
  if( bTextOnly && (eType==SQLITE_FLOAT || eType==SQLITE_BLOB) ){
    eType = SQLITE_TEXT;
  }
  switch( eType ){
    case SQLITE_TEXT:
    case SQLITE_INTEGER: {
      const char *zIn = (const char*)sqlite3_value_text(pIn);
      int n = sqlite3_value_bytes(pIn);
      p = decimalNewFromText(zIn, n);
      if( p==0 ) goto new_failed;
      break;
    }
 
    case SQLITE_FLOAT: {
      p = decimalFromDouble(sqlite3_value_double(pIn));
      break;
    }
 
    case SQLITE_BLOB: {
      const unsigned char *x;
      unsigned int i;
      sqlite3_uint64 v = 0;
      double r;
 
      if( sqlite3_value_bytes(pIn)!=sizeof(r) ) break;
      x = sqlite3_value_blob(pIn);
      for(i=0; i<sizeof(r); i++){
        v = (v<<8) | x[i];
      }
      memcpy(&r, &v, sizeof(r));
      p = decimalFromDouble(r);
      break;
    }
 
    case SQLITE_NULL: {
      break;
    }
  }
  return p;
 
new_failed:
  if( pCtx ) sqlite3_result_error_nomem(pCtx);
  sqlite3_free(p);
  return 0;
}

References decimalFromDouble(), decimalNewFromText(), sqlite3_free, sqlite3_result_error_nomem, sqlite3_value_blob, sqlite3_value_bytes, sqlite3_value_double, sqlite3_value_text, sqlite3_value_type, SQLITE_BLOB, SQLITE_FLOAT, SQLITE_INTEGER, SQLITE_NULL, and SQLITE_TEXT.

Referenced by decimalAddFunc(), decimalCmpFunc(), decimalFunc(), decimalMulFunc(), decimalSubFunc(), decimalSumInverse(), and decimalSumStep().

Here is the call graph for this function:

Here is the caller graph for this function:

decimal_result()

void decimal_result ( sqlite3_context * pCtx, Decimal * p )

static

                                                             {
  char *z;
  int i, j;
  int n;
  if( p==0 || p->oom ){
    sqlite3_result_error_nomem(pCtx);
    return;
  }
  if( p->isNull ){
    sqlite3_result_null(pCtx);
    return;
  }
  z = sqlite3_malloc( p->nDigit+4 );
  if( z==0 ){
    sqlite3_result_error_nomem(pCtx);
    return;
  }
  i = 0;
  if( p->nDigit==0 || (p->nDigit==1 && p->a[0]==0) ){
    p->sign = 0;
  }
  if( p->sign ){
    z[0] = '-';
    i = 1;
  }
  n = p->nDigit - p->nFrac;
  if( n<=0 ){
    z[i++] = '0';
  }
  j = 0;
  while( n>1 && p->a[j]==0 ){
    j++;
    n--;
  }
  while( n>0  ){
    z[i++] = p->a[j] + '0';
    j++;
    n--;
  }
  if( p->nFrac ){
    z[i++] = '.';
    do{
      z[i++] = p->a[j] + '0';
      j++;
    }while( j<p->nDigit );
  }
  z[i] = 0;
  sqlite3_result_text(pCtx, z, i, sqlite3_free);
}

References Decimal::a, Decimal::isNull, Decimal::nDigit, Decimal::nFrac, Decimal::oom, Decimal::sign, sqlite3_free, sqlite3_malloc, sqlite3_result_error_nomem, sqlite3_result_null, and sqlite3_result_text.

Referenced by decimalAddFunc(), decimalFunc(), decimalMulFunc(), decimalSubFunc(), decimalSumFinalize(), and decimalSumValue().

Here is the caller graph for this function:

decimal_result_sci()

void decimal_result_sci ( sqlite3_context * pCtx, Decimal * p )

static

                                                                 {
  char *z;       /* The output buffer */
  int i;         /* Loop counter */
  int nZero;     /* Number of leading zeros */
  int nDigit;    /* Number of digits not counting trailing zeros */
  int nFrac;     /* Digits to the right of the decimal point */
  int exp;       /* Exponent value */
  signed char zero;     /* Zero value */
  signed char *a;       /* Array of digits */
 
  if( p==0 || p->oom ){
    sqlite3_result_error_nomem(pCtx);
    return;
  }
  if( p->isNull ){
    sqlite3_result_null(pCtx);
    return;
  }
  for(nDigit=p->nDigit; nDigit>0 && p->a[nDigit-1]==0; nDigit--){}
  for(nZero=0; nZero<nDigit && p->a[nZero]==0; nZero++){}
  nFrac = p->nFrac + (nDigit - p->nDigit);
  nDigit -= nZero;
  z = sqlite3_malloc( nDigit+20 );
  if( z==0 ){
    sqlite3_result_error_nomem(pCtx);
    return;
  }
  if( nDigit==0 ){
    zero = 0;
    a = &zero;
    nDigit = 1;
    nFrac = 0;
  }else{
    a = &p->a[nZero];
  }
  if( p->sign && nDigit>0 ){
    z[0] = '-';
  }else{
    z[0] = '+';
  }
  z[1] = a[0]+'0';
  z[2] = '.';
  if( nDigit==1 ){
    z[3] = '0';
    i = 4;
  }else{
    for(i=1; i<nDigit; i++){
      z[2+i] = a[i]+'0';
    }
    i = nDigit+2;
  }
  exp = nDigit - nFrac - 1;
  sqlite3_snprintf(nDigit+20-i, &z[i], "e%+03d", exp);
  sqlite3_result_text(pCtx, z, -1, sqlite3_free);
}

References a, Decimal::a, Decimal::isNull, Decimal::nDigit, Decimal::nFrac, Decimal::oom, Decimal::sign, sqlite3_free, sqlite3_malloc, sqlite3_result_error_nomem, sqlite3_result_null, sqlite3_result_text, and sqlite3_snprintf.

Referenced by decimalFunc(), and decimalPow2Func().

Here is the caller graph for this function:

decimalAddFunc()

void decimalAddFunc ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  Decimal *pA = decimal_new(context, argv[0], 1);
  Decimal *pB = decimal_new(context, argv[1], 1);
  UNUSED_PARAMETER(argc);
  decimal_add(pA, pB);
  decimal_result(context, pA);
  decimal_free(pA);
  decimal_free(pB);
}

References decimal_add(), decimal_free(), decimal_new(), decimal_result(), and UNUSED_PARAMETER.

Referenced by sqlite3_decimal_init().

Here is the call graph for this function:

Here is the caller graph for this function:

decimalCmpFunc()

void decimalCmpFunc ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  Decimal *pA = 0, *pB = 0;
  int rc;
 
  UNUSED_PARAMETER(argc);
  pA = decimal_new(context, argv[0], 1);
  if( pA==0 || pA->isNull ) goto cmp_done;
  pB = decimal_new(context, argv[1], 1);
  if( pB==0 || pB->isNull ) goto cmp_done;
  rc = decimal_cmp(pA, pB);
  if( rc<0 ) rc = -1;
  else if( rc>0 ) rc = +1;
  sqlite3_result_int(context, rc);
cmp_done:
  decimal_free(pA);
  decimal_free(pB);
}

References decimal_cmp(), decimal_free(), decimal_new(), Decimal::isNull, sqlite3_result_int, and UNUSED_PARAMETER.

Referenced by sqlite3_decimal_init().

Here is the call graph for this function:

Here is the caller graph for this function:

decimalCollFunc()

int decimalCollFunc ( void * notUsed, int nKey1, const void * pKey1, int nKey2, const void * pKey2 )

static

 {
  const unsigned char *zA = (const unsigned char*)pKey1;
  const unsigned char *zB = (const unsigned char*)pKey2;
  Decimal *pA = decimalNewFromText((const char*)zA, nKey1);
  Decimal *pB = decimalNewFromText((const char*)zB, nKey2);
  int rc;
  UNUSED_PARAMETER(notUsed);
  if( pA==0 || pB==0 ){
    rc = 0;
  }else{
    rc = decimal_cmp(pA, pB);
  }
  decimal_free(pA);
  decimal_free(pB);
  return rc;
}

References decimal_cmp(), decimal_free(), decimalNewFromText(), and UNUSED_PARAMETER.

Referenced by sqlite3_decimal_init().

Here is the call graph for this function:

Here is the caller graph for this function:

decimalFromDouble()

Decimal * decimalFromDouble ( double r )

static

                                           {
  sqlite3_int64 m, a;
  int e;
  int isNeg;
  Decimal *pA;
  Decimal *pX;
  char zNum[100];
  if( r<0.0 ){
    isNeg = 1;
    r = -r;
  }else{
    isNeg = 0;
  }
  memcpy(&a,&r,sizeof(a));
  if( a==0 ){
    e = 0;
    m = 0;
  }else{
    e = a>>52;
    m = a & ((((sqlite3_int64)1)<<52)-1);
    if( e==0 ){
      m <<= 1;
    }else{
      m |= ((sqlite3_int64)1)<<52;
    }
    while( e<1075 && m>0 && (m&1)==0 ){
      m >>= 1;
      e++;
    }
    if( isNeg ) m = -m;
    e = e - 1075;
    if( e>971 ){
      return 0;  /* A NaN or an Infinity */
    }
  }
 
  /* At this point m is the integer significand and e is the exponent */
  sqlite3_snprintf(sizeof(zNum), zNum, "%lld", m);
  pA = decimalNewFromText(zNum, (int)strlen(zNum));
  pX = decimalPow2(e);
  decimalMul(pA, pX);
  decimal_free(pX);
  return pA;
}

References a, decimal_free(), decimalMul(), decimalNewFromText(), decimalPow2(), e, and sqlite3_snprintf.

Referenced by decimal_new().

Here is the call graph for this function:

Here is the caller graph for this function:

decimalFunc()

void decimalFunc ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  Decimal *p =  decimal_new(context, argv[0], 0);
  UNUSED_PARAMETER(argc);
  if( p ){
    if( sqlite3_user_data(context)!=0 ){
      decimal_result_sci(context, p);
    }else{
      decimal_result(context, p);
    }
    decimal_free(p);
  }
}

References decimal_free(), decimal_new(), decimal_result(), decimal_result_sci(), sqlite3_user_data, and UNUSED_PARAMETER.

Referenced by sqlite3_decimal_init().

Here is the call graph for this function:

Here is the caller graph for this function:

decimalMul()

void decimalMul ( Decimal * pA, Decimal * pB )

static

                                                {
  signed char *acc = 0;
  int i, j, k;
  int minFrac;
 
  if( pA==0 || pA->oom || pA->isNull
   || pB==0 || pB->oom || pB->isNull 
  ){
    goto mul_end;
  }
  acc = sqlite3_malloc64( pA->nDigit + pB->nDigit + 2 );
  if( acc==0 ){
    pA->oom = 1;
    goto mul_end;
  }
  memset(acc, 0, pA->nDigit + pB->nDigit + 2);
  minFrac = pA->nFrac;
  if( pB->nFrac<minFrac ) minFrac = pB->nFrac;
  for(i=pA->nDigit-1; i>=0; i--){
    signed char f = pA->a[i];
    int carry = 0, x;
    for(j=pB->nDigit-1, k=i+j+3; j>=0; j--, k--){
      x = acc[k] + f*pB->a[j] + carry;
      acc[k] = x%10;
      carry = x/10;
    }
    x = acc[k] + carry;
    acc[k] = x%10;
    acc[k-1] += x/10;
  }
  sqlite3_free(pA->a);
  pA->a = acc;
  acc = 0;
  pA->nDigit += pB->nDigit + 2;
  pA->nFrac += pB->nFrac;
  pA->sign ^= pB->sign;
  while( pA->nFrac>minFrac && pA->a[pA->nDigit-1]==0 ){
    pA->nFrac--;
    pA->nDigit--;
  }
 
mul_end:
  sqlite3_free(acc);
}

References Decimal::a, Decimal::isNull, Decimal::nDigit, Decimal::nFrac, Decimal::oom, Decimal::sign, sqlite3_free, and sqlite3_malloc64.

Referenced by decimalFromDouble(), decimalMulFunc(), and decimalPow2().

Here is the caller graph for this function:

decimalMulFunc()

void decimalMulFunc ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  Decimal *pA = decimal_new(context, argv[0], 1);
  Decimal *pB = decimal_new(context, argv[1], 1);
  UNUSED_PARAMETER(argc);
  if( pA==0 || pA->oom || pA->isNull
   || pB==0 || pB->oom || pB->isNull 
  ){
    goto mul_end;
  }
  decimalMul(pA, pB);
  if( pA->oom ){
    goto mul_end;
  }
  decimal_result(context, pA);
 
mul_end:
  decimal_free(pA);
  decimal_free(pB);
}

References decimal_free(), decimal_new(), decimal_result(), decimalMul(), Decimal::isNull, Decimal::oom, and UNUSED_PARAMETER.

Referenced by sqlite3_decimal_init().

Here is the call graph for this function:

Here is the caller graph for this function:

decimalNewFromText()

Decimal * decimalNewFromText ( const char * zIn, int n )

static

                                                          {
  Decimal *p = 0;
  int i;
  int iExp = 0;
 
  p = sqlite3_malloc( sizeof(*p) );
  if( p==0 ) goto new_from_text_failed;
  p->sign = 0;
  p->oom = 0;
  p->isInit = 1;
  p->isNull = 0;
  p->nDigit = 0;
  p->nFrac = 0;
  p->a = sqlite3_malloc64( n+1 );
  if( p->a==0 ) goto new_from_text_failed;
  for(i=0; IsSpace(zIn[i]); i++){}
  if( zIn[i]=='-' ){
    p->sign = 1;
    i++;
  }else if( zIn[i]=='+' ){
    i++;
  }
  while( i<n && zIn[i]=='0' ) i++;
  while( i<n ){
    char c = zIn[i];
    if( c>='0' && c<='9' ){
      p->a[p->nDigit++] = c - '0';
    }else if( c=='.' ){
      p->nFrac = p->nDigit + 1;
    }else if( c=='e' || c=='E' ){
      int j = i+1;
      int neg = 0;
      if( j>=n ) break;
      if( zIn[j]=='-' ){
        neg = 1;
        j++;
      }else if( zIn[j]=='+' ){
        j++;
      }
      while( j<n && iExp<1000000 ){
        if( zIn[j]>='0' && zIn[j]<='9' ){
          iExp = iExp*10 + zIn[j] - '0';
        }
        j++;
      }
      if( neg ) iExp = -iExp;
      break;
    }
    i++;
  }
  if( p->nFrac ){
    p->nFrac = p->nDigit - (p->nFrac - 1);
  }
  if( iExp>0 ){
    if( p->nFrac>0 ){
      if( iExp<=p->nFrac ){
        p->nFrac -= iExp;
        iExp = 0;
      }else{
        iExp -= p->nFrac;
        p->nFrac = 0;
      }
    }
    if( iExp>0 ){   
      p->a = sqlite3_realloc64(p->a, p->nDigit + iExp + 1 );
      if( p->a==0 ) goto new_from_text_failed;
      memset(p->a+p->nDigit, 0, iExp);
      p->nDigit += iExp;
    }
  }else if( iExp<0 ){
    int nExtra;
    iExp = -iExp;
    nExtra = p->nDigit - p->nFrac - 1;
    if( nExtra ){
      if( nExtra>=iExp ){
        p->nFrac += iExp;
        iExp  = 0;
      }else{
        iExp -= nExtra;
        p->nFrac = p->nDigit - 1;
      }
    }
    if( iExp>0 ){
      p->a = sqlite3_realloc64(p->a, p->nDigit + iExp + 1 );
      if( p->a==0 ) goto new_from_text_failed;
      memmove(p->a+iExp, p->a, p->nDigit);
      memset(p->a, 0, iExp);
      p->nDigit += iExp;
      p->nFrac += iExp;
    }
  }
  return p;
 
new_from_text_failed:
  if( p ){
    if( p->a ) sqlite3_free(p->a);
    sqlite3_free(p);
  }
  return 0;
}

References Decimal::a, c, Decimal::isInit, Decimal::isNull, IsSpace, Decimal::nDigit, Decimal::nFrac, Decimal::oom, Decimal::sign, sqlite3_free, sqlite3_malloc, sqlite3_malloc64, and sqlite3_realloc64.

Referenced by decimal_new(), decimalCollFunc(), decimalFromDouble(), and decimalPow2().

Here is the caller graph for this function:

decimalPow2()

Decimal * decimalPow2 ( int N )

static

                                  {
  Decimal *pA = 0;      /* The result to be returned */
  Decimal *pX = 0;      /* Multiplier */
  if( N<-20000 || N>20000 ) goto pow2_fault;
  pA = decimalNewFromText("1.0", 3);
  if( pA==0 || pA->oom ) goto pow2_fault;
  if( N==0 ) return pA;
  if( N>0 ){
    pX = decimalNewFromText("2.0", 3);
  }else{
    N = -N;
    pX = decimalNewFromText("0.5", 3);
  }
  if( pX==0 || pX->oom ) goto pow2_fault;
  while( 1 /* Exit by break */ ){
    if( N & 1 ){
      decimalMul(pA, pX);
      if( pA->oom ) goto pow2_fault;
    }
    N >>= 1;
    if( N==0 ) break;
    decimalMul(pX, pX);
  }
  decimal_free(pX);
  return pA;
 
pow2_fault:
  decimal_free(pA);
  decimal_free(pX);
  return 0;
}

References decimal_free(), decimalMul(), decimalNewFromText(), and Decimal::oom.

Referenced by decimalFromDouble(), and decimalPow2Func().

Here is the call graph for this function:

Here is the caller graph for this function:

decimalPow2Func()

void decimalPow2Func ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  UNUSED_PARAMETER(argc);
  if( sqlite3_value_type(argv[0])==SQLITE_INTEGER ){
    Decimal *pA = decimalPow2(sqlite3_value_int(argv[0]));
    decimal_result_sci(context, pA);
    decimal_free(pA);
  }
}

References decimal_free(), decimal_result_sci(), decimalPow2(), sqlite3_value_int, sqlite3_value_type, SQLITE_INTEGER, and UNUSED_PARAMETER.

Referenced by sqlite3_decimal_init().

Here is the call graph for this function:

Here is the caller graph for this function:

decimalSubFunc()

void decimalSubFunc ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  Decimal *pA = decimal_new(context, argv[0], 1);
  Decimal *pB = decimal_new(context, argv[1], 1);
  UNUSED_PARAMETER(argc);
  if( pB ){
    pB->sign = !pB->sign;
    decimal_add(pA, pB);
    decimal_result(context, pA);
  }
  decimal_free(pA);
  decimal_free(pB);
}

References decimal_add(), decimal_free(), decimal_new(), decimal_result(), Decimal::sign, and UNUSED_PARAMETER.

Referenced by sqlite3_decimal_init().

Here is the call graph for this function:

Here is the caller graph for this function:

decimalSumFinalize()

void decimalSumFinalize ( sqlite3_context * context )

static

                                                        {
  Decimal *p = sqlite3_aggregate_context(context, 0);
  if( p==0 ) return;
  decimal_result(context, p);
  decimal_clear(p);
}

References decimal_clear(), decimal_result(), and sqlite3_aggregate_context.

Referenced by sqlite3_decimal_init().

Here is the call graph for this function:

Here is the caller graph for this function:

decimalSumInverse()

void decimalSumInverse ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  Decimal *p;
  Decimal *pArg;
  UNUSED_PARAMETER(argc);
  p = sqlite3_aggregate_context(context, sizeof(*p));
  if( p==0 ) return;
  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
  pArg = decimal_new(context, argv[0], 1);
  if( pArg ) pArg->sign = !pArg->sign;
  decimal_add(p, pArg);
  decimal_free(pArg);
}

References decimal_add(), decimal_free(), decimal_new(), Decimal::sign, sqlite3_aggregate_context, sqlite3_value_type, SQLITE_NULL, and UNUSED_PARAMETER.

Referenced by sqlite3_decimal_init().

Here is the call graph for this function:

Here is the caller graph for this function:

decimalSumStep()

void decimalSumStep ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  Decimal *p;
  Decimal *pArg;
  UNUSED_PARAMETER(argc);
  p = sqlite3_aggregate_context(context, sizeof(*p));
  if( p==0 ) return;
  if( !p->isInit ){
    p->isInit = 1;
    p->a = sqlite3_malloc(2);
    if( p->a==0 ){
      p->oom = 1;
    }else{
      p->a[0] = 0;
    }
    p->nDigit = 1;
    p->nFrac = 0;
  }
  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
  pArg = decimal_new(context, argv[0], 1);
  decimal_add(p, pArg);
  decimal_free(pArg);
}

References Decimal::a, decimal_add(), decimal_free(), decimal_new(), Decimal::isInit, Decimal::nDigit, Decimal::nFrac, Decimal::oom, sqlite3_aggregate_context, sqlite3_malloc, sqlite3_value_type, SQLITE_NULL, and UNUSED_PARAMETER.

Referenced by sqlite3_decimal_init().

Here is the call graph for this function:

Here is the caller graph for this function:

decimalSumValue()

void decimalSumValue ( sqlite3_context * context )

static

                                                     {
  Decimal *p = sqlite3_aggregate_context(context, 0);
  if( p==0 ) return;
  decimal_result(context, p);
}

References decimal_result(), and sqlite3_aggregate_context.

Referenced by sqlite3_decimal_init().

Here is the call graph for this function:

Here is the caller graph for this function:

decodeUtf8()

int decodeUtf8 ( const unsigned char * z, int * pU )

static

                                                      {
  if( (z[0] & 0xe0)==0xc0 && (z[1] & 0xc0)==0x80 ){
    *pU = ((z[0] & 0x1f)<<6) | (z[1] & 0x3f);
    return 2;
  }
  if( (z[0] & 0xf0)==0xe0 && (z[1] & 0xc0)==0x80 && (z[2] & 0xc0)==0x80 ){
    *pU = ((z[0] & 0x0f)<<12) | ((z[1] & 0x3f)<<6) | (z[2] & 0x3f);
    return 3;
  }
  if( (z[0] & 0xf8)==0xf0 && (z[1] & 0xc0)==0x80 && (z[2] & 0xc0)==0x80
   && (z[3] & 0xc0)==0x80
  ){
    *pU = ((z[0] & 0x0f)<<18) | ((z[1] & 0x3f)<<12) | ((z[2] & 0x3f))<<6
                              | (z[4] & 0x3f);
    return 4;
  }
  *pU = 0;
  return 1;
}

Referenced by translateForDisplayAndDup(), and utf8_width_print().

Here is the caller graph for this function:

deduceDatabaseType()

int deduceDatabaseType	(	const char *	zName,
		int	dfltZip )

                                                      {
  FILE *f = sqlite3_fopen(zName, "rb");
  size_t n;
  int rc = SHELL_OPEN_UNSPEC;
  char zBuf[100];
  if( f==0 ){
    if( dfltZip && sqlite3_strlike("%.zip",zName,0)==0 ){
       return SHELL_OPEN_ZIPFILE;
    }else{
       return SHELL_OPEN_NORMAL;
    }
  }
  n = fread(zBuf, 16, 1, f);
  if( n==1 && memcmp(zBuf, "SQLite format 3", 16)==0 ){
    fclose(f);
    return SHELL_OPEN_NORMAL;
  }
  fseek(f, -25, SEEK_END);
  n = fread(zBuf, 25, 1, f);
  if( n==1 && memcmp(zBuf, "Start-Of-SQLite3-", 17)==0 ){
    rc = SHELL_OPEN_APPENDVFS;
  }else{
    fseek(f, -22, SEEK_END);
    n = fread(zBuf, 22, 1, f);
    if( n==1 && zBuf[0]==0x50 && zBuf[1]==0x4b && zBuf[2]==0x05
       && zBuf[3]==0x06 ){
      rc = SHELL_OPEN_ZIPFILE;
    }else if( n==0 && dfltZip && sqlite3_strlike("%.zip",zName,0)==0 ){
      rc = SHELL_OPEN_ZIPFILE;
    }
  }
  fclose(f);

References SHELL_OPEN_APPENDVFS, SHELL_OPEN_NORMAL, SHELL_OPEN_UNSPEC, SHELL_OPEN_ZIPFILE, sqlite3_fopen, and sqlite3_strlike.

Referenced by open_db().

Here is the caller graph for this function:

disable_debug_trace_modes()

void disable_debug_trace_modes ( void )

static

                                           {
  unsigned int zero = 0;
  sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 0, &savedSelectTrace);
  sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 1, &zero);
  sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 2, &savedWhereTrace);

References savedSelectTrace, savedWhereTrace, sqlite3_test_control, and SQLITE_TESTCTRL_TRACEFLAGS.

Referenced by shell_exec().

Here is the caller graph for this function:

display_scanstats()

void display_scanstats ( sqlite3 * db, ShellState * pArg )

static

 {
#ifndef SQLITE_ENABLE_STMT_SCANSTATUS
  UNUSED_PARAMETER(db);
  UNUSED_PARAMETER(pArg);
#else
  if( pArg->scanstatsOn==3 ){
    const char *zSql =
      "  SELECT addr, opcode, p1, p2, p3, p4, p5, comment, nexec,"
      "   format('% 6s (%.2f%%)',"
      "      CASE WHEN ncycle<100_000 THEN ncycle || ' '"
      "         WHEN ncycle<100_000_000 THEN (ncycle/1_000) || 'K'"
      "         WHEN ncycle<100_000_000_000 THEN (ncycle/1_000_000) || 'M'"
      "         ELSE (ncycle/1000_000_000) || 'G' END,"
      "       ncycle*100.0/(sum(ncycle) OVER ())"
      "   )  AS cycles"
      "   FROM bytecode(?)";
 
    int rc = SQLITE_OK;
    sqlite3_stmt *pStmt = 0;
    rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
    if( rc==SQLITE_OK ){
      sqlite3_stmt *pSave = pArg->pStmt;
      pArg->pStmt = pStmt;
      sqlite3_bind_pointer(pStmt, 1, pSave, "stmt-pointer", 0);
 
      pArg->cnt = 0;
      pArg->cMode = MODE_ScanExp;
      explain_data_prepare(pArg, pStmt);
      exec_prepared_stmt(pArg, pStmt);
      explain_data_delete(pArg);
 
      sqlite3_finalize(pStmt);
      pArg->pStmt = pSave;
    }
  }else{
    display_explain_scanstats(db, pArg);
  }

References ShellState::cMode, ShellState::cnt, exec_prepared_stmt(), explain_data_delete(), explain_data_prepare(), MODE_ScanExp, ShellState::pStmt, ShellState::scanstatsOn, sqlite3_bind_pointer, sqlite3_finalize, sqlite3_prepare_v2, SQLITE_OK, and UNUSED_PARAMETER.

Referenced by shell_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

display_stats()

int display_stats ( sqlite3 * db, ShellState * pArg, int bReset )

static

 {
  int iCur;
  int iHiwtr;
  FILE *out;
  if( pArg==0 || pArg->out==0 ) return 0;
  out = pArg->out;
 
  if( pArg->pStmt && pArg->statsOn==2 ){
    int nCol, i, x;
    sqlite3_stmt *pStmt = pArg->pStmt;
    char z[100];
    nCol = sqlite3_column_count(pStmt);
    sqlite3_fprintf(out, "%-36s %d\n", "Number of output columns:", nCol);
    for(i=0; i<nCol; i++){
      sqlite3_snprintf(sizeof(z),z,"Column %d %nname:", i, &x);
      sqlite3_fprintf(out, "%-36s %s\n", z, sqlite3_column_name(pStmt,i));
#ifndef SQLITE_OMIT_DECLTYPE
      sqlite3_snprintf(30, z+x, "declared type:");
      sqlite3_fprintf(out, "%-36s %s\n", z, sqlite3_column_decltype(pStmt, i));
#endif
#ifdef SQLITE_ENABLE_COLUMN_METADATA
      sqlite3_snprintf(30, z+x, "database name:");
      sqlite3_fprintf(out, "%-36s %s\n", z,
                           sqlite3_column_database_name(pStmt,i));
      sqlite3_snprintf(30, z+x, "table name:");
      sqlite3_fprintf(out, "%-36s %s\n", z, sqlite3_column_table_name(pStmt,i));
      sqlite3_snprintf(30, z+x, "origin name:");
      sqlite3_fprintf(out, "%-36s %s\n", z,sqlite3_column_origin_name(pStmt,i));
#endif
    }
  }
 
  if( pArg->statsOn==3 ){
    if( pArg->pStmt ){
      iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP,bReset);
      sqlite3_fprintf(out, "VM-steps: %d\n", iCur);
    }
    return 0;
  }
 
  displayStatLine(out, "Memory Used:",
     "%lld (max %lld) bytes", SQLITE_STATUS_MEMORY_USED, bReset);
  displayStatLine(out, "Number of Outstanding Allocations:",
     "%lld (max %lld)", SQLITE_STATUS_MALLOC_COUNT, bReset);
  if( pArg->shellFlgs & SHFLG_Pagecache ){
    displayStatLine(out, "Number of Pcache Pages Used:",
       "%lld (max %lld) pages", SQLITE_STATUS_PAGECACHE_USED, bReset);
  }
  displayStatLine(out, "Number of Pcache Overflow Bytes:",
     "%lld (max %lld) bytes", SQLITE_STATUS_PAGECACHE_OVERFLOW, bReset);
  displayStatLine(out, "Largest Allocation:",
     "%lld bytes", SQLITE_STATUS_MALLOC_SIZE, bReset);
  displayStatLine(out, "Largest Pcache Allocation:",
     "%lld bytes", SQLITE_STATUS_PAGECACHE_SIZE, bReset);
#ifdef YYTRACKMAXSTACKDEPTH
  displayStatLine(out, "Deepest Parser Stack:",
     "%lld (max %lld)", SQLITE_STATUS_PARSER_STACK, bReset);
#endif
 
  if( db ){
    if( pArg->shellFlgs & SHFLG_Lookaside ){
      iHiwtr = iCur = -1;
      sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED,
                        &iCur, &iHiwtr, bReset);
      sqlite3_fprintf(out, 
           "Lookaside Slots Used:                %d (max %d)\n", iCur, iHiwtr);
      sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT,
                        &iCur, &iHiwtr, bReset);
      sqlite3_fprintf(out,
           "Successful lookaside attempts:       %d\n", iHiwtr);
      sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE,
                        &iCur, &iHiwtr, bReset);
      sqlite3_fprintf(out,
           "Lookaside failures due to size:      %d\n", iHiwtr);
      sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL,
                        &iCur, &iHiwtr, bReset);
      sqlite3_fprintf(out,
           "Lookaside failures due to OOM:       %d\n", iHiwtr);
    }
    iHiwtr = iCur = -1;
    sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);
    sqlite3_fprintf(out,
           "Pager Heap Usage:                    %d bytes\n", iCur);
    iHiwtr = iCur = -1;
    sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1);
    sqlite3_fprintf(out,
           "Page cache hits:                     %d\n", iCur);
    iHiwtr = iCur = -1;
    sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1);
    sqlite3_fprintf(out,
           "Page cache misses:                   %d\n", iCur);
    iHiwtr = iCur = -1;
    sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1);
    sqlite3_fprintf(out,
           "Page cache writes:                   %d\n", iCur);
    iHiwtr = iCur = -1;
    sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_SPILL, &iCur, &iHiwtr, 1);
    sqlite3_fprintf(out,
           "Page cache spills:                   %d\n", iCur);
    iHiwtr = iCur = -1;
    sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset);
    sqlite3_fprintf(out,
           "Schema Heap Usage:                   %d bytes\n", iCur);
    iHiwtr = iCur = -1;
    sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset);
    sqlite3_fprintf(out,
           "Statement Heap/Lookaside Usage:      %d bytes\n", iCur);
  }
 
  if( pArg->pStmt ){
    int iHit, iMiss;
    iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP,
                               bReset);
    sqlite3_fprintf(out,
           "Fullscan Steps:                      %d\n", iCur);
    iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset);
    sqlite3_fprintf(out,
           "Sort Operations:                     %d\n", iCur);
    iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX,bReset);
    sqlite3_fprintf(out,
           "Autoindex Inserts:                   %d\n", iCur);
    iHit = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FILTER_HIT,
                               bReset);
    iMiss = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FILTER_MISS,
                                bReset);
    if( iHit || iMiss ){
      sqlite3_fprintf(out,
           "Bloom filter bypass taken:           %d/%d\n", iHit, iHit+iMiss);
    }
    iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset);
    sqlite3_fprintf(out,
           "Virtual Machine Steps:               %d\n", iCur);
    iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_REPREPARE,bReset);
    sqlite3_fprintf(out,
           "Reprepare operations:                %d\n", iCur);
    iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_RUN, bReset);
    sqlite3_fprintf(out,
           "Number of times run:                 %d\n", iCur);
    iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_MEMUSED, bReset);
    sqlite3_fprintf(out,
           "Memory used by prepared stmt:        %d\n", iCur);
  }
 
#ifdef __linux__
  displayLinuxIoStats(pArg->out);
#endif
 
  /* Do not remove this machine readable comment: extra-stats-output-here */
 

References displayStatLine(), ShellState::out, ShellState::pStmt, ShellState::shellFlgs, SHFLG_Lookaside, SHFLG_Pagecache, sqlite3_column_count, sqlite3_column_database_name, sqlite3_column_decltype, sqlite3_column_name, sqlite3_column_origin_name, sqlite3_column_table_name, sqlite3_db_status, sqlite3_fprintf, sqlite3_snprintf, sqlite3_stmt_status, SQLITE_DBSTATUS_CACHE_HIT, SQLITE_DBSTATUS_CACHE_MISS, SQLITE_DBSTATUS_CACHE_SPILL, SQLITE_DBSTATUS_CACHE_USED, SQLITE_DBSTATUS_CACHE_WRITE, SQLITE_DBSTATUS_LOOKASIDE_HIT, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE, SQLITE_DBSTATUS_LOOKASIDE_USED, SQLITE_DBSTATUS_SCHEMA_USED, SQLITE_DBSTATUS_STMT_USED, SQLITE_STATUS_MALLOC_COUNT, SQLITE_STATUS_MALLOC_SIZE, SQLITE_STATUS_MEMORY_USED, SQLITE_STATUS_PAGECACHE_OVERFLOW, SQLITE_STATUS_PAGECACHE_SIZE, SQLITE_STATUS_PAGECACHE_USED, SQLITE_STATUS_PARSER_STACK, SQLITE_STMTSTATUS_AUTOINDEX, SQLITE_STMTSTATUS_FILTER_HIT, SQLITE_STMTSTATUS_FILTER_MISS, SQLITE_STMTSTATUS_FULLSCAN_STEP, SQLITE_STMTSTATUS_MEMUSED, SQLITE_STMTSTATUS_REPREPARE, SQLITE_STMTSTATUS_RUN, SQLITE_STMTSTATUS_SORT, SQLITE_STMTSTATUS_VM_STEP, and ShellState::statsOn.

Referenced by do_meta_command(), and shell_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

displayStatLine()

void displayStatLine ( FILE * out, char * zLabel, char * zFormat, int iStatusCtrl, int bReset )

static

 {
  sqlite3_int64 iCur = -1;
  sqlite3_int64 iHiwtr = -1;
  int i, nPercent;
  char zLine[200];
  sqlite3_status64(iStatusCtrl, &iCur, &iHiwtr, bReset);
  for(i=0, nPercent=0; zFormat[i]; i++){
    if( zFormat[i]=='%' ) nPercent++;
  }
  if( nPercent>1 ){
    sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iCur, iHiwtr);
  }else{
    sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iHiwtr);
  }

References sqlite3_fprintf, sqlite3_snprintf, and sqlite3_status64.

Referenced by display_stats().

Here is the caller graph for this function:

do_meta_command()

int do_meta_command ( char * zLine, ShellState * p )

static

                                                      {
  int h = 1;
  int nArg = 0;
  int n, c;
  int rc = 0;
  char *azArg[52];
 
#ifndef SQLITE_OMIT_VIRTUALTABLE
  if( p->expert.pExpert ){
    expertFinish(p, 1, 0);
  }
#endif
 
  /* Parse the input line into tokens.
  */
  while( zLine[h] && nArg<ArraySize(azArg)-1 ){
    while( IsSpace(zLine[h]) ){ h++; }
    if( zLine[h]==0 ) break;
    if( zLine[h]=='\'' || zLine[h]=='"' ){
      int delim = zLine[h++];
      azArg[nArg++] = &zLine[h];
      while( zLine[h] && zLine[h]!=delim ){
        if( zLine[h]=='\\' && delim=='"' && zLine[h+1]!=0 ) h++;
        h++;
      }
      if( zLine[h]==delim ){
        zLine[h++] = 0;
      }
      if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
    }else{
      azArg[nArg++] = &zLine[h];
      while( zLine[h] && !IsSpace(zLine[h]) ){ h++; }
      if( zLine[h] ) zLine[h++] = 0;
    }
  }
  azArg[nArg] = 0;
 
  /* Process the input line.
  */
  if( nArg==0 ) return 0; /* no tokens, no error */
  n = strlen30(azArg[0]);
  c = azArg[0][0];
  clearTempFile(p);
 
#ifndef SQLITE_OMIT_AUTHORIZATION
  if( c=='a' && cli_strncmp(azArg[0], "auth", n)==0 ){
    if( nArg!=2 ){
      sqlite3_fprintf(stderr, "Usage: .auth ON|OFF\n");
      rc = 1;
      goto meta_command_exit;
    }
    open_db(p, 0);
    if( booleanValue(azArg[1]) ){
      sqlite3_set_authorizer(p->db, shellAuth, p);
    }else if( p->bSafeModePersist ){
      sqlite3_set_authorizer(p->db, safeModeAuth, p);
    }else{
      sqlite3_set_authorizer(p->db, 0, 0);
    }
  }else
#endif
 
#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) \
  && !defined(SQLITE_SHELL_FIDDLE)
  if( c=='a' && cli_strncmp(azArg[0], "archive", n)==0 ){
    open_db(p, 0);
    failIfSafeMode(p, "cannot run .archive in safe mode");
    rc = arDotCommand(p, 0, azArg, nArg);
  }else
#endif
 
#ifndef SQLITE_SHELL_FIDDLE
  if( (c=='b' && n>=3 && cli_strncmp(azArg[0], "backup", n)==0)
   || (c=='s' && n>=3 && cli_strncmp(azArg[0], "save", n)==0)
  ){
    const char *zDestFile = 0;
    const char *zDb = 0;
    sqlite3 *pDest;
    sqlite3_backup *pBackup;
    int j;
    int bAsync = 0;
    const char *zVfs = 0;
    failIfSafeMode(p, "cannot run .%s in safe mode", azArg[0]);
    for(j=1; j<nArg; j++){
      const char *z = azArg[j];
      if( z[0]=='-' ){
        if( z[1]=='-' ) z++;
        if( cli_strcmp(z, "-append")==0 ){
          zVfs = "apndvfs";
        }else
        if( cli_strcmp(z, "-async")==0 ){
          bAsync = 1;
        }else
        {
          sqlite3_fprintf(stderr,"unknown option: %s\n", azArg[j]);
          return 1;
        }
      }else if( zDestFile==0 ){
        zDestFile = azArg[j];
      }else if( zDb==0 ){
        zDb = zDestFile;
        zDestFile = azArg[j];
      }else{
        sqlite3_fprintf(stderr, "Usage: .backup ?DB? ?OPTIONS? FILENAME\n");
        return 1;
      }
    }
    if( zDestFile==0 ){
      sqlite3_fprintf(stderr, "missing FILENAME argument on .backup\n");
      return 1;
    }
    if( zDb==0 ) zDb = "main";
    rc = sqlite3_open_v2(zDestFile, &pDest,
                  SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, zVfs);
    if( rc!=SQLITE_OK ){
      sqlite3_fprintf(stderr,"Error: cannot open \"%s\"\n", zDestFile);
      close_db(pDest);
      return 1;
    }
    if( bAsync ){
      sqlite3_exec(pDest, "PRAGMA synchronous=OFF; PRAGMA journal_mode=OFF;",
                   0, 0, 0);
    }
    open_db(p, 0);
    pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
    if( pBackup==0 ){
      shellDatabaseError(pDest);
      close_db(pDest);
      return 1;
    }
    while(  (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
    sqlite3_backup_finish(pBackup);
    if( rc==SQLITE_DONE ){
      rc = 0;
    }else{
      shellDatabaseError(pDest);
      rc = 1;
    }
    close_db(pDest);
  }else
#endif /* !defined(SQLITE_SHELL_FIDDLE) */
 
  if( c=='b' && n>=3 && cli_strncmp(azArg[0], "bail", n)==0 ){
    if( nArg==2 ){
      bail_on_error = booleanValue(azArg[1]);
    }else{
      eputz("Usage: .bail on|off\n");
      rc = 1;
    }
  }else
 
  /* Undocumented.  Legacy only.  See "crlf" below */
  if( c=='b' && n>=3 && cli_strncmp(azArg[0], "binary", n)==0 ){
    eputz("The \".binary\" command is deprecated.\n");
    rc = 1;
  }else
 
  /* The undocumented ".breakpoint" command causes a call to the no-op
  ** routine named test_breakpoint().
  */
  if( c=='b' && n>=3 && cli_strncmp(azArg[0], "breakpoint", n)==0 ){
    test_breakpoint();
  }else
 
#ifndef SQLITE_SHELL_FIDDLE
  if( c=='c' && cli_strcmp(azArg[0],"cd")==0 ){
    failIfSafeMode(p, "cannot run .cd in safe mode");
    if( nArg==2 ){
#if defined(_WIN32) || defined(WIN32)
      wchar_t *z = sqlite3_win32_utf8_to_unicode(azArg[1]);
      rc = !SetCurrentDirectoryW(z);
      sqlite3_free(z);
#else
      rc = chdir(azArg[1]);
#endif
      if( rc ){
        sqlite3_fprintf(stderr,"Cannot change to directory \"%s\"\n", azArg[1]);
        rc = 1;
      }
    }else{
      eputz("Usage: .cd DIRECTORY\n");
      rc = 1;
    }
  }else
#endif /* !defined(SQLITE_SHELL_FIDDLE) */
 
  if( c=='c' && n>=3 && cli_strncmp(azArg[0], "changes", n)==0 ){
    if( nArg==2 ){
      setOrClearFlag(p, SHFLG_CountChanges, azArg[1]);
    }else{
      eputz("Usage: .changes on|off\n");
      rc = 1;
    }
  }else
 
#ifndef SQLITE_SHELL_FIDDLE
  /* Cancel output redirection, if it is currently set (by .testcase)
  ** Then read the content of the testcase-out.txt file and compare against
  ** azArg[1].  If there are differences, report an error and exit.
  */
  if( c=='c' && n>=3 && cli_strncmp(azArg[0], "check", n)==0 ){
    char *zRes = 0;
    output_reset(p);
    if( nArg!=2 ){
      eputz("Usage: .check GLOB-PATTERN\n");
      rc = 2;
    }else if( (zRes = readFile("testcase-out.txt", 0))==0 ){
      rc = 2;
    }else if( testcase_glob(azArg[1],zRes)==0 ){
      sqlite3_fprintf(stderr,
            "testcase-%s FAILED\n Expected: [%s]\n      Got: [%s]\n",
            p->zTestcase, azArg[1], zRes);
      rc = 1;
    }else{
      sqlite3_fprintf(p->out, "testcase-%s ok\n", p->zTestcase);
      p->nCheck++;
    }
    sqlite3_free(zRes);
  }else
#endif /* !defined(SQLITE_SHELL_FIDDLE) */
 
#ifndef SQLITE_SHELL_FIDDLE
  if( c=='c' && cli_strncmp(azArg[0], "clone", n)==0 ){
    failIfSafeMode(p, "cannot run .clone in safe mode");
    if( nArg==2 ){
      tryToClone(p, azArg[1]);
    }else{
      eputz("Usage: .clone FILENAME\n");
      rc = 1;
    }
  }else
#endif /* !defined(SQLITE_SHELL_FIDDLE) */
 
  if( c=='c' && cli_strncmp(azArg[0], "connection", n)==0 ){
    if( nArg==1 ){
      /* List available connections */
      int i;
      for(i=0; i<ArraySize(p->aAuxDb); i++){
        const char *zFile = p->aAuxDb[i].zDbFilename;
        if( p->aAuxDb[i].db==0 && p->pAuxDb!=&p->aAuxDb[i] ){
          zFile = "(not open)";
        }else if( zFile==0 ){
          zFile = "(memory)";
        }else if( zFile[0]==0 ){
          zFile = "(temporary-file)";
        }
        if( p->pAuxDb == &p->aAuxDb[i] ){
          sqlite3_fprintf(stdout, "ACTIVE %d: %s\n", i, zFile);
        }else if( p->aAuxDb[i].db!=0 ){
          sqlite3_fprintf(stdout, "       %d: %s\n", i, zFile);
        }
      }
    }else if( nArg==2 && IsDigit(azArg[1][0]) && azArg[1][1]==0 ){
      int i = azArg[1][0] - '0';
      if( p->pAuxDb != &p->aAuxDb[i] && i>=0 && i<ArraySize(p->aAuxDb) ){
        p->pAuxDb->db = p->db;
        p->pAuxDb = &p->aAuxDb[i];
        globalDb = p->db = p->pAuxDb->db;
        p->pAuxDb->db = 0;
      }
    }else if( nArg==3 && cli_strcmp(azArg[1], "close")==0
           && IsDigit(azArg[2][0]) && azArg[2][1]==0 ){
      int i = azArg[2][0] - '0';
      if( i<0 || i>=ArraySize(p->aAuxDb) ){
        /* No-op */
      }else if( p->pAuxDb == &p->aAuxDb[i] ){
        eputz("cannot close the active database connection\n");
        rc = 1;
      }else if( p->aAuxDb[i].db ){
        session_close_all(p, i);
        close_db(p->aAuxDb[i].db);
        p->aAuxDb[i].db = 0;
      }
    }else{
      eputz("Usage: .connection [close] [CONNECTION-NUMBER]\n");
      rc = 1;
    }
  }else
 
  if( c=='c' && n==4
   && (cli_strncmp(azArg[0], "crlf", n)==0
       || cli_strncmp(azArg[0], "crnl",n)==0)
  ){
    if( nArg==2 ){
#ifdef _WIN32
      p->crlfMode = booleanValue(azArg[1]);
#else
      p->crlfMode = 0;
#endif
    }
    sqlite3_fprintf(stderr, "crlf is %s\n", p->crlfMode ? "ON" : "OFF");
  }else
 
  if( c=='d' && n>1 && cli_strncmp(azArg[0], "databases", n)==0 ){
    char **azName = 0;
    int nName = 0;
    sqlite3_stmt *pStmt;
    int i;
    open_db(p, 0);
    rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
    if( rc ){
      shellDatabaseError(p->db);
      rc = 1;
    }else{
      while( sqlite3_step(pStmt)==SQLITE_ROW ){
        const char *zSchema = (const char *)sqlite3_column_text(pStmt,1);
        const char *zFile = (const char*)sqlite3_column_text(pStmt,2);
        if( zSchema==0 || zFile==0 ) continue;
        azName = sqlite3_realloc(azName, (nName+1)*2*sizeof(char*));
        shell_check_oom(azName);
        azName[nName*2] = strdup(zSchema);
        azName[nName*2+1] = strdup(zFile);
        nName++;
      }
    }
    sqlite3_finalize(pStmt);
    for(i=0; i<nName; i++){
      int eTxn = sqlite3_txn_state(p->db, azName[i*2]);
      int bRdonly = sqlite3_db_readonly(p->db, azName[i*2]);
      const char *z = azName[i*2+1];
      sqlite3_fprintf(p->out, "%s: %s %s%s\n",
            azName[i*2], z && z[0] ? z : "\"\"", bRdonly ? "r/o" : "r/w",
            eTxn==SQLITE_TXN_NONE ? "" :
            eTxn==SQLITE_TXN_READ ? " read-txn" : " write-txn");
      free(azName[i*2]);
      free(azName[i*2+1]);
    }
    sqlite3_free(azName);
  }else
 
  if( c=='d' && n>=3 && cli_strncmp(azArg[0], "dbconfig", n)==0 ){
    static const struct DbConfigChoices {
      const char *zName;
      int op;
    } aDbConfig[] = {
        { "attach_create",      SQLITE_DBCONFIG_ENABLE_ATTACH_CREATE  },
        { "attach_write",       SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE   },
        { "comments",           SQLITE_DBCONFIG_ENABLE_COMMENTS       },
        { "defensive",          SQLITE_DBCONFIG_DEFENSIVE             },
        { "dqs_ddl",            SQLITE_DBCONFIG_DQS_DDL               },
        { "dqs_dml",            SQLITE_DBCONFIG_DQS_DML               },
        { "enable_fkey",        SQLITE_DBCONFIG_ENABLE_FKEY           },
        { "enable_qpsg",        SQLITE_DBCONFIG_ENABLE_QPSG           },
        { "enable_trigger",     SQLITE_DBCONFIG_ENABLE_TRIGGER        },
        { "enable_view",        SQLITE_DBCONFIG_ENABLE_VIEW           },
        { "fts3_tokenizer",     SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER },
        { "legacy_alter_table", SQLITE_DBCONFIG_LEGACY_ALTER_TABLE    },
        { "legacy_file_format", SQLITE_DBCONFIG_LEGACY_FILE_FORMAT    },
        { "load_extension",     SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION },
        { "no_ckpt_on_close",   SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE      },
        { "reset_database",     SQLITE_DBCONFIG_RESET_DATABASE        },
        { "reverse_scanorder",  SQLITE_DBCONFIG_REVERSE_SCANORDER     },
        { "stmt_scanstatus",    SQLITE_DBCONFIG_STMT_SCANSTATUS       },
        { "trigger_eqp",        SQLITE_DBCONFIG_TRIGGER_EQP           },
        { "trusted_schema",     SQLITE_DBCONFIG_TRUSTED_SCHEMA        },
        { "writable_schema",    SQLITE_DBCONFIG_WRITABLE_SCHEMA       },
    };
    int ii, v;
    open_db(p, 0);
    for(ii=0; ii<ArraySize(aDbConfig); ii++){
      if( nArg>1 && cli_strcmp(azArg[1], aDbConfig[ii].zName)!=0 ) continue;
      if( nArg>=3 ){
        sqlite3_db_config(p->db, aDbConfig[ii].op, booleanValue(azArg[2]), 0);
      }
      sqlite3_db_config(p->db, aDbConfig[ii].op, -1, &v);
      sqlite3_fprintf(p->out, "%19s %s\n",
                      aDbConfig[ii].zName, v ? "on" : "off");
      if( nArg>1 ) break;
    }
    if( nArg>1 && ii==ArraySize(aDbConfig) ){
      sqlite3_fprintf(stderr,"Error: unknown dbconfig \"%s\"\n", azArg[1]);
      eputz("Enter \".dbconfig\" with no arguments for a list\n");
    }
  }else
 
#if SQLITE_SHELL_HAVE_RECOVER
  if( c=='d' && n>=3 && cli_strncmp(azArg[0], "dbinfo", n)==0 ){
    rc = shell_dbinfo_command(p, nArg, azArg);
  }else
 
  if( c=='r' && cli_strncmp(azArg[0], "recover", n)==0 ){
    open_db(p, 0);
    rc = recoverDatabaseCmd(p, nArg, azArg);
  }else
#endif /* SQLITE_SHELL_HAVE_RECOVER */
 
  if( c=='d' && cli_strncmp(azArg[0], "dump", n)==0 ){
    char *zLike = 0;
    char *zSql;
    int i;
    int savedShowHeader = p->showHeader;
    int savedShellFlags = p->shellFlgs;
    ShellClearFlag(p,
       SHFLG_PreserveRowid|SHFLG_Newlines|SHFLG_Echo
       |SHFLG_DumpDataOnly|SHFLG_DumpNoSys);
    for(i=1; i<nArg; i++){
      if( azArg[i][0]=='-' ){
        const char *z = azArg[i]+1;
        if( z[0]=='-' ) z++;
        if( cli_strcmp(z,"preserve-rowids")==0 ){
#ifdef SQLITE_OMIT_VIRTUALTABLE
          eputz("The --preserve-rowids option is not compatible"
                " with SQLITE_OMIT_VIRTUALTABLE\n");
          rc = 1;
          sqlite3_free(zLike);
          goto meta_command_exit;
#else
          ShellSetFlag(p, SHFLG_PreserveRowid);
#endif
        }else
        if( cli_strcmp(z,"newlines")==0 ){
          ShellSetFlag(p, SHFLG_Newlines);
        }else
        if( cli_strcmp(z,"data-only")==0 ){
          ShellSetFlag(p, SHFLG_DumpDataOnly);
        }else
        if( cli_strcmp(z,"nosys")==0 ){
          ShellSetFlag(p, SHFLG_DumpNoSys);
        }else
        {
          sqlite3_fprintf(stderr,
               "Unknown option \"%s\" on \".dump\"\n", azArg[i]);
          rc = 1;
          sqlite3_free(zLike);
          goto meta_command_exit;
        }
      }else{
        /* azArg[i] contains a LIKE pattern. This ".dump" request should
        ** only dump data for tables for which either the table name matches
        ** the LIKE pattern, or the table appears to be a shadow table of
        ** a virtual table for which the name matches the LIKE pattern.
        */
        char *zExpr = sqlite3_mprintf(
            "name LIKE %Q ESCAPE '\\' OR EXISTS ("
            "  SELECT 1 FROM sqlite_schema WHERE "
            "    name LIKE %Q ESCAPE '\\' AND"
            "    sql LIKE 'CREATE VIRTUAL TABLE%%' AND"
            "    substr(o.name, 1, length(name)+1) == (name||'_')"
            ")", azArg[i], azArg[i]
        );
 
        if( zLike ){
          zLike = sqlite3_mprintf("%z OR %z", zLike, zExpr);
        }else{
          zLike = zExpr;
        }
      }
    }
 
    open_db(p, 0);
 
    outputDumpWarning(p, zLike);
    if( (p->shellFlgs & SHFLG_DumpDataOnly)==0 ){
      /* 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. */
      sqlite3_fputs("PRAGMA foreign_keys=OFF;\n", p->out);
      sqlite3_fputs("BEGIN TRANSACTION;\n", p->out);
    }
    p->writableSchema = 0;
    p->showHeader = 0;
    /* Set writable_schema=ON since doing so forces SQLite to initialize
    ** as much of the schema as it can even if the sqlite_schema table is
    ** corrupt. */
    sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
    p->nErr = 0;
    if( zLike==0 ) zLike = sqlite3_mprintf("true");
    zSql = sqlite3_mprintf(
      "SELECT name, type, sql FROM sqlite_schema AS o "
      "WHERE (%s) AND type=='table'"
      "  AND sql NOT NULL"
      " ORDER BY tbl_name='sqlite_sequence', rowid",
      zLike
    );
    run_schema_dump_query(p,zSql);
    sqlite3_free(zSql);
    if( (p->shellFlgs & SHFLG_DumpDataOnly)==0 ){
      zSql = sqlite3_mprintf(
        "SELECT sql FROM sqlite_schema AS o "
        "WHERE (%s) AND sql NOT NULL"
        "  AND type IN ('index','trigger','view') "
        "ORDER BY type COLLATE NOCASE DESC",
        zLike
      );
      run_table_dump_query(p, zSql);
      sqlite3_free(zSql);
    }
    sqlite3_free(zLike);
    if( p->writableSchema ){
      sqlite3_fputs("PRAGMA writable_schema=OFF;\n", p->out);
      p->writableSchema = 0;
    }
    sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
    sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0);
    if( (p->shellFlgs & SHFLG_DumpDataOnly)==0 ){
      sqlite3_fputs(p->nErr?"ROLLBACK; -- due to errors\n":"COMMIT;\n", p->out);
    }
    p->showHeader = savedShowHeader;
    p->shellFlgs = savedShellFlags;
  }else
 
  if( c=='e' && cli_strncmp(azArg[0], "echo", n)==0 ){
    if( nArg==2 ){
      setOrClearFlag(p, SHFLG_Echo, azArg[1]);
    }else{
      eputz("Usage: .echo on|off\n");
      rc = 1;
    }
  }else
 
  if( c=='d' && n>=3 && cli_strncmp(azArg[0], "dbtotxt", n)==0 ){
    rc = shell_dbtotxt_command(p, nArg, azArg);
  }else
 
  if( c=='e' && cli_strncmp(azArg[0], "eqp", n)==0 ){
    if( nArg==2 ){
      p->autoEQPtest = 0;
      if( p->autoEQPtrace ){
        if( p->db ) sqlite3_exec(p->db, "PRAGMA vdbe_trace=OFF;", 0, 0, 0);
        p->autoEQPtrace = 0;
      }
      if( cli_strcmp(azArg[1],"full")==0 ){
        p->autoEQP = AUTOEQP_full;
      }else if( cli_strcmp(azArg[1],"trigger")==0 ){
        p->autoEQP = AUTOEQP_trigger;
#ifdef SQLITE_DEBUG
      }else if( cli_strcmp(azArg[1],"test")==0 ){
        p->autoEQP = AUTOEQP_on;
        p->autoEQPtest = 1;
      }else if( cli_strcmp(azArg[1],"trace")==0 ){
        p->autoEQP = AUTOEQP_full;
        p->autoEQPtrace = 1;
        open_db(p, 0);
        sqlite3_exec(p->db, "SELECT name FROM sqlite_schema LIMIT 1", 0, 0, 0);
        sqlite3_exec(p->db, "PRAGMA vdbe_trace=ON;", 0, 0, 0);
#endif
      }else{
        p->autoEQP = (u8)booleanValue(azArg[1]);
      }
    }else{
      eputz("Usage: .eqp off|on|trace|trigger|full\n");
      rc = 1;
    }
  }else
 
#ifndef SQLITE_SHELL_FIDDLE
  if( c=='e' && cli_strncmp(azArg[0], "exit", n)==0 ){
    if( nArg>1 && (rc = (int)integerValue(azArg[1]))!=0 ) exit(rc);
    rc = 2;
  }else
#endif
 
  /* The ".explain" command is automatic now.  It is largely pointless.  It
  ** retained purely for backwards compatibility */
  if( c=='e' && cli_strncmp(azArg[0], "explain", n)==0 ){
    int val = 1;
    if( nArg>=2 ){
      if( cli_strcmp(azArg[1],"auto")==0 ){
        val = 99;
      }else{
        val =  booleanValue(azArg[1]);
      }
    }
    if( val==1 && p->mode!=MODE_Explain ){
      p->normalMode = p->mode;
      p->mode = MODE_Explain;
      p->autoExplain = 0;
    }else if( val==0 ){
      if( p->mode==MODE_Explain ) p->mode = p->normalMode;
      p->autoExplain = 0;
    }else if( val==99 ){
      if( p->mode==MODE_Explain ) p->mode = p->normalMode;
      p->autoExplain = 1;
    }
  }else
 
#ifndef SQLITE_OMIT_VIRTUALTABLE
  if( c=='e' && cli_strncmp(azArg[0], "expert", n)==0 ){
    if( p->bSafeMode ){
      sqlite3_fprintf(stderr,
            "Cannot run experimental commands such as \"%s\" in safe mode\n",
            azArg[0]);
      rc = 1;
    }else{
      open_db(p, 0);
      expertDotCommand(p, azArg, nArg);
    }
  }else
#endif
 
  if( c=='f' && cli_strncmp(azArg[0], "filectrl", n)==0 ){
    static const struct {
       const char *zCtrlName;   /* Name of a test-control option */
       int ctrlCode;            /* Integer code for that option */
       const char *zUsage;      /* Usage notes */
    } aCtrl[] = {
      { "chunk_size",     SQLITE_FCNTL_CHUNK_SIZE,      "SIZE"           },
      { "data_version",   SQLITE_FCNTL_DATA_VERSION,    ""               },
      { "has_moved",      SQLITE_FCNTL_HAS_MOVED,       ""               },
      { "lock_timeout",   SQLITE_FCNTL_LOCK_TIMEOUT,    "MILLISEC"       },
      { "persist_wal",    SQLITE_FCNTL_PERSIST_WAL,     "[BOOLEAN]"      },
   /* { "pragma",         SQLITE_FCNTL_PRAGMA,          "NAME ARG"       },*/
      { "psow",       SQLITE_FCNTL_POWERSAFE_OVERWRITE, "[BOOLEAN]"      },
      { "reserve_bytes",  SQLITE_FCNTL_RESERVE_BYTES,   "[N]"            },
      { "size_limit",     SQLITE_FCNTL_SIZE_LIMIT,      "[LIMIT]"        },
      { "tempfilename",   SQLITE_FCNTL_TEMPFILENAME,    ""               },
   /* { "win32_av_retry", SQLITE_FCNTL_WIN32_AV_RETRY,  "COUNT DELAY"    },*/
    };
    int filectrl = -1;
    int iCtrl = -1;
    sqlite3_int64 iRes = 0;  /* Integer result to display if rc2==1 */
    int isOk = 0;            /* 0: usage  1: %lld  2: no-result */
    int n2, i;
    const char *zCmd = 0;
    const char *zSchema = 0;
 
    open_db(p, 0);
    zCmd = nArg>=2 ? azArg[1] : "help";
 
    if( zCmd[0]=='-'
     && (cli_strcmp(zCmd,"--schema")==0 || cli_strcmp(zCmd,"-schema")==0)
     && nArg>=4
    ){
      zSchema = azArg[2];
      for(i=3; i<nArg; i++) azArg[i-2] = azArg[i];
      nArg -= 2;
      zCmd = azArg[1];
    }
 
    /* The argument can optionally begin with "-" or "--" */
    if( zCmd[0]=='-' && zCmd[1] ){
      zCmd++;
      if( zCmd[0]=='-' && zCmd[1] ) zCmd++;
    }
 
    /* --help lists all file-controls */
    if( cli_strcmp(zCmd,"help")==0 ){
      sqlite3_fputs("Available file-controls:\n", p->out);
      for(i=0; i<ArraySize(aCtrl); i++){
        sqlite3_fprintf(p->out,
               "  .filectrl %s %s\n", aCtrl[i].zCtrlName, aCtrl[i].zUsage);
      }
      rc = 1;
      goto meta_command_exit;
    }
 
    /* convert filectrl text option to value. allow any unique prefix
    ** of the option name, or a numerical value. */
    n2 = strlen30(zCmd);
    for(i=0; i<ArraySize(aCtrl); i++){
      if( cli_strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){
        if( filectrl<0 ){
          filectrl = aCtrl[i].ctrlCode;
          iCtrl = i;
        }else{
          sqlite3_fprintf(stderr,"Error: ambiguous file-control: \"%s\"\n"
                "Use \".filectrl --help\" for help\n", zCmd);
          rc = 1;
          goto meta_command_exit;
        }
      }
    }
    if( filectrl<0 ){
      sqlite3_fprintf(stderr,"Error: unknown file-control: %s\n"
            "Use \".filectrl --help\" for help\n", zCmd);
    }else{
      switch(filectrl){
        case SQLITE_FCNTL_SIZE_LIMIT: {
          if( nArg!=2 && nArg!=3 ) break;
          iRes = nArg==3 ? integerValue(azArg[2]) : -1;
          sqlite3_file_control(p->db, zSchema, SQLITE_FCNTL_SIZE_LIMIT, &iRes);
          isOk = 1;
          break;
        }
        case SQLITE_FCNTL_LOCK_TIMEOUT:
        case SQLITE_FCNTL_CHUNK_SIZE: {
          int x;
          if( nArg!=3 ) break;
          x = (int)integerValue(azArg[2]);
          sqlite3_file_control(p->db, zSchema, filectrl, &x);
          isOk = 2;
          break;
        }
        case SQLITE_FCNTL_PERSIST_WAL:
        case SQLITE_FCNTL_POWERSAFE_OVERWRITE: {
          int x;
          if( nArg!=2 && nArg!=3 ) break;
          x = nArg==3 ? booleanValue(azArg[2]) : -1;
          sqlite3_file_control(p->db, zSchema, filectrl, &x);
          iRes = x;
          isOk = 1;
          break;
        }
        case SQLITE_FCNTL_DATA_VERSION:
        case SQLITE_FCNTL_HAS_MOVED: {
          int x;
          if( nArg!=2 ) break;
          sqlite3_file_control(p->db, zSchema, filectrl, &x);
          iRes = x;
          isOk = 1;
          break;
        }
        case SQLITE_FCNTL_TEMPFILENAME: {
          char *z = 0;
          if( nArg!=2 ) break;
          sqlite3_file_control(p->db, zSchema, filectrl, &z);
          if( z ){
            sqlite3_fprintf(p->out, "%s\n", z);
            sqlite3_free(z);
          }
          isOk = 2;
          break;
        }
        case SQLITE_FCNTL_RESERVE_BYTES: {
          int x;
          if( nArg>=3 ){
            x = atoi(azArg[2]);
            sqlite3_file_control(p->db, zSchema, filectrl, &x);
          }
          x = -1;
          sqlite3_file_control(p->db, zSchema, filectrl, &x);
          sqlite3_fprintf(p->out, "%d\n", x);
          isOk = 2;
          break;
        }
      }
    }
    if( isOk==0 && iCtrl>=0 ){
      sqlite3_fprintf(p->out, "Usage: .filectrl %s %s\n",
                      zCmd, aCtrl[iCtrl].zUsage);
      rc = 1;
    }else if( isOk==1 ){
      char zBuf[100];
      sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", iRes);
      sqlite3_fprintf(p->out, "%s\n", zBuf);
    }
  }else
 
  if( c=='f' && cli_strncmp(azArg[0], "fullschema", n)==0 ){
    ShellState data;
    int doStats = 0;
    memcpy(&data, p, sizeof(data));
    data.showHeader = 0;
    data.cMode = data.mode = MODE_Semi;
    if( nArg==2 && optionMatch(azArg[1], "indent") ){
      data.cMode = data.mode = MODE_Pretty;
      nArg = 1;
    }
    if( nArg!=1 ){
      eputz("Usage: .fullschema ?--indent?\n");
      rc = 1;
      goto meta_command_exit;
    }
    open_db(p, 0);
    rc = sqlite3_exec(p->db,
       "SELECT sql FROM"
       "  (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
       "     FROM sqlite_schema UNION ALL"
       "   SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_schema) "
       "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
       "ORDER BY x",
       callback, &data, 0
    );
    if( rc==SQLITE_OK ){
      sqlite3_stmt *pStmt;
      rc = sqlite3_prepare_v2(p->db,
               "SELECT rowid FROM sqlite_schema"
               " WHERE name GLOB 'sqlite_stat[134]'",
               -1, &pStmt, 0);
      if( rc==SQLITE_OK ){
        doStats = sqlite3_step(pStmt)==SQLITE_ROW;
        sqlite3_finalize(pStmt);
      }
    }
    if( doStats==0 ){
      sqlite3_fputs("/* No STAT tables available */\n", p->out);
    }else{
      sqlite3_fputs("ANALYZE sqlite_schema;\n", p->out);
      data.cMode = data.mode = MODE_Insert;
      data.zDestTable = "sqlite_stat1";
      shell_exec(&data, "SELECT * FROM sqlite_stat1", 0);
      data.zDestTable = "sqlite_stat4";
      shell_exec(&data, "SELECT * FROM sqlite_stat4", 0);
      sqlite3_fputs("ANALYZE sqlite_schema;\n", p->out);
    }
  }else
 
  if( c=='h' && cli_strncmp(azArg[0], "headers", n)==0 ){
    if( nArg==2 ){
      p->showHeader = booleanValue(azArg[1]);
      p->shellFlgs |= SHFLG_HeaderSet;
    }else{
      eputz("Usage: .headers on|off\n");
      rc = 1;
    }
  }else
 
  if( c=='h' && cli_strncmp(azArg[0], "help", n)==0 ){
    if( nArg>=2 ){
      n = showHelp(p->out, azArg[1]);
      if( n==0 ){
        sqlite3_fprintf(p->out, "Nothing matches '%s'\n", azArg[1]);
      }
    }else{
      showHelp(p->out, 0);
    }
  }else
 
#ifndef SQLITE_SHELL_FIDDLE
  if( c=='i' && cli_strncmp(azArg[0], "import", n)==0 ){
    char *zTable = 0;           /* Insert data into this table */
    char *zSchema = 0;          /* Schema of zTable */
    char *zFile = 0;            /* Name of file to extra content from */
    sqlite3_stmt *pStmt = NULL; /* A statement */
    int nCol;                   /* Number of columns in the table */
    i64 nByte;                  /* Number of bytes in an SQL string */
    int i, j;                   /* Loop counters */
    int needCommit;             /* True to COMMIT or ROLLBACK at end */
    int nSep;                   /* Number of bytes in p->colSeparator[] */
    char *zSql = 0;             /* An SQL statement */
    ImportCtx sCtx;             /* Reader context */
    char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */
    int eVerbose = 0;           /* Larger for more console output */
    int nSkip = 0;              /* Initial lines to skip */
    int useOutputMode = 1;      /* Use output mode to determine separators */
    char *zCreate = 0;          /* CREATE TABLE statement text */
 
    failIfSafeMode(p, "cannot run .import in safe mode");
    memset(&sCtx, 0, sizeof(sCtx));
    if( p->mode==MODE_Ascii ){
      xRead = ascii_read_one_field;
    }else{
      xRead = csv_read_one_field;
    }
    rc = 1;
    for(i=1; i<nArg; i++){
      char *z = azArg[i];
      if( z[0]=='-' && z[1]=='-' ) z++;
      if( z[0]!='-' ){
        if( zFile==0 ){
          zFile = z;
        }else if( zTable==0 ){
          zTable = z;
        }else{
          sqlite3_fprintf(p->out, "ERROR: extra argument: \"%s\". Usage:\n",z);
          showHelp(p->out, "import");
          goto meta_command_exit;
        }
      }else if( cli_strcmp(z,"-v")==0 ){
        eVerbose++;
      }else if( cli_strcmp(z,"-schema")==0 && i<nArg-1 ){
        zSchema = azArg[++i];
      }else if( cli_strcmp(z,"-skip")==0 && i<nArg-1 ){
        nSkip = integerValue(azArg[++i]);
      }else if( cli_strcmp(z,"-ascii")==0 ){
        sCtx.cColSep = SEP_Unit[0];
        sCtx.cRowSep = SEP_Record[0];
        xRead = ascii_read_one_field;
        useOutputMode = 0;
      }else if( cli_strcmp(z,"-csv")==0 ){
        sCtx.cColSep = ',';
        sCtx.cRowSep = '\n';
        xRead = csv_read_one_field;
        useOutputMode = 0;
      }else{
        sqlite3_fprintf(p->out, "ERROR: unknown option: \"%s\".  Usage:\n", z);
        showHelp(p->out, "import");
        goto meta_command_exit;
      }
    }
    if( zTable==0 ){
      sqlite3_fprintf(p->out, "ERROR: missing %s argument. Usage:\n",
            zFile==0 ? "FILE" : "TABLE");
      showHelp(p->out, "import");
      goto meta_command_exit;
    }
    seenInterrupt = 0;
    open_db(p, 0);
    if( useOutputMode ){
      /* If neither the --csv or --ascii options are specified, then set
      ** the column and row separator characters from the output mode. */
      nSep = strlen30(p->colSeparator);
      if( nSep==0 ){
        eputz("Error: non-null column separator required for import\n");
        goto meta_command_exit;
      }
      if( nSep>1 ){
        eputz("Error: multi-character column separators not allowed"
              " for import\n");
        goto meta_command_exit;
      }
      nSep = strlen30(p->rowSeparator);
      if( nSep==0 ){
        eputz("Error: non-null row separator required for import\n");
        goto meta_command_exit;
      }
      if( nSep==2 && p->mode==MODE_Csv
       && cli_strcmp(p->rowSeparator,SEP_CrLf)==0
      ){
        /* When importing CSV (only), if the row separator is set to the
        ** default output row separator, change it to the default input
        ** row separator.  This avoids having to maintain different input
        ** and output row separators. */
        sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
        nSep = strlen30(p->rowSeparator);
      }
      if( nSep>1 ){
        eputz("Error: multi-character row separators not allowed"
              " for import\n");
        goto meta_command_exit;
      }
      sCtx.cColSep = (u8)p->colSeparator[0];
      sCtx.cRowSep = (u8)p->rowSeparator[0];
    }
    sCtx.zFile = zFile;
    sCtx.nLine = 1;
    if( sCtx.zFile[0]=='|' ){
#ifdef SQLITE_OMIT_POPEN
      eputz("Error: pipes are not supported in this OS\n");
      goto meta_command_exit;
#else
      sCtx.in = sqlite3_popen(sCtx.zFile+1, "r");
      sCtx.zFile = "<pipe>";
      sCtx.xCloser = pclose;
#endif
    }else{
      sCtx.in = sqlite3_fopen(sCtx.zFile, "rb");
      sCtx.xCloser = fclose;
    }
    if( sCtx.in==0 ){
      sqlite3_fprintf(stderr,"Error: cannot open \"%s\"\n", zFile);
      goto meta_command_exit;
    }
    if( eVerbose>=2 || (eVerbose>=1 && useOutputMode) ){
      char zSep[2];
      zSep[1] = 0;
      zSep[0] = sCtx.cColSep;
      sqlite3_fputs("Column separator ", p->out);
      output_c_string(p->out, zSep);
      sqlite3_fputs(", row separator ", p->out);
      zSep[0] = sCtx.cRowSep;
      output_c_string(p->out, zSep);
      sqlite3_fputs("\n", p->out);
    }
    sCtx.z = sqlite3_malloc64(120);
    if( sCtx.z==0 ){
      import_cleanup(&sCtx);
      shell_out_of_memory();
    }
    /* Below, resources must be freed before exit. */
    while( (nSkip--)>0 ){
      while( xRead(&sCtx) && sCtx.cTerm==sCtx.cColSep ){}
    }
    import_append_char(&sCtx, 0);    /* To ensure sCtx.z is allocated */
    if( sqlite3_table_column_metadata(p->db, zSchema, zTable,0,0,0,0,0,0) 
     && 0==db_int(p->db, "SELECT count(*) FROM \"%w\".sqlite_schema"
                         " WHERE name=%Q AND type='view'",
                         zSchema ? zSchema : "main", zTable)
    ){
      /* Table does not exist.  Create it. */
      sqlite3 *dbCols = 0;
      char *zRenames = 0;
      char *zColDefs;
      zCreate = sqlite3_mprintf("CREATE TABLE \"%w\".\"%w\"", 
                    zSchema ? zSchema : "main", zTable);
      while( xRead(&sCtx) ){
        zAutoColumn(sCtx.z, &dbCols, 0);
        if( sCtx.cTerm!=sCtx.cColSep ) break;
      }
      zColDefs = zAutoColumn(0, &dbCols, &zRenames);
      if( zRenames!=0 ){
        sqlite3_fprintf((stdin_is_interactive && p->in==stdin)? p->out : stderr,
              "Columns renamed during .import %s due to duplicates:\n"
              "%s\n", sCtx.zFile, zRenames);
        sqlite3_free(zRenames);
      }
      assert(dbCols==0);
      if( zColDefs==0 ){
        sqlite3_fprintf(stderr,"%s: empty file\n", sCtx.zFile);
        import_cleanup(&sCtx);
        rc = 1;
        sqlite3_free(zCreate);
        goto meta_command_exit;
      }
      zCreate = sqlite3_mprintf("%z%z\n", zCreate, zColDefs);
      if( zCreate==0 ){
        import_cleanup(&sCtx);
        shell_out_of_memory();
      }
      if( eVerbose>=1 ){
        sqlite3_fprintf(p->out, "%s\n", zCreate);
      }
      rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
      if( rc ){
        sqlite3_fprintf(stderr,
             "%s failed:\n%s\n", zCreate, sqlite3_errmsg(p->db));
      }
      sqlite3_free(zCreate);
      zCreate = 0;
      if( rc ){
        import_cleanup(&sCtx);
        rc = 1;
        goto meta_command_exit;
      }
    }
    zSql = sqlite3_mprintf("SELECT count(*) FROM pragma_table_info(%Q,%Q);",
                           zTable, zSchema);
    if( zSql==0 ){
      import_cleanup(&sCtx);
      shell_out_of_memory();
    }
    rc =  sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
    sqlite3_free(zSql);
    zSql = 0;
    if( rc ){
      if (pStmt) sqlite3_finalize(pStmt);
      shellDatabaseError(p->db);
      import_cleanup(&sCtx);
      rc = 1;
      goto meta_command_exit;
    }
    if( sqlite3_step(pStmt)==SQLITE_ROW ){
      nCol = sqlite3_column_int(pStmt, 0);
    }else{
      nCol = 0;
    }
    sqlite3_finalize(pStmt);
    pStmt = 0;
    if( nCol==0 ) return 0; /* no columns, no error */
 
    nByte = 64                 /* space for "INSERT INTO", "VALUES(", ")\0" */
          + (zSchema ? strlen(zSchema)*2 + 2: 0)  /* Quoted schema name */
          + strlen(zTable)*2 + 2                  /* Quoted table name */
          + nCol*2;            /* Space for ",?" for each column */
    zSql = sqlite3_malloc64( nByte );
    if( zSql==0 ){
      import_cleanup(&sCtx);
      shell_out_of_memory();
    }
    if( zSchema ){
      sqlite3_snprintf(nByte, zSql, "INSERT INTO \"%w\".\"%w\" VALUES(?", 
                       zSchema, zTable);
    }else{
      sqlite3_snprintf(nByte, zSql, "INSERT INTO \"%w\" VALUES(?", zTable);
    }
    j = strlen30(zSql);
    for(i=1; i<nCol; i++){
      zSql[j++] = ',';
      zSql[j++] = '?';
    }
    zSql[j++] = ')';
    zSql[j] = 0;
    assert( j<nByte );
    if( eVerbose>=2 ){
      sqlite3_fprintf(p->out, "Insert using: %s\n", zSql);
    }
    rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
    sqlite3_free(zSql);
    zSql = 0;
    if( rc ){
      shellDatabaseError(p->db);
      if (pStmt) sqlite3_finalize(pStmt);
      import_cleanup(&sCtx);
      rc = 1;
      goto meta_command_exit;
    }
    needCommit = sqlite3_get_autocommit(p->db);
    if( needCommit ) sqlite3_exec(p->db, "BEGIN", 0, 0, 0);
    do{
      int startLine = sCtx.nLine;
      for(i=0; i<nCol; i++){
        char *z = xRead(&sCtx);
        /*
        ** Did we reach end-of-file before finding any columns?
        ** If so, stop instead of NULL filling the remaining columns.
        */
        if( z==0 && i==0 ) break;
        /*
        ** Did we reach end-of-file OR end-of-line before finding any
        ** columns in ASCII mode?  If so, stop instead of NULL filling
        ** the remaining columns.
        */
        if( p->mode==MODE_Ascii && (z==0 || z[0]==0) && i==0 ) break;
        /*
        ** For CSV mode, per RFC 4180, accept EOF in lieu of final
        ** record terminator but only for last field of multi-field row.
        ** (If there are too few fields, it's not valid CSV anyway.)
        */
        if( z==0 && (xRead==csv_read_one_field) && i==nCol-1 && i>0 ){
          z = "";
        }
        sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT);
        if( i<nCol-1 && sCtx.cTerm!=sCtx.cColSep ){
          sqlite3_fprintf(stderr,"%s:%d: expected %d columns but found %d"
                " - filling the rest with NULL\n",
                sCtx.zFile, startLine, nCol, i+1);
          i += 2;
          while( i<=nCol ){ sqlite3_bind_null(pStmt, i); i++; }
        }
      }
      if( sCtx.cTerm==sCtx.cColSep ){
        do{
          xRead(&sCtx);
          i++;
        }while( sCtx.cTerm==sCtx.cColSep );
        sqlite3_fprintf(stderr,
              "%s:%d: expected %d columns but found %d - extras ignored\n",
              sCtx.zFile, startLine, nCol, i);
      }
      if( i>=nCol ){
        sqlite3_step(pStmt);
        rc = sqlite3_reset(pStmt);
        if( rc!=SQLITE_OK ){
          sqlite3_fprintf(stderr,"%s:%d: INSERT failed: %s\n",
                sCtx.zFile, startLine, sqlite3_errmsg(p->db));
          sCtx.nErr++;
        }else{
          sCtx.nRow++;
        }
      }
    }while( sCtx.cTerm!=EOF );
 
    import_cleanup(&sCtx);
    sqlite3_finalize(pStmt);
    if( needCommit ) sqlite3_exec(p->db, "COMMIT", 0, 0, 0);
    if( eVerbose>0 ){
      sqlite3_fprintf(p->out,
            "Added %d rows with %d errors using %d lines of input\n",
            sCtx.nRow, sCtx.nErr, sCtx.nLine-1);
    }
  }else
#endif /* !defined(SQLITE_SHELL_FIDDLE) */
 
#ifndef SQLITE_UNTESTABLE
  if( c=='i' && cli_strncmp(azArg[0], "imposter", n)==0 ){
    char *zSql;
    char *zCollist = 0;
    sqlite3_stmt *pStmt;
    int tnum = 0;
    int isWO = 0;  /* True if making an imposter of a WITHOUT ROWID table */
    int lenPK = 0; /* Length of the PRIMARY KEY string for isWO tables */
    int i;
    if( !ShellHasFlag(p,SHFLG_TestingMode) ){
      sqlite3_fprintf(stderr,".%s unavailable without --unsafe-testing\n",
            "imposter");
      rc = 1;
      goto meta_command_exit;
    }
    if( !(nArg==3 || (nArg==2 && sqlite3_stricmp(azArg[1],"off")==0)) ){
      eputz("Usage: .imposter INDEX IMPOSTER\n"
            "       .imposter off\n");
      /* Also allowed, but not documented:
      **
      **    .imposter TABLE IMPOSTER
      **
      ** where TABLE is a WITHOUT ROWID table.  In that case, the
      ** imposter is another WITHOUT ROWID table with the columns in
      ** storage order. */
      rc = 1;
      goto meta_command_exit;
    }
    open_db(p, 0);
    if( nArg==2 ){
      sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 1);
      goto meta_command_exit;
    }
    zSql = sqlite3_mprintf(
      "SELECT rootpage, 0 FROM sqlite_schema"
      " WHERE name='%q' AND type='index'"
      "UNION ALL "
      "SELECT rootpage, 1 FROM sqlite_schema"
      " WHERE name='%q' AND type='table'"
      "   AND sql LIKE '%%without%%rowid%%'",
      azArg[1], azArg[1]
    );
    sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
    sqlite3_free(zSql);
    if( sqlite3_step(pStmt)==SQLITE_ROW ){
      tnum = sqlite3_column_int(pStmt, 0);
      isWO = sqlite3_column_int(pStmt, 1);
    }
    sqlite3_finalize(pStmt);
    zSql = sqlite3_mprintf("PRAGMA index_xinfo='%q'", azArg[1]);
    rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
    sqlite3_free(zSql);
    i = 0;
    while( rc==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){
      char zLabel[20];
      const char *zCol = (const char*)sqlite3_column_text(pStmt,2);
      i++;
      if( zCol==0 ){
        if( sqlite3_column_int(pStmt,1)==-1 ){
          zCol = "_ROWID_";
        }else{
          sqlite3_snprintf(sizeof(zLabel),zLabel,"expr%d",i);
          zCol = zLabel;
        }
      }
      if( isWO && lenPK==0 && sqlite3_column_int(pStmt,5)==0 && zCollist ){
        lenPK = (int)strlen(zCollist);
      }
      if( zCollist==0 ){
        zCollist = sqlite3_mprintf("\"%w\"", zCol);
      }else{
        zCollist = sqlite3_mprintf("%z,\"%w\"", zCollist, zCol);
      }
    }
    sqlite3_finalize(pStmt);
    if( i==0 || tnum==0 ){
      sqlite3_fprintf(stderr,"no such index: \"%s\"\n", azArg[1]);
      rc = 1;
      sqlite3_free(zCollist);
      goto meta_command_exit;
    }
    if( lenPK==0 ) lenPK = 100000;
    zSql = sqlite3_mprintf(
          "CREATE TABLE \"%w\"(%s,PRIMARY KEY(%.*s))WITHOUT ROWID",
          azArg[2], zCollist, lenPK, zCollist);
    sqlite3_free(zCollist);
    rc = sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 1, tnum);
    if( rc==SQLITE_OK ){
      rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
      sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 0);
      if( rc ){
        sqlite3_fprintf(stderr,
              "Error in [%s]: %s\n", zSql, sqlite3_errmsg(p->db));
      }else{
        sqlite3_fprintf(stdout, "%s;\n", zSql);
        sqlite3_fprintf(stdout,
              "WARNING: writing to an imposter table will corrupt"
              " the \"%s\" %s!\n", azArg[1], isWO ? "table" : "index");
      }
    }else{
      sqlite3_fprintf(stderr,"SQLITE_TESTCTRL_IMPOSTER returns %d\n", rc);
      rc = 1;
    }
    sqlite3_free(zSql);
  }else
#endif /* !defined(SQLITE_OMIT_TEST_CONTROL) */
 
  if( c=='i' && cli_strncmp(azArg[0], "intck", n)==0 ){
    i64 iArg = 0;
    if( nArg==2 ){
      iArg = integerValue(azArg[1]);
      if( iArg==0 ) iArg = -1;
    }
    if( (nArg!=1 && nArg!=2) || iArg<0 ){
      sqlite3_fprintf(stderr,"%s","Usage: .intck STEPS_PER_UNLOCK\n");
      rc = 1;
      goto meta_command_exit;
    }
    open_db(p, 0);
    rc = intckDatabaseCmd(p, iArg);
  }else
 
#ifdef SQLITE_ENABLE_IOTRACE
  if( c=='i' && cli_strncmp(azArg[0], "iotrace", n)==0 ){
    SQLITE_API extern void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...);
    if( iotrace && iotrace!=stdout ) fclose(iotrace);
    iotrace = 0;
    if( nArg<2 ){
      sqlite3IoTrace = 0;
    }else if( cli_strcmp(azArg[1], "-")==0 ){
      sqlite3IoTrace = iotracePrintf;
      iotrace = stdout;
    }else{
      iotrace = sqlite3_fopen(azArg[1], "w");
      if( iotrace==0 ){
        sqlite3_fprintf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
        sqlite3IoTrace = 0;
        rc = 1;
      }else{
        sqlite3IoTrace = iotracePrintf;
      }
    }
  }else
#endif
 
  if( c=='l' && n>=5 && cli_strncmp(azArg[0], "limits", n)==0 ){
    static const struct {
       const char *zLimitName;   /* Name of a limit */
       int limitCode;            /* Integer code for that limit */
    } aLimit[] = {
      { "length",                SQLITE_LIMIT_LENGTH                    },
      { "sql_length",            SQLITE_LIMIT_SQL_LENGTH                },
      { "column",                SQLITE_LIMIT_COLUMN                    },
      { "expr_depth",            SQLITE_LIMIT_EXPR_DEPTH                },
      { "compound_select",       SQLITE_LIMIT_COMPOUND_SELECT           },
      { "vdbe_op",               SQLITE_LIMIT_VDBE_OP                   },
      { "function_arg",          SQLITE_LIMIT_FUNCTION_ARG              },
      { "attached",              SQLITE_LIMIT_ATTACHED                  },
      { "like_pattern_length",   SQLITE_LIMIT_LIKE_PATTERN_LENGTH       },
      { "variable_number",       SQLITE_LIMIT_VARIABLE_NUMBER           },
      { "trigger_depth",         SQLITE_LIMIT_TRIGGER_DEPTH             },
      { "worker_threads",        SQLITE_LIMIT_WORKER_THREADS            },
    };
    int i, n2;
    open_db(p, 0);
    if( nArg==1 ){
      for(i=0; i<ArraySize(aLimit); i++){
        sqlite3_fprintf(stdout, "%20s %d\n", aLimit[i].zLimitName,
              sqlite3_limit(p->db, aLimit[i].limitCode, -1));
      }
    }else if( nArg>3 ){
      eputz("Usage: .limit NAME ?NEW-VALUE?\n");
      rc = 1;
      goto meta_command_exit;
    }else{
      int iLimit = -1;
      n2 = strlen30(azArg[1]);
      for(i=0; i<ArraySize(aLimit); i++){
        if( sqlite3_strnicmp(aLimit[i].zLimitName, azArg[1], n2)==0 ){
          if( iLimit<0 ){
            iLimit = i;
          }else{
            sqlite3_fprintf(stderr,"ambiguous limit: \"%s\"\n", azArg[1]);
            rc = 1;
            goto meta_command_exit;
          }
        }
      }
      if( iLimit<0 ){
        sqlite3_fprintf(stderr,"unknown limit: \"%s\"\n"
              "enter \".limits\" with no arguments for a list.\n",
              azArg[1]);
        rc = 1;
        goto meta_command_exit;
      }
      if( nArg==3 ){
        sqlite3_limit(p->db, aLimit[iLimit].limitCode,
                      (int)integerValue(azArg[2]));
      }
      sqlite3_fprintf(stdout, "%20s %d\n", aLimit[iLimit].zLimitName,
            sqlite3_limit(p->db, aLimit[iLimit].limitCode, -1));
    }
  }else
 
  if( c=='l' && n>2 && cli_strncmp(azArg[0], "lint", n)==0 ){
    open_db(p, 0);
    lintDotCommand(p, azArg, nArg);
  }else
 
#if !defined(SQLITE_OMIT_LOAD_EXTENSION) && !defined(SQLITE_SHELL_FIDDLE)
  if( c=='l' && cli_strncmp(azArg[0], "load", n)==0 ){
    const char *zFile, *zProc;
    char *zErrMsg = 0;
    failIfSafeMode(p, "cannot run .load in safe mode");
    if( nArg<2 || azArg[1][0]==0 ){
      /* Must have a non-empty FILE. (Will not load self.) */
      eputz("Usage: .load FILE ?ENTRYPOINT?\n");
      rc = 1;
      goto meta_command_exit;
    }
    zFile = azArg[1];
    zProc = nArg>=3 ? azArg[2] : 0;
    open_db(p, 0);
    rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
    if( rc!=SQLITE_OK ){
      shellEmitError(zErrMsg);
      sqlite3_free(zErrMsg);
      rc = 1;
    }
  }else
#endif
 
  if( c=='l' && cli_strncmp(azArg[0], "log", n)==0 ){
    if( nArg!=2 ){
      eputz("Usage: .log FILENAME\n");
      rc = 1;
    }else{
      const char *zFile = azArg[1];
      if( p->bSafeMode
       && cli_strcmp(zFile,"on")!=0
       && cli_strcmp(zFile,"off")!=0
      ){
        sputz(stdout, "cannot set .log to anything other"
              " than \"on\" or \"off\"\n");
        zFile = "off";
      }
      output_file_close(p->pLog);
      if( cli_strcmp(zFile,"on")==0 ) zFile = "stdout";
      p->pLog = output_file_open(zFile);
    }
  }else
 
  if( c=='m' && cli_strncmp(azArg[0], "mode", n)==0 ){
    const char *zMode = 0;
    const char *zTabname = 0;
    int i, n2;
    int chng = 0;       /* 0x01:  change to cmopts.  0x02:  Any other change */
    ColModeOpts cmOpts = ColModeOpts_default;
    for(i=1; i<nArg; i++){
      const char *z = azArg[i];
      if( optionMatch(z,"wrap") && i+1<nArg ){
        cmOpts.iWrap = integerValue(azArg[++i]);
        chng |= 1;
      }else if( optionMatch(z,"ww") ){
        cmOpts.bWordWrap = 1;
        chng |= 1;
      }else if( optionMatch(z,"wordwrap") && i+1<nArg ){
        cmOpts.bWordWrap = (u8)booleanValue(azArg[++i]);
        chng |= 1;
      }else if( optionMatch(z,"quote") ){
        cmOpts.bQuote = 1;
        chng |= 1;
      }else if( optionMatch(z,"noquote") ){
        cmOpts.bQuote = 0;
        chng |= 1;
      }else if( optionMatch(z,"escape") && i+1<nArg ){
        /* See similar code at tag-20250224-1 */
        const char *zEsc = azArg[++i];
        int k;
        for(k=0; k<ArraySize(shell_EscModeNames); k++){
          if( sqlite3_stricmp(zEsc,shell_EscModeNames[k])==0 ){
            p->eEscMode = k;
            chng |= 2;
            break;
          }
        }
        if( k>=ArraySize(shell_EscModeNames) ){
          sqlite3_fprintf(stderr, "unknown control character escape mode \"%s\""
                                  " - choices:", zEsc);
          for(k=0; k<ArraySize(shell_EscModeNames); k++){
            sqlite3_fprintf(stderr, " %s", shell_EscModeNames[k]);
          }
          sqlite3_fprintf(stderr, "\n");
          rc = 1;
          goto meta_command_exit;
        }
      }else if( zMode==0 ){
        zMode = z;
        /* Apply defaults for qbox pseudo-mode.  If that
         * overwrites already-set values, user was informed of this.
         */
        chng |= 1;
        if( cli_strcmp(z, "qbox")==0 ){
          ColModeOpts cmo = ColModeOpts_default_qbox;
          zMode = "box";
          cmOpts = cmo;
        }
      }else if( zTabname==0 ){
        zTabname = z;
      }else if( z[0]=='-' ){
        sqlite3_fprintf(stderr,"unknown option: %s\n", z);
        eputz("options:\n"
              "  --escape MODE\n"
              "  --noquote\n"
              "  --quote\n"
              "  --wordwrap on/off\n"
              "  --wrap N\n"
              "  --ww\n");
        rc = 1;
        goto meta_command_exit;
      }else{
        sqlite3_fprintf(stderr,"extra argument: \"%s\"\n", z);
        rc = 1;
        goto meta_command_exit;
      }
    }
    if( !chng ){
      if( p->mode==MODE_Column
       || (p->mode>=MODE_Markdown && p->mode<=MODE_Box)
      ){
        sqlite3_fprintf(p->out,
              "current output mode: %s --wrap %d --wordwrap %s "
              "--%squote --escape %s\n",
              modeDescr[p->mode], p->cmOpts.iWrap,
              p->cmOpts.bWordWrap ? "on" : "off",
              p->cmOpts.bQuote ? "" : "no",
              shell_EscModeNames[p->eEscMode]
        );
      }else{
        sqlite3_fprintf(p->out,
              "current output mode: %s --escape %s\n",
              modeDescr[p->mode],
              shell_EscModeNames[p->eEscMode]
        );
      }
    }
    if( zMode==0 ){
      zMode = modeDescr[p->mode];
      if( (chng&1)==0 ) cmOpts = p->cmOpts;
    }
    n2 = strlen30(zMode);
    if( cli_strncmp(zMode,"lines",n2)==0 ){
      p->mode = MODE_Line;
      sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
    }else if( cli_strncmp(zMode,"columns",n2)==0 ){
      p->mode = MODE_Column;
      if( (p->shellFlgs & SHFLG_HeaderSet)==0 ){
        p->showHeader = 1;
      }
      sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
      p->cmOpts = cmOpts;
    }else if( cli_strncmp(zMode,"list",n2)==0 ){
      p->mode = MODE_List;
      sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Column);
      sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
    }else if( cli_strncmp(zMode,"html",n2)==0 ){
      p->mode = MODE_Html;
    }else if( cli_strncmp(zMode,"tcl",n2)==0 ){
      p->mode = MODE_Tcl;
      sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Space);
      sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
    }else if( cli_strncmp(zMode,"csv",n2)==0 ){
      p->mode = MODE_Csv;
      sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma);
      sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf);
    }else if( cli_strncmp(zMode,"tabs",n2)==0 ){
      p->mode = MODE_List;
      sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Tab);
    }else if( cli_strncmp(zMode,"insert",n2)==0 ){
      p->mode = MODE_Insert;
      set_table_name(p, zTabname ? zTabname : "table");
      if( p->eEscMode==SHELL_ESC_OFF ){
        ShellSetFlag(p, SHFLG_Newlines);
      }else{
        ShellClearFlag(p, SHFLG_Newlines);
      }
    }else if( cli_strncmp(zMode,"quote",n2)==0 ){
      p->mode = MODE_Quote;
      sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma);
      sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
    }else if( cli_strncmp(zMode,"ascii",n2)==0 ){
      p->mode = MODE_Ascii;
      sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Unit);
      sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Record);
    }else if( cli_strncmp(zMode,"markdown",n2)==0 ){
      p->mode = MODE_Markdown;
      p->cmOpts = cmOpts;
    }else if( cli_strncmp(zMode,"table",n2)==0 ){
      p->mode = MODE_Table;
      p->cmOpts = cmOpts;
    }else if( cli_strncmp(zMode,"box",n2)==0 ){
      p->mode = MODE_Box;
      p->cmOpts = cmOpts;
    }else if( cli_strncmp(zMode,"count",n2)==0 ){
      p->mode = MODE_Count;
    }else if( cli_strncmp(zMode,"off",n2)==0 ){
      p->mode = MODE_Off;
    }else if( cli_strncmp(zMode,"json",n2)==0 ){
      p->mode = MODE_Json;
    }else{
      eputz("Error: mode should be one of: "
            "ascii box column csv html insert json line list markdown "
            "qbox quote table tabs tcl\n");
      rc = 1;
    }
    p->cMode = p->mode;
  }else
 
#ifndef SQLITE_SHELL_FIDDLE
  if( c=='n' && cli_strcmp(azArg[0], "nonce")==0 ){
    if( nArg!=2 ){
      eputz("Usage: .nonce NONCE\n");
      rc = 1;
    }else if( p->zNonce==0 || cli_strcmp(azArg[1],p->zNonce)!=0 ){
      sqlite3_fprintf(stderr,"line %d: incorrect nonce: \"%s\"\n",
            p->lineno, azArg[1]);
      exit(1);
    }else{
      p->bSafeMode = 0;
      return 0;  /* Return immediately to bypass the safe mode reset
                 ** at the end of this procedure */
    }
  }else
#endif /* !defined(SQLITE_SHELL_FIDDLE) */
 
  if( c=='n' && cli_strncmp(azArg[0], "nullvalue", n)==0 ){
    if( nArg==2 ){
      sqlite3_snprintf(sizeof(p->nullValue), p->nullValue,
                       "%.*s", (int)ArraySize(p->nullValue)-1, azArg[1]);
    }else{
      eputz("Usage: .nullvalue STRING\n");
      rc = 1;
    }
  }else
 
  if( c=='o' && cli_strncmp(azArg[0], "open", n)==0 && n>=2 ){
    const char *zFN = 0;     /* Pointer to constant filename */
    char *zNewFilename = 0;  /* Name of the database file to open */
    int iName = 1;           /* Index in azArg[] of the filename */
    int newFlag = 0;         /* True to delete file before opening */
    int openMode = SHELL_OPEN_UNSPEC;
 
    /* Check for command-line arguments */
    for(iName=1; iName<nArg; iName++){
      const char *z = azArg[iName];
#ifndef SQLITE_SHELL_FIDDLE
      if( optionMatch(z,"new") ){
        newFlag = 1;
#ifdef SQLITE_HAVE_ZLIB
      }else if( optionMatch(z, "zip") ){
        openMode = SHELL_OPEN_ZIPFILE;
#endif
      }else if( optionMatch(z, "append") ){
        openMode = SHELL_OPEN_APPENDVFS;
      }else if( optionMatch(z, "readonly") ){
        openMode = SHELL_OPEN_READONLY;
      }else if( optionMatch(z, "nofollow") ){
        p->openFlags |= SQLITE_OPEN_NOFOLLOW;
#ifndef SQLITE_OMIT_DESERIALIZE
      }else if( optionMatch(z, "deserialize") ){
        openMode = SHELL_OPEN_DESERIALIZE;
      }else if( optionMatch(z, "hexdb") ){
        openMode = SHELL_OPEN_HEXDB;
      }else if( optionMatch(z, "maxsize") && iName+1<nArg ){
        p->szMax = integerValue(azArg[++iName]);
#endif /* SQLITE_OMIT_DESERIALIZE */
      }else
#endif /* !SQLITE_SHELL_FIDDLE */
      if( z[0]=='-' ){
        sqlite3_fprintf(stderr,"unknown option: %s\n", z);
        rc = 1;
        goto meta_command_exit;
      }else if( zFN ){
        sqlite3_fprintf(stderr,"extra argument: \"%s\"\n", z);
        rc = 1;
        goto meta_command_exit;
      }else{
        zFN = z;
      }
    }
 
    /* Close the existing database */
    session_close_all(p, -1);
    close_db(p->db);
    p->db = 0;
    p->pAuxDb->zDbFilename = 0;
    sqlite3_free(p->pAuxDb->zFreeOnClose);
    p->pAuxDb->zFreeOnClose = 0;
    p->openMode = openMode;
    p->openFlags = 0;
    p->szMax = 0;
 
    /* If a filename is specified, try to open it first */
    if( zFN || p->openMode==SHELL_OPEN_HEXDB ){
      if( newFlag && zFN && !p->bSafeMode ) shellDeleteFile(zFN);
#ifndef SQLITE_SHELL_FIDDLE
      if( p->bSafeMode
       && p->openMode!=SHELL_OPEN_HEXDB
       && zFN
       && cli_strcmp(zFN,":memory:")!=0
      ){
        failIfSafeMode(p, "cannot open disk-based database files in safe mode");
      }
#else
      /* WASM mode has its own sandboxed pseudo-filesystem. */
#endif
      if( zFN ){
        zNewFilename = sqlite3_mprintf("%s", zFN);
        shell_check_oom(zNewFilename);
      }else{
        zNewFilename = 0;
      }
      p->pAuxDb->zDbFilename = zNewFilename;
      open_db(p, OPEN_DB_KEEPALIVE);
      if( p->db==0 ){
        sqlite3_fprintf(stderr,"Error: cannot open '%s'\n", zNewFilename);
        sqlite3_free(zNewFilename);
      }else{
        p->pAuxDb->zFreeOnClose = zNewFilename;
      }
    }
    if( p->db==0 ){
      /* As a fall-back open a TEMP database */
      p->pAuxDb->zDbFilename = 0;
      open_db(p, 0);
    }
  }else
 
#ifndef SQLITE_SHELL_FIDDLE
  if( (c=='o'
        && (cli_strncmp(azArg[0], "output", n)==0
            || cli_strncmp(azArg[0], "once", n)==0))
   || (c=='e' && n==5 && cli_strcmp(azArg[0],"excel")==0)
   || (c=='w' && n==3 && cli_strcmp(azArg[0],"www")==0)
  ){
    char *zFile = 0;
    int i;
    int eMode = 0;          /* 0: .outout/.once, 'x'=.excel, 'w'=.www */
    int bOnce = 0;          /* 0: .output, 1: .once, 2: .excel/.www */
    int bPlain = 0;         /* --plain option */
    static const char *zBomUtf8 = "\357\273\277";
    const char *zBom = 0;
 
    failIfSafeMode(p, "cannot run .%s in safe mode", azArg[0]);
    if( c=='e' ){
      eMode = 'x';
      bOnce = 2;
    }else if( c=='w' ){
      eMode = 'w';
      bOnce = 2;
    }else if( cli_strncmp(azArg[0],"once",n)==0 ){
      bOnce = 1;
    }
    for(i=1; i<nArg; i++){
      char *z = azArg[i];
      if( z[0]=='-' ){
        if( z[1]=='-' ) z++;
        if( cli_strcmp(z,"-bom")==0 ){
          zBom = zBomUtf8;
        }else if( cli_strcmp(z,"-plain")==0 ){
          bPlain = 1;
        }else if( c=='o' && cli_strcmp(z,"-x")==0 ){
          eMode = 'x';  /* spreadsheet */
        }else if( c=='o' && cli_strcmp(z,"-e")==0 ){
          eMode = 'e';  /* text editor */
        }else if( c=='o' && cli_strcmp(z,"-w")==0 ){
          eMode = 'w';  /* Web browser */
        }else{
          sqlite3_fprintf(p->out,
                          "ERROR: unknown option: \"%s\". Usage:\n", azArg[i]);
          showHelp(p->out, azArg[0]);
          rc = 1;
          goto meta_command_exit;
        }
      }else if( zFile==0 && eMode==0 ){
        if( cli_strcmp(z, "off")==0 ){
#ifdef _WIN32
          zFile = sqlite3_mprintf("nul");
#else
          zFile = sqlite3_mprintf("/dev/null");
#endif
        }else{
          zFile = sqlite3_mprintf("%s", z);
        }
        if( zFile && zFile[0]=='|' ){
          while( i+1<nArg ) zFile = sqlite3_mprintf("%z %s", zFile, azArg[++i]);
          break;
        }
      }else{
        sqlite3_fprintf(p->out,
            "ERROR: extra parameter: \"%s\".  Usage:\n", azArg[i]);
        showHelp(p->out, azArg[0]);
        rc = 1;
        sqlite3_free(zFile);
        goto meta_command_exit;
      }
    }
    if( zFile==0 ){
      zFile = sqlite3_mprintf("stdout");
    }
    shell_check_oom(zFile);
    if( bOnce ){
      p->outCount = 2;
    }else{
      p->outCount = 0;
    }
    output_reset(p);
#ifndef SQLITE_NOHAVE_SYSTEM
    if( eMode=='e' || eMode=='x' || eMode=='w' ){
      p->doXdgOpen = 1;
      outputModePush(p);
      if( eMode=='x' ){
        /* spreadsheet mode.  Output as CSV. */
        newTempFile(p, "csv");
        ShellClearFlag(p, SHFLG_Echo);
        p->mode = MODE_Csv;
        sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma);
        sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf);
#ifdef _WIN32
        zBom = zBomUtf8;  /* Always include the BOM on Windows, as Excel does
                          ** not work without it. */
#endif
      }else if( eMode=='w' ){
        /* web-browser mode. */
        newTempFile(p, "html");
        if( !bPlain ) p->mode = MODE_Www;
      }else{
        /* text editor mode */
        newTempFile(p, "txt");
      }
      sqlite3_free(zFile);
      zFile = sqlite3_mprintf("%s", p->zTempFile);
    }
#endif /* SQLITE_NOHAVE_SYSTEM */
    shell_check_oom(zFile);
    if( zFile[0]=='|' ){
#ifdef SQLITE_OMIT_POPEN
      eputz("Error: pipes are not supported in this OS\n");
      rc = 1;
      output_redir(p, stdout);
#else
      FILE *pfPipe = sqlite3_popen(zFile + 1, "w");
      if( pfPipe==0 ){
        assert( stderr!=NULL );
        sqlite3_fprintf(stderr,"Error: cannot open pipe \"%s\"\n", zFile + 1);
        rc = 1;
      }else{
        output_redir(p, pfPipe);
        if( zBom ) sqlite3_fputs(zBom, pfPipe);
        sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
      }
#endif
    }else{
      FILE *pfFile = output_file_open(zFile);
      if( pfFile==0 ){
        if( cli_strcmp(zFile,"off")!=0 ){
         assert( stderr!=NULL );
         sqlite3_fprintf(stderr,"Error: cannot write to \"%s\"\n", zFile);
        }
        rc = 1;
      } else {
        output_redir(p, pfFile);
        if( zBom ) sqlite3_fputs(zBom, pfFile);
        if( bPlain && eMode=='w' ){
          sqlite3_fputs(
            "<!DOCTYPE html>\n<BODY>\n<PLAINTEXT>\n",
            pfFile
          );
        }
        sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
      }
    }
    sqlite3_free(zFile);
  }else
#endif /* !defined(SQLITE_SHELL_FIDDLE) */
 
  if( c=='p' && n>=3 && cli_strncmp(azArg[0], "parameter", n)==0 ){
    open_db(p,0);
    if( nArg<=1 ) goto parameter_syntax_error;
 
    /* .parameter clear
    ** Clear all bind parameters by dropping the TEMP table that holds them.
    */
    if( nArg==2 && cli_strcmp(azArg[1],"clear")==0 ){
      sqlite3_exec(p->db, "DROP TABLE IF EXISTS temp.sqlite_parameters;",
                   0, 0, 0);
    }else
 
    /* .parameter list
    ** List all bind parameters.
    */
    if( nArg==2 && cli_strcmp(azArg[1],"list")==0 ){
      sqlite3_stmt *pStmt = 0;
      int rx;
      int len = 0;
      rx = sqlite3_prepare_v2(p->db,
             "SELECT max(length(key)) "
             "FROM temp.sqlite_parameters;", -1, &pStmt, 0);
      if( rx==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){
        len = sqlite3_column_int(pStmt, 0);
        if( len>40 ) len = 40;
      }
      sqlite3_finalize(pStmt);
      pStmt = 0;
      if( len ){
        rx = sqlite3_prepare_v2(p->db,
             "SELECT key, quote(value) "
             "FROM temp.sqlite_parameters;", -1, &pStmt, 0);
        while( rx==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){
          sqlite3_fprintf(p->out,
                "%-*s %s\n", len, sqlite3_column_text(pStmt,0),
                sqlite3_column_text(pStmt,1));
        }
        sqlite3_finalize(pStmt);
      }
    }else
 
    /* .parameter init
    ** Make sure the TEMP table used to hold bind parameters exists.
    ** Create it if necessary.
    */
    if( nArg==2 && cli_strcmp(azArg[1],"init")==0 ){
      bind_table_init(p);
    }else
 
    /* .parameter set NAME VALUE
    ** Set or reset a bind parameter.  NAME should be the full parameter
    ** name exactly as it appears in the query.  (ex: $abc, @def).  The
    ** VALUE can be in either SQL literal notation, or if not it will be
    ** understood to be a text string.
    */
    if( nArg==4 && cli_strcmp(azArg[1],"set")==0 ){
      int rx;
      char *zSql;
      sqlite3_stmt *pStmt;
      const char *zKey = azArg[2];
      const char *zValue = azArg[3];
      bind_table_init(p);
      zSql = sqlite3_mprintf(
                  "REPLACE INTO temp.sqlite_parameters(key,value)"
                  "VALUES(%Q,%s);", zKey, zValue);
      shell_check_oom(zSql);
      pStmt = 0;
      rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
      sqlite3_free(zSql);
      if( rx!=SQLITE_OK ){
        sqlite3_finalize(pStmt);
        pStmt = 0;
        zSql = sqlite3_mprintf(
                   "REPLACE INTO temp.sqlite_parameters(key,value)"
                   "VALUES(%Q,%Q);", zKey, zValue);
        shell_check_oom(zSql);
        rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
        sqlite3_free(zSql);
        if( rx!=SQLITE_OK ){
          sqlite3_fprintf(p->out, "Error: %s\n", sqlite3_errmsg(p->db));
          sqlite3_finalize(pStmt);
          pStmt = 0;
          rc = 1;
        }
      }
      bind_prepared_stmt(p, pStmt);
      sqlite3_step(pStmt);
      sqlite3_finalize(pStmt);
    }else
 
    /* .parameter unset NAME
    ** Remove the NAME binding from the parameter binding table, if it
    ** exists.
    */
    if( nArg==3 && cli_strcmp(azArg[1],"unset")==0 ){
      char *zSql = sqlite3_mprintf(
          "DELETE FROM temp.sqlite_parameters WHERE key=%Q", azArg[2]);
      shell_check_oom(zSql);
      sqlite3_exec(p->db, zSql, 0, 0, 0);
      sqlite3_free(zSql);
    }else
    /* If no command name matches, show a syntax error */
    parameter_syntax_error:
    showHelp(p->out, "parameter");
  }else
 
  if( c=='p' && n>=3 && cli_strncmp(azArg[0], "print", n)==0 ){
    int i;
    for(i=1; i<nArg; i++){
      if( i>1 ) sqlite3_fputs(" ", p->out);
      sqlite3_fputs(azArg[i], p->out);
    }
    sqlite3_fputs("\n", p->out);
  }else
 
#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
  if( c=='p' && n>=3 && cli_strncmp(azArg[0], "progress", n)==0 ){
    int i;
    int nn = 0;
    p->flgProgress = 0;
    p->mxProgress = 0;
    p->nProgress = 0;
    for(i=1; i<nArg; i++){
      const char *z = azArg[i];
      if( z[0]=='-' ){
        z++;
        if( z[0]=='-' ) z++;
        if( cli_strcmp(z,"quiet")==0 || cli_strcmp(z,"q")==0 ){
          p->flgProgress |= SHELL_PROGRESS_QUIET;
          continue;
        }
        if( cli_strcmp(z,"reset")==0 ){
          p->flgProgress |= SHELL_PROGRESS_RESET;
          continue;
        }
        if( cli_strcmp(z,"once")==0 ){
          p->flgProgress |= SHELL_PROGRESS_ONCE;
          continue;
        }
        if( cli_strcmp(z,"limit")==0 ){
          if( i+1>=nArg ){
            eputz("Error: missing argument on --limit\n");
            rc = 1;
            goto meta_command_exit;
          }else{
            p->mxProgress = (int)integerValue(azArg[++i]);
          }
          continue;
        }
        sqlite3_fprintf(stderr,"Error: unknown option: \"%s\"\n", azArg[i]);
        rc = 1;
        goto meta_command_exit;
      }else{
        nn = (int)integerValue(z);
      }
    }
    open_db(p, 0);
    sqlite3_progress_handler(p->db, nn, progress_handler, p);
  }else
#endif /* SQLITE_OMIT_PROGRESS_CALLBACK */
 
  if( c=='p' && cli_strncmp(azArg[0], "prompt", n)==0 ){
    if( nArg >= 2) {
      shell_strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
    }
    if( nArg >= 3) {
      shell_strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
    }
  }else
 
#ifndef SQLITE_SHELL_FIDDLE
  if( c=='q' && cli_strncmp(azArg[0], "quit", n)==0 ){
    rc = 2;
  }else
#endif
 
#ifndef SQLITE_SHELL_FIDDLE
  if( c=='r' && n>=3 && cli_strncmp(azArg[0], "read", n)==0 ){
    FILE *inSaved = p->in;
    int savedLineno = p->lineno;
    failIfSafeMode(p, "cannot run .read in safe mode");
    if( nArg!=2 ){
      eputz("Usage: .read FILE\n");
      rc = 1;
      goto meta_command_exit;
    }
    if( azArg[1][0]=='|' ){
#ifdef SQLITE_OMIT_POPEN
      eputz("Error: pipes are not supported in this OS\n");
      rc = 1;
#else
      p->in = sqlite3_popen(azArg[1]+1, "r");
      if( p->in==0 ){
        sqlite3_fprintf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
        rc = 1;
      }else{
        rc = process_input(p);
        pclose(p->in);
      }
#endif
    }else if( (p->in = openChrSource(azArg[1]))==0 ){
      sqlite3_fprintf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
      rc = 1;
    }else{
      rc = process_input(p);
      fclose(p->in);
    }
    p->in = inSaved;
    p->lineno = savedLineno;
  }else
#endif /* !defined(SQLITE_SHELL_FIDDLE) */
 
#ifndef SQLITE_SHELL_FIDDLE
  if( c=='r' && n>=3 && cli_strncmp(azArg[0], "restore", n)==0 ){
    const char *zSrcFile;
    const char *zDb;
    sqlite3 *pSrc;
    sqlite3_backup *pBackup;
    int nTimeout = 0;
 
    failIfSafeMode(p, "cannot run .restore in safe mode");
    if( nArg==2 ){
      zSrcFile = azArg[1];
      zDb = "main";
    }else if( nArg==3 ){
      zSrcFile = azArg[2];
      zDb = azArg[1];
    }else{
      eputz("Usage: .restore ?DB? FILE\n");
      rc = 1;
      goto meta_command_exit;
    }
    rc = sqlite3_open(zSrcFile, &pSrc);
    if( rc!=SQLITE_OK ){
      sqlite3_fprintf(stderr,"Error: cannot open \"%s\"\n", zSrcFile);
      close_db(pSrc);
      return 1;
    }
    open_db(p, 0);
    pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
    if( pBackup==0 ){
      shellDatabaseError(p->db);
      close_db(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 ){
      eputz("Error: source database is busy\n");
      rc = 1;
    }else{
      shellDatabaseError(p->db);
      rc = 1;
    }
    close_db(pSrc);
  }else
#endif /* !defined(SQLITE_SHELL_FIDDLE) */
 
  if( c=='s' &&
     (cli_strncmp(azArg[0], "scanstats",  n)==0 ||
      cli_strncmp(azArg[0], "scanstatus", n)==0)
  ){
    if( nArg==2 ){
      if( cli_strcmp(azArg[1], "vm")==0 ){
        p->scanstatsOn = 3;
      }else
      if( cli_strcmp(azArg[1], "est")==0 ){
        p->scanstatsOn = 2;
      }else{
        p->scanstatsOn = (u8)booleanValue(azArg[1]);
      }
      open_db(p, 0);
      sqlite3_db_config(
          p->db, SQLITE_DBCONFIG_STMT_SCANSTATUS, p->scanstatsOn, (int*)0
      );
#if !defined(SQLITE_ENABLE_STMT_SCANSTATUS)
      eputz("Warning: .scanstats not available in this build.\n");
#elif !defined(SQLITE_ENABLE_BYTECODE_VTAB)
      if( p->scanstatsOn==3 ){
        eputz("Warning: \".scanstats vm\" not available in this build.\n");
      }
#endif
    }else{
      eputz("Usage: .scanstats on|off|est\n");
      rc = 1;
    }
  }else
 
  if( c=='s' && cli_strncmp(azArg[0], "schema", n)==0 ){
    ShellText sSelect;
    ShellState data;
    char *zErrMsg = 0;
    const char *zDiv = "(";
    const char *zName = 0;
    int iSchema = 0;
    int bDebug = 0;
    int bNoSystemTabs = 0;
    int ii;
 
    open_db(p, 0);
    memcpy(&data, p, sizeof(data));
    data.showHeader = 0;
    data.cMode = data.mode = MODE_Semi;
    initText(&sSelect);
    for(ii=1; ii<nArg; ii++){
      if( optionMatch(azArg[ii],"indent") ){
        data.cMode = data.mode = MODE_Pretty;
      }else if( optionMatch(azArg[ii],"debug") ){
        bDebug = 1;
      }else if( optionMatch(azArg[ii],"nosys") ){
        bNoSystemTabs = 1;
      }else if( azArg[ii][0]=='-' ){
        sqlite3_fprintf(stderr,"Unknown option: \"%s\"\n", azArg[ii]);
        rc = 1;
        goto meta_command_exit;
      }else if( zName==0 ){
        zName = azArg[ii];
      }else{
        eputz("Usage: .schema ?--indent? ?--nosys? ?LIKE-PATTERN?\n");
        rc = 1;
        goto meta_command_exit;
      }
    }
    if( zName!=0 ){
      int isSchema = sqlite3_strlike(zName, "sqlite_master", '\\')==0
                  || sqlite3_strlike(zName, "sqlite_schema", '\\')==0
                  || sqlite3_strlike(zName,"sqlite_temp_master", '\\')==0
                  || sqlite3_strlike(zName,"sqlite_temp_schema", '\\')==0;
      if( isSchema ){
        char *new_argv[2], *new_colv[2];
        new_argv[0] = sqlite3_mprintf(
                      "CREATE TABLE %s (\n"
                      "  type text,\n"
                      "  name text,\n"
                      "  tbl_name text,\n"
                      "  rootpage integer,\n"
                      "  sql text\n"
                      ")", zName);
        shell_check_oom(new_argv[0]);
        new_argv[1] = 0;
        new_colv[0] = "sql";
        new_colv[1] = 0;
        callback(&data, 1, new_argv, new_colv);
        sqlite3_free(new_argv[0]);
      }
    }
    if( zDiv ){
      sqlite3_stmt *pStmt = 0;
      rc = sqlite3_prepare_v2(p->db, "SELECT name FROM pragma_database_list",
                              -1, &pStmt, 0);
      if( rc ){
        shellDatabaseError(p->db);
        sqlite3_finalize(pStmt);
        rc = 1;
        goto meta_command_exit;
      }
      appendText(&sSelect, "SELECT sql FROM", 0);
      iSchema = 0;
      while( sqlite3_step(pStmt)==SQLITE_ROW ){
        const char *zDb = (const char*)sqlite3_column_text(pStmt, 0);
        char zScNum[30];
        sqlite3_snprintf(sizeof(zScNum), zScNum, "%d", ++iSchema);
        appendText(&sSelect, zDiv, 0);
        zDiv = " UNION ALL ";
        appendText(&sSelect, "SELECT shell_add_schema(sql,", 0);
        if( sqlite3_stricmp(zDb, "main")!=0 ){
          appendText(&sSelect, zDb, '\'');
        }else{
          appendText(&sSelect, "NULL", 0);
        }
        appendText(&sSelect, ",name) AS sql, type, tbl_name, name, rowid,", 0);
        appendText(&sSelect, zScNum, 0);
        appendText(&sSelect, " AS snum, ", 0);
        appendText(&sSelect, zDb, '\'');
        appendText(&sSelect, " AS sname FROM ", 0);
        appendText(&sSelect, zDb, quoteChar(zDb));
        appendText(&sSelect, ".sqlite_schema", 0);
      }
      sqlite3_finalize(pStmt);
#ifndef SQLITE_OMIT_INTROSPECTION_PRAGMAS
      if( zName ){
        appendText(&sSelect,
           " UNION ALL SELECT shell_module_schema(name),"
           " 'table', name, name, name, 9e+99, 'main' FROM pragma_module_list",
        0);
      }
#endif
      appendText(&sSelect, ") WHERE ", 0);
      if( zName ){
        char *zQarg = sqlite3_mprintf("%Q", zName);
        int bGlob;
        shell_check_oom(zQarg);
        bGlob = strchr(zName, '*') != 0 || strchr(zName, '?') != 0 ||
                strchr(zName, '[') != 0;
        if( strchr(zName, '.') ){
          appendText(&sSelect, "lower(printf('%s.%s',sname,tbl_name))", 0);
        }else{
          appendText(&sSelect, "lower(tbl_name)", 0);
        }
        appendText(&sSelect, bGlob ? " GLOB " : " LIKE ", 0);
        appendText(&sSelect, zQarg, 0);
        if( !bGlob ){
          appendText(&sSelect, " ESCAPE '\\' ", 0);
        }
        appendText(&sSelect, " AND ", 0);
        sqlite3_free(zQarg);
      }
      if( bNoSystemTabs ){
        appendText(&sSelect, "name NOT LIKE 'sqlite_%%' AND ", 0);
      }
      appendText(&sSelect, "sql IS NOT NULL"
                           " ORDER BY snum, rowid", 0);
      if( bDebug ){
        sqlite3_fprintf(p->out, "SQL: %s;\n", sSelect.z);
      }else{
        rc = sqlite3_exec(p->db, sSelect.z, callback, &data, &zErrMsg);
      }
      freeText(&sSelect);
    }
    if( zErrMsg ){
      shellEmitError(zErrMsg);
      sqlite3_free(zErrMsg);
      rc = 1;
    }else if( rc != SQLITE_OK ){
      eputz("Error: querying schema information\n");
      rc = 1;
    }else{
      rc = 0;
    }
  }else
 
  if( (c=='s' && n==11 && cli_strncmp(azArg[0], "selecttrace", n)==0)
   || (c=='t' && n==9  && cli_strncmp(azArg[0], "treetrace", n)==0)
  ){
    unsigned int x = nArg>=2? (unsigned int)integerValue(azArg[1]) : 0xffffffff;
    sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 1, &x);
  }else
 
#if defined(SQLITE_ENABLE_SESSION)
  if( c=='s' && cli_strncmp(azArg[0],"session",n)==0 && n>=3 ){
    struct AuxDb *pAuxDb = p->pAuxDb;
    OpenSession *pSession = &pAuxDb->aSession[0];
    char **azCmd = &azArg[1];
    int iSes = 0;
    int nCmd = nArg - 1;
    int i;
    if( nArg<=1 ) goto session_syntax_error;
    open_db(p, 0);
    if( nArg>=3 ){
      for(iSes=0; iSes<pAuxDb->nSession; iSes++){
        if( cli_strcmp(pAuxDb->aSession[iSes].zName, azArg[1])==0 ) break;
      }
      if( iSes<pAuxDb->nSession ){
        pSession = &pAuxDb->aSession[iSes];
        azCmd++;
        nCmd--;
      }else{
        pSession = &pAuxDb->aSession[0];
        iSes = 0;
      }
    }
 
    /* .session attach TABLE
    ** Invoke the sqlite3session_attach() interface to attach a particular
    ** table so that it is never filtered.
    */
    if( cli_strcmp(azCmd[0],"attach")==0 ){
      if( nCmd!=2 ) goto session_syntax_error;
      if( pSession->p==0 ){
        session_not_open:
        eputz("ERROR: No sessions are open\n");
      }else{
        rc = sqlite3session_attach(pSession->p, azCmd[1]);
        if( rc ){
          sqlite3_fprintf(stderr,
               "ERROR: sqlite3session_attach() returns %d\n",rc);
          rc = 0;
        }
      }
    }else
 
    /* .session changeset FILE
    ** .session patchset FILE
    ** Write a changeset or patchset into a file.  The file is overwritten.
    */
    if( cli_strcmp(azCmd[0],"changeset")==0
     || cli_strcmp(azCmd[0],"patchset")==0
    ){
      FILE *out = 0;
      failIfSafeMode(p, "cannot run \".session %s\" in safe mode", azCmd[0]);
      if( nCmd!=2 ) goto session_syntax_error;
      if( pSession->p==0 ) goto session_not_open;
      out = sqlite3_fopen(azCmd[1], "wb");
      if( out==0 ){
        sqlite3_fprintf(stderr,"ERROR: cannot open \"%s\" for writing\n",
              azCmd[1]);
      }else{
        int szChng;
        void *pChng;
        if( azCmd[0][0]=='c' ){
          rc = sqlite3session_changeset(pSession->p, &szChng, &pChng);
        }else{
          rc = sqlite3session_patchset(pSession->p, &szChng, &pChng);
        }
        if( rc ){
          sqlite3_fprintf(stdout, "Error: error code %d\n", rc);
          rc = 0;
        }
        if( pChng
          && fwrite(pChng, szChng, 1, out)!=1 ){
          sqlite3_fprintf(stderr,
              "ERROR: Failed to write entire %d-byte output\n", szChng);
        }
        sqlite3_free(pChng);
        fclose(out);
      }
    }else
 
    /* .session close
    ** Close the identified session
    */
    if( cli_strcmp(azCmd[0], "close")==0 ){
      if( nCmd!=1 ) goto session_syntax_error;
      if( pAuxDb->nSession ){
        session_close(pSession);
        pAuxDb->aSession[iSes] = pAuxDb->aSession[--pAuxDb->nSession];
      }
    }else
 
    /* .session enable ?BOOLEAN?
    ** Query or set the enable flag
    */
    if( cli_strcmp(azCmd[0], "enable")==0 ){
      int ii;
      if( nCmd>2 ) goto session_syntax_error;
      ii = nCmd==1 ? -1 : booleanValue(azCmd[1]);
      if( pAuxDb->nSession ){
        ii = sqlite3session_enable(pSession->p, ii);
        sqlite3_fprintf(p->out,
            "session %s enable flag = %d\n", pSession->zName, ii);
      }
    }else
 
    /* .session filter GLOB ....
    ** Set a list of GLOB patterns of table names to be excluded.
    */
    if( cli_strcmp(azCmd[0], "filter")==0 ){
      int ii, nByte;
      if( nCmd<2 ) goto session_syntax_error;
      if( pAuxDb->nSession ){
        for(ii=0; ii<pSession->nFilter; ii++){
          sqlite3_free(pSession->azFilter[ii]);
        }
        sqlite3_free(pSession->azFilter);
        nByte = sizeof(pSession->azFilter[0])*(nCmd-1);
        pSession->azFilter = sqlite3_malloc( nByte );
        shell_check_oom( pSession->azFilter );
        for(ii=1; ii<nCmd; ii++){
          char *x = pSession->azFilter[ii-1] = sqlite3_mprintf("%s", azCmd[ii]);
          shell_check_oom(x);
        }
        pSession->nFilter = ii-1;
      }
    }else
 
    /* .session indirect ?BOOLEAN?
    ** Query or set the indirect flag
    */
    if( cli_strcmp(azCmd[0], "indirect")==0 ){
      int ii;
      if( nCmd>2 ) goto session_syntax_error;
      ii = nCmd==1 ? -1 : booleanValue(azCmd[1]);
      if( pAuxDb->nSession ){
        ii = sqlite3session_indirect(pSession->p, ii);
        sqlite3_fprintf(p->out,
            "session %s indirect flag = %d\n", pSession->zName, ii);
      }
    }else
 
    /* .session isempty
    ** Determine if the session is empty
    */
    if( cli_strcmp(azCmd[0], "isempty")==0 ){
      int ii;
      if( nCmd!=1 ) goto session_syntax_error;
      if( pAuxDb->nSession ){
        ii = sqlite3session_isempty(pSession->p);
        sqlite3_fprintf(p->out,
             "session %s isempty flag = %d\n", pSession->zName, ii);
      }
    }else
 
    /* .session list
    ** List all currently open sessions
    */
    if( cli_strcmp(azCmd[0],"list")==0 ){
      for(i=0; i<pAuxDb->nSession; i++){
        sqlite3_fprintf(p->out, "%d %s\n", i, pAuxDb->aSession[i].zName);
      }
    }else
 
    /* .session open DB NAME
    ** Open a new session called NAME on the attached database DB.
    ** DB is normally "main".
    */
    if( cli_strcmp(azCmd[0],"open")==0 ){
      char *zName;
      if( nCmd!=3 ) goto session_syntax_error;
      zName = azCmd[2];
      if( zName[0]==0 ) goto session_syntax_error;
      for(i=0; i<pAuxDb->nSession; i++){
        if( cli_strcmp(pAuxDb->aSession[i].zName,zName)==0 ){
          sqlite3_fprintf(stderr,"Session \"%s\" already exists\n", zName);
          goto meta_command_exit;
        }
      }
      if( pAuxDb->nSession>=ArraySize(pAuxDb->aSession) ){
        sqlite3_fprintf(stderr,
           "Maximum of %d sessions\n", ArraySize(pAuxDb->aSession));
        goto meta_command_exit;
      }
      pSession = &pAuxDb->aSession[pAuxDb->nSession];
      rc = sqlite3session_create(p->db, azCmd[1], &pSession->p);
      if( rc ){
        sqlite3_fprintf(stderr,"Cannot open session: error code=%d\n", rc);
        rc = 0;
        goto meta_command_exit;
      }
      pSession->nFilter = 0;
      sqlite3session_table_filter(pSession->p, session_filter, pSession);
      pAuxDb->nSession++;
      pSession->zName = sqlite3_mprintf("%s", zName);
      shell_check_oom(pSession->zName);
    }else
    /* If no command name matches, show a syntax error */
    session_syntax_error:
    showHelp(p->out, "session");
  }else
#endif
 
#ifdef SQLITE_DEBUG
  /* Undocumented commands for internal testing.  Subject to change
  ** without notice. */
  if( c=='s' && n>=10 && cli_strncmp(azArg[0], "selftest-", 9)==0 ){
    if( cli_strncmp(azArg[0]+9, "boolean", n-9)==0 ){
      int i, v;
      for(i=1; i<nArg; i++){
        v = booleanValue(azArg[i]);
        sqlite3_fprintf(p->out, "%s: %d 0x%x\n", azArg[i], v, v);
      }
    }
    if( cli_strncmp(azArg[0]+9, "integer", n-9)==0 ){
      int i; sqlite3_int64 v;
      for(i=1; i<nArg; i++){
        char zBuf[200];
        v = integerValue(azArg[i]);
        sqlite3_snprintf(sizeof(zBuf),zBuf,"%s: %lld 0x%llx\n", azArg[i],v,v);
        sqlite3_fputs(zBuf, p->out);
      }
    }
  }else
#endif
 
  if( c=='s' && n>=4 && cli_strncmp(azArg[0],"selftest",n)==0 ){
    int bIsInit = 0;         /* True to initialize the SELFTEST table */
    int bVerbose = 0;        /* Verbose output */
    int bSelftestExists;     /* True if SELFTEST already exists */
    int i, k;                /* Loop counters */
    int nTest = 0;           /* Number of tests runs */
    int nErr = 0;            /* Number of errors seen */
    ShellText str;           /* Answer for a query */
    sqlite3_stmt *pStmt = 0; /* Query against the SELFTEST table */
 
    open_db(p,0);
    for(i=1; i<nArg; i++){
      const char *z = azArg[i];
      if( z[0]=='-' && z[1]=='-' ) z++;
      if( cli_strcmp(z,"-init")==0 ){
        bIsInit = 1;
      }else
      if( cli_strcmp(z,"-v")==0 ){
        bVerbose++;
      }else
      {
        sqlite3_fprintf(stderr,
              "Unknown option \"%s\" on \"%s\"\n", azArg[i], azArg[0]);
        sqlite3_fputs("Should be one of: --init -v\n", stderr);
        rc = 1;
        goto meta_command_exit;
      }
    }
    if( sqlite3_table_column_metadata(p->db,"main","selftest",0,0,0,0,0,0)
           != SQLITE_OK ){
      bSelftestExists = 0;
    }else{
      bSelftestExists = 1;
    }
    if( bIsInit ){
      createSelftestTable(p);
      bSelftestExists = 1;
    }
    initText(&str);
    appendText(&str, "x", 0);
    for(k=bSelftestExists; k>=0; k--){
      if( k==1 ){
        rc = sqlite3_prepare_v2(p->db,
            "SELECT tno,op,cmd,ans FROM selftest ORDER BY tno",
            -1, &pStmt, 0);
      }else{
        rc = sqlite3_prepare_v2(p->db,
          "VALUES(0,'memo','Missing SELFTEST table - default checks only',''),"
          "      (1,'run','PRAGMA integrity_check','ok')",
          -1, &pStmt, 0);
      }
      if( rc ){
        eputz("Error querying the selftest table\n");
        rc = 1;
        sqlite3_finalize(pStmt);
        goto meta_command_exit;
      }
      for(i=1; sqlite3_step(pStmt)==SQLITE_ROW; i++){
        int tno = sqlite3_column_int(pStmt, 0);
        const char *zOp = (const char*)sqlite3_column_text(pStmt, 1);
        const char *zSql = (const char*)sqlite3_column_text(pStmt, 2);
        const char *zAns = (const char*)sqlite3_column_text(pStmt, 3);
 
        if( zOp==0 ) continue;
        if( zSql==0 ) continue;
        if( zAns==0 ) continue;
        k = 0;
        if( bVerbose>0 ){
          sqlite3_fprintf(stdout, "%d: %s %s\n", tno, zOp, zSql);
        }
        if( cli_strcmp(zOp,"memo")==0 ){
          sqlite3_fprintf(p->out, "%s\n", zSql);
        }else
        if( cli_strcmp(zOp,"run")==0 ){
          char *zErrMsg = 0;
          str.n = 0;
          str.z[0] = 0;
          rc = sqlite3_exec(p->db, zSql, captureOutputCallback, &str, &zErrMsg);
          nTest++;
          if( bVerbose ){
            sqlite3_fprintf(p->out, "Result: %s\n", str.z);
          }
          if( rc || zErrMsg ){
            nErr++;
            rc = 1;
            sqlite3_fprintf(p->out, "%d: error-code-%d: %s\n", tno, rc,zErrMsg);
            sqlite3_free(zErrMsg);
          }else if( cli_strcmp(zAns,str.z)!=0 ){
            nErr++;
            rc = 1;
            sqlite3_fprintf(p->out, "%d: Expected: [%s]\n", tno, zAns);
            sqlite3_fprintf(p->out, "%d:      Got: [%s]\n", tno, str.z);
          }
        }
        else{
          sqlite3_fprintf(stderr,
                "Unknown operation \"%s\" on selftest line %d\n", zOp, tno);
          rc = 1;
          break;
        }
      } /* End loop over rows of content from SELFTEST */
      sqlite3_finalize(pStmt);
    } /* End loop over k */
    freeText(&str);
    sqlite3_fprintf(p->out, "%d errors out of %d tests\n", nErr, nTest);
  }else
 
  if( c=='s' && cli_strncmp(azArg[0], "separator", n)==0 ){
    if( nArg<2 || nArg>3 ){
      eputz("Usage: .separator COL ?ROW?\n");
      rc = 1;
    }
    if( nArg>=2 ){
      sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator,
                       "%.*s", (int)ArraySize(p->colSeparator)-1, azArg[1]);
    }
    if( nArg>=3 ){
      sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator,
                       "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]);
    }
  }else
 
  if( c=='s' && n>=4 && cli_strncmp(azArg[0],"sha3sum",n)==0 ){
    const char *zLike = 0;   /* Which table to checksum. 0 means everything */
    int i;                   /* Loop counter */
    int bSchema = 0;         /* Also hash the schema */
    int bSeparate = 0;       /* Hash each table separately */
    int iSize = 224;         /* Hash algorithm to use */
    int bDebug = 0;          /* Only show the query that would have run */
    sqlite3_stmt *pStmt;     /* For querying tables names */
    char *zSql;              /* SQL to be run */
    char *zSep;              /* Separator */
    ShellText sSql;          /* Complete SQL for the query to run the hash */
    ShellText sQuery;        /* Set of queries used to read all content */
    open_db(p, 0);
    for(i=1; i<nArg; i++){
      const char *z = azArg[i];
      if( z[0]=='-' ){
        z++;
        if( z[0]=='-' ) z++;
        if( cli_strcmp(z,"schema")==0 ){
          bSchema = 1;
        }else
        if( cli_strcmp(z,"sha3-224")==0 || cli_strcmp(z,"sha3-256")==0
         || cli_strcmp(z,"sha3-384")==0 || cli_strcmp(z,"sha3-512")==0
        ){
          iSize = atoi(&z[5]);
        }else
        if( cli_strcmp(z,"debug")==0 ){
          bDebug = 1;
        }else
        {
          sqlite3_fprintf(stderr,
                  "Unknown option \"%s\" on \"%s\"\n", azArg[i], azArg[0]);
          showHelp(p->out, azArg[0]);
          rc = 1;
          goto meta_command_exit;
        }
      }else if( zLike ){
        eputz("Usage: .sha3sum ?OPTIONS? ?LIKE-PATTERN?\n");
        rc = 1;
        goto meta_command_exit;
      }else{
        zLike = z;
        bSeparate = 1;
        if( sqlite3_strlike("sqlite\\_%", zLike, '\\')==0 ) bSchema = 1;
      }
    }
    if( bSchema ){
      zSql = "SELECT lower(name) as tname FROM sqlite_schema"
             " WHERE type='table' AND coalesce(rootpage,0)>1"
             " UNION ALL SELECT 'sqlite_schema'"
             " ORDER BY 1 collate nocase";
    }else{
      zSql = "SELECT lower(name) as tname FROM sqlite_schema"
             " WHERE type='table' AND coalesce(rootpage,0)>1"
             " AND name NOT LIKE 'sqlite_%'"
             " ORDER BY 1 collate nocase";
    }
    sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
    initText(&sQuery);
    initText(&sSql);
    appendText(&sSql, "WITH [sha3sum$query](a,b) AS(",0);
    zSep = "VALUES(";
    while( SQLITE_ROW==sqlite3_step(pStmt) ){
      const char *zTab = (const char*)sqlite3_column_text(pStmt,0);
      if( zTab==0 ) continue;
      if( zLike && sqlite3_strlike(zLike, zTab, 0)!=0 ) continue;
      if( cli_strncmp(zTab, "sqlite_",7)!=0 ){
        appendText(&sQuery,"SELECT * FROM ", 0);
        appendText(&sQuery,zTab,'"');
        appendText(&sQuery," NOT INDEXED;", 0);
      }else if( cli_strcmp(zTab, "sqlite_schema")==0 ){
        appendText(&sQuery,"SELECT type,name,tbl_name,sql FROM sqlite_schema"
                           " ORDER BY name;", 0);
      }else if( cli_strcmp(zTab, "sqlite_sequence")==0 ){
        appendText(&sQuery,"SELECT name,seq FROM sqlite_sequence"
                           " ORDER BY name;", 0);
      }else if( cli_strcmp(zTab, "sqlite_stat1")==0 ){
        appendText(&sQuery,"SELECT tbl,idx,stat FROM sqlite_stat1"
                           " ORDER BY tbl,idx;", 0);
      }else if( cli_strcmp(zTab, "sqlite_stat4")==0 ){
        appendText(&sQuery, "SELECT * FROM ", 0);
        appendText(&sQuery, zTab, 0);
        appendText(&sQuery, " ORDER BY tbl, idx, rowid;\n", 0);
      }
      appendText(&sSql, zSep, 0);
      appendText(&sSql, sQuery.z, '\'');
      sQuery.n = 0;
      appendText(&sSql, ",", 0);
      appendText(&sSql, zTab, '\'');
      zSep = "),(";
    }
    sqlite3_finalize(pStmt);
    if( bSeparate ){
      zSql = sqlite3_mprintf(
          "%s))"
          " SELECT lower(hex(sha3_query(a,%d))) AS hash, b AS label"
          "   FROM [sha3sum$query]",
          sSql.z, iSize);
    }else{
      zSql = sqlite3_mprintf(
          "%s))"
          " SELECT lower(hex(sha3_query(group_concat(a,''),%d))) AS hash"
          "   FROM [sha3sum$query]",
          sSql.z, iSize);
    }
    shell_check_oom(zSql);
    freeText(&sQuery);
    freeText(&sSql);
    if( bDebug ){
      sqlite3_fprintf(p->out, "%s\n", zSql);
    }else{
      shell_exec(p, zSql, 0);
    }
#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) && !defined(SQLITE_OMIT_VIRTUALTABLE)
    {
      int lrc;
      char *zRevText = /* Query for reversible to-blob-to-text check */
        "SELECT lower(name) as tname FROM sqlite_schema\n"
        "WHERE type='table' AND coalesce(rootpage,0)>1\n"
        "AND name NOT LIKE 'sqlite_%%'%s\n"
        "ORDER BY 1 collate nocase";
      zRevText = sqlite3_mprintf(zRevText, zLike? " AND name LIKE $tspec" : "");
      zRevText = sqlite3_mprintf(
          /* lower-case query is first run, producing upper-case query. */
          "with tabcols as materialized(\n"
          "select tname, cname\n"
          "from ("
          " select printf('\"%%w\"',ss.tname) as tname,"
          " printf('\"%%w\"',ti.name) as cname\n"
          " from (%z) ss\n inner join pragma_table_info(tname) ti))\n"
          "select 'SELECT total(bad_text_count) AS bad_text_count\n"
          "FROM ('||group_concat(query, ' UNION ALL ')||')' as btc_query\n"
          " from (select 'SELECT COUNT(*) AS bad_text_count\n"
          "FROM '||tname||' WHERE '\n"
          "||group_concat('CAST(CAST('||cname||' AS BLOB) AS TEXT)<>'||cname\n"
          "|| ' AND typeof('||cname||')=''text'' ',\n"
          "' OR ') as query, tname from tabcols group by tname)"
          , zRevText);
      shell_check_oom(zRevText);
      if( bDebug ) sqlite3_fprintf(p->out, "%s\n", zRevText);
      lrc = sqlite3_prepare_v2(p->db, zRevText, -1, &pStmt, 0);
      if( lrc!=SQLITE_OK ){
        /* assert(lrc==SQLITE_NOMEM); // might also be SQLITE_ERROR if the
        ** user does cruel and unnatural things like ".limit expr_depth 0". */
        rc = 1;
      }else{
        if( zLike ) sqlite3_bind_text(pStmt,1,zLike,-1,SQLITE_STATIC);
        lrc = SQLITE_ROW==sqlite3_step(pStmt);
        if( lrc ){
          const char *zGenQuery = (char*)sqlite3_column_text(pStmt,0);
          sqlite3_stmt *pCheckStmt;
          lrc = sqlite3_prepare_v2(p->db, zGenQuery, -1, &pCheckStmt, 0);
          if( bDebug ) sqlite3_fprintf(p->out, "%s\n", zGenQuery);
          if( lrc!=SQLITE_OK ){
            rc = 1;
          }else{
            if( SQLITE_ROW==sqlite3_step(pCheckStmt) ){
              double countIrreversible = sqlite3_column_double(pCheckStmt, 0);
              if( countIrreversible>0 ){
                int sz = (int)(countIrreversible + 0.5);
                sqlite3_fprintf(stderr,
                      "Digest includes %d invalidly encoded text field%s.\n",
                      sz, (sz>1)? "s": "");
              }
            }
            sqlite3_finalize(pCheckStmt);
          }
          sqlite3_finalize(pStmt);
        }
      }
      if( rc ) eputz(".sha3sum failed.\n");
      sqlite3_free(zRevText);
    }
#endif /* !defined(*_OMIT_SCHEMA_PRAGMAS) && !defined(*_OMIT_VIRTUALTABLE) */
    sqlite3_free(zSql);
  }else
 
#if !defined(SQLITE_NOHAVE_SYSTEM) && !defined(SQLITE_SHELL_FIDDLE)
  if( c=='s'
   && (cli_strncmp(azArg[0], "shell", n)==0
       || cli_strncmp(azArg[0],"system",n)==0)
  ){
    char *zCmd;
    int i, x;
    failIfSafeMode(p, "cannot run .%s in safe mode", azArg[0]);
    if( nArg<2 ){
      eputz("Usage: .system COMMAND\n");
      rc = 1;
      goto meta_command_exit;
    }
    zCmd = sqlite3_mprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]);
    for(i=2; i<nArg && zCmd!=0; i++){
      zCmd = sqlite3_mprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"",
                             zCmd, azArg[i]);
    }
    /*consoleRestore();*/
    x = zCmd!=0 ? system(zCmd) : 1;
    /*consoleRenewSetup();*/
    sqlite3_free(zCmd);
    if( x ) sqlite3_fprintf(stderr,"System command returns %d\n", x);
  }else
#endif /* !defined(SQLITE_NOHAVE_SYSTEM) && !defined(SQLITE_SHELL_FIDDLE) */
 
  if( c=='s' && cli_strncmp(azArg[0], "show", n)==0 ){
    static const char *azBool[] = { "off", "on", "trigger", "full"};
    const char *zOut;
    int i;
    if( nArg!=1 ){
      eputz("Usage: .show\n");
      rc = 1;
      goto meta_command_exit;
    }
    sqlite3_fprintf(p->out, "%12.12s: %s\n","echo",
          azBool[ShellHasFlag(p, SHFLG_Echo)]);
    sqlite3_fprintf(p->out, "%12.12s: %s\n","eqp", azBool[p->autoEQP&3]);
    sqlite3_fprintf(p->out, "%12.12s: %s\n","explain",
          p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off");
    sqlite3_fprintf(p->out, "%12.12s: %s\n","headers",
          azBool[p->showHeader!=0]);
    if( p->mode==MODE_Column
     || (p->mode>=MODE_Markdown && p->mode<=MODE_Box)
    ){
      sqlite3_fprintf(p->out,
            "%12.12s: %s --wrap %d --wordwrap %s --%squote\n", "mode",
            modeDescr[p->mode], p->cmOpts.iWrap,
            p->cmOpts.bWordWrap ? "on" : "off",
            p->cmOpts.bQuote ? "" : "no");
    }else{
      sqlite3_fprintf(p->out, "%12.12s: %s\n","mode", modeDescr[p->mode]);
    }
    sqlite3_fprintf(p->out, "%12.12s: ", "nullvalue");
    output_c_string(p->out, p->nullValue);
    sqlite3_fputs("\n", p->out);
    sqlite3_fprintf(p->out, "%12.12s: %s\n","output",
          strlen30(p->outfile) ? p->outfile : "stdout");
    sqlite3_fprintf(p->out, "%12.12s: ", "colseparator");
    output_c_string(p->out, p->colSeparator);
    sqlite3_fputs("\n", p->out);
    sqlite3_fprintf(p->out, "%12.12s: ", "rowseparator");
    output_c_string(p->out, p->rowSeparator);
    sqlite3_fputs("\n", p->out);
    switch( p->statsOn ){
      case 0:  zOut = "off";     break;
      default: zOut = "on";      break;
      case 2:  zOut = "stmt";    break;
      case 3:  zOut = "vmstep";  break;
    }
    sqlite3_fprintf(p->out, "%12.12s: %s\n","stats", zOut);
    sqlite3_fprintf(p->out, "%12.12s: ", "width");
    for (i=0;i<p->nWidth;i++) {
      sqlite3_fprintf(p->out, "%d ", p->colWidth[i]);
    }
    sqlite3_fputs("\n", p->out);
    sqlite3_fprintf(p->out, "%12.12s: %s\n", "filename",
          p->pAuxDb->zDbFilename ? p->pAuxDb->zDbFilename : "");
  }else
 
  if( c=='s' && cli_strncmp(azArg[0], "stats", n)==0 ){
    if( nArg==2 ){
      if( cli_strcmp(azArg[1],"stmt")==0 ){
        p->statsOn = 2;
      }else if( cli_strcmp(azArg[1],"vmstep")==0 ){
        p->statsOn = 3;
      }else{
        p->statsOn = (u8)booleanValue(azArg[1]);
      }
    }else if( nArg==1 ){
      display_stats(p->db, p, 0);
    }else{
      eputz("Usage: .stats ?on|off|stmt|vmstep?\n");
      rc = 1;
    }
  }else
 
  if( (c=='t' && n>1 && cli_strncmp(azArg[0], "tables", n)==0)
   || (c=='i' && (cli_strncmp(azArg[0], "indices", n)==0
                 || cli_strncmp(azArg[0], "indexes", n)==0) )
  ){
    sqlite3_stmt *pStmt;
    char **azResult;
    int nRow, nAlloc;
    int ii;
    ShellText s;
    initText(&s);
    open_db(p, 0);
    rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
    if( rc ){
      sqlite3_finalize(pStmt);
      return shellDatabaseError(p->db);
    }
 
    if( nArg>2 && c=='i' ){
      /* It is an historical accident that the .indexes command shows an error
      ** when called with the wrong number of arguments whereas the .tables
      ** command does not. */
      eputz("Usage: .indexes ?LIKE-PATTERN?\n");
      rc = 1;
      sqlite3_finalize(pStmt);
      goto meta_command_exit;
    }
    for(ii=0; sqlite3_step(pStmt)==SQLITE_ROW; ii++){
      const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1);
      if( zDbName==0 ) continue;
      if( s.z && s.z[0] ) appendText(&s, " UNION ALL ", 0);
      if( sqlite3_stricmp(zDbName, "main")==0 ){
        appendText(&s, "SELECT name FROM ", 0);
      }else{
        appendText(&s, "SELECT ", 0);
        appendText(&s, zDbName, '\'');
        appendText(&s, "||'.'||name FROM ", 0);
      }
      appendText(&s, zDbName, '"');
      appendText(&s, ".sqlite_schema ", 0);
      if( c=='t' ){
        appendText(&s," WHERE type IN ('table','view')"
                      "   AND name NOT LIKE 'sqlite_%'"
                      "   AND name LIKE ?1", 0);
      }else{
        appendText(&s," WHERE type='index'"
                      "   AND tbl_name LIKE ?1", 0);
      }
    }
    rc = sqlite3_finalize(pStmt);
    if( rc==SQLITE_OK ){
      appendText(&s, " ORDER BY 1", 0);
      rc = sqlite3_prepare_v2(p->db, s.z, -1, &pStmt, 0);
    }
    freeText(&s);
    if( rc ) return shellDatabaseError(p->db);
 
    /* Run the SQL statement prepared by the above block. Store the results
    ** as an array of nul-terminated strings in azResult[].  */
    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 n2 = nAlloc*2 + 10;
        azNew = sqlite3_realloc64(azResult, sizeof(azResult[0])*n2);
        shell_check_oom(azNew);
        nAlloc = n2;
        azResult = azNew;
      }
      azResult[nRow] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0));
      shell_check_oom(azResult[nRow]);
      nRow++;
    }
    if( sqlite3_finalize(pStmt)!=SQLITE_OK ){
      rc = shellDatabaseError(p->db);
    }
 
    /* Pretty-print the contents of array azResult[] to the output */
    if( rc==0 && 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 ? "" : "  ";
          sqlite3_fprintf(p->out,
               "%s%-*s", zSp, maxlen, azResult[j] ? azResult[j]:"");
        }
        sqlite3_fputs("\n", p->out);
      }
    }
 
    for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]);
    sqlite3_free(azResult);
  }else
 
#ifndef SQLITE_SHELL_FIDDLE
  /* Begin redirecting output to the file "testcase-out.txt" */
  if( c=='t' && cli_strcmp(azArg[0],"testcase")==0 ){
    output_reset(p);
    p->out = output_file_open("testcase-out.txt");
    if( p->out==0 ){
      eputz("Error: cannot open 'testcase-out.txt'\n");
    }
    if( nArg>=2 ){
      sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "%s", azArg[1]);
    }else{
      sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "?");
    }
  }else
#endif /* !defined(SQLITE_SHELL_FIDDLE) */
 
#ifndef SQLITE_UNTESTABLE
  if( c=='t' && n>=8 && cli_strncmp(azArg[0], "testctrl", n)==0 ){
    static const struct {
       const char *zCtrlName;   /* Name of a test-control option */
       int ctrlCode;            /* Integer code for that option */
       int unSafe;              /* Not valid unless --unsafe-testing */
       const char *zUsage;      /* Usage notes */
    } aCtrl[] = {
    {"always",             SQLITE_TESTCTRL_ALWAYS, 1,     "BOOLEAN"         },
    {"assert",             SQLITE_TESTCTRL_ASSERT, 1,     "BOOLEAN"         },
  /*{"benign_malloc_hooks",SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS,1, ""        },*/
  /*{"bitvec_test",        SQLITE_TESTCTRL_BITVEC_TEST, 1,  ""              },*/
    {"byteorder",          SQLITE_TESTCTRL_BYTEORDER, 0,  ""                },
    {"extra_schema_checks",SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS,0,"BOOLEAN"  },
    {"fault_install",      SQLITE_TESTCTRL_FAULT_INSTALL, 1,"args..."       },
    {"fk_no_action",       SQLITE_TESTCTRL_FK_NO_ACTION, 0, "BOOLEAN"       },
    {"imposter",         SQLITE_TESTCTRL_IMPOSTER,1,"SCHEMA ON/OFF ROOTPAGE"},
    {"internal_functions", SQLITE_TESTCTRL_INTERNAL_FUNCTIONS,0,""          },
    {"json_selfcheck",     SQLITE_TESTCTRL_JSON_SELFCHECK ,0,"BOOLEAN"      },
    {"localtime_fault",    SQLITE_TESTCTRL_LOCALTIME_FAULT,0,"BOOLEAN"      },
    {"never_corrupt",      SQLITE_TESTCTRL_NEVER_CORRUPT,1, "BOOLEAN"       },
    {"optimizations",      SQLITE_TESTCTRL_OPTIMIZATIONS,0,"DISABLE-MASK ..."},
#ifdef YYCOVERAGE
    {"parser_coverage",    SQLITE_TESTCTRL_PARSER_COVERAGE,0,""             },
#endif
    {"pending_byte",       SQLITE_TESTCTRL_PENDING_BYTE,1, "OFFSET  "       },
    {"prng_restore",       SQLITE_TESTCTRL_PRNG_RESTORE,0, ""               },
    {"prng_save",          SQLITE_TESTCTRL_PRNG_SAVE,   0, ""               },
    {"prng_seed",          SQLITE_TESTCTRL_PRNG_SEED,   0, "SEED ?db?"      },
    {"seek_count",         SQLITE_TESTCTRL_SEEK_COUNT,  0, ""               },
    {"sorter_mmap",        SQLITE_TESTCTRL_SORTER_MMAP, 0, "NMAX"           },
    {"tune",               SQLITE_TESTCTRL_TUNE,        1, "ID VALUE"       },
    };
    int testctrl = -1;
    int iCtrl = -1;
    int rc2 = 0;    /* 0: usage.  1: %d  2: %x  3: no-output */
    int isOk = 0;
    int i, n2;
    const char *zCmd = 0;
 
    open_db(p, 0);
    zCmd = nArg>=2 ? azArg[1] : "help";
 
    /* The argument can optionally begin with "-" or "--" */
    if( zCmd[0]=='-' && zCmd[1] ){
      zCmd++;
      if( zCmd[0]=='-' && zCmd[1] ) zCmd++;
    }
 
    /* --help lists all test-controls */
    if( cli_strcmp(zCmd,"help")==0 ){
      sqlite3_fputs("Available test-controls:\n", p->out);
      for(i=0; i<ArraySize(aCtrl); i++){
        if( aCtrl[i].unSafe && !ShellHasFlag(p,SHFLG_TestingMode) ) continue;
        sqlite3_fprintf(p->out, "  .testctrl %s %s\n",
              aCtrl[i].zCtrlName, aCtrl[i].zUsage);
      }
      rc = 1;
      goto meta_command_exit;
    }
 
    /* convert testctrl text option to value. allow any unique prefix
    ** of the option name, or a numerical value. */
    n2 = strlen30(zCmd);
    for(i=0; i<ArraySize(aCtrl); i++){
      if( aCtrl[i].unSafe && !ShellHasFlag(p,SHFLG_TestingMode) ) continue;
      if( cli_strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){
        if( testctrl<0 ){
          testctrl = aCtrl[i].ctrlCode;
          iCtrl = i;
        }else{
          sqlite3_fprintf(stderr,"Error: ambiguous test-control: \"%s\"\n"
                "Use \".testctrl --help\" for help\n", zCmd);
          rc = 1;
          goto meta_command_exit;
        }
      }
    }
    if( testctrl<0 ){
      sqlite3_fprintf(stderr,"Error: unknown test-control: %s\n"
            "Use \".testctrl --help\" for help\n", zCmd);
    }else{
      switch(testctrl){
 
        /* Special processing for .testctrl opt MASK ...
        ** Each MASK argument can be one of:
        **
        **      +LABEL       Enable the named optimization 
        **
        **      -LABEL       Disable the named optimization
        **
        **      INTEGER      Mask of optimizations to disable
        */
        case SQLITE_TESTCTRL_OPTIMIZATIONS: {
          static const struct {
             unsigned int mask;    /* Mask for this optimization */
             unsigned int bDsply;  /* Display this on output */
             const char *zLabel;   /* Name of optimization */
          } aLabel[] = {
            { 0x00000001, 1, "QueryFlattener" },
            { 0x00000001, 0, "Flatten" },
            { 0x00000002, 1, "WindowFunc" },
            { 0x00000004, 1, "GroupByOrder" },
            { 0x00000008, 1, "FactorOutConst" },
            { 0x00000010, 1, "DistinctOpt" },
            { 0x00000020, 1, "CoverIdxScan" },
            { 0x00000040, 1, "OrderByIdxJoin" },
            { 0x00000080, 1, "Transitive" },
            { 0x00000100, 1, "OmitNoopJoin" },
            { 0x00000200, 1, "CountOfView" },
            { 0x00000400, 1, "CurosrHints" },
            { 0x00000800, 1, "Stat4" },
            { 0x00001000, 1, "PushDown" },
            { 0x00002000, 1, "SimplifyJoin" },
            { 0x00004000, 1, "SkipScan" },
            { 0x00008000, 1, "PropagateConst" },
            { 0x00010000, 1, "MinMaxOpt" },
            { 0x00020000, 1, "SeekScan" },
            { 0x00040000, 1, "OmitOrderBy" },
            { 0x00080000, 1, "BloomFilter" },
            { 0x00100000, 1, "BloomPulldown" },
            { 0x00200000, 1, "BalancedMerge" },
            { 0x00400000, 1, "ReleaseReg" },
            { 0x00800000, 1, "FlttnUnionAll" },
            { 0x01000000, 1, "IndexedEXpr" },
            { 0x02000000, 1, "Coroutines" },
            { 0x04000000, 1, "NullUnusedCols" },
            { 0x08000000, 1, "OnePass" },
            { 0x10000000, 1, "OrderBySubq" },
            { 0x20000000, 1, "StarQuery" },
            { 0xffffffff, 0, "All" },
          };
          unsigned int curOpt;
          unsigned int newOpt;
          unsigned int m;
          int ii;
          int nOff;
          sqlite3_test_control(SQLITE_TESTCTRL_GETOPT, p->db, &curOpt);
          newOpt = curOpt;
          for(ii=2; ii<nArg; ii++){
            const char *z = azArg[ii];
            int useLabel = 0;
            const char *zLabel = 0;
            if( (z[0]=='+'|| z[0]=='-') && !IsDigit(z[1]) ){
              useLabel = z[0];
              zLabel = &z[1];
            }else if( !IsDigit(z[0]) && z[0]!=0 && !IsDigit(z[1]) ){
              useLabel = '+';
              zLabel = z;
            }else{
              newOpt = (unsigned int)strtol(z,0,0);
            }
            if( useLabel ){
              int jj;
              for(jj=0; jj<ArraySize(aLabel); jj++){
                if( sqlite3_stricmp(zLabel, aLabel[jj].zLabel)==0 ) break;
              }
              if( jj>=ArraySize(aLabel) ){
                sqlite3_fprintf(stderr,
                    "Error: no such optimization: \"%s\"\n", zLabel);
                sqlite3_fputs("Should be one of:", stderr);
                for(jj=0; jj<ArraySize(aLabel); jj++){
                  sqlite3_fprintf(stderr," %s", aLabel[jj].zLabel);
                }
                sqlite3_fputs("\n", stderr);
                rc = 1;
                goto meta_command_exit;
              }
              if( useLabel=='+' ){
                newOpt &= ~aLabel[jj].mask;
              }else{
                newOpt |= aLabel[jj].mask;
              }
            }
          }
          if( curOpt!=newOpt ){
            sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS,p->db,newOpt);
          }
          for(ii=nOff=0, m=1; ii<32; ii++, m <<= 1){
            if( m & newOpt ) nOff++;
          }
          if( nOff<12 ){
            sqlite3_fputs("+All", p->out);
            for(ii=0; ii<ArraySize(aLabel); ii++){
              if( !aLabel[ii].bDsply  ) continue;
              if( (newOpt & aLabel[ii].mask)!=0 ){
                sqlite3_fprintf(p->out, " -%s", aLabel[ii].zLabel);
              }
            }
          }else{
            sqlite3_fputs("-All", p->out);
            for(ii=0; ii<ArraySize(aLabel); ii++){
              if( !aLabel[ii].bDsply  ) continue;
              if( (newOpt & aLabel[ii].mask)==0 ){
                sqlite3_fprintf(p->out, " +%s", aLabel[ii].zLabel);
              }
            }
          }
          sqlite3_fputs("\n", p->out);
          rc2 = isOk = 3;
          break;
        }
 
        /* sqlite3_test_control(int, db, int) */
        case SQLITE_TESTCTRL_FK_NO_ACTION:
          if( nArg==3 ){
            unsigned int opt = (unsigned int)strtol(azArg[2], 0, 0);
            rc2 = sqlite3_test_control(testctrl, p->db, opt);
            isOk = 3;
          }
          break;
 
        /* sqlite3_test_control(int) */
        case SQLITE_TESTCTRL_PRNG_SAVE:
        case SQLITE_TESTCTRL_PRNG_RESTORE:
        case SQLITE_TESTCTRL_BYTEORDER:
          if( nArg==2 ){
            rc2 = sqlite3_test_control(testctrl);
            isOk = testctrl==SQLITE_TESTCTRL_BYTEORDER ? 1 : 3;
          }
          break;
 
        /* sqlite3_test_control(int, uint) */
        case SQLITE_TESTCTRL_PENDING_BYTE:
          if( nArg==3 ){
            unsigned int opt = (unsigned int)integerValue(azArg[2]);
            rc2 = sqlite3_test_control(testctrl, opt);
            isOk = 3;
          }
          break;
 
        /* sqlite3_test_control(int, int, sqlite3*) */
        case SQLITE_TESTCTRL_PRNG_SEED:
          if( nArg==3 || nArg==4 ){
            int ii = (int)integerValue(azArg[2]);
            sqlite3 *db;
            if( ii==0 && cli_strcmp(azArg[2],"random")==0 ){
              sqlite3_randomness(sizeof(ii),&ii);
              sqlite3_fprintf(stdout, "-- random seed: %d\n", ii);
            }
            if( nArg==3 ){
              db = 0;
            }else{
              db = p->db;
              /* Make sure the schema has been loaded */
              sqlite3_table_column_metadata(db, 0, "x", 0, 0, 0, 0, 0, 0);
            }
            rc2 = sqlite3_test_control(testctrl, ii, db);
            isOk = 3;
          }
          break;
 
        /* sqlite3_test_control(int, int) */
        case SQLITE_TESTCTRL_ASSERT:
        case SQLITE_TESTCTRL_ALWAYS:
          if( nArg==3 ){
            int opt = booleanValue(azArg[2]);
            rc2 = sqlite3_test_control(testctrl, opt);
            isOk = 1;
          }
          break;
 
        /* sqlite3_test_control(int, int) */
        case SQLITE_TESTCTRL_LOCALTIME_FAULT:
        case SQLITE_TESTCTRL_NEVER_CORRUPT:
          if( nArg==3 ){
            int opt = booleanValue(azArg[2]);
            rc2 = sqlite3_test_control(testctrl, opt);
            isOk = 3;
          }
          break;
 
        /* sqlite3_test_control(sqlite3*) */
        case SQLITE_TESTCTRL_INTERNAL_FUNCTIONS:
          rc2 = sqlite3_test_control(testctrl, p->db);
          isOk = 3;
          break;
 
        case SQLITE_TESTCTRL_IMPOSTER:
          if( nArg==5 ){
            rc2 = sqlite3_test_control(testctrl, p->db,
                          azArg[2],
                          integerValue(azArg[3]),
                          integerValue(azArg[4]));
            isOk = 3;
          }
          break;
 
        case SQLITE_TESTCTRL_SEEK_COUNT: {
          u64 x = 0;
          rc2 = sqlite3_test_control(testctrl, p->db, &x);
          sqlite3_fprintf(p->out, "%llu\n", x);
          isOk = 3;
          break;
        }
 
#ifdef YYCOVERAGE
        case SQLITE_TESTCTRL_PARSER_COVERAGE: {
          if( nArg==2 ){
            sqlite3_test_control(testctrl, p->out);
            isOk = 3;
          }
          break;
        }
#endif
#ifdef SQLITE_DEBUG
        case SQLITE_TESTCTRL_TUNE: {
          if( nArg==4 ){
            int id = (int)integerValue(azArg[2]);
            int val = (int)integerValue(azArg[3]);
            sqlite3_test_control(testctrl, id, &val);
            isOk = 3;
          }else if( nArg==3 ){
            int id = (int)integerValue(azArg[2]);
            sqlite3_test_control(testctrl, -id, &rc2);
            isOk = 1;
          }else if( nArg==2 ){
            int id = 1;
            while(1){
              int val = 0;
              rc2 = sqlite3_test_control(testctrl, -id, &val);
              if( rc2!=SQLITE_OK ) break;
              if( id>1 ) sqlite3_fputs("  ", p->out);
              sqlite3_fprintf(p->out, "%d: %d", id, val);
              id++;
            }
            if( id>1 ) sqlite3_fputs("\n", p->out);
            isOk = 3;
          }
          break;
        }
#endif
        case SQLITE_TESTCTRL_SORTER_MMAP:
          if( nArg==3 ){
            int opt = (unsigned int)integerValue(azArg[2]);
            rc2 = sqlite3_test_control(testctrl, p->db, opt);
            isOk = 3;
          }
          break;
        case SQLITE_TESTCTRL_JSON_SELFCHECK:
          if( nArg==2 ){
            rc2 = -1;
            isOk = 1;
          }else{
            rc2 = booleanValue(azArg[2]);
            isOk = 3;
          }
          sqlite3_test_control(testctrl, &rc2);
          break;
        case SQLITE_TESTCTRL_FAULT_INSTALL: {
          int kk;
          int bShowHelp = nArg<=2;
          isOk = 3;
          for(kk=2; kk<nArg; kk++){
            const char *z = azArg[kk];
            if( z[0]=='-' && z[1]=='-' ) z++;
            if( cli_strcmp(z,"off")==0 ){
              sqlite3_test_control(testctrl, 0);
            }else if( cli_strcmp(z,"on")==0 ){
              faultsim_state.iCnt = faultsim_state.nSkip;
              if( faultsim_state.iErr==0 ) faultsim_state.iErr = 1;
              faultsim_state.nHit = 0;
              sqlite3_test_control(testctrl, faultsim_callback);
            }else if( cli_strcmp(z,"reset")==0 ){
              faultsim_state.iCnt = faultsim_state.nSkip;
              faultsim_state.nHit = 0;
              sqlite3_test_control(testctrl, faultsim_callback);
            }else if( cli_strcmp(z,"status")==0 ){
              sqlite3_fprintf(p->out, "faultsim.iId:       %d\n",
                              faultsim_state.iId);
              sqlite3_fprintf(p->out, "faultsim.iErr:      %d\n",
                              faultsim_state.iErr);
              sqlite3_fprintf(p->out, "faultsim.iCnt:      %d\n",
                              faultsim_state.iCnt);
              sqlite3_fprintf(p->out, "faultsim.nHit:      %d\n",
                              faultsim_state.nHit);
              sqlite3_fprintf(p->out, "faultsim.iInterval: %d\n",
                              faultsim_state.iInterval);
              sqlite3_fprintf(p->out, "faultsim.eVerbose:  %d\n",
                              faultsim_state.eVerbose);
              sqlite3_fprintf(p->out, "faultsim.nRepeat:   %d\n",
                              faultsim_state.nRepeat);
              sqlite3_fprintf(p->out, "faultsim.nSkip:     %d\n",
                              faultsim_state.nSkip);
            }else if( cli_strcmp(z,"-v")==0 ){
              if( faultsim_state.eVerbose<2 ) faultsim_state.eVerbose++;
            }else if( cli_strcmp(z,"-q")==0 ){
              if( faultsim_state.eVerbose>0 ) faultsim_state.eVerbose--;
            }else if( cli_strcmp(z,"-id")==0 && kk+1<nArg ){
              faultsim_state.iId = atoi(azArg[++kk]);
            }else if( cli_strcmp(z,"-errcode")==0 && kk+1<nArg ){
              faultsim_state.iErr = atoi(azArg[++kk]);
            }else if( cli_strcmp(z,"-interval")==0 && kk+1<nArg ){
              faultsim_state.iInterval = atoi(azArg[++kk]);
            }else if( cli_strcmp(z,"-repeat")==0 && kk+1<nArg ){
              faultsim_state.nRepeat = atoi(azArg[++kk]);
           }else if( cli_strcmp(z,"-skip")==0 && kk+1<nArg ){
              faultsim_state.nSkip = atoi(azArg[++kk]);
            }else if( cli_strcmp(z,"-?")==0 || sqlite3_strglob("*help*",z)==0){
              bShowHelp = 1;
            }else{
              sqlite3_fprintf(stderr,
                  "Unrecognized fault_install argument: \"%s\"\n",
                  azArg[kk]);
              rc = 1;
              bShowHelp = 1;
              break;
            }
          }
          if( bShowHelp ){
            sqlite3_fputs(
               "Usage: .testctrl fault_install ARGS\n"
               "Possible arguments:\n"
               "   off               Disable faultsim\n"
               "   on                Activate faultsim\n"
               "   reset             Reset the trigger counter\n"
               "   status            Show current status\n"
               "   -v                Increase verbosity\n"
               "   -q                Decrease verbosity\n"
               "   --errcode N       When triggered, return N as error code\n"
               "   --id ID           Trigger only for the ID specified\n"
               "   --interval N      Trigger only after every N-th call\n"
               "   --repeat N        Turn off after N hits.  0 means never\n"
               "   --skip N          Skip the first N encounters\n"
               ,p->out
            );
          }
          break;
        }
      }
    }
    if( isOk==0 && iCtrl>=0 ){
      sqlite3_fprintf(p->out,
          "Usage: .testctrl %s %s\n", zCmd,aCtrl[iCtrl].zUsage);
      rc = 1;
    }else if( isOk==1 ){
      sqlite3_fprintf(p->out, "%d\n", rc2);
    }else if( isOk==2 ){
      sqlite3_fprintf(p->out, "0x%08x\n", rc2);
    }
  }else
#endif /* !defined(SQLITE_UNTESTABLE) */
 
  if( c=='t' && n>4 && cli_strncmp(azArg[0], "timeout", n)==0 ){
    open_db(p, 0);
    sqlite3_busy_timeout(p->db, nArg>=2 ? (int)integerValue(azArg[1]) : 0);
  }else
 
  if( c=='t' && n>=5 && cli_strncmp(azArg[0], "timer", n)==0 ){
    if( nArg==2 ){
      enableTimer = booleanValue(azArg[1]);
      if( enableTimer && !HAS_TIMER ){
        eputz("Error: timer not available on this system.\n");
        enableTimer = 0;
      }
    }else{
      eputz("Usage: .timer on|off\n");
      rc = 1;
    }
  }else
 
#ifndef SQLITE_OMIT_TRACE
  if( c=='t' && cli_strncmp(azArg[0], "trace", n)==0 ){
    int mType = 0;
    int jj;
    open_db(p, 0);
    for(jj=1; jj<nArg; jj++){
      const char *z = azArg[jj];
      if( z[0]=='-' ){
        if( optionMatch(z, "expanded") ){
          p->eTraceType = SHELL_TRACE_EXPANDED;
        }
#ifdef SQLITE_ENABLE_NORMALIZE
        else if( optionMatch(z, "normalized") ){
          p->eTraceType = SHELL_TRACE_NORMALIZED;
        }
#endif
        else if( optionMatch(z, "plain") ){
          p->eTraceType = SHELL_TRACE_PLAIN;
        }
        else if( optionMatch(z, "profile") ){
          mType |= SQLITE_TRACE_PROFILE;
        }
        else if( optionMatch(z, "row") ){
          mType |= SQLITE_TRACE_ROW;
        }
        else if( optionMatch(z, "stmt") ){
          mType |= SQLITE_TRACE_STMT;
        }
        else if( optionMatch(z, "close") ){
          mType |= SQLITE_TRACE_CLOSE;
        }
        else {
          sqlite3_fprintf(stderr,"Unknown option \"%s\" on \".trace\"\n", z);
          rc = 1;
          goto meta_command_exit;
        }
      }else{
        output_file_close(p->traceOut);
        p->traceOut = output_file_open(z);
      }
    }
    if( p->traceOut==0 ){
      sqlite3_trace_v2(p->db, 0, 0, 0);
    }else{
      if( mType==0 ) mType = SQLITE_TRACE_STMT;
      sqlite3_trace_v2(p->db, mType, sql_trace_callback, p);
    }
  }else
#endif /* !defined(SQLITE_OMIT_TRACE) */
 
#if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_VIRTUALTABLE)
  if( c=='u' && cli_strncmp(azArg[0], "unmodule", n)==0 ){
    int ii;
    int lenOpt;
    char *zOpt;
    if( nArg<2 ){
      eputz("Usage: .unmodule [--allexcept] NAME ...\n");
      rc = 1;
      goto meta_command_exit;
    }
    open_db(p, 0);
    zOpt = azArg[1];
    if( zOpt[0]=='-' && zOpt[1]=='-' && zOpt[2]!=0 ) zOpt++;
    lenOpt = (int)strlen(zOpt);
    if( lenOpt>=3 && cli_strncmp(zOpt, "-allexcept",lenOpt)==0 ){
      assert( azArg[nArg]==0 );
      sqlite3_drop_modules(p->db, nArg>2 ? (const char**)(azArg+2) : 0);
    }else{
      for(ii=1; ii<nArg; ii++){
        sqlite3_create_module(p->db, azArg[ii], 0, 0);
      }
    }
  }else
#endif
 
  if( c=='v' && cli_strncmp(azArg[0], "version", n)==0 ){
    char *zPtrSz = sizeof(void*)==8 ? "64-bit" : "32-bit";
    sqlite3_fprintf(p->out, "SQLite %s %s\n" /*extra-version-info*/,
          sqlite3_libversion(), sqlite3_sourceid());
#if SQLITE_HAVE_ZLIB
    sqlite3_fprintf(p->out, "zlib version %s\n", zlibVersion());
#endif
#define CTIMEOPT_VAL_(opt) #opt
#define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt)
#if defined(__clang__) && defined(__clang_major__)
    sqlite3_fprintf(p->out, "clang-" CTIMEOPT_VAL(__clang_major__) "."
          CTIMEOPT_VAL(__clang_minor__) "."
          CTIMEOPT_VAL(__clang_patchlevel__) " (%s)\n", zPtrSz);
#elif defined(_MSC_VER)
    sqlite3_fprintf(p->out, "msvc-" CTIMEOPT_VAL(_MSC_VER) " (%s)\n", zPtrSz);
#elif defined(__GNUC__) && defined(__VERSION__)
    sqlite3_fprintf(p->out, "gcc-" __VERSION__ " (%s)\n", zPtrSz);
#endif
  }else
 
  if( c=='v' && cli_strncmp(azArg[0], "vfsinfo", n)==0 ){
    const char *zDbName = nArg==2 ? azArg[1] : "main";
    sqlite3_vfs *pVfs = 0;
    if( p->db ){
      sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFS_POINTER, &pVfs);
      if( pVfs ){
        sqlite3_fprintf(p->out, "vfs.zName      = \"%s\"\n", pVfs->zName);
        sqlite3_fprintf(p->out, "vfs.iVersion   = %d\n", pVfs->iVersion);
        sqlite3_fprintf(p->out, "vfs.szOsFile   = %d\n", pVfs->szOsFile);
        sqlite3_fprintf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname);
      }
    }
  }else
 
  if( c=='v' && cli_strncmp(azArg[0], "vfslist", n)==0 ){
    sqlite3_vfs *pVfs;
    sqlite3_vfs *pCurrent = 0;
    if( p->db ){
      sqlite3_file_control(p->db, "main", SQLITE_FCNTL_VFS_POINTER, &pCurrent);
    }
    for(pVfs=sqlite3_vfs_find(0); pVfs; pVfs=pVfs->pNext){
      sqlite3_fprintf(p->out, "vfs.zName      = \"%s\"%s\n", pVfs->zName,
            pVfs==pCurrent ? "  <--- CURRENT" : "");
      sqlite3_fprintf(p->out, "vfs.iVersion   = %d\n", pVfs->iVersion);
      sqlite3_fprintf(p->out, "vfs.szOsFile   = %d\n", pVfs->szOsFile);
      sqlite3_fprintf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname);
      if( pVfs->pNext ){
        sqlite3_fputs("-----------------------------------\n", p->out);
      }
    }
  }else
 
  if( c=='v' && cli_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 ){
        sqlite3_fprintf(p->out, "%s\n", zVfsName);
        sqlite3_free(zVfsName);
      }
    }
  }else
 
  if( c=='w' && cli_strncmp(azArg[0], "wheretrace", n)==0 ){
    unsigned int x = nArg>=2? (unsigned int)integerValue(azArg[1]) : 0xffffffff;
    sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 3, &x);
  }else
 
  if( c=='w' && cli_strncmp(azArg[0], "width", n)==0 ){
    int j;
    assert( nArg<=ArraySize(azArg) );
    p->nWidth = nArg-1;
    p->colWidth = realloc(p->colWidth, (p->nWidth+1)*sizeof(int)*2);
    if( p->colWidth==0 && p->nWidth>0 ) shell_out_of_memory();
    if( p->nWidth ) p->actualWidth = &p->colWidth[p->nWidth];
    for(j=1; j<nArg; j++){
      p->colWidth[j-1] = (int)integerValue(azArg[j]);
    }
  }else
 
  {
    sqlite3_fprintf(stderr,"Error: unknown command or invalid arguments: "
          " \"%s\". Enter \".help\" for help\n", azArg[0]);
    rc = 1;
  }
 
meta_command_exit:
  if( p->outCount ){
    p->outCount--;
    if( p->outCount==0 ) output_reset(p);
  }
  p->bSafeMode = p->bSafeModePersist;

References ShellState::aAuxDb, ShellState::actualWidth, appendText(), ArraySize, ascii_read_one_field(), ShellState::autoEQP, AUTOEQP_full, AUTOEQP_on, AUTOEQP_trigger, ShellState::autoEQPtest, ShellState::autoEQPtrace, ShellState::autoExplain, bail_on_error, bind_prepared_stmt(), bind_table_init(), booleanValue(), ColModeOpts::bQuote, ShellState::bSafeMode, ShellState::bSafeModePersist, ColModeOpts::bWordWrap, c, callback(), captureOutputCallback(), ImportCtx::cColSep, clearTempFile(), cli_strcmp(), cli_strncmp(), close_db(), ShellState::cMode, ShellState::cmOpts, ColModeOpts_default, ColModeOpts_default_qbox, ShellState::colSeparator, ShellState::colWidth, continuePrompt, createSelftestTable(), ShellState::crlfMode, ImportCtx::cRowSep, csv_read_one_field(), ImportCtx::cTerm, CTIMEOPT_VAL, ShellState::AuxDb::db, ShellState::db, db_int(), display_stats(), ShellState::doXdgOpen, ShellState::eEscMode, enableTimer, eputz, ShellState::eTraceType, ShellState::expert, expertDotCommand(), expertFinish(), failIfSafeMode(), faultsim_callback(), faultsim_state, ShellState::flgProgress, freeText(), globalDb, HAS_TIMER, import_append_char(), import_cleanup(), ImportCtx::in, ShellState::in, initText(), intckDatabaseCmd(), integerValue(), IsDigit, IsSpace, sqlite3_vfs::iVersion, ColModeOpts::iWrap, ShellState::lineno, lintDotCommand(), mainPrompt, ShellState::mode, MODE_Ascii, MODE_Box, MODE_Column, MODE_Count, MODE_Csv, MODE_Explain, MODE_Html, MODE_Insert, MODE_Json, MODE_Line, MODE_List, MODE_Markdown, MODE_Off, MODE_Pretty, MODE_Quote, MODE_Semi, MODE_Table, MODE_Tcl, MODE_Www, modeDescr, sqlite3_vfs::mxPathname, ShellState::mxProgress, ShellText::n, ShellState::nCheck, ImportCtx::nErr, ShellState::nErr, newTempFile(), ImportCtx::nLine, ShellState::normalMode, ShellState::nProgress, ImportCtx::nRow, ShellState::nullValue, ShellState::nWidth, open_db(), OPEN_DB_KEEPALIVE, openChrSource(), ShellState::openFlags, ShellState::openMode, optionMatch(), ShellState::out, ShellState::outCount, ShellState::outfile, output_c_string(), output_file_close(), output_file_open(), output_redir(), output_reset(), outputDumpWarning(), outputModePush(), ShellState::pAuxDb, pclose(), ExpertInfo::pExpert, ShellState::pLog, sqlite3_vfs::pNext, process_input(), progress_handler(), quoteChar(), readFile(), resolve_backslashes(), ShellState::rowSeparator, run_schema_dump_query(), run_table_dump_query(), safeModeAuth(), ShellState::scanstatsOn, seenInterrupt, SEP_Column, SEP_Comma, SEP_CrLf, SEP_Record, SEP_Row, SEP_Space, SEP_Tab, SEP_Unit, session_close_all, set_table_name(), setOrClearFlag(), shell_check_oom(), shell_dbtotxt_command(), SHELL_ESC_OFF, shell_EscModeNames, shell_exec(), SHELL_OPEN_APPENDVFS, SHELL_OPEN_DESERIALIZE, SHELL_OPEN_HEXDB, SHELL_OPEN_READONLY, SHELL_OPEN_UNSPEC, SHELL_OPEN_ZIPFILE, shell_out_of_memory(), SHELL_PROGRESS_ONCE, SHELL_PROGRESS_QUIET, SHELL_PROGRESS_RESET, shell_strncpy(), SHELL_TRACE_EXPANDED, SHELL_TRACE_NORMALIZED, SHELL_TRACE_PLAIN, shellAuth(), ShellClearFlag, shellDatabaseError(), shellDeleteFile(), shellEmitError(), ShellState::shellFlgs, ShellHasFlag, ShellSetFlag, SHFLG_CountChanges, SHFLG_DumpDataOnly, SHFLG_DumpNoSys, SHFLG_Echo, SHFLG_HeaderSet, SHFLG_Newlines, SHFLG_PreserveRowid, SHFLG_TestingMode, ShellState::showHeader, showHelp(), sputz, sql_trace_callback(), sqlite3_backup_finish, sqlite3_backup_init, sqlite3_backup_step, sqlite3_bind_null, sqlite3_bind_text, sqlite3_busy_timeout, sqlite3_column_double, sqlite3_column_int, sqlite3_column_text, sqlite3_create_module, sqlite3_db_config, sqlite3_db_readonly, sqlite3_drop_modules, sqlite3_errmsg, sqlite3_exec, sqlite3_file_control, sqlite3_finalize, sqlite3_fopen, sqlite3_fprintf, sqlite3_fputs, sqlite3_free, sqlite3_get_autocommit, sqlite3_libversion, sqlite3_limit, sqlite3_load_extension, sqlite3_malloc, sqlite3_malloc64, sqlite3_mprintf, sqlite3_open, sqlite3_open_v2, sqlite3_popen, sqlite3_prepare_v2, sqlite3_progress_handler, sqlite3_randomness, sqlite3_realloc, sqlite3_realloc64, sqlite3_reset, sqlite3_set_authorizer, sqlite3_sleep, sqlite3_snprintf, sqlite3_sourceid, sqlite3_step, sqlite3_strglob, sqlite3_stricmp, sqlite3_strlike, sqlite3_strnicmp, sqlite3_table_column_metadata, sqlite3_test_control, sqlite3_trace_v2, sqlite3_txn_state, sqlite3_vfs_find, SQLITE_API, SQLITE_BUSY, SQLITE_CDECL, SQLITE_DBCONFIG_DEFENSIVE, SQLITE_DBCONFIG_DQS_DDL, SQLITE_DBCONFIG_DQS_DML, SQLITE_DBCONFIG_ENABLE_ATTACH_CREATE, SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE, SQLITE_DBCONFIG_ENABLE_COMMENTS, SQLITE_DBCONFIG_ENABLE_FKEY, SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, SQLITE_DBCONFIG_ENABLE_QPSG, SQLITE_DBCONFIG_ENABLE_TRIGGER, SQLITE_DBCONFIG_ENABLE_VIEW, SQLITE_DBCONFIG_LEGACY_ALTER_TABLE, SQLITE_DBCONFIG_LEGACY_FILE_FORMAT, SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE, SQLITE_DBCONFIG_RESET_DATABASE, SQLITE_DBCONFIG_REVERSE_SCANORDER, SQLITE_DBCONFIG_STMT_SCANSTATUS, SQLITE_DBCONFIG_TRIGGER_EQP, SQLITE_DBCONFIG_TRUSTED_SCHEMA, SQLITE_DBCONFIG_WRITABLE_SCHEMA, SQLITE_DONE, SQLITE_FCNTL_CHUNK_SIZE, SQLITE_FCNTL_DATA_VERSION, SQLITE_FCNTL_HAS_MOVED, SQLITE_FCNTL_LOCK_TIMEOUT, SQLITE_FCNTL_PERSIST_WAL, SQLITE_FCNTL_POWERSAFE_OVERWRITE, SQLITE_FCNTL_RESERVE_BYTES, SQLITE_FCNTL_SIZE_LIMIT, SQLITE_FCNTL_TEMPFILENAME, SQLITE_FCNTL_VFS_POINTER, SQLITE_FCNTL_VFSNAME, SQLITE_LIMIT_ATTACHED, SQLITE_LIMIT_COLUMN, SQLITE_LIMIT_COMPOUND_SELECT, SQLITE_LIMIT_EXPR_DEPTH, SQLITE_LIMIT_FUNCTION_ARG, SQLITE_LIMIT_LENGTH, SQLITE_LIMIT_LIKE_PATTERN_LENGTH, SQLITE_LIMIT_SQL_LENGTH, SQLITE_LIMIT_TRIGGER_DEPTH, SQLITE_LIMIT_VARIABLE_NUMBER, SQLITE_LIMIT_VDBE_OP, SQLITE_LIMIT_WORKER_THREADS, SQLITE_LOCKED, SQLITE_OK, SQLITE_OPEN_CREATE, SQLITE_OPEN_NOFOLLOW, SQLITE_OPEN_READWRITE, SQLITE_ROW, SQLITE_STATIC, SQLITE_TESTCTRL_ALWAYS, SQLITE_TESTCTRL_ASSERT, SQLITE_TESTCTRL_BYTEORDER, SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS, SQLITE_TESTCTRL_FAULT_INSTALL, SQLITE_TESTCTRL_FK_NO_ACTION, SQLITE_TESTCTRL_GETOPT, SQLITE_TESTCTRL_IMPOSTER, SQLITE_TESTCTRL_INTERNAL_FUNCTIONS, SQLITE_TESTCTRL_JSON_SELFCHECK, SQLITE_TESTCTRL_LOCALTIME_FAULT, SQLITE_TESTCTRL_NEVER_CORRUPT, SQLITE_TESTCTRL_OPTIMIZATIONS, SQLITE_TESTCTRL_PARSER_COVERAGE, SQLITE_TESTCTRL_PENDING_BYTE, SQLITE_TESTCTRL_PRNG_RESTORE, SQLITE_TESTCTRL_PRNG_SAVE, SQLITE_TESTCTRL_PRNG_SEED, SQLITE_TESTCTRL_SEEK_COUNT, SQLITE_TESTCTRL_SORTER_MMAP, SQLITE_TESTCTRL_TRACEFLAGS, SQLITE_TESTCTRL_TUNE, SQLITE_TRACE_CLOSE, SQLITE_TRACE_PROFILE, SQLITE_TRACE_ROW, SQLITE_TRACE_STMT, SQLITE_TRANSIENT, SQLITE_TXN_NONE, SQLITE_TXN_READ, ShellState::statsOn, stdin_is_interactive, strlen30(), ShellState::szMax, sqlite3_vfs::szOsFile, test_breakpoint(), testcase_glob(), ShellState::traceOut, tryToClone(), ShellState::writableSchema, ImportCtx::xCloser, ImportCtx::z, ShellText::z, zAutoColumn(), ShellState::AuxDb::zDbFilename, ShellState::zDestTable, ImportCtx::zFile, ShellState::AuxDb::zFreeOnClose, sqlite3_vfs::zName, ShellState::zNonce, ShellState::zTempFile, and ShellState::zTestcase.

Referenced by main(), and process_input().

Here is the call graph for this function:

Here is the caller graph for this function:

doAutoDetectRestore()

int doAutoDetectRestore ( ShellState * p, const char * zSql )

static

       : Nothing left to do. This function becomes a no-op.
*/
static int doAutoDetectRestore(ShellState *p, const char *zSql){
  int rc = SQLITE_OK;
 
  if( p->eRestoreState<7 ){
    switch( p->eRestoreState ){
      case 0: {
        const char *zExpect = "PRAGMA foreign_keys=OFF;";
        assert( strlen(zExpect)==24 );
        if( p->bSafeMode==0
         && strlen(zSql)>=24
         && memcmp(zSql, zExpect, 25)==0
        ){
          p->eRestoreState = 1;
        }else{
          p->eRestoreState = 7;
        }
        break;
      };
  
      case 1: {
        int bIsDump = 0;
        const char *zExpect = "BEGIN TRANSACTION;";
        assert( strlen(zExpect)==18 );
        if( memcmp(zSql, zExpect, 19)==0 ){
          /* Now check if the database is empty. */
          const char *zQuery = "SELECT 1 FROM sqlite_schema LIMIT 1";
          sqlite3_stmt *pStmt = 0;
  
          bIsDump = 1;
          shellPrepare(p->db, &rc, zQuery, &pStmt);
          if( rc==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){
            bIsDump = 0;
          }
          shellFinalize(&rc, pStmt);
        }
        if( bIsDump && rc==SQLITE_OK ){
          int bDefense = 0;
          int bDqsDdl = 0;
          sqlite3_db_config(p->db, SQLITE_DBCONFIG_DEFENSIVE, -1, &bDefense);
          sqlite3_db_config(p->db, SQLITE_DBCONFIG_DQS_DDL, -1, &bDqsDdl);
          sqlite3_db_config(p->db, SQLITE_DBCONFIG_DEFENSIVE, 0, 0);
          sqlite3_db_config(p->db, SQLITE_DBCONFIG_DQS_DDL, 1, 0);
          p->eRestoreState = (bDefense ? 2 : 0) + (bDqsDdl ? 4 : 0);
        }else{
          p->eRestoreState = 7;
        }
        break;
      }
  
      default: {
        if( sqlite3_get_autocommit(p->db) ){
          if( (p->eRestoreState & 2) ){
            sqlite3_db_config(p->db, SQLITE_DBCONFIG_DEFENSIVE, 1, 0);
          }
          if( (p->eRestoreState & 4) ){
            sqlite3_db_config(p->db, SQLITE_DBCONFIG_DQS_DDL, 0, 0);
          }
          p->eRestoreState = 7;
        }
        break;
      }
    }
  }
 

References ShellState::bSafeMode, ShellState::db, ShellState::eRestoreState, shellFinalize(), shellPrepare(), sqlite3_db_config, sqlite3_get_autocommit, sqlite3_step, SQLITE_DBCONFIG_DEFENSIVE, SQLITE_DBCONFIG_DQS_DDL, SQLITE_OK, and SQLITE_ROW.

Referenced by runOneSqlLine().

Here is the call graph for this function:

Here is the caller graph for this function:

dummyCompare()

int dummyCompare	(	void *	up1,
		int	up2,
		const void *	up3,
		int	up4,
		const void *	up5 )

                                                                               {
  (void)up1;
  (void)up2;
  (void)up3;
  (void)up4;
  (void)up5;
  assert(0); /* VDBE should never be run. */
  return 0;
}

Referenced by useDummyCS().

Here is the caller graph for this function:

dummyUDF()

void dummyUDF	(	sqlite3_context *	up1,
		int	up2,
		sqlite3_value **	up3 )

                                                                 {
  (void)up1;
  (void)up2;
  (void)up3;
  assert(0); /* VDBE should never be run. */
}

Referenced by registerUDFs().

Here is the caller graph for this function:

dummyUDFvalue()

void dummyUDFvalue

(

sqlite3_context *

up1

)

                                        {
  (void)up1;
  assert(0); /* VDBE should never be run. */
}

Referenced by registerUDFs().

Here is the caller graph for this function:

dump_callback()

int dump_callback ( void * pArg, int nArg, char ** azArg, char ** azNotUsed )

static

                                                                              {
  int rc;
  const char *zTable;
  const char *zType;
  const char *zSql;
  ShellState *p = (ShellState *)pArg;
  int dataOnly;
  int noSys;
 
  UNUSED_PARAMETER(azNotUsed);
  if( nArg!=3 || azArg==0 ) return 0;
  zTable = azArg[0];
  zType = azArg[1];
  zSql = azArg[2];
  if( zTable==0 ) return 0;
  if( zType==0 ) return 0;
  dataOnly = (p->shellFlgs & SHFLG_DumpDataOnly)!=0;
  noSys    = (p->shellFlgs & SHFLG_DumpNoSys)!=0;
 
  if( cli_strcmp(zTable, "sqlite_sequence")==0 && !noSys ){
    /* no-op */
  }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 && !noSys ){
    if( !dataOnly ) sqlite3_fputs("ANALYZE sqlite_schema;\n", p->out);
  }else if( cli_strncmp(zTable, "sqlite_", 7)==0 ){
    return 0;
  }else if( dataOnly ){
    /* no-op */
  }else if( cli_strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
    char *zIns;
    if( !p->writableSchema ){
      sqlite3_fputs("PRAGMA writable_schema=ON;\n", p->out);
      p->writableSchema = 1;
    }
    zIns = sqlite3_mprintf(
       "INSERT INTO sqlite_schema(type,name,tbl_name,rootpage,sql)"
       "VALUES('table','%q','%q',0,'%q');",
       zTable, zTable, zSql);
    shell_check_oom(zIns);
    sqlite3_fprintf(p->out, "%s\n", zIns);
    sqlite3_free(zIns);
    return 0;
  }else{
    printSchemaLine(p->out, zSql, ";\n");
  }
 
  if( cli_strcmp(zType, "table")==0 ){
    ShellText sSelect;
    ShellText sTable;
    char **azCol;
    int i;
    char *savedDestTable;
    int savedMode;
 
    azCol = tableColumnList(p, zTable);
    if( azCol==0 ){
      p->nErr++;
      return 0;
    }
 
    /* Always quote the table name, even if it appears to be pure ascii,
    ** in case it is a keyword. Ex:  INSERT INTO "table" ... */
    initText(&sTable);
    appendText(&sTable, zTable, quoteChar(zTable));
    /* If preserving the rowid, add a column list after the table name.
    ** In other words:  "INSERT INTO tab(rowid,a,b,c,...) VALUES(...)"
    ** instead of the usual "INSERT INTO tab VALUES(...)".
    */
    if( azCol[0] ){
      appendText(&sTable, "(", 0);
      appendText(&sTable, azCol[0], 0);
      for(i=1; azCol[i]; i++){
        appendText(&sTable, ",", 0);
        appendText(&sTable, azCol[i], quoteChar(azCol[i]));
      }
      appendText(&sTable, ")", 0);
    }
 
    /* Build an appropriate SELECT statement */
    initText(&sSelect);
    appendText(&sSelect, "SELECT ", 0);
    if( azCol[0] ){
      appendText(&sSelect, azCol[0], 0);
      appendText(&sSelect, ",", 0);
    }
    for(i=1; azCol[i]; i++){
      appendText(&sSelect, azCol[i], quoteChar(azCol[i]));
      if( azCol[i+1] ){
        appendText(&sSelect, ",", 0);
      }
    }
    freeColumnList(azCol);
    appendText(&sSelect, " FROM ", 0);
    appendText(&sSelect, zTable, quoteChar(zTable));
 
    savedDestTable = p->zDestTable;
    savedMode = p->mode;
    p->zDestTable = sTable.z;
    p->mode = p->cMode = MODE_Insert;
    rc = shell_exec(p, sSelect.z, 0);
    if( (rc&0xff)==SQLITE_CORRUPT ){
      sqlite3_fputs("/****** CORRUPTION ERROR *******/\n", p->out);
      toggleSelectOrder(p->db);
      shell_exec(p, sSelect.z, 0);
      toggleSelectOrder(p->db);
    }
    p->zDestTable = savedDestTable;
    p->mode = savedMode;
    freeText(&sTable);
    freeText(&sSelect);
    if( rc ) p->nErr++;
  }

References appendText(), cli_strcmp(), cli_strncmp(), ShellState::cMode, ShellState::db, freeColumnList(), freeText(), initText(), ShellState::mode, MODE_Insert, ShellState::nErr, ShellState::out, printSchemaLine(), quoteChar(), shell_check_oom(), shell_exec(), ShellState::shellFlgs, SHFLG_DumpDataOnly, SHFLG_DumpNoSys, sqlite3_fprintf, sqlite3_fputs, sqlite3_free, sqlite3_mprintf, sqlite3_strglob, SQLITE_CORRUPT, tableColumnList(), toggleSelectOrder(), UNUSED_PARAMETER, ShellState::writableSchema, ShellText::z, and ShellState::zDestTable.

Referenced by run_schema_dump_query().

Here is the call graph for this function:

Here is the caller graph for this function:

dynamicContinuePrompt()

char * dynamicContinuePrompt ( void )

static

                                        {
  if( continuePrompt[0]==0
      || (dynPrompt.zScannerAwaits==0 && dynPrompt.inParenLevel == 0) ){
    return continuePrompt;
  }else{
    if( dynPrompt.zScannerAwaits ){
      size_t ncp = strlen(continuePrompt);
      size_t ndp = strlen(dynPrompt.zScannerAwaits);
      if( ndp > ncp-3 ) return continuePrompt;
      shell_strcpy(dynPrompt.dynamicPrompt, dynPrompt.zScannerAwaits);
      while( ndp<3 ) dynPrompt.dynamicPrompt[ndp++] = ' ';
      shell_strncpy(dynPrompt.dynamicPrompt+3, continuePrompt+3,
              PROMPT_LEN_MAX-4);
    }else{
      if( dynPrompt.inParenLevel>9 ){
        shell_strncpy(dynPrompt.dynamicPrompt, "(..", 4);
      }else if( dynPrompt.inParenLevel<0 ){
        shell_strncpy(dynPrompt.dynamicPrompt, ")x!", 4);
      }else{
        shell_strncpy(dynPrompt.dynamicPrompt, "(x.", 4);
        dynPrompt.dynamicPrompt[2] = (char)('0'+dynPrompt.inParenLevel);
      }
      shell_strncpy(dynPrompt.dynamicPrompt+3, continuePrompt+3,
                    PROMPT_LEN_MAX-4);
    }
  }
  return dynPrompt.dynamicPrompt;
}

References continuePrompt, dynPrompt, PROMPT_LEN_MAX, shell_strcpy(), and shell_strncpy().

Here is the call graph for this function:

echo_group_input()

void echo_group_input ( ShellState * p, const char * zDo )

static

                                                            {
  if( ShellHasFlag(p, SHFLG_Echo) ){
    sqlite3_fprintf(p->out, "%s\n", zDo);
    fflush(p->out);

Referenced by main(), and process_input().

Here is the caller graph for this function:

editFunc()

void editFunc ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  const char *zEditor;
  char *zTempFile = 0;
  sqlite3 *db;
  char *zCmd = 0;
  int bBin;
  int rc;
  int hasCRLF = 0;
  FILE *f = 0;
  sqlite3_int64 sz;
  sqlite3_int64 x;
  unsigned char *p = 0;
 
  if( argc==2 ){
    zEditor = (const char*)sqlite3_value_text(argv[1]);
  }else{
    zEditor = getenv("VISUAL");
  }
  if( zEditor==0 ){
    sqlite3_result_error(context, "no editor for edit()", -1);
    return;
  }
  if( sqlite3_value_type(argv[0])==SQLITE_NULL ){
    sqlite3_result_error(context, "NULL input to edit()", -1);
    return;
  }
  db = sqlite3_context_db_handle(context);
  zTempFile = 0;
  sqlite3_file_control(db, 0, SQLITE_FCNTL_TEMPFILENAME, &zTempFile);
  if( zTempFile==0 ){
    sqlite3_uint64 r = 0;
    sqlite3_randomness(sizeof(r), &r);
    zTempFile = sqlite3_mprintf("temp%llx", r);
    if( zTempFile==0 ){
      sqlite3_result_error_nomem(context);
      return;
    }
  }
  bBin = sqlite3_value_type(argv[0])==SQLITE_BLOB;
  /* When writing the file to be edited, do \n to \r\n conversions on systems
  ** that want \r\n line endings */
  f = sqlite3_fopen(zTempFile, bBin ? "wb" : "w");
  if( f==0 ){
    sqlite3_result_error(context, "edit() cannot open temp file", -1);
    goto edit_func_end;
  }
  sz = sqlite3_value_bytes(argv[0]);
  if( bBin ){
    x = fwrite(sqlite3_value_blob(argv[0]), 1, (size_t)sz, f);
  }else{
    const char *z = (const char*)sqlite3_value_text(argv[0]);
    /* Remember whether or not the value originally contained \r\n */
    if( z && strstr(z,"\r\n")!=0 ) hasCRLF = 1;
    x = fwrite(sqlite3_value_text(argv[0]), 1, (size_t)sz, f);
  }
  fclose(f);
  f = 0;
  if( x!=sz ){
    sqlite3_result_error(context, "edit() could not write the whole file", -1);
    goto edit_func_end;
  }
  zCmd = sqlite3_mprintf("%s \"%s\"", zEditor, zTempFile);
  if( zCmd==0 ){
    sqlite3_result_error_nomem(context);
    goto edit_func_end;
  }
  rc = system(zCmd);
  sqlite3_free(zCmd);
  if( rc ){
    sqlite3_result_error(context, "EDITOR returned non-zero", -1);
    goto edit_func_end;
  }
  f = sqlite3_fopen(zTempFile, "rb");
  if( f==0 ){
    sqlite3_result_error(context,
      "edit() cannot reopen temp file after edit", -1);
    goto edit_func_end;
  }
  fseek(f, 0, SEEK_END);
  sz = ftell(f);
  rewind(f);
  p = sqlite3_malloc64( sz+1 );
  if( p==0 ){
    sqlite3_result_error_nomem(context);
    goto edit_func_end;
  }
  x = fread(p, 1, (size_t)sz, f);
  fclose(f);
  f = 0;
  if( x!=sz ){
    sqlite3_result_error(context, "could not read back the whole file", -1);
    goto edit_func_end;
  }
  if( bBin ){
    sqlite3_result_blob64(context, p, sz, sqlite3_free);
  }else{
    sqlite3_int64 i, j;
    if( hasCRLF ){
      /* If the original contains \r\n then do no conversions back to \n */
    }else{
      /* If the file did not originally contain \r\n then convert any new
      ** \r\n back into \n */
      p[sz] = 0;
      for(i=j=0; i<sz; i++){
        if( p[i]=='\r' && p[i+1]=='\n' ) i++;
        p[j++] = p[i];
      }
      sz = j;
      p[sz] = 0;
    }
    sqlite3_result_text64(context, (const char*)p, sz,
                          sqlite3_free, SQLITE_UTF8);
  }
  p = 0;
 
edit_func_end:
  if( f ) fclose(f);
  unlink(zTempFile);
  sqlite3_free(zTempFile);

References sqlite3_context_db_handle, sqlite3_file_control, sqlite3_fopen, sqlite3_free, sqlite3_malloc64, sqlite3_mprintf, sqlite3_randomness, sqlite3_result_blob64, sqlite3_result_error, sqlite3_result_error_nomem, sqlite3_result_text64, sqlite3_value_blob, sqlite3_value_bytes, sqlite3_value_text, sqlite3_value_type, SQLITE_BLOB, SQLITE_FCNTL_TEMPFILENAME, SQLITE_NULL, and SQLITE_UTF8.

Referenced by open_db().

Here is the caller graph for this function:

endTimer()

void endTimer ( FILE * out )

static

                               {
  if( enableTimer ){
    sqlite3_int64 iEnd = timeOfDay();
    struct rusage sEnd;
    getrusage(RUSAGE_SELF, &sEnd);
    sqlite3_fprintf(out, "Run Time: real %.3f user %f sys %f\n",
          (iEnd - iBegin)*0.001,
          timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
          timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
  }
}

References enableTimer, iBegin, sBegin, sqlite3_fprintf, timeDiff(), and timeOfDay().

Here is the call graph for this function:

eqp_append()

void eqp_append ( ShellState * p, int iEqpId, int p2, const char * zText )

static

                                                                            {
  EQPGraphRow *pNew;
  i64 nText;
  if( zText==0 ) return;
  nText = strlen(zText);
  if( p->autoEQPtest ){
    sqlite3_fprintf(p->out, "%d,%d,%s\n", iEqpId, p2, zText);
  }
  pNew = sqlite3_malloc64( sizeof(*pNew) + nText );
  shell_check_oom(pNew);
  pNew->iEqpId = iEqpId;
  pNew->iParentId = p2;
  memcpy(pNew->zText, zText, nText+1);
  pNew->pNext = 0;
  if( p->sGraph.pLast ){
    p->sGraph.pLast->pNext = pNew;
  }else{
    p->sGraph.pRow = pNew;
  }

References ShellState::autoEQPtest, EQPGraphRow::iEqpId, EQPGraphRow::iParentId, ShellState::out, EQPGraph::pLast, EQPGraphRow::pNext, EQPGraph::pRow, ShellState::sGraph, shell_check_oom(), sqlite3_fprintf, sqlite3_malloc64, and EQPGraphRow::zText.

Referenced by shell_callback(), and shell_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

eqp_next_row()

EQPGraphRow * eqp_next_row ( ShellState * p, int iEqpId, EQPGraphRow * pOld )

static

                                                                              {
  EQPGraphRow *pRow = pOld ? pOld->pNext : p->sGraph.pRow;
  while( pRow && pRow->iParentId!=iEqpId ) pRow = pRow->pNext;

References EQPGraphRow::iParentId, EQPGraphRow::pNext, EQPGraph::pRow, and ShellState::sGraph.

Referenced by eqp_render_level().

Here is the caller graph for this function:

eqp_render()

void eqp_render ( ShellState * p, i64 nCycle )

static

                                                 {
  EQPGraphRow *pRow = p->sGraph.pRow;
  if( pRow ){
    if( pRow->zText[0]=='-' ){
      if( pRow->pNext==0 ){
        eqp_reset(p);
        return;
      }
      sqlite3_fprintf(p->out, "%s\n", pRow->zText+3);
      p->sGraph.pRow = pRow->pNext;
      sqlite3_free(pRow);
    }else if( nCycle>0 ){
      sqlite3_fprintf(p->out, "QUERY PLAN (cycles=%lld [100%%])\n", nCycle);
    }else{
      sqlite3_fputs("QUERY PLAN\n", p->out);
    }
    p->sGraph.zPrefix[0] = 0;
    eqp_render_level(p, 0);
    eqp_reset(p);

References eqp_render_level(), eqp_reset(), ShellState::out, EQPGraphRow::pNext, EQPGraph::pRow, ShellState::sGraph, sqlite3_fprintf, sqlite3_fputs, sqlite3_free, EQPGraph::zPrefix, and EQPGraphRow::zText.

Referenced by shell_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

eqp_render_level()

void eqp_render_level ( ShellState * p, int iEqpId )

static

                                                       {
  EQPGraphRow *pRow, *pNext;
  i64 n = strlen(p->sGraph.zPrefix);
  char *z;
  for(pRow = eqp_next_row(p, iEqpId, 0); pRow; pRow = pNext){
    pNext = eqp_next_row(p, iEqpId, pRow);
    z = pRow->zText;
    sqlite3_fprintf(p->out, "%s%s%s\n", p->sGraph.zPrefix,
                            pNext ? "|--" : "`--", z);
    if( n<(i64)sizeof(p->sGraph.zPrefix)-7 ){
      memcpy(&p->sGraph.zPrefix[n], pNext ? "|  " : "   ", 4);
      eqp_render_level(p, pRow->iEqpId);
      p->sGraph.zPrefix[n] = 0;
    }

References eqp_next_row(), eqp_render_level(), EQPGraphRow::iEqpId, ShellState::out, ShellState::sGraph, sqlite3_fprintf, EQPGraph::zPrefix, and EQPGraphRow::zText.

Referenced by eqp_render(), and eqp_render_level().

Here is the call graph for this function:

Here is the caller graph for this function:

eqp_reset()

void eqp_reset ( ShellState * p )

static

                                    {
  EQPGraphRow *pRow, *pNext;
  for(pRow = p->sGraph.pRow; pRow; pRow = pNext){
    pNext = pRow->pNext;
    sqlite3_free(pRow);
  }

References EQPGraphRow::pNext, EQPGraph::pRow, ShellState::sGraph, and sqlite3_free.

Referenced by eqp_render().

Here is the caller graph for this function:

escapeOutput()

const char * escapeOutput ( ShellState * p, const char * zInX, char ** ppFree )

static

 {
  i64 i, j;
  i64 nCtrl = 0;
  unsigned char *zIn;
  unsigned char c;
  unsigned char *zOut;
 
 
  /* No escaping if disabled */
  if( p->eEscMode==SHELL_ESC_OFF ){
    *ppFree = 0;
     return zInX;
  }
 
  /* Count the number of control characters in the string. */
  zIn = (unsigned char*)zInX;
  for(i=0; (c = zIn[i])!=0; i++){
    if( c<=0x1f
     && c!='\t'
     && c!='\n'
     && (c!='\r' || zIn[i+1]!='\n')
    ){
      nCtrl++;
    }
  }
  if( nCtrl==0 ){
    *ppFree = 0;
    return zInX;
  }
  if( p->eEscMode==SHELL_ESC_SYMBOL ) nCtrl *= 2;
  zOut = sqlite3_malloc64( i + nCtrl + 1 );
  shell_check_oom(zOut);
  for(i=j=0; (c = zIn[i])!=0; i++){
    if( c>0x1f
     || c=='\t'
     || c=='\n'
     || (c=='\r' && zIn[i+1]=='\n')
    ){
      continue;
    }
    if( i>0 ){
      memcpy(&zOut[j], zIn, i);
      j += i;
    }
    zIn += i+1;
    i = -1;
    switch( p->eEscMode ){
      case SHELL_ESC_SYMBOL: 
        zOut[j++] = 0xe2;
        zOut[j++] = 0x90;
        zOut[j++] = 0x80+c;
        break;
      case SHELL_ESC_ASCII:
        zOut[j++] = '^';
        zOut[j++] = 0x40+c;
        break;
    }
  }
  if( i>0 ){
    memcpy(&zOut[j], zIn, i);
    j += i;
  }
  zOut[j] = 0;
  *ppFree = (char*)zOut;

References c, ShellState::eEscMode, shell_check_oom(), SHELL_ESC_ASCII, SHELL_ESC_OFF, SHELL_ESC_SYMBOL, and sqlite3_malloc64.

Referenced by shell_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

exec_prepared_stmt()

void exec_prepared_stmt ( ShellState * pArg, sqlite3_stmt * pStmt )

static

 {
  int rc;
  sqlite3_uint64 nRow = 0;
 
  if( pArg->cMode==MODE_Column
   || pArg->cMode==MODE_Table
   || pArg->cMode==MODE_Box
   || pArg->cMode==MODE_Markdown
  ){
    exec_prepared_stmt_columnar(pArg, pStmt);
    return;
  }
 
  /* 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 ){
    /* allocate space for col name ptr, value ptr, and type */
    int nCol = sqlite3_column_count(pStmt);
    void *pData = sqlite3_malloc64(3*nCol*sizeof(const char*) + 1);
    if( !pData ){
      shell_out_of_memory();
    }else{
      char **azCols = (char **)pData;      /* Names of result columns */
      char **azVals = &azCols[nCol];       /* Results */
      int *aiTypes = (int *)&azVals[nCol]; /* Result types */
      int i, x;
      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{
        nRow++;
        /* extract the data and data types */
        for(i=0; i<nCol; i++){
          aiTypes[i] = x = sqlite3_column_type(pStmt, i);
          if( x==SQLITE_BLOB
           && pArg
           && (pArg->cMode==MODE_Insert || pArg->cMode==MODE_Quote)
          ){
            azVals[i] = "";
          }else{
            azVals[i] = (char*)sqlite3_column_text(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( shell_callback(pArg, nCol, azVals, azCols, aiTypes) ){
            rc = SQLITE_ABORT;
          }else{
            rc = sqlite3_step(pStmt);
          }
        }
      } while( SQLITE_ROW == rc );
      sqlite3_free(pData);
      if( pArg->cMode==MODE_Json ){
        sqlite3_fputs("]\n", pArg->out);
      }else if( pArg->cMode==MODE_Www ){
        sqlite3_fputs("</TABLE>\n<PRE>\n", pArg->out);
      }else if( pArg->cMode==MODE_Count ){
        char zBuf[200];
        sqlite3_snprintf(sizeof(zBuf), zBuf, "%llu row%s\n",
                         nRow, nRow!=1 ? "s" : "");
        printf("%s", zBuf);
      }
    }

References ShellState::cMode, exec_prepared_stmt_columnar(), MODE_Box, MODE_Column, MODE_Count, MODE_Insert, MODE_Json, MODE_Markdown, MODE_Quote, MODE_Table, MODE_Www, ShellState::out, shell_callback(), shell_out_of_memory(), sqlite3_column_count, sqlite3_column_name, sqlite3_column_text, sqlite3_column_type, sqlite3_fputs, sqlite3_free, sqlite3_malloc64, sqlite3_snprintf, sqlite3_step, SQLITE_ABORT, SQLITE_BLOB, SQLITE_NOMEM, SQLITE_NULL, and SQLITE_ROW.

Referenced by display_scanstats(), and shell_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

exec_prepared_stmt_columnar()

void exec_prepared_stmt_columnar ( ShellState * p, sqlite3_stmt * pStmt )

static

 {
  sqlite3_int64 nRow = 0;
  int nColumn = 0;
  char **azData = 0;
  sqlite3_int64 nAlloc = 0;
  char *abRowDiv = 0;
  const unsigned char *uz;
  const char *z;
  char **azQuoted = 0;
  int rc;
  sqlite3_int64 i, nData;
  int j, nTotal, w, n;
  const char *colSep = 0;
  const char *rowSep = 0;
  const unsigned char **azNextLine = 0;
  int bNextLine = 0;
  int bMultiLineRowExists = 0;
  int bw = p->cmOpts.bWordWrap;
  const char *zEmpty = "";
  const char *zShowNull = p->nullValue;
 
  rc = sqlite3_step(pStmt);
  if( rc!=SQLITE_ROW ) return;
  nColumn = sqlite3_column_count(pStmt);
  if( nColumn==0 ) goto columnar_end;
  nAlloc = nColumn*4;
  if( nAlloc<=0 ) nAlloc = 1;
  azData = sqlite3_malloc64( nAlloc*sizeof(char*) );
  shell_check_oom(azData);
  azNextLine = sqlite3_malloc64( nColumn*sizeof(char*) );
  shell_check_oom(azNextLine);
  memset((void*)azNextLine, 0, nColumn*sizeof(char*) );
  if( p->cmOpts.bQuote ){
    azQuoted = sqlite3_malloc64( nColumn*sizeof(char*) );
    shell_check_oom(azQuoted);
    memset(azQuoted, 0, nColumn*sizeof(char*) );
  }
  abRowDiv = sqlite3_malloc64( nAlloc/nColumn );
  shell_check_oom(abRowDiv);
  if( nColumn>p->nWidth ){
    p->colWidth = realloc(p->colWidth, (nColumn+1)*2*sizeof(int));
    shell_check_oom(p->colWidth);
    for(i=p->nWidth; i<nColumn; i++) p->colWidth[i] = 0;
    p->nWidth = nColumn;
    p->actualWidth = &p->colWidth[nColumn];
  }
  memset(p->actualWidth, 0, nColumn*sizeof(int));
  for(i=0; i<nColumn; i++){
    w = p->colWidth[i];
    if( w<0 ) w = -w;
    p->actualWidth[i] = w;
  }
  for(i=0; i<nColumn; i++){
    const unsigned char *zNotUsed;
    int wx = p->colWidth[i];
    if( wx==0 ){
      wx = p->cmOpts.iWrap;
    }
    if( wx<0 ) wx = -wx;
    uz = (const unsigned char*)sqlite3_column_name(pStmt,i);
    if( uz==0 ) uz = (u8*)"";
    azData[i] = translateForDisplayAndDup(p, uz, &zNotUsed, wx, bw);
  }
  do{
    int useNextLine = bNextLine;
    bNextLine = 0;
    if( (nRow+2)*nColumn >= nAlloc ){
      nAlloc *= 2;
      azData = sqlite3_realloc64(azData, nAlloc*sizeof(char*));
      shell_check_oom(azData);
      abRowDiv = sqlite3_realloc64(abRowDiv, nAlloc/nColumn);
      shell_check_oom(abRowDiv);
    }
    abRowDiv[nRow] = 1;
    nRow++;
    for(i=0; i<nColumn; i++){
      int wx = p->colWidth[i];
      if( wx==0 ){
        wx = p->cmOpts.iWrap;
      }
      if( wx<0 ) wx = -wx;
      if( useNextLine ){
        uz = azNextLine[i];
        if( uz==0 ) uz = (u8*)zEmpty;
      }else if( p->cmOpts.bQuote ){
        assert( azQuoted!=0 );
        sqlite3_free(azQuoted[i]);
        azQuoted[i] = quoted_column(pStmt,i);
        uz = (const unsigned char*)azQuoted[i];
      }else{
        uz = (const unsigned char*)sqlite3_column_text(pStmt,i);
        if( uz==0 ) uz = (u8*)zShowNull;
      }
      azData[nRow*nColumn + i]
        = translateForDisplayAndDup(p, uz, &azNextLine[i], wx, bw);
      if( azNextLine[i] ){
        bNextLine = 1;
        abRowDiv[nRow-1] = 0;
        bMultiLineRowExists = 1;
      }
    }
  }while( bNextLine || sqlite3_step(pStmt)==SQLITE_ROW );
  nTotal = nColumn*(nRow+1);
  for(i=0; i<nTotal; i++){
    z = azData[i];
    if( z==0 ) z = (char*)zEmpty;
    n = strlenChar(z);
    j = i%nColumn;
    if( n>p->actualWidth[j] ) p->actualWidth[j] = n;
  }
  if( seenInterrupt ) goto columnar_end;
  switch( p->cMode ){
    case MODE_Column: {
      colSep = "  ";
      rowSep = "\n";
      if( p->showHeader ){
        for(i=0; i<nColumn; i++){
          w = p->actualWidth[i];
          if( p->colWidth[i]<0 ) w = -w;
          utf8_width_print(p->out, w, azData[i]);
          sqlite3_fputs(i==nColumn-1?"\n":"  ", p->out);
        }
        for(i=0; i<nColumn; i++){
          print_dashes(p->out, p->actualWidth[i]);
          sqlite3_fputs(i==nColumn-1?"\n":"  ", p->out);
        }
      }
      break;
    }
    case MODE_Table: {
      colSep = " | ";
      rowSep = " |\n";
      print_row_separator(p, nColumn, "+");
      sqlite3_fputs("| ", p->out);
      for(i=0; i<nColumn; i++){
        w = p->actualWidth[i];
        n = strlenChar(azData[i]);
        sqlite3_fprintf(p->out, "%*s%s%*s", (w-n)/2, "",
                        azData[i], (w-n+1)/2, "");
        sqlite3_fputs(i==nColumn-1?" |\n":" | ", p->out);
      }
      print_row_separator(p, nColumn, "+");
      break;
    }
    case MODE_Markdown: {
      colSep = " | ";
      rowSep = " |\n";
      sqlite3_fputs("| ", p->out);
      for(i=0; i<nColumn; i++){
        w = p->actualWidth[i];
        n = strlenChar(azData[i]);
        sqlite3_fprintf(p->out, "%*s%s%*s", (w-n)/2, "",
                        azData[i], (w-n+1)/2, "");
        sqlite3_fputs(i==nColumn-1?" |\n":" | ", p->out);
      }
      print_row_separator(p, nColumn, "|");
      break;
    }
    case MODE_Box: {
      colSep = " " BOX_13 " ";
      rowSep = " " BOX_13 "\n";
      print_box_row_separator(p, nColumn, BOX_23, BOX_234, BOX_34);
      sqlite3_fputs(BOX_13 " ", p->out);
      for(i=0; i<nColumn; i++){
        w = p->actualWidth[i];
        n = strlenChar(azData[i]);
        sqlite3_fprintf(p->out, "%*s%s%*s%s",
              (w-n)/2, "", azData[i], (w-n+1)/2, "",
              i==nColumn-1?" "BOX_13"\n":" "BOX_13" ");
      }
      print_box_row_separator(p, nColumn, BOX_123, BOX_1234, BOX_134);
      break;
    }
  }
  for(i=nColumn, j=0; i<nTotal; i++, j++){
    if( j==0 && p->cMode!=MODE_Column ){
      sqlite3_fputs(p->cMode==MODE_Box?BOX_13" ":"| ", p->out);
    }
    z = azData[i];
    if( z==0 ) z = p->nullValue;
    w = p->actualWidth[j];
    if( p->colWidth[j]<0 ) w = -w;
    utf8_width_print(p->out, w, z);
    if( j==nColumn-1 ){
      sqlite3_fputs(rowSep, p->out);
      if( bMultiLineRowExists && abRowDiv[i/nColumn-1] && i+1<nTotal ){
        if( p->cMode==MODE_Table ){
          print_row_separator(p, nColumn, "+");
        }else if( p->cMode==MODE_Box ){
          print_box_row_separator(p, nColumn, BOX_123, BOX_1234, BOX_134);
        }else if( p->cMode==MODE_Column ){
          sqlite3_fputs("\n", p->out);
        }
      }
      j = -1;
      if( seenInterrupt ) goto columnar_end;
    }else{
      sqlite3_fputs(colSep, p->out);
    }
  }
  if( p->cMode==MODE_Table ){
    print_row_separator(p, nColumn, "+");
  }else if( p->cMode==MODE_Box ){
    print_box_row_separator(p, nColumn, BOX_12, BOX_124, BOX_14);
  }
columnar_end:
  if( seenInterrupt ){
    sqlite3_fputs("Interrupt\n", p->out);
  }
  nData = (nRow+1)*nColumn;
  for(i=0; i<nData; i++){
    z = azData[i];
    if( z!=zEmpty && z!=zShowNull ) free(azData[i]);
  }
  sqlite3_free(azData);
  sqlite3_free((void*)azNextLine);
  sqlite3_free(abRowDiv);
  if( azQuoted ){
    for(i=0; i<nColumn; i++) sqlite3_free(azQuoted[i]);
    sqlite3_free(azQuoted);

References ShellState::actualWidth, BOX_12, BOX_123, BOX_1234, BOX_124, BOX_13, BOX_134, BOX_14, BOX_23, BOX_234, BOX_34, ColModeOpts::bQuote, ColModeOpts::bWordWrap, ShellState::cMode, ShellState::cmOpts, ShellState::colWidth, ColModeOpts::iWrap, MODE_Box, MODE_Column, MODE_Markdown, MODE_Table, ShellState::nullValue, ShellState::nWidth, ShellState::out, print_box_row_separator(), print_dashes(), print_row_separator(), quoted_column(), seenInterrupt, shell_check_oom(), ShellState::showHeader, sqlite3_column_count, sqlite3_column_name, sqlite3_column_text, sqlite3_fprintf, sqlite3_fputs, sqlite3_free, sqlite3_malloc64, sqlite3_realloc64, sqlite3_step, SQLITE_ROW, strlenChar(), translateForDisplayAndDup(), and utf8_width_print().

Referenced by exec_prepared_stmt().

Here is the call graph for this function:

Here is the caller graph for this function:

expertBestIndex()

int expertBestIndex ( sqlite3_vtab * pVtab, sqlite3_index_info * pIdxInfo )

static

                                                                             {
  ExpertVtab *p = (ExpertVtab*)pVtab;
  int rc = SQLITE_OK;
  int n = 0;
  IdxScan *pScan;
  const int opmask = 
    SQLITE_INDEX_CONSTRAINT_EQ | SQLITE_INDEX_CONSTRAINT_GT |
    SQLITE_INDEX_CONSTRAINT_LT | SQLITE_INDEX_CONSTRAINT_GE |
    SQLITE_INDEX_CONSTRAINT_LE;
 
  pScan = idxMalloc(&rc, sizeof(IdxScan));
  if( pScan ){
    int i;
 
    /* Link the new scan object into the list */
    pScan->pTab = p->pTab;
    pScan->pNextScan = p->pExpert->pScan;
    p->pExpert->pScan = pScan;
 
    /* Add the constraints to the IdxScan object */
    for(i=0; i<pIdxInfo->nConstraint; i++){
      struct sqlite3_index_constraint *pCons = &pIdxInfo->aConstraint[i];
      if( pCons->usable 
       && pCons->iColumn>=0 
       && p->pTab->aCol[pCons->iColumn].iPk==0
       && (pCons->op & opmask) 
      ){
        IdxConstraint *pNew;
        const char *zColl = sqlite3_vtab_collation(pIdxInfo, i);
        pNew = idxNewConstraint(&rc, zColl);
        if( pNew ){
          pNew->iCol = pCons->iColumn;
          if( pCons->op==SQLITE_INDEX_CONSTRAINT_EQ ){
            pNew->pNext = pScan->pEq;
            pScan->pEq = pNew;
          }else{
            pNew->bRange = 1;
            pNew->pNext = pScan->pRange;
            pScan->pRange = pNew;
          }
        }
        n++;
        pIdxInfo->aConstraintUsage[i].argvIndex = n;
      }
    }
 
    /* Add the ORDER BY to the IdxScan object */
    for(i=pIdxInfo->nOrderBy-1; i>=0; i--){
      int iCol = pIdxInfo->aOrderBy[i].iColumn;
      if( iCol>=0 ){
        IdxConstraint *pNew = idxNewConstraint(&rc, p->pTab->aCol[iCol].zColl);
        if( pNew ){
          pNew->iCol = iCol;
          pNew->bDesc = pIdxInfo->aOrderBy[i].desc;
          pNew->pNext = pScan->pOrder;
          pNew->pLink = pScan->pOrder;
          pScan->pOrder = pNew;
          n++;
        }
      }
    }
  }
 
  pIdxInfo->estimatedCost = 1000000.0 / (n+1);
  return rc;
}

References IdxTable::aCol, sqlite3_index_info::aConstraint, sqlite3_index_info::aConstraintUsage, sqlite3_index_info::aOrderBy, sqlite3_index_info::sqlite3_index_constraint_usage::argvIndex, IdxConstraint::bDesc, IdxConstraint::bRange, sqlite3_index_info::sqlite3_index_orderby::desc, sqlite3_index_info::estimatedCost, IdxConstraint::iCol, sqlite3_index_info::sqlite3_index_orderby::iColumn, idxMalloc(), idxNewConstraint(), IdxColumn::iPk, sqlite3_index_info::nConstraint, sqlite3_index_info::nOrderBy, IdxScan::pEq, ExpertVtab::pExpert, IdxConstraint::pLink, IdxConstraint::pNext, IdxScan::pNextScan, IdxScan::pOrder, IdxScan::pRange, sqlite3expert::pScan, ExpertVtab::pTab, IdxScan::pTab, sqlite3_vtab_collation, SQLITE_INDEX_CONSTRAINT_EQ, SQLITE_INDEX_CONSTRAINT_GE, SQLITE_INDEX_CONSTRAINT_GT, SQLITE_INDEX_CONSTRAINT_LE, SQLITE_INDEX_CONSTRAINT_LT, SQLITE_OK, and IdxColumn::zColl.

Referenced by idxRegisterVtab().

Here is the call graph for this function:

Here is the caller graph for this function:

expertClose()

int expertClose ( sqlite3_vtab_cursor * cur )

static

                                                {
  ExpertCsr *pCsr = (ExpertCsr*)cur;
  sqlite3_finalize(pCsr->pData);
  sqlite3_free(pCsr);
  return SQLITE_OK;
}

References ExpertCsr::pData, sqlite3_finalize, sqlite3_free, and SQLITE_OK.

Referenced by idxRegisterVtab().

Here is the caller graph for this function:

expertColumn()

int expertColumn ( sqlite3_vtab_cursor * cur, sqlite3_context * ctx, int i )

static

                                                                              {
  ExpertCsr *pCsr = (ExpertCsr*)cur;
  sqlite3_value *pVal;
  pVal = sqlite3_column_value(pCsr->pData, i);
  if( pVal ){
    sqlite3_result_value(ctx, pVal);
  }
  return SQLITE_OK;
}

References ExpertCsr::pData, sqlite3_column_value, sqlite3_result_value, and SQLITE_OK.

Referenced by idxRegisterVtab().

Here is the caller graph for this function:

expertConnect()

int expertConnect ( sqlite3 * db, void * pAux, int argc, const char *const * argv, sqlite3_vtab ** ppVtab, char ** pzErr )

static

 {
  sqlite3expert *pExpert = (sqlite3expert*)pAux;
  ExpertVtab *p = 0;
  int rc;
 
  if( argc!=4 ){
    *pzErr = sqlite3_mprintf("internal error!");
    rc = SQLITE_ERROR;
  }else{
    char *zCreateTable = expertDequote(argv[3]);
    if( zCreateTable ){
      rc = sqlite3_declare_vtab(db, zCreateTable);
      if( rc==SQLITE_OK ){
        p = idxMalloc(&rc, sizeof(ExpertVtab));
      }
      if( rc==SQLITE_OK ){
        p->pExpert = pExpert;
        p->pTab = pExpert->pTable;
        assert( sqlite3_stricmp(p->pTab->zName, argv[2])==0 );
      }
      sqlite3_free(zCreateTable);
    }else{
      rc = SQLITE_NOMEM;
    }
  }
 
  *ppVtab = (sqlite3_vtab*)p;
  return rc;
}

References expertDequote(), idxMalloc(), ExpertVtab::pExpert, ExpertVtab::pTab, sqlite3expert::pTable, sqlite3_declare_vtab, sqlite3_free, sqlite3_mprintf, sqlite3_stricmp, SQLITE_ERROR, SQLITE_NOMEM, SQLITE_OK, and IdxTable::zName.

Referenced by idxRegisterVtab().

Here is the call graph for this function:

Here is the caller graph for this function:

expertDbContainsObject()

int expertDbContainsObject ( sqlite3 * db, const char * zTab, int * pbContains )

static

 {
  const char *zSql = "SELECT 1 FROM sqlite_schema WHERE name = ?";
  sqlite3_stmt *pSql = 0;
  int rc = SQLITE_OK;
  int ret = 0;
 
  rc = sqlite3_prepare_v2(db, zSql, -1, &pSql, 0);
  if( rc==SQLITE_OK ){
    sqlite3_bind_text(pSql, 1, zTab, -1, SQLITE_STATIC);
    if( SQLITE_ROW==sqlite3_step(pSql) ){
      ret = 1;
    }
    rc = sqlite3_finalize(pSql);
  }
 
  *pbContains = ret;
  return rc;
}

References sqlite3_bind_text, sqlite3_finalize, sqlite3_prepare_v2, sqlite3_step, SQLITE_OK, SQLITE_ROW, and SQLITE_STATIC.

Referenced by idxCreateVtabSchema(), and sqlite3_expert_new().

Here is the caller graph for this function:

expertDequote()

char * expertDequote ( const char * zIn )

static

                                           {
  int n = STRLEN(zIn);
  char *zRet = sqlite3_malloc(n);
 
  assert( zIn[0]=='\'' );
  assert( zIn[n-1]=='\'' );
 
  if( zRet ){
    int iOut = 0;
    int iIn = 0;
    for(iIn=1; iIn<(n-1); iIn++){
      if( zIn[iIn]=='\'' ){
        assert( zIn[iIn+1]=='\'' );
        iIn++;
      }
      zRet[iOut++] = zIn[iIn];
    }
    zRet[iOut] = '\0';
  }
 
  return zRet;
}

References sqlite3_malloc, and STRLEN.

Referenced by expertConnect().

Here is the caller graph for this function:

expertDisconnect()

int expertDisconnect ( sqlite3_vtab * pVtab )

static

                                                {
  ExpertVtab *p = (ExpertVtab*)pVtab;
  sqlite3_free(p);
  return SQLITE_OK;
}

References sqlite3_free, and SQLITE_OK.

Referenced by idxRegisterVtab().

Here is the caller graph for this function:

expertDotCommand()

int expertDotCommand ( ShellState * pState, char ** azArg, int nArg )

static

 {
  int rc = SQLITE_OK;
  char *zErr = 0;
  int i;
  int iSample = 0;
 
  assert( pState->expert.pExpert==0 );
  memset(&pState->expert, 0, sizeof(ExpertInfo));
 
  for(i=1; rc==SQLITE_OK && i<nArg; i++){
    char *z = azArg[i];
    int n;
    if( z[0]=='-' && z[1]=='-' ) z++;
    n = strlen30(z);
    if( n>=2 && 0==cli_strncmp(z, "-verbose", n) ){
      pState->expert.bVerbose = 1;
    }
    else if( n>=2 && 0==cli_strncmp(z, "-sample", n) ){
      if( i==(nArg-1) ){
        sqlite3_fprintf(stderr, "option requires an argument: %s\n", z);
        rc = SQLITE_ERROR;
      }else{
        iSample = (int)integerValue(azArg[++i]);
        if( iSample<0 || iSample>100 ){
          sqlite3_fprintf(stderr,"value out of range: %s\n", azArg[i]);
          rc = SQLITE_ERROR;
        }
      }
    }
    else{
      sqlite3_fprintf(stderr,"unknown option: %s\n", z);
      rc = SQLITE_ERROR;
    }
  }
 
  if( rc==SQLITE_OK ){
    pState->expert.pExpert = sqlite3_expert_new(pState->db, &zErr);
    if( pState->expert.pExpert==0 ){
      sqlite3_fprintf(stderr,
          "sqlite3_expert_new: %s\n", zErr ? zErr : "out of memory");
      rc = SQLITE_ERROR;
    }else{
      sqlite3_expert_config(
          pState->expert.pExpert, EXPERT_CONFIG_SAMPLE, iSample
      );
    }
  }
  sqlite3_free(zErr);
 

References ExpertInfo::bVerbose, cli_strncmp(), ShellState::db, ShellState::expert, EXPERT_CONFIG_SAMPLE, integerValue(), ExpertInfo::pExpert, sqlite3_expert_config(), sqlite3_expert_new(), sqlite3_fprintf, sqlite3_free, SQLITE_ERROR, SQLITE_OK, and strlen30().

Referenced by do_meta_command().

Here is the call graph for this function:

Here is the caller graph for this function:

expertEof()

int expertEof ( sqlite3_vtab_cursor * cur )

static

                                              {
  ExpertCsr *pCsr = (ExpertCsr*)cur;
  return pCsr->pData==0;
}

References ExpertCsr::pData.

Referenced by idxRegisterVtab().

Here is the caller graph for this function:

expertFilter()

int expertFilter ( sqlite3_vtab_cursor * cur, int idxNum, const char * idxStr, int argc, sqlite3_value ** argv )

static

 {
  ExpertCsr *pCsr = (ExpertCsr*)cur;
  ExpertVtab *pVtab = (ExpertVtab*)(cur->pVtab);
  sqlite3expert *pExpert = pVtab->pExpert;
  int rc;
 
  (void)idxNum;
  (void)idxStr;
  (void)argc;
  (void)argv;
  rc = sqlite3_finalize(pCsr->pData);
  pCsr->pData = 0;
  if( rc==SQLITE_OK ){
    rc = idxPrintfPrepareStmt(pExpert->db, &pCsr->pData, &pVtab->base.zErrMsg,
        "SELECT * FROM main.%Q WHERE sqlite_expert_sample()", pVtab->pTab->zName
    );
  }
 
  if( rc==SQLITE_OK ){
    rc = expertNext(cur);
  }
  return rc;
}

References ExpertVtab::base, sqlite3expert::db, expertNext(), idxPrintfPrepareStmt(), ExpertCsr::pData, ExpertVtab::pExpert, ExpertVtab::pTab, sqlite3_vtab_cursor::pVtab, sqlite3_finalize, SQLITE_OK, sqlite3_vtab::zErrMsg, and IdxTable::zName.

Referenced by idxRegisterVtab().

Here is the call graph for this function:

Here is the caller graph for this function:

expertFinish()

int expertFinish ( ShellState * pState, int bCancel, char ** pzErr )

static

 {
  int rc = SQLITE_OK;
  sqlite3expert *p = pState->expert.pExpert;
  FILE *out = pState->out;
  assert( p );
  assert( bCancel || pzErr==0 || *pzErr==0 );
  if( bCancel==0 ){
    int bVerbose = pState->expert.bVerbose;
 
    rc = sqlite3_expert_analyze(p, pzErr);
    if( rc==SQLITE_OK ){
      int nQuery = sqlite3_expert_count(p);
      int i;
 
      if( bVerbose ){
        const char *zCand = sqlite3_expert_report(p,0,EXPERT_REPORT_CANDIDATES);
        sqlite3_fputs("-- Candidates -----------------------------\n", out);
        sqlite3_fprintf(out, "%s\n", zCand);
      }
      for(i=0; i<nQuery; i++){
        const char *zSql = sqlite3_expert_report(p, i, EXPERT_REPORT_SQL);
        const char *zIdx = sqlite3_expert_report(p, i, EXPERT_REPORT_INDEXES);
        const char *zEQP = sqlite3_expert_report(p, i, EXPERT_REPORT_PLAN);
        if( zIdx==0 ) zIdx = "(no new indexes)\n";
        if( bVerbose ){
          sqlite3_fprintf(out,
              "-- Query %d --------------------------------\n"
              "%s\n\n"
              ,i+1, zSql);
        }
        sqlite3_fprintf(out, "%s\n%s\n", zIdx, zEQP);
      }
    }
  }
  sqlite3_expert_destroy(p);
  pState->expert.pExpert = 0;

References ExpertInfo::bVerbose, ShellState::expert, EXPERT_REPORT_CANDIDATES, EXPERT_REPORT_INDEXES, EXPERT_REPORT_PLAN, EXPERT_REPORT_SQL, ShellState::out, ExpertInfo::pExpert, sqlite3_expert_analyze(), sqlite3_expert_count(), sqlite3_expert_destroy(), sqlite3_expert_report(), sqlite3_fprintf, sqlite3_fputs, and SQLITE_OK.

Referenced by do_meta_command(), main(), and shell_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

expertHandleSQL()

int expertHandleSQL ( ShellState * pState, const char * zSql, char ** pzErr )

static

 {
  assert( pState->expert.pExpert );
  assert( pzErr==0 || *pzErr==0 );

References ShellState::expert, ExpertInfo::pExpert, and sqlite3_expert_sql().

Referenced by shell_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

expertNext()

int expertNext ( sqlite3_vtab_cursor * cur )

static

                                               {
  ExpertCsr *pCsr = (ExpertCsr*)cur;
  int rc = SQLITE_OK;
 
  assert( pCsr->pData );
  rc = sqlite3_step(pCsr->pData);
  if( rc!=SQLITE_ROW ){
    rc = sqlite3_finalize(pCsr->pData);
    pCsr->pData = 0;
  }else{
    rc = SQLITE_OK;
  }
 
  return rc;
}

References ExpertCsr::pData, sqlite3_finalize, sqlite3_step, SQLITE_OK, and SQLITE_ROW.

Referenced by expertFilter(), and idxRegisterVtab().

Here is the caller graph for this function:

expertOpen()

int expertOpen ( sqlite3_vtab * pVTab, sqlite3_vtab_cursor ** ppCursor )

static

                                                                          {
  int rc = SQLITE_OK;
  ExpertCsr *pCsr;
  (void)pVTab;
  pCsr = idxMalloc(&rc, sizeof(ExpertCsr));
  *ppCursor = (sqlite3_vtab_cursor*)pCsr;
  return rc;
}

References idxMalloc(), and SQLITE_OK.

Referenced by idxRegisterVtab().

Here is the call graph for this function:

Here is the caller graph for this function:

expertRowid()

int expertRowid ( sqlite3_vtab_cursor * cur, sqlite_int64 * pRowid )

static

                                                                      {
  (void)cur;
  *pRowid = 0;
  return SQLITE_OK;
}

References SQLITE_OK.

Referenced by idxRegisterVtab().

Here is the caller graph for this function:

expertSchemaSql()

int expertSchemaSql ( sqlite3 * db, const char * zSql, char ** pzErr )

static

                                                                       {
  int rc = SQLITE_OK;
  char *zErr = 0;
 
  rc = sqlite3_exec(db, zSql, 0, 0, &zErr);
  if( rc!=SQLITE_OK && zErr ){
    int nErr = STRLEN(zErr);
    if( nErr>=15 && memcmp(zErr, "no such module:", 15)==0 ){
      sqlite3_free(zErr);
      rc = SQLITE_OK;
      zErr = 0;
    }
  }
 
  *pzErr = zErr;
  return rc;
}

References sqlite3_exec, sqlite3_free, SQLITE_OK, and STRLEN.

Referenced by idxCreateVtabSchema(), and sqlite3_expert_new().

Here is the caller graph for this function:

expertUpdate()

int expertUpdate ( sqlite3_vtab * pVtab, int nData, sqlite3_value ** azData, sqlite_int64 * pRowid )

static

 {
  (void)pVtab;
  (void)nData;
  (void)azData;
  (void)pRowid;
  return SQLITE_OK;
}

References SQLITE_OK.

Referenced by idxRegisterVtab().

Here is the caller graph for this function:

explain_data_delete()

void explain_data_delete ( ShellState * p )

static

                                              {
  sqlite3_free(p->aiIndent);
  p->aiIndent = 0;
  p->nIndent = 0;

References ShellState::aiIndent, ShellState::iIndent, ShellState::nIndent, and sqlite3_free.

Referenced by display_scanstats(), and shell_exec().

Here is the caller graph for this function:

explain_data_prepare()

void explain_data_prepare ( ShellState * p, sqlite3_stmt * pSql )

static

                                                                   {
  int *abYield = 0;               /* True if op is an OP_Yield */
  int nAlloc = 0;                 /* Allocated size of p->aiIndent[], abYield */
  int iOp;                        /* Index of operation in p->aiIndent[] */
 
  const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext",
                           "Return", 0 };
  const char *azYield[] = { "Yield", "SeekLT", "SeekGT", "RowSetRead",
                            "Rewind", 0 };
  const char *azGoto[] = { "Goto", 0 };
 
  /* The caller guarantees that the leftmost 4 columns of the statement
  ** passed to this function are equivalent to the leftmost 4 columns
  ** of EXPLAIN statement output. In practice the statement may be
  ** an EXPLAIN, or it may be a query on the bytecode() virtual table.  */
  assert( sqlite3_column_count(pSql)>=4 );
  assert( 0==sqlite3_stricmp( sqlite3_column_name(pSql, 0), "addr" ) );
  assert( 0==sqlite3_stricmp( sqlite3_column_name(pSql, 1), "opcode" ) );
  assert( 0==sqlite3_stricmp( sqlite3_column_name(pSql, 2), "p1" ) );
  assert( 0==sqlite3_stricmp( sqlite3_column_name(pSql, 3), "p2" ) );
 
  for(iOp=0; SQLITE_ROW==sqlite3_step(pSql); iOp++){
    int i;
    int iAddr = sqlite3_column_int(pSql, 0);
    const char *zOp = (const char*)sqlite3_column_text(pSql, 1);
    int p1 = sqlite3_column_int(pSql, 2);
    int p2 = sqlite3_column_int(pSql, 3);
 
    /* Assuming that p2 is an instruction address, set variable p2op to the
    ** index of that instruction in the aiIndent[] array. p2 and p2op may be
    ** different if the current instruction is part of a sub-program generated
    ** by an SQL trigger or foreign key.  */
    int p2op = (p2 + (iOp-iAddr));
 
    /* Grow the p->aiIndent array as required */
    if( iOp>=nAlloc ){
      nAlloc += 100;
      p->aiIndent = (int*)sqlite3_realloc64(p->aiIndent, nAlloc*sizeof(int));
      shell_check_oom(p->aiIndent);
      abYield = (int*)sqlite3_realloc64(abYield, nAlloc*sizeof(int));
      shell_check_oom(abYield);
    }
 
    abYield[iOp] = str_in_array(zOp, azYield);
    p->aiIndent[iOp] = 0;
    p->nIndent = iOp+1;
    if( str_in_array(zOp, azNext) && p2op>0 ){
      for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2;
    }
    if( str_in_array(zOp, azGoto) && p2op<iOp && (abYield[p2op] || p1) ){
      for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2;
    }
  }
 
  p->iIndent = 0;
  sqlite3_free(abYield);

References ShellState::aiIndent, ShellState::iIndent, ShellState::nIndent, shell_check_oom(), sqlite3_column_count, sqlite3_column_int, sqlite3_column_name, sqlite3_column_text, sqlite3_free, sqlite3_realloc64, sqlite3_reset, sqlite3_step, sqlite3_stricmp, SQLITE_ROW, and str_in_array().

Referenced by display_scanstats(), and shell_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

failIfSafeMode()

void failIfSafeMode ( ShellState * p, const char * zErrMsg, ... )

static

 {
  if( p->bSafeMode ){
    va_list ap;
    char *zMsg;
    va_start(ap, zErrMsg);
    zMsg = sqlite3_vmprintf(zErrMsg, ap);
    va_end(ap);
    sqlite3_fprintf(stderr, "line %d: %s\n", p->lineno, zMsg);
    exit(1);

References ShellState::bSafeMode, ShellState::lineno, sqlite3_fprintf, and sqlite3_vmprintf.

Referenced by do_meta_command(), and safeModeAuth().

Here is the caller graph for this function:

faultsim_callback()

int faultsim_callback ( int iArg )

static

                                      {
  if( faultsim_state.iId>0 && faultsim_state.iId!=iArg ){
    return SQLITE_OK;
  }
  if( faultsim_state.iCnt ){
    if( faultsim_state.iCnt>0 ) faultsim_state.iCnt--;
    if( faultsim_state.eVerbose>=2 ){
      sqlite3_fprintf(stdout, 
         "FAULT-SIM id=%d no-fault (cnt=%d)\n", iArg, faultsim_state.iCnt);
    }
    return SQLITE_OK;
  }
  if( faultsim_state.eVerbose>=1 ){
    sqlite3_fprintf(stdout, 
         "FAULT-SIM id=%d returns %d\n", iArg, faultsim_state.iErr);
  }
  faultsim_state.iCnt = faultsim_state.iInterval;
  faultsim_state.nHit++;
  if( faultsim_state.nRepeat>0 && faultsim_state.nRepeat<=faultsim_state.nHit ){
    faultsim_state.iCnt = -1;
  }

References faultsim_state, sqlite3_fprintf, and SQLITE_OK.

Referenced by do_meta_command().

Here is the caller graph for this function:

fileLinkStat()

int fileLinkStat ( const char * zPath, struct stat * pStatBuf )

static

 {
#if defined(_WIN32)
  return fileStat(zPath, pStatBuf);
#else
  return lstat(zPath, pStatBuf);
#endif
}

References fileStat(), and STRUCT_STAT.

Referenced by fsdirFilter(), and fsdirNext().

Here is the call graph for this function:

Here is the caller graph for this function:

fileStat()

int fileStat ( const char * zPath, struct stat * pStatBuf )

static

 {
#if defined(_WIN32)
  sqlite3_int64 sz = strlen(zPath);
  wchar_t *b1 = sqlite3_malloc64( (sz+1)*sizeof(b1[0]) );
  int rc;
  if( b1==0 ) return 1;
  sz = MultiByteToWideChar(CP_UTF8, 0, zPath, sz, b1, sz);
  b1[sz] = 0;
  rc = _wstat(b1, pStatBuf);
  if( rc==0 ) statTimesToUtc(zPath, pStatBuf);
  return rc;
#else
  return stat(zPath, pStatBuf);
#endif
}

References sqlite3_malloc64, and STRUCT_STAT.

Referenced by fileLinkStat(), makeDirectory(), and writeFile().

Here is the caller graph for this function:

fileTail()

const char * fileTail ( const char * z )

static

                                          {
  size_t i;
  if( z==0 ) return 0;
  i = strlen(z)-1;
  while( i>0 && z[i-1]!='/' ){ i--; }
  return &z[i];
}

Referenced by vfstraceOpen().

Here is the caller graph for this function:

find_home_dir()

char * find_home_dir ( int clearFlag )

static

                                         {
  static char *home_dir = NULL;
  if( clearFlag ){
    free(home_dir);
    home_dir = 0;
    return 0;
  }
  if( home_dir ) return home_dir;
 
#if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) \
     && !defined(__RTP__) && !defined(_WRS_KERNEL) && !defined(SQLITE_WASI)
  {
    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 ){
    i64 n = strlen(home_dir) + 1;
    char *z = malloc( n );
    if( z ) memcpy(z, home_dir, n);
    home_dir = z;
  }
 

References sqlite3_snprintf, and strlen30().

Referenced by main(), and process_sqliterc().

Here is the call graph for this function:

Here is the caller graph for this function:

find_xdg_config()

char * find_xdg_config ( void )

static

                                  {
#if defined(_WIN32) || defined(WIN32) || defined(_WIN32_WCE) \
     || defined(__RTP__) || defined(_WRS_KERNEL)
  return 0;
#else
  char *zConfig = 0;
  const char *zXdgHome;
 
  zXdgHome = getenv("XDG_CONFIG_HOME");
  if( zXdgHome==0 ){
    const char *zHome = getenv("HOME");
    if( zHome==0 ) return 0;
    zConfig = sqlite3_mprintf("%s/.config/sqlite3/sqliterc", zHome);
  }else{
    zConfig = sqlite3_mprintf("%s/sqlite3/sqliterc", zXdgHome);
  }
  shell_check_oom(zConfig);
  if( access(zConfig,0)!=0 ){
    sqlite3_free(zConfig);
    zConfig = 0;
  }
  return zConfig;

References shell_check_oom(), sqlite3_free, and sqlite3_mprintf.

Referenced by process_sqliterc().

Here is the call graph for this function:

Here is the caller graph for this function:

freeColumnList()

void freeColumnList ( char ** azCol )

static

                                        {
  int i;
  for(i=1; azCol[i]; i++){
    sqlite3_free(azCol[i]);
  }
  /* azCol[0] is a static string */

References sqlite3_free.

Referenced by dump_callback(), and tableColumnList().

Here is the caller graph for this function:

freeText()

void freeText ( ShellText * p )

static

                                  {
  free(p->z);
  initText(p);
}

References initText(), and ShellText::z.

Referenced by do_meta_command(), dump_callback(), and shellFakeSchema().

Here is the call graph for this function:

Here is the caller graph for this function:

fromBase64()

u8 * fromBase64 ( char * pIn, int ncIn, u8 * pOut )

static

                                                      {
  if( ncIn>0 && pIn[ncIn-1]=='\n' ) --ncIn;
  while( ncIn>0 && *pIn!=PAD_CHAR ){
    static signed char nboi[] = { 0, 0, 1, 2, 3 };
    char *pUse = skipNonB64(pIn, ncIn);
    unsigned long qv = 0L;
    int nti, nbo, nac;
    ncIn -= (pUse - pIn);
    pIn = pUse;
    nti = (ncIn>4)? 4 : ncIn;
    ncIn -= nti;
    nbo = nboi[nti];
    if( nbo==0 ) break;
    for( nac=0; nac<4; ++nac ){
      char c = (nac<nti)? *pIn++ : b64Numerals[0];
      u8 bdp = BX_DV_PROTO(c);
      switch( bdp ){
      case ND:
        /*  Treat dark non-digits as pad, but they terminate decode too. */
        ncIn = 0;
        deliberate_fall_through; /* FALLTHRU */
      case WS:
        /* Treat whitespace as pad and terminate this group.*/
        nti = nac;
        deliberate_fall_through; /* FALLTHRU */
      case PC:
        bdp = 0;
        --nbo;
        deliberate_fall_through; /* FALLTHRU */
      default: /* bdp is the digit value. */
        qv = qv<<6 | bdp;
        break;
      }
    }
    switch( nbo ){
    case 3:
      pOut[2] = (qv) & 0xff;
      deliberate_fall_through; /* FALLTHRU */
    case 2:
      pOut[1] = (qv>>8) & 0xff;
      deliberate_fall_through; /* FALLTHRU */
    case 1:
      pOut[0] = (qv>>16) & 0xff;
      break;
    }
    pOut += nbo;
  }
  return pOut;
}

References b64Numerals, BX_DV_PROTO, c, deliberate_fall_through, ND, PAD_CHAR, PC, skipNonB64(), and WS.

Referenced by base64().

Here is the call graph for this function:

Here is the caller graph for this function:

fromBase85()

u8 * fromBase85 ( char * pIn, int ncIn, u8 * pOut )

static

                                                      {
  if( ncIn>0 && pIn[ncIn-1]=='\n' ) --ncIn;
  while( ncIn>0 ){
    static signed char nboi[] = { 0, 0, 1, 2, 3, 4 };
    char *pUse = skipNonB85(pIn, ncIn);
    unsigned long qv = 0L;
    int nti, nbo;
    ncIn -= (pUse - pIn);
    pIn = pUse;
    nti = (ncIn>5)? 5 : ncIn;
    nbo = nboi[nti];
    if( nbo==0 ) break;
    while( nti>0 ){
      char c = *pIn++;
      u8 cdo = B85_DNOS(c);
      --ncIn;
      if( cdo==0 ) break;
      qv = 85 * qv + (c - cdo);
      --nti;
    }
    nbo -= nti; /* Adjust for early (non-digit) end of group. */
    switch( nbo ){
    case 4:
      *pOut++ = (qv >> 24)&0xff;
      /* FALLTHRU */
    case 3:
      *pOut++ = (qv >> 16)&0xff;
      /* FALLTHRU */
    case 2:
      *pOut++ = (qv >> 8)&0xff;
      /* FALLTHRU */
    case 1:
      *pOut++ = qv&0xff;
      /* FALLTHRU */
    case 0:
      break;
    }
  }
  return pOut;
}

References B85_DNOS, c, and skipNonB85().

Referenced by base85().

Here is the call graph for this function:

Here is the caller graph for this function:

fsdirBestIndex()

int fsdirBestIndex ( sqlite3_vtab * tab, sqlite3_index_info * pIdxInfo )

static

 {
  int i;                 /* Loop over constraints */
  int idxPath = -1;      /* Index in pIdxInfo->aConstraint of PATH= */
  int idxDir = -1;       /* Index in pIdxInfo->aConstraint of DIR= */
  int seenPath = 0;      /* True if an unusable PATH= constraint is seen */
  int seenDir = 0;       /* True if an unusable DIR= constraint is seen */
  const struct sqlite3_index_constraint *pConstraint;
 
  (void)tab;
  pConstraint = pIdxInfo->aConstraint;
  for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){
    if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
    switch( pConstraint->iColumn ){
      case FSDIR_COLUMN_PATH: {
        if( pConstraint->usable ){
          idxPath = i;
          seenPath = 0;
        }else if( idxPath<0 ){
          seenPath = 1;
        }
        break;
      }
      case FSDIR_COLUMN_DIR: {
        if( pConstraint->usable ){
          idxDir = i;
          seenDir = 0;
        }else if( idxDir<0 ){
          seenDir = 1;
        }
        break;
      }
    } 
  }
  if( seenPath || seenDir ){
    /* If input parameters are unusable, disallow this plan */
    return SQLITE_CONSTRAINT;
  }
 
  if( idxPath<0 ){
    pIdxInfo->idxNum = 0;
    /* The pIdxInfo->estimatedCost should have been initialized to a huge
    ** number.  Leave it unchanged. */
    pIdxInfo->estimatedRows = 0x7fffffff;
  }else{
    pIdxInfo->aConstraintUsage[idxPath].omit = 1;
    pIdxInfo->aConstraintUsage[idxPath].argvIndex = 1;
    if( idxDir>=0 ){
      pIdxInfo->aConstraintUsage[idxDir].omit = 1;
      pIdxInfo->aConstraintUsage[idxDir].argvIndex = 2;
      pIdxInfo->idxNum = 2;
      pIdxInfo->estimatedCost = 10.0;
    }else{
      pIdxInfo->idxNum = 1;
      pIdxInfo->estimatedCost = 100.0;
    }
  }
 
  return SQLITE_OK;
}

References sqlite3_index_info::aConstraint, sqlite3_index_info::aConstraintUsage, sqlite3_index_info::sqlite3_index_constraint_usage::argvIndex, sqlite3_index_info::estimatedCost, sqlite3_index_info::estimatedRows, FSDIR_COLUMN_DIR, FSDIR_COLUMN_PATH, sqlite3_index_info::idxNum, sqlite3_index_info::nConstraint, sqlite3_index_info::sqlite3_index_constraint_usage::omit, SQLITE_CONSTRAINT, SQLITE_INDEX_CONSTRAINT_EQ, and SQLITE_OK.

Referenced by fsdirRegister().

Here is the caller graph for this function:

fsdirClose()

int fsdirClose ( sqlite3_vtab_cursor * cur )

static

                                               {
  fsdir_cursor *pCur = (fsdir_cursor*)cur;
 
  fsdirResetCursor(pCur);
  sqlite3_free(pCur);
  return SQLITE_OK;
}

References fsdirResetCursor(), sqlite3_free, and SQLITE_OK.

Referenced by fsdirRegister().

Here is the call graph for this function:

Here is the caller graph for this function:

fsdirColumn()

int fsdirColumn ( sqlite3_vtab_cursor * cur, sqlite3_context * ctx, int i )

static

 {
  fsdir_cursor *pCur = (fsdir_cursor*)cur;
  switch( i ){
    case FSDIR_COLUMN_NAME: {
      sqlite3_result_text(ctx, &pCur->zPath[pCur->nBase], -1, SQLITE_TRANSIENT);
      break;
    }
 
    case FSDIR_COLUMN_MODE:
      sqlite3_result_int64(ctx, pCur->sStat.st_mode);
      break;
 
    case FSDIR_COLUMN_MTIME:
      sqlite3_result_int64(ctx, pCur->sStat.st_mtime);
      break;
 
    case FSDIR_COLUMN_DATA: {
      mode_t m = pCur->sStat.st_mode;
      if( S_ISDIR(m) ){
        sqlite3_result_null(ctx);
#if !defined(_WIN32) && !defined(WIN32)
      }else if( S_ISLNK(m) ){
        char aStatic[64];
        char *aBuf = aStatic;
        sqlite3_int64 nBuf = 64;
        int n;
 
        while( 1 ){
          n = readlink(pCur->zPath, aBuf, nBuf);
          if( n<nBuf ) break;
          if( aBuf!=aStatic ) sqlite3_free(aBuf);
          nBuf = nBuf*2;
          aBuf = sqlite3_malloc64(nBuf);
          if( aBuf==0 ){
            sqlite3_result_error_nomem(ctx);
            return SQLITE_NOMEM;
          }
        }
 
        sqlite3_result_text(ctx, aBuf, n, SQLITE_TRANSIENT);
        if( aBuf!=aStatic ) sqlite3_free(aBuf);
#endif
      }else{
        readFileContents(ctx, pCur->zPath);
      }
    }
    case FSDIR_COLUMN_PATH:
    default: {
      /* The FSDIR_COLUMN_PATH and FSDIR_COLUMN_DIR are input parameters.
      ** always return their values as NULL */
      break;
    }
  }
  return SQLITE_OK;
}

References FSDIR_COLUMN_DATA, FSDIR_COLUMN_MODE, FSDIR_COLUMN_MTIME, FSDIR_COLUMN_NAME, FSDIR_COLUMN_PATH, fsdir_cursor::nBase, readFileContents(), sqlite3_free, sqlite3_malloc64, sqlite3_result_error_nomem, sqlite3_result_int64, sqlite3_result_null, sqlite3_result_text, SQLITE_NOMEM, SQLITE_OK, SQLITE_TRANSIENT, fsdir_cursor::sStat, and fsdir_cursor::zPath.

Referenced by fsdirRegister().

Here is the call graph for this function:

Here is the caller graph for this function:

fsdirConnect()

int fsdirConnect ( sqlite3 * db, void * pAux, int argc, const char *const * argv, sqlite3_vtab ** ppVtab, char ** pzErr )

static

 {
  fsdir_tab *pNew = 0;
  int rc;
  (void)pAux;
  (void)argc;
  (void)argv;
  (void)pzErr;
  rc = sqlite3_declare_vtab(db, "CREATE TABLE x" FSDIR_SCHEMA);
  if( rc==SQLITE_OK ){
    pNew = (fsdir_tab*)sqlite3_malloc( sizeof(*pNew) );
    if( pNew==0 ) return SQLITE_NOMEM;
    memset(pNew, 0, sizeof(*pNew));
    sqlite3_vtab_config(db, SQLITE_VTAB_DIRECTONLY);
  }
  *ppVtab = (sqlite3_vtab*)pNew;
  return rc;
}

References FSDIR_SCHEMA, sqlite3_declare_vtab, sqlite3_malloc, sqlite3_vtab_config, SQLITE_NOMEM, SQLITE_OK, and SQLITE_VTAB_DIRECTONLY.

Referenced by fsdirRegister().

Here is the caller graph for this function:

fsdirDisconnect()

int fsdirDisconnect ( sqlite3_vtab * pVtab )

static

                                               {
  sqlite3_free(pVtab);
  return SQLITE_OK;
}

References sqlite3_free, and SQLITE_OK.

Referenced by fsdirRegister().

Here is the caller graph for this function:

fsdirEof()

int fsdirEof ( sqlite3_vtab_cursor * cur )

static

                                             {
  fsdir_cursor *pCur = (fsdir_cursor*)cur;
  return (pCur->zPath==0);
}

References fsdir_cursor::zPath.

Referenced by fsdirRegister().

Here is the caller graph for this function:

fsdirFilter()

int fsdirFilter ( sqlite3_vtab_cursor * cur, int idxNum, const char * idxStr, int argc, sqlite3_value ** argv )

static

 {
  const char *zDir = 0;
  fsdir_cursor *pCur = (fsdir_cursor*)cur;
  (void)idxStr;
  fsdirResetCursor(pCur);
 
  if( idxNum==0 ){
    fsdirSetErrmsg(pCur, "table function fsdir requires an argument");
    return SQLITE_ERROR;
  }
 
  assert( argc==idxNum && (argc==1 || argc==2) );
  zDir = (const char*)sqlite3_value_text(argv[0]);
  if( zDir==0 ){
    fsdirSetErrmsg(pCur, "table function fsdir requires a non-NULL argument");
    return SQLITE_ERROR;
  }
  if( argc==2 ){
    pCur->zBase = (const char*)sqlite3_value_text(argv[1]);
  }
  if( pCur->zBase ){
    pCur->nBase = (int)strlen(pCur->zBase)+1;
    pCur->zPath = sqlite3_mprintf("%s/%s", pCur->zBase, zDir);
  }else{
    pCur->zPath = sqlite3_mprintf("%s", zDir);
  }
 
  if( pCur->zPath==0 ){
    return SQLITE_NOMEM;
  }
  if( fileLinkStat(pCur->zPath, &pCur->sStat) ){
    fsdirSetErrmsg(pCur, "cannot stat file: %s", pCur->zPath);
    return SQLITE_ERROR;
  }
 
  return SQLITE_OK;
}

References fileLinkStat(), fsdirResetCursor(), fsdirSetErrmsg(), fsdir_cursor::nBase, sqlite3_mprintf, sqlite3_value_text, SQLITE_ERROR, SQLITE_NOMEM, SQLITE_OK, fsdir_cursor::sStat, fsdir_cursor::zBase, and fsdir_cursor::zPath.

Referenced by fsdirRegister().

Here is the call graph for this function:

Here is the caller graph for this function:

fsdirNext()

int fsdirNext ( sqlite3_vtab_cursor * cur )

static

                                              {
  fsdir_cursor *pCur = (fsdir_cursor*)cur;
  mode_t m = pCur->sStat.st_mode;
 
  pCur->iRowid++;
  if( S_ISDIR(m) ){
    /* Descend into this directory */
    int iNew = pCur->iLvl + 1;
    FsdirLevel *pLvl;
    if( iNew>=pCur->nLvl ){
      int nNew = iNew+1;
      sqlite3_int64 nByte = nNew*sizeof(FsdirLevel);
      FsdirLevel *aNew = (FsdirLevel*)sqlite3_realloc64(pCur->aLvl, nByte);
      if( aNew==0 ) return SQLITE_NOMEM;
      memset(&aNew[pCur->nLvl], 0, sizeof(FsdirLevel)*(nNew-pCur->nLvl));
      pCur->aLvl = aNew;
      pCur->nLvl = nNew;
    }
    pCur->iLvl = iNew;
    pLvl = &pCur->aLvl[iNew];
    
    pLvl->zDir = pCur->zPath;
    pCur->zPath = 0;
    pLvl->pDir = opendir(pLvl->zDir);
    if( pLvl->pDir==0 ){
      fsdirSetErrmsg(pCur, "cannot read directory: %s", pCur->zPath);
      return SQLITE_ERROR;
    }
  }
 
  while( pCur->iLvl>=0 ){
    FsdirLevel *pLvl = &pCur->aLvl[pCur->iLvl];
    struct dirent *pEntry = readdir(pLvl->pDir);
    if( pEntry ){
      if( pEntry->d_name[0]=='.' ){
       if( pEntry->d_name[1]=='.' && pEntry->d_name[2]=='\0' ) continue;
       if( pEntry->d_name[1]=='\0' ) continue;
      }
      sqlite3_free(pCur->zPath);
      pCur->zPath = sqlite3_mprintf("%s/%s", pLvl->zDir, pEntry->d_name);
      if( pCur->zPath==0 ) return SQLITE_NOMEM;
      if( fileLinkStat(pCur->zPath, &pCur->sStat) ){
        fsdirSetErrmsg(pCur, "cannot stat file: %s", pCur->zPath);
        return SQLITE_ERROR;
      }
      return SQLITE_OK;
    }
    closedir(pLvl->pDir);
    sqlite3_free(pLvl->zDir);
    pLvl->pDir = 0;
    pLvl->zDir = 0;
    pCur->iLvl--;
  }
 
  /* EOF */
  sqlite3_free(pCur->zPath);
  pCur->zPath = 0;
  return SQLITE_OK;
}

References fsdir_cursor::aLvl, fileLinkStat(), fsdirSetErrmsg(), fsdir_cursor::iLvl, fsdir_cursor::iRowid, fsdir_cursor::nLvl, FsdirLevel::pDir, sqlite3_free, sqlite3_mprintf, sqlite3_realloc64, SQLITE_ERROR, SQLITE_NOMEM, SQLITE_OK, fsdir_cursor::sStat, FsdirLevel::zDir, and fsdir_cursor::zPath.

Referenced by fsdirRegister().

Here is the call graph for this function:

Here is the caller graph for this function:

fsdirOpen()

int fsdirOpen ( sqlite3_vtab * p, sqlite3_vtab_cursor ** ppCursor )

static

                                                                     {
  fsdir_cursor *pCur;
  (void)p;
  pCur = sqlite3_malloc( sizeof(*pCur) );
  if( pCur==0 ) return SQLITE_NOMEM;
  memset(pCur, 0, sizeof(*pCur));
  pCur->iLvl = -1;
  *ppCursor = &pCur->base;
  return SQLITE_OK;
}

References fsdir_cursor::base, fsdir_cursor::iLvl, sqlite3_malloc, SQLITE_NOMEM, and SQLITE_OK.

Referenced by fsdirRegister().

Here is the caller graph for this function:

fsdirRegister()

int fsdirRegister ( sqlite3 * db )

static

                                     {
  static sqlite3_module fsdirModule = {
    0,                         /* iVersion */
    0,                         /* xCreate */
    fsdirConnect,              /* xConnect */
    fsdirBestIndex,            /* xBestIndex */
    fsdirDisconnect,           /* xDisconnect */
    0,                         /* xDestroy */
    fsdirOpen,                 /* xOpen - open a cursor */
    fsdirClose,                /* xClose - close a cursor */
    fsdirFilter,               /* xFilter - configure scan constraints */
    fsdirNext,                 /* xNext - advance a cursor */
    fsdirEof,                  /* xEof - check for end of scan */
    fsdirColumn,               /* xColumn - read data */
    fsdirRowid,                /* xRowid - read data */
    0,                         /* xUpdate */
    0,                         /* xBegin */
    0,                         /* xSync */
    0,                         /* xCommit */
    0,                         /* xRollback */
    0,                         /* xFindMethod */
    0,                         /* xRename */
    0,                         /* xSavepoint */
    0,                         /* xRelease */
    0,                         /* xRollbackTo */
    0,                         /* xShadowName */
    0                          /* xIntegrity */
  };
 
  int rc = sqlite3_create_module(db, "fsdir", &fsdirModule, 0);
  return rc;
}

References fsdirBestIndex(), fsdirClose(), fsdirColumn(), fsdirConnect(), fsdirDisconnect(), fsdirEof(), fsdirFilter(), fsdirNext(), fsdirOpen(), fsdirRowid(), and sqlite3_create_module.

Referenced by sqlite3_fileio_init().

Here is the call graph for this function:

Here is the caller graph for this function:

fsdirResetCursor()

void fsdirResetCursor ( fsdir_cursor * pCur )

static

                                                {
  int i;
  for(i=0; i<=pCur->iLvl; i++){
    FsdirLevel *pLvl = &pCur->aLvl[i];
    if( pLvl->pDir ) closedir(pLvl->pDir);
    sqlite3_free(pLvl->zDir);
  }
  sqlite3_free(pCur->zPath);
  sqlite3_free(pCur->aLvl);
  pCur->aLvl = 0;
  pCur->zPath = 0;
  pCur->zBase = 0;
  pCur->nBase = 0;
  pCur->nLvl = 0;
  pCur->iLvl = -1;
  pCur->iRowid = 1;
}

References fsdir_cursor::aLvl, fsdir_cursor::iLvl, fsdir_cursor::iRowid, fsdir_cursor::nBase, fsdir_cursor::nLvl, FsdirLevel::pDir, sqlite3_free, fsdir_cursor::zBase, FsdirLevel::zDir, and fsdir_cursor::zPath.

Referenced by fsdirClose(), and fsdirFilter().

Here is the caller graph for this function:

fsdirRowid()

int fsdirRowid ( sqlite3_vtab_cursor * cur, sqlite_int64 * pRowid )

static

                                                                     {
  fsdir_cursor *pCur = (fsdir_cursor*)cur;
  *pRowid = pCur->iRowid;
  return SQLITE_OK;
}

References fsdir_cursor::iRowid, and SQLITE_OK.

Referenced by fsdirRegister().

Here is the caller graph for this function:

fsdirSetErrmsg()

void fsdirSetErrmsg ( fsdir_cursor * pCur, const char * zFmt, ... )

static

                                                                     {
  va_list ap;
  va_start(ap, zFmt);
  pCur->base.pVtab->zErrMsg = sqlite3_vmprintf(zFmt, ap);
  va_end(ap);
}

References fsdir_cursor::base, sqlite3_vtab_cursor::pVtab, sqlite3_vmprintf, and sqlite3_vtab::zErrMsg.

Referenced by fsdirFilter(), and fsdirNext().

Here is the caller graph for this function:

genSeqMember()

sqlite3_int64 genSeqMember ( sqlite3_int64 smBase, sqlite3_int64 smStep, sqlite3_uint64 ix )

static

 {
  static const sqlite3_uint64 mxI64 =
      ((sqlite3_uint64)0x7fffffff)<<32 | 0xffffffff;
  if( ix>=mxI64 ){
    /* Get ix into signed i64 range. */
    ix -= mxI64;
    /* With 2's complement ALU, this next can be 1 step, but is split into
     * 2 for UBSAN's satisfaction (and hypothetical 1's complement ALUs.) */
    smBase += (mxI64/2) * smStep;
    smBase += (mxI64 - mxI64/2) * smStep;
  }
  /* Under UBSAN (or on 1's complement machines), must do this last term
   * in steps to avoid the dreaded (and harmless) signed multiply overflow. */
  if( ix>=2 ){
    sqlite3_int64 ix2 = (sqlite3_int64)ix/2;
    smBase += ix2*smStep;
    ix -= ix2;
  }
  return smBase + ((sqlite3_int64)ix)*smStep;
}

Referenced by setupSequence().

Here is the caller graph for this function:

hash_finish()

void hash_finish ( SHA1Context * p, char * zOut, int bAsBinary )

static

 {
  unsigned int i;
  unsigned char finalcount[8];
  unsigned char digest[20];
  static const char zEncode[] = "0123456789abcdef";
 
  for (i = 0; i < 8; i++){
    finalcount[i] = (unsigned char)((p->count[(i >= 4 ? 0 : 1)]
       >> ((3-(i & 3)) * 8) ) & 255); /* Endian independent */
  }
  hash_step(p, (const unsigned char *)"\200", 1);
  while ((p->count[0] & 504) != 448){
    hash_step(p, (const unsigned char *)"\0", 1);
  }
  hash_step(p, finalcount, 8);  /* Should cause a SHA1Transform() */
  for (i = 0; i < 20; i++){
    digest[i] = (unsigned char)((p->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
  }
  if( bAsBinary ){
    memcpy(zOut, digest, 20);
  }else{
    for(i=0; i<20; i++){
      zOut[i*2] = zEncode[(digest[i]>>4)&0xf];
      zOut[i*2+1] = zEncode[digest[i] & 0xf];
    }
    zOut[i*2]= 0;
  }
}

References SHA1Context::count, hash_step(), and SHA1Context::state.

Referenced by sha1Func(), and sha1QueryFunc().

Here is the call graph for this function:

Here is the caller graph for this function:

hash_init()

void hash_init ( SHA1Context * p )

static

                                     {
  /* SHA1 initialization constants */
  p->state[0] = 0x67452301;
  p->state[1] = 0xEFCDAB89;
  p->state[2] = 0x98BADCFE;
  p->state[3] = 0x10325476;
  p->state[4] = 0xC3D2E1F0;
  p->count[0] = p->count[1] = 0;
}

References SHA1Context::count, and SHA1Context::state.

Referenced by sha1Func(), and sha1QueryFunc().

Here is the caller graph for this function:

hash_step()

void hash_step ( SHA1Context * p, const unsigned char * data, unsigned int len )

static

 {
  unsigned int i, j;
 
  j = p->count[0];
  if( (p->count[0] += len << 3) < j ){
    p->count[1] += (len>>29)+1;
  }
  j = (j >> 3) & 63;
  if( (j + len) > 63 ){
    (void)memcpy(&p->buffer[j], data, (i = 64-j));
    SHA1Transform(p->state, p->buffer);
    for(; i + 63 < len; i += 64){
      SHA1Transform(p->state, &data[i]);
    }
    j = 0;
  }else{
    i = 0;
  }
  (void)memcpy(&p->buffer[j], &data[i], len - i);
}

References SHA1Context::buffer, SHA1Context::count, SHA1Transform(), and SHA1Context::state.

Referenced by hash_finish(), hash_step_vformat(), sha1Func(), and sha1QueryFunc().

Here is the call graph for this function:

Here is the caller graph for this function:

hash_step_vformat()

void hash_step_vformat ( SHA1Context * p, const char * zFormat, ... )

static

 {
  va_list ap;
  int n;
  char zBuf[50];
  va_start(ap, zFormat);
  sqlite3_vsnprintf(sizeof(zBuf),zBuf,zFormat,ap);
  va_end(ap);
  n = (int)strlen(zBuf);
  hash_step(p, (unsigned char*)zBuf, n);
}

References hash_step(), and sqlite3_vsnprintf.

Referenced by sha1QueryFunc().

Here is the call graph for this function:

Here is the caller graph for this function:

hexDigitValue()

int hexDigitValue ( char c )

static

                                {
  if( c>='0' && c<='9' ) return c - '0';
  if( c>='a' && c<='f' ) return c - 'a' + 10;
  if( c>='A' && c<='F' ) return c - 'A' + 10;
  return -1;
}

References c.

Referenced by booleanValue(), integerValue(), and resolve_backslashes().

Here is the caller graph for this function:

idxAppendColDefn()

char * idxAppendColDefn ( int * pRc, char * zIn, IdxTable * pTab, IdxConstraint * pCons )

static

 {
  char *zRet = zIn;
  IdxColumn *p = &pTab->aCol[pCons->iCol];
  if( zRet ) zRet = idxAppendText(pRc, zRet, ", ");
 
  if( idxIdentifierRequiresQuotes(p->zName) ){
    zRet = idxAppendText(pRc, zRet, "%Q", p->zName);
  }else{
    zRet = idxAppendText(pRc, zRet, "%s", p->zName);
  }
 
  if( sqlite3_stricmp(p->zColl, pCons->zColl) ){
    if( idxIdentifierRequiresQuotes(pCons->zColl) ){
      zRet = idxAppendText(pRc, zRet, " COLLATE %Q", pCons->zColl);
    }else{
      zRet = idxAppendText(pRc, zRet, " COLLATE %s", pCons->zColl);
    }
  }
 
  if( pCons->bDesc ){
    zRet = idxAppendText(pRc, zRet, " DESC");
  }
  return zRet;
}

References IdxTable::aCol, IdxConstraint::bDesc, IdxConstraint::iCol, idxAppendText(), idxIdentifierRequiresQuotes(), sqlite3_stricmp, IdxColumn::zColl, IdxConstraint::zColl, and IdxColumn::zName.

Referenced by idxCreateFromCons().

Here is the call graph for this function:

Here is the caller graph for this function:

idxAppendText()

char * idxAppendText ( int * pRc, char * zIn, const char * zFmt, ... )

static

                                                                      {
  va_list ap;
  char *zAppend = 0;
  char *zRet = 0;
  int nIn = zIn ? STRLEN(zIn) : 0;
  int nAppend = 0;
  va_start(ap, zFmt);
  if( *pRc==SQLITE_OK ){
    zAppend = sqlite3_vmprintf(zFmt, ap);
    if( zAppend ){
      nAppend = STRLEN(zAppend);
      zRet = (char*)sqlite3_malloc(nIn + nAppend + 1);
    }
    if( zAppend && zRet ){
      if( nIn ) memcpy(zRet, zIn, nIn);
      memcpy(&zRet[nIn], zAppend, nAppend+1);
    }else{
      sqlite3_free(zRet);
      zRet = 0;
      *pRc = SQLITE_NOMEM;
    }
    sqlite3_free(zAppend);
    sqlite3_free(zIn);
  }
  va_end(ap);
  return zRet;
}

References sqlite3_free, sqlite3_malloc, sqlite3_vmprintf, SQLITE_NOMEM, SQLITE_OK, and STRLEN.

Referenced by idxAppendColDefn(), idxCreateVtabSchema(), idxFindIndexes(), idxPopulateOneStat1(), idxProcessOneTrigger(), and sqlite3_expert_analyze().

Here is the caller graph for this function:

idxAuthCallback()

int idxAuthCallback ( void * pCtx, int eOp, const char * z3, const char * z4, const char * zDb, const char * zTrigger )

static

 {
  int rc = SQLITE_OK;
  (void)z4;
  (void)zTrigger;
  if( eOp==SQLITE_INSERT || eOp==SQLITE_UPDATE || eOp==SQLITE_DELETE ){
    if( sqlite3_stricmp(zDb, "main")==0 ){
      sqlite3expert *p = (sqlite3expert*)pCtx;
      IdxTable *pTab;
      for(pTab=p->pTable; pTab; pTab=pTab->pNext){
        if( 0==sqlite3_stricmp(z3, pTab->zName) ) break;
      }
      if( pTab ){
        IdxWrite *pWrite;
        for(pWrite=p->pWrite; pWrite; pWrite=pWrite->pNext){
          if( pWrite->pTab==pTab && pWrite->eOp==eOp ) break;
        }
        if( pWrite==0 ){
          pWrite = idxMalloc(&rc, sizeof(IdxWrite));
          if( rc==SQLITE_OK ){
            pWrite->pTab = pTab;
            pWrite->eOp = eOp;
            pWrite->pNext = p->pWrite;
            p->pWrite = pWrite;
          }
        }
      }
    }
  }
  return rc;
}

References IdxWrite::eOp, idxMalloc(), IdxTable::pNext, IdxWrite::pNext, IdxWrite::pTab, sqlite3expert::pTable, sqlite3expert::pWrite, sqlite3_stricmp, SQLITE_DELETE, SQLITE_INSERT, SQLITE_OK, SQLITE_UPDATE, and IdxTable::zName.

Referenced by sqlite3_expert_new().

Here is the call graph for this function:

Here is the caller graph for this function:

idxBuildSampleTable()

int idxBuildSampleTable ( sqlite3expert * p, const char * zTab )

static

                                                                  {
  int rc;
  char *zSql;
 
  rc = sqlite3_exec(p->dbv,"DROP TABLE IF EXISTS temp."UNIQUE_TABLE_NAME,0,0,0);
  if( rc!=SQLITE_OK ) return rc;
 
  zSql = sqlite3_mprintf(
      "CREATE TABLE temp." UNIQUE_TABLE_NAME " AS SELECT * FROM %Q", zTab
  );
  if( zSql==0 ) return SQLITE_NOMEM;
  rc = sqlite3_exec(p->dbv, zSql, 0, 0, 0);
  sqlite3_free(zSql);
 
  return rc;
}

References sqlite3expert::dbv, sqlite3_exec, sqlite3_free, sqlite3_mprintf, SQLITE_NOMEM, SQLITE_OK, and UNIQUE_TABLE_NAME.

Referenced by idxPopulateStat1().

Here is the caller graph for this function:

idxConstraintFree()

void idxConstraintFree ( IdxConstraint * pConstraint )

static

                                                         {
  IdxConstraint *pNext;
  IdxConstraint *p;
 
  for(p=pConstraint; p; p=pNext){
    pNext = p->pNext;
    sqlite3_free(p);
  }
}

References IdxConstraint::pNext, and sqlite3_free.

Referenced by idxScanFree().

Here is the caller graph for this function:

idxCreateCandidates()

int idxCreateCandidates ( sqlite3expert * p )

static

                                                {
  int rc = SQLITE_OK;
  IdxScan *pIter;
 
  for(pIter=p->pScan; pIter && rc==SQLITE_OK; pIter=pIter->pNextScan){
    rc = idxCreateFromWhere(p, pIter, 0);
    if( rc==SQLITE_OK && pIter->pOrder ){
      rc = idxCreateFromWhere(p, pIter, pIter->pOrder);
    }
  }
 
  return rc;
}

References idxCreateFromWhere(), IdxScan::pNextScan, IdxScan::pOrder, sqlite3expert::pScan, and SQLITE_OK.

Referenced by sqlite3_expert_analyze().

Here is the call graph for this function:

Here is the caller graph for this function:

idxCreateFromCons()

int idxCreateFromCons ( sqlite3expert * p, IdxScan * pScan, IdxConstraint * pEq, IdxConstraint * pTail )

static

 {
  sqlite3 *dbm = p->dbm;
  int rc = SQLITE_OK;
  if( (pEq || pTail) && 0==idxFindCompatible(&rc, dbm, pScan, pEq, pTail) ){
    IdxTable *pTab = pScan->pTab;
    char *zCols = 0;
    char *zIdx = 0;
    IdxConstraint *pCons;
    unsigned int h = 0;
    const char *zFmt;
 
    for(pCons=pEq; pCons; pCons=pCons->pLink){
      zCols = idxAppendColDefn(&rc, zCols, pTab, pCons);
    }
    for(pCons=pTail; pCons; pCons=pCons->pLink){
      zCols = idxAppendColDefn(&rc, zCols, pTab, pCons);
    }
 
    if( rc==SQLITE_OK ){
      /* Hash the list of columns to come up with a name for the index */
      const char *zTable = pScan->pTab->zName;
      int quoteTable = idxIdentifierRequiresQuotes(zTable);
      char *zName = 0;          /* Index name */
      int collisions = 0;
      do{
        int i;
        char *zFind;
        for(i=0; zCols[i]; i++){
          h += ((h<<3) + zCols[i]);
        }
        sqlite3_free(zName);
        zName = sqlite3_mprintf("%s_idx_%08x", zTable, h);
        if( zName==0 ) break;
        /* Is is unique among table, view and index names? */
        zFmt = "SELECT count(*) FROM sqlite_schema WHERE name=%Q"
          " AND type in ('index','table','view')";
        zFind = sqlite3_mprintf(zFmt, zName);
        i = 0;
        rc = sqlite3_exec(dbm, zFind, countNonzeros, &i, 0);
        assert(rc==SQLITE_OK);
        sqlite3_free(zFind);
        if( i==0 ){
          collisions = 0;
          break;
        }
        ++collisions;
      }while( collisions<50 && zName!=0 );
      if( collisions ){
        /* This return means "Gave up trying to find a unique index name." */
        rc = SQLITE_BUSY_TIMEOUT;
      }else if( zName==0 ){
        rc = SQLITE_NOMEM;
      }else{
        if( quoteTable ){
          zFmt = "CREATE INDEX \"%w\" ON \"%w\"(%s)";
        }else{
          zFmt = "CREATE INDEX %s ON %s(%s)";
        }
        zIdx = sqlite3_mprintf(zFmt, zName, zTable, zCols);
        if( !zIdx ){
          rc = SQLITE_NOMEM;
        }else{
          rc = sqlite3_exec(dbm, zIdx, 0, 0, p->pzErrmsg);
          if( rc!=SQLITE_OK ){
            rc = SQLITE_BUSY_TIMEOUT;
          }else{
            idxHashAdd(&rc, &p->hIdx, zName, zIdx);
          }
        }
        sqlite3_free(zName);
        sqlite3_free(zIdx);
      }
    }
 
    sqlite3_free(zCols);
  }
  return rc;
}

References countNonzeros(), sqlite3expert::dbm, sqlite3expert::hIdx, idxAppendColDefn(), idxFindCompatible(), idxHashAdd(), idxIdentifierRequiresQuotes(), IdxConstraint::pLink, IdxScan::pTab, sqlite3expert::pzErrmsg, sqlite3_exec, sqlite3_free, sqlite3_mprintf, SQLITE_BUSY_TIMEOUT, SQLITE_NOMEM, SQLITE_OK, and IdxTable::zName.

Referenced by idxCreateFromWhere().

Here is the call graph for this function:

Here is the caller graph for this function:

idxCreateFromWhere()

int idxCreateFromWhere ( sqlite3expert * p, IdxScan * pScan, IdxConstraint * pTail )

static

 {
  IdxConstraint *p1 = 0;
  IdxConstraint *pCon;
  int rc;
 
  /* Gather up all the == constraints. */
  for(pCon=pScan->pEq; pCon; pCon=pCon->pNext){
    if( !idxFindConstraint(p1, pCon) && !idxFindConstraint(pTail, pCon) ){
      pCon->pLink = p1;
      p1 = pCon;
    }
  }
 
  /* Create an index using the == constraints collected above. And the
  ** range constraint/ORDER BY terms passed in by the caller, if any. */
  rc = idxCreateFromCons(p, pScan, p1, pTail);
 
  /* If no range/ORDER BY passed by the caller, create a version of the
  ** index for each range constraint.  */
  if( pTail==0 ){
    for(pCon=pScan->pRange; rc==SQLITE_OK && pCon; pCon=pCon->pNext){
      assert( pCon->pLink==0 );
      if( !idxFindConstraint(p1, pCon) && !idxFindConstraint(pTail, pCon) ){
        rc = idxCreateFromCons(p, pScan, p1, pCon);
      }
    }
  }
 
  return rc;
}

References idxCreateFromCons(), idxFindConstraint(), IdxScan::pEq, IdxConstraint::pLink, IdxConstraint::pNext, IdxScan::pRange, and SQLITE_OK.

Referenced by idxCreateCandidates().

Here is the call graph for this function:

Here is the caller graph for this function:

idxCreateVtabSchema()

int idxCreateVtabSchema ( sqlite3expert * p, char ** pzErrmsg )

static

                                                                 {
  int rc = idxRegisterVtab(p);
  sqlite3_stmt *pSchema = 0;
 
  /* For each table in the main db schema:
  **
  **   1) Add an entry to the p->pTable list, and
  **   2) Create the equivalent virtual table in dbv.
  */
  rc = idxPrepareStmt(p->db, &pSchema, pzErrmsg,
      "SELECT type, name, sql, 1, "
      "       substr(sql,1,14)=='create virtual' COLLATE nocase "
      "FROM sqlite_schema "
      "WHERE type IN ('table','view') AND "
      "      substr(name,1,7)!='sqlite_' COLLATE nocase "
      " UNION ALL "
      "SELECT type, name, sql, 2, 0 FROM sqlite_schema "
      "WHERE type = 'trigger'"
      "  AND tbl_name IN(SELECT name FROM sqlite_schema WHERE type = 'view') "
      "ORDER BY 4, 5 DESC, 1"
  );
  while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSchema) ){
    const char *zType = (const char*)sqlite3_column_text(pSchema, 0);
    const char *zName = (const char*)sqlite3_column_text(pSchema, 1);
    const char *zSql = (const char*)sqlite3_column_text(pSchema, 2);
    int bVirtual = sqlite3_column_int(pSchema, 4);
    int bExists = 0;
 
    if( zType==0 || zName==0 ) continue;
    rc = expertDbContainsObject(p->dbv, zName, &bExists);
    if( rc || bExists ) continue;
 
    if( zType[0]=='v' || zType[1]=='r' || bVirtual ){
      /* A view. Or a trigger on a view. */
      if( zSql ) rc = expertSchemaSql(p->dbv, zSql, pzErrmsg);
    }else{
      IdxTable *pTab;
      rc = idxGetTableInfo(p->db, zName, &pTab, pzErrmsg);
      if( rc==SQLITE_OK && ALWAYS(pTab!=0) ){
        int i;
        char *zInner = 0;
        char *zOuter = 0;
        pTab->pNext = p->pTable;
        p->pTable = pTab;
 
        /* The statement the vtab will pass to sqlite3_declare_vtab() */
        zInner = idxAppendText(&rc, 0, "CREATE TABLE x(");
        for(i=0; i<pTab->nCol; i++){
          zInner = idxAppendText(&rc, zInner, "%s%Q COLLATE %s", 
              (i==0 ? "" : ", "), pTab->aCol[i].zName, pTab->aCol[i].zColl
          );
        }
        zInner = idxAppendText(&rc, zInner, ")");
 
        /* The CVT statement to create the vtab */
        zOuter = idxAppendText(&rc, 0, 
            "CREATE VIRTUAL TABLE %Q USING expert(%Q)", zName, zInner
        );
        if( rc==SQLITE_OK ){
          rc = sqlite3_exec(p->dbv, zOuter, 0, 0, pzErrmsg);
        }
        sqlite3_free(zInner);
        sqlite3_free(zOuter);
      }
    }
  }
  idxFinalize(&rc, pSchema);
  return rc;
}

References IdxTable::aCol, ALWAYS, sqlite3expert::db, sqlite3expert::dbv, expertDbContainsObject(), expertSchemaSql(), idxAppendText(), idxFinalize(), idxGetTableInfo(), idxPrepareStmt(), idxRegisterVtab(), IdxTable::nCol, IdxTable::pNext, sqlite3expert::pTable, sqlite3_column_int, sqlite3_column_text, sqlite3_exec, sqlite3_free, sqlite3_step, SQLITE_OK, SQLITE_ROW, IdxColumn::zColl, and IdxColumn::zName.

Referenced by sqlite3_expert_new().

Here is the call graph for this function:

Here is the caller graph for this function:

idxDatabaseError()

void idxDatabaseError ( sqlite3 * db, char ** pzErrmsg )

static

 {
  *pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(db));
}

References sqlite3_errmsg, and sqlite3_mprintf.

Referenced by idxPrepareStmt(), idxProcessOneTrigger(), and sqlite3_expert_sql().

Here is the caller graph for this function:

idxFinalize()

void idxFinalize ( int * pRc, sqlite3_stmt * pStmt )

static

                                                      {
  int rc = sqlite3_finalize(pStmt);
  if( *pRc==SQLITE_OK ) *pRc = rc;
}

References sqlite3_finalize, and SQLITE_OK.

Referenced by idxCreateVtabSchema(), idxFindCompatible(), idxFindIndexes(), idxGetTableInfo(), idxLargestIndex(), idxPopulateOneStat1(), idxPopulateStat1(), idxProcessOneTrigger(), and sqlite3_expert_new().

Here is the caller graph for this function:

idxFindCompatible()

int idxFindCompatible ( int * pRc, sqlite3 * dbm, IdxScan * pScan, IdxConstraint * pEq, IdxConstraint * pTail )

static

 {
  const char *zTbl = pScan->pTab->zName;
  sqlite3_stmt *pIdxList = 0;
  IdxConstraint *pIter;
  int nEq = 0;                    /* Number of elements in pEq */
  int rc;
 
  /* Count the elements in list pEq */
  for(pIter=pEq; pIter; pIter=pIter->pLink) nEq++;
 
  rc = idxPrintfPrepareStmt(dbm, &pIdxList, 0, "PRAGMA index_list=%Q", zTbl);
  while( rc==SQLITE_OK && sqlite3_step(pIdxList)==SQLITE_ROW ){
    int bMatch = 1;
    IdxConstraint *pT = pTail;
    sqlite3_stmt *pInfo = 0;
    const char *zIdx = (const char*)sqlite3_column_text(pIdxList, 1);
    if( zIdx==0 ) continue;
 
    /* Zero the IdxConstraint.bFlag values in the pEq list */
    for(pIter=pEq; pIter; pIter=pIter->pLink) pIter->bFlag = 0;
 
    rc = idxPrintfPrepareStmt(dbm, &pInfo, 0, "PRAGMA index_xInfo=%Q", zIdx);
    while( rc==SQLITE_OK && sqlite3_step(pInfo)==SQLITE_ROW ){
      int iIdx = sqlite3_column_int(pInfo, 0);
      int iCol = sqlite3_column_int(pInfo, 1);
      const char *zColl = (const char*)sqlite3_column_text(pInfo, 4);
 
      if( iIdx<nEq ){
        for(pIter=pEq; pIter; pIter=pIter->pLink){
          if( pIter->bFlag ) continue;
          if( pIter->iCol!=iCol ) continue;
          if( sqlite3_stricmp(pIter->zColl, zColl) ) continue;
          pIter->bFlag = 1;
          break;
        }
        if( pIter==0 ){
          bMatch = 0;
          break;
        }
      }else{
        if( pT ){
          if( pT->iCol!=iCol || sqlite3_stricmp(pT->zColl, zColl) ){
            bMatch = 0;
            break;
          }
          pT = pT->pLink;
        }
      }
    }
    idxFinalize(&rc, pInfo);
 
    if( rc==SQLITE_OK && bMatch ){
      sqlite3_finalize(pIdxList);
      return 1;
    }
  }
  idxFinalize(&rc, pIdxList);
 
  *pRc = rc;
  return 0;
}

References IdxConstraint::bFlag, IdxConstraint::iCol, idxFinalize(), idxPrintfPrepareStmt(), IdxConstraint::pLink, IdxScan::pTab, sqlite3_column_int, sqlite3_column_text, sqlite3_finalize, sqlite3_step, sqlite3_stricmp, SQLITE_OK, SQLITE_ROW, IdxConstraint::zColl, and IdxTable::zName.

Referenced by idxCreateFromCons().

Here is the call graph for this function:

Here is the caller graph for this function:

idxFindConstraint()

int idxFindConstraint ( IdxConstraint * pList, IdxConstraint * p )

static

                                                                    {
  IdxConstraint *pCmp;
  for(pCmp=pList; pCmp; pCmp=pCmp->pLink){
    if( p->iCol==pCmp->iCol ) return 1;
  }
  return 0;
}

References IdxConstraint::iCol, and IdxConstraint::pLink.

Referenced by idxCreateFromWhere().

Here is the caller graph for this function:

idxFindIndexes()

int idxFindIndexes ( sqlite3expert * p, char ** pzErr )

static

 {
  IdxStatement *pStmt;
  sqlite3 *dbm = p->dbm;
  int rc = SQLITE_OK;
 
  IdxHash hIdx;
  idxHashInit(&hIdx);
 
  for(pStmt=p->pStatement; rc==SQLITE_OK && pStmt; pStmt=pStmt->pNext){
    IdxHashEntry *pEntry;
    sqlite3_stmt *pExplain = 0;
    idxHashClear(&hIdx);
    rc = idxPrintfPrepareStmt(dbm, &pExplain, pzErr,
        "EXPLAIN QUERY PLAN %s", pStmt->zSql
    );
    while( rc==SQLITE_OK && sqlite3_step(pExplain)==SQLITE_ROW ){
      /* int iId = sqlite3_column_int(pExplain, 0); */
      /* int iParent = sqlite3_column_int(pExplain, 1); */
      /* int iNotUsed = sqlite3_column_int(pExplain, 2); */
      const char *zDetail = (const char*)sqlite3_column_text(pExplain, 3);
      int nDetail;
      int i;
 
      if( !zDetail ) continue;
      nDetail = STRLEN(zDetail);
 
      for(i=0; i<nDetail; i++){
        const char *zIdx = 0;
        if( i+13<nDetail && memcmp(&zDetail[i], " USING INDEX ", 13)==0 ){
          zIdx = &zDetail[i+13];
        }else if( i+22<nDetail 
            && memcmp(&zDetail[i], " USING COVERING INDEX ", 22)==0 
        ){
          zIdx = &zDetail[i+22];
        }
        if( zIdx ){
          const char *zSql;
          int nIdx = 0;
          while( zIdx[nIdx]!='\0' && (zIdx[nIdx]!=' ' || zIdx[nIdx+1]!='(') ){
            nIdx++;
          }
          zSql = idxHashSearch(&p->hIdx, zIdx, nIdx);
          if( zSql ){
            idxHashAdd(&rc, &hIdx, zSql, 0);
            if( rc ) goto find_indexes_out;
          }
          break;
        }
      }
 
      if( zDetail[0]!='-' ){
        pStmt->zEQP = idxAppendText(&rc, pStmt->zEQP, "%s\n", zDetail);
      }
    }
 
    for(pEntry=hIdx.pFirst; pEntry; pEntry=pEntry->pNext){
      pStmt->zIdx = idxAppendText(&rc, pStmt->zIdx, "%s;\n", pEntry->zKey);
    }
 
    idxFinalize(&rc, pExplain);
  }
 
 find_indexes_out:
  idxHashClear(&hIdx);
  return rc;
}

References sqlite3expert::dbm, sqlite3expert::hIdx, idxAppendText(), idxFinalize(), idxHashAdd(), idxHashClear(), idxHashInit(), idxHashSearch(), idxPrintfPrepareStmt(), IdxHash::pFirst, IdxHashEntry::pNext, IdxStatement::pNext, sqlite3expert::pStatement, sqlite3_column_text, sqlite3_step, SQLITE_OK, SQLITE_ROW, STRLEN, IdxStatement::zEQP, IdxStatement::zIdx, IdxHashEntry::zKey, and IdxStatement::zSql.

Referenced by sqlite3_expert_analyze().

Here is the call graph for this function:

Here is the caller graph for this function:

idxGetTableInfo()

int idxGetTableInfo ( sqlite3 * db, const char * zTab, IdxTable ** ppOut, char ** pzErrmsg )

static

 {
  sqlite3_stmt *p1 = 0;
  int nCol = 0;
  int nTab;
  int nByte;
  IdxTable *pNew = 0;
  int rc, rc2;
  char *pCsr = 0;
  int nPk = 0;
 
  *ppOut = 0;
  if( zTab==0 ) return SQLITE_ERROR;
  nTab = STRLEN(zTab);
  nByte = sizeof(IdxTable) + nTab + 1;
  rc = idxPrintfPrepareStmt(db, &p1, pzErrmsg, "PRAGMA table_xinfo=%Q", zTab);
  while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(p1) ){
    const char *zCol = (const char*)sqlite3_column_text(p1, 1);
    const char *zColSeq = 0;
    if( zCol==0 ){
      rc = SQLITE_ERROR;
      break;
    }
    nByte += 1 + STRLEN(zCol);
    rc = sqlite3_table_column_metadata(
        db, "main", zTab, zCol, 0, &zColSeq, 0, 0, 0
    );
    if( zColSeq==0 ) zColSeq = "binary";
    nByte += 1 + STRLEN(zColSeq);
    nCol++;
    nPk += (sqlite3_column_int(p1, 5)>0);
  }
  rc2 = sqlite3_reset(p1);
  if( rc==SQLITE_OK ) rc = rc2;
 
  nByte += sizeof(IdxColumn) * nCol;
  if( rc==SQLITE_OK ){
    pNew = idxMalloc(&rc, nByte);
  }
  if( rc==SQLITE_OK ){
    pNew->aCol = (IdxColumn*)&pNew[1];
    pNew->nCol = nCol;
    pCsr = (char*)&pNew->aCol[nCol];
  }
 
  nCol = 0;
  while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(p1) ){
    const char *zCol = (const char*)sqlite3_column_text(p1, 1);
    const char *zColSeq = 0;
    int nCopy;
    if( zCol==0 ) continue;
    nCopy = STRLEN(zCol) + 1;
    pNew->aCol[nCol].zName = pCsr;
    pNew->aCol[nCol].iPk = (sqlite3_column_int(p1, 5)==1 && nPk==1);
    memcpy(pCsr, zCol, nCopy);
    pCsr += nCopy;
 
    rc = sqlite3_table_column_metadata(
        db, "main", zTab, zCol, 0, &zColSeq, 0, 0, 0
    );
    if( rc==SQLITE_OK ){
      if( zColSeq==0 ) zColSeq = "binary";
      nCopy = STRLEN(zColSeq) + 1;
      pNew->aCol[nCol].zColl = pCsr;
      memcpy(pCsr, zColSeq, nCopy);
      pCsr += nCopy;
    }
 
    nCol++;
  }
  idxFinalize(&rc, p1);
 
  if( rc!=SQLITE_OK ){
    sqlite3_free(pNew);
    pNew = 0;
  }else if( ALWAYS(pNew!=0) ){
    pNew->zName = pCsr;
    if( ALWAYS(pNew->zName!=0) ) memcpy(pNew->zName, zTab, nTab+1);
  }
 
  *ppOut = pNew;
  return rc;
}

References IdxTable::aCol, ALWAYS, idxFinalize(), idxMalloc(), idxPrintfPrepareStmt(), IdxColumn::iPk, IdxTable::nCol, sqlite3_column_int, sqlite3_column_text, sqlite3_free, sqlite3_reset, sqlite3_step, sqlite3_table_column_metadata, SQLITE_ERROR, SQLITE_OK, SQLITE_ROW, STRLEN, IdxColumn::zColl, IdxColumn::zName, and IdxTable::zName.

Referenced by idxCreateVtabSchema().

Here is the call graph for this function:

Here is the caller graph for this function:

idxHashAdd()

int idxHashAdd ( int * pRc, IdxHash * pHash, const char * zKey, const char * zVal )

static

 {
  int nKey = STRLEN(zKey);
  int iHash = idxHashString(zKey, nKey);
  int nVal = (zVal ? STRLEN(zVal) : 0);
  IdxHashEntry *pEntry;
  assert( iHash>=0 );
  for(pEntry=pHash->aHash[iHash]; pEntry; pEntry=pEntry->pHashNext){
    if( STRLEN(pEntry->zKey)==nKey && 0==memcmp(pEntry->zKey, zKey, nKey) ){
      return 1;
    }
  }
  pEntry = idxMalloc(pRc, sizeof(IdxHashEntry) + nKey+1 + nVal+1);
  if( pEntry ){
    pEntry->zKey = (char*)&pEntry[1];
    memcpy(pEntry->zKey, zKey, nKey);
    if( zVal ){
      pEntry->zVal = &pEntry->zKey[nKey+1];
      memcpy(pEntry->zVal, zVal, nVal);
    }
    pEntry->pHashNext = pHash->aHash[iHash];
    pHash->aHash[iHash] = pEntry;
 
    pEntry->pNext = pHash->pFirst;
    pHash->pFirst = pEntry;
  }
  return 0;
}

References IdxHash::aHash, idxHashString(), idxMalloc(), IdxHash::pFirst, IdxHashEntry::pHashNext, IdxHashEntry::pNext, STRLEN, IdxHashEntry::zKey, and IdxHashEntry::zVal.

Referenced by idxCreateFromCons(), and idxFindIndexes().

Here is the call graph for this function:

Here is the caller graph for this function:

idxHashClear()

void idxHashClear ( IdxHash * pHash )

static

                                        {
  int i;
  for(i=0; i<IDX_HASH_SIZE; i++){
    IdxHashEntry *pEntry;
    IdxHashEntry *pNext;
    for(pEntry=pHash->aHash[i]; pEntry; pEntry=pNext){
      pNext = pEntry->pHashNext;
      sqlite3_free(pEntry->zVal2);
      sqlite3_free(pEntry);
    }
  }
  memset(pHash, 0, sizeof(IdxHash));
}

References IdxHash::aHash, IDX_HASH_SIZE, IdxHashEntry::pHashNext, sqlite3_free, and IdxHashEntry::zVal2.

Referenced by idxFindIndexes(), and sqlite3_expert_destroy().

Here is the caller graph for this function:

idxHashFind()

IdxHashEntry * idxHashFind ( IdxHash * pHash, const char * zKey, int nKey )

static

                                                                            {
  int iHash;
  IdxHashEntry *pEntry;
  if( nKey<0 ) nKey = STRLEN(zKey);
  iHash = idxHashString(zKey, nKey);
  assert( iHash>=0 );
  for(pEntry=pHash->aHash[iHash]; pEntry; pEntry=pEntry->pHashNext){
    if( STRLEN(pEntry->zKey)==nKey && 0==memcmp(pEntry->zKey, zKey, nKey) ){
      return pEntry;
    }
  }
  return 0;
}

References IdxHash::aHash, idxHashString(), IdxHashEntry::pHashNext, STRLEN, and IdxHashEntry::zKey.

Referenced by idxHashSearch(), and idxPopulateOneStat1().

Here is the call graph for this function:

Here is the caller graph for this function:

idxHashInit()

void idxHashInit ( IdxHash * pHash )

static

                                       {
  memset(pHash, 0, sizeof(IdxHash));
}

Referenced by idxFindIndexes().

Here is the caller graph for this function:

idxHashSearch()

const char * idxHashSearch ( IdxHash * pHash, const char * zKey, int nKey )

static

                                                                            {
  IdxHashEntry *pEntry = idxHashFind(pHash, zKey, nKey);
  if( pEntry ) return pEntry->zVal;
  return 0;
}

References idxHashFind(), and IdxHashEntry::zVal.

Referenced by idxFindIndexes().

Here is the call graph for this function:

Here is the caller graph for this function:

idxHashString()

int idxHashString ( const char * z, int n )

static

                                              {
  unsigned int ret = 0;
  int i;
  for(i=0; i<n; i++){
    ret += (ret<<3) + (unsigned char)(z[i]);
  }
  return (int)(ret % IDX_HASH_SIZE);
}

References IDX_HASH_SIZE.

Referenced by idxHashAdd(), and idxHashFind().

Here is the caller graph for this function:

idxIdentifierRequiresQuotes()

int idxIdentifierRequiresQuotes ( const char * zId )

static

                                                       {
  int i;
  int nId = STRLEN(zId);
  
  if( sqlite3_keyword_check(zId, nId) ) return 1;
 
  for(i=0; zId[i]; i++){
    if( !(zId[i]=='_')
     && !(zId[i]>='0' && zId[i]<='9')
     && !(zId[i]>='a' && zId[i]<='z')
     && !(zId[i]>='A' && zId[i]<='Z')
    ){
      return 1;
    }
  }
  return 0;
}

References sqlite3_keyword_check, and STRLEN.

Referenced by idxAppendColDefn(), and idxCreateFromCons().

Here is the caller graph for this function:

idxLargestIndex()

int idxLargestIndex ( sqlite3 * db, int * pnMax, char ** pzErr )

static

                                                                 {
  int rc = SQLITE_OK;
  const char *zMax = 
    "SELECT max(i.seqno) FROM "
    "  sqlite_schema AS s, "
    "  pragma_index_list(s.name) AS l, "
    "  pragma_index_info(l.name) AS i "
    "WHERE s.type = 'table'";
  sqlite3_stmt *pMax = 0;
 
  *pnMax = 0;
  rc = idxPrepareStmt(db, &pMax, pzErr, zMax);
  if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pMax) ){
    *pnMax = sqlite3_column_int(pMax, 0) + 1;
  }
  idxFinalize(&rc, pMax);
 
  return rc;
}

References idxFinalize(), idxPrepareStmt(), sqlite3_column_int, sqlite3_step, SQLITE_OK, and SQLITE_ROW.

Referenced by idxPopulateStat1().

Here is the call graph for this function:

Here is the caller graph for this function:

idxMalloc()

void * idxMalloc ( int * pRc, int nByte )

static

                                           {
  void *pRet;
  assert( *pRc==SQLITE_OK );
  assert( nByte>0 );
  pRet = sqlite3_malloc(nByte);
  if( pRet ){
    memset(pRet, 0, nByte);
  }else{
    *pRc = SQLITE_NOMEM;
  }
  return pRet;
}

References sqlite3_malloc, SQLITE_NOMEM, and SQLITE_OK.

Referenced by expertBestIndex(), expertConnect(), expertOpen(), idxAuthCallback(), idxGetTableInfo(), idxHashAdd(), idxNewConstraint(), idxPopulateOneStat1(), idxPopulateStat1(), sqlite3_expert_new(), and sqlite3_expert_sql().

Here is the caller graph for this function:

idxNewConstraint()

IdxConstraint * idxNewConstraint ( int * pRc, const char * zColl )

static

                                                                   {
  IdxConstraint *pNew;
  int nColl = STRLEN(zColl);
 
  assert( *pRc==SQLITE_OK );
  pNew = (IdxConstraint*)idxMalloc(pRc, sizeof(IdxConstraint) * nColl + 1);
  if( pNew ){
    pNew->zColl = (char*)&pNew[1];
    memcpy(pNew->zColl, zColl, nColl+1);
  }
  return pNew;
}

References idxMalloc(), SQLITE_OK, STRLEN, and IdxConstraint::zColl.

Referenced by expertBestIndex().

Here is the call graph for this function:

Here is the caller graph for this function:

idxPopulateOneStat1()

int idxPopulateOneStat1 ( sqlite3expert * p, sqlite3_stmt * pIndexXInfo, sqlite3_stmt * pWriteStat, const char * zTab, const char * zIdx, char ** pzErr )

static

 {
  char *zCols = 0;
  char *zOrder = 0;
  char *zQuery = 0;
  int nCol = 0;
  int i;
  sqlite3_stmt *pQuery = 0;
  int *aStat = 0;
  int rc = SQLITE_OK;
 
  assert( p->iSample>0 );
 
  /* Formulate the query text */
  sqlite3_bind_text(pIndexXInfo, 1, zIdx, -1, SQLITE_STATIC);
  while( SQLITE_OK==rc && SQLITE_ROW==sqlite3_step(pIndexXInfo) ){
    const char *zComma = zCols==0 ? "" : ", ";
    const char *zName = (const char*)sqlite3_column_text(pIndexXInfo, 0);
    const char *zColl = (const char*)sqlite3_column_text(pIndexXInfo, 1);
    if( zName==0 ){
      /* This index contains an expression. Ignore it. */
      sqlite3_free(zCols);
      sqlite3_free(zOrder);
      return sqlite3_reset(pIndexXInfo);
    }
    zCols = idxAppendText(&rc, zCols, 
        "%sx.%Q IS sqlite_expert_rem(%d, x.%Q) COLLATE %s", 
        zComma, zName, nCol, zName, zColl
    );
    zOrder = idxAppendText(&rc, zOrder, "%s%d", zComma, ++nCol);
  }
  sqlite3_reset(pIndexXInfo);
  if( rc==SQLITE_OK ){
    if( p->iSample==100 ){
      zQuery = sqlite3_mprintf(
          "SELECT %s FROM %Q x ORDER BY %s", zCols, zTab, zOrder
      );
    }else{
      zQuery = sqlite3_mprintf(
          "SELECT %s FROM temp."UNIQUE_TABLE_NAME" x ORDER BY %s", zCols, zOrder
      );
    }
  }
  sqlite3_free(zCols);
  sqlite3_free(zOrder);
 
  /* Formulate the query text */
  if( rc==SQLITE_OK ){
    sqlite3 *dbrem = (p->iSample==100 ? p->db : p->dbv);
    rc = idxPrepareStmt(dbrem, &pQuery, pzErr, zQuery);
  }
  sqlite3_free(zQuery);
 
  if( rc==SQLITE_OK ){
    aStat = (int*)idxMalloc(&rc, sizeof(int)*(nCol+1));
  }
  if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pQuery) ){
    IdxHashEntry *pEntry;
    char *zStat = 0;
    for(i=0; i<=nCol; i++) aStat[i] = 1;
    while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pQuery) ){
      aStat[0]++;
      for(i=0; i<nCol; i++){
        if( sqlite3_column_int(pQuery, i)==0 ) break;
      }
      for(/*no-op*/; i<nCol; i++){
        aStat[i+1]++;
      }
    }
 
    if( rc==SQLITE_OK ){
      int s0 = aStat[0];
      zStat = sqlite3_mprintf("%d", s0);
      if( zStat==0 ) rc = SQLITE_NOMEM;
      for(i=1; rc==SQLITE_OK && i<=nCol; i++){
        zStat = idxAppendText(&rc, zStat, " %d", (s0+aStat[i]/2) / aStat[i]);
      }
    }
 
    if( rc==SQLITE_OK ){
      sqlite3_bind_text(pWriteStat, 1, zTab, -1, SQLITE_STATIC);
      sqlite3_bind_text(pWriteStat, 2, zIdx, -1, SQLITE_STATIC);
      sqlite3_bind_text(pWriteStat, 3, zStat, -1, SQLITE_STATIC);
      sqlite3_step(pWriteStat);
      rc = sqlite3_reset(pWriteStat);
    }
 
    pEntry = idxHashFind(&p->hIdx, zIdx, STRLEN(zIdx));
    if( pEntry ){
      assert( pEntry->zVal2==0 );
      pEntry->zVal2 = zStat;
    }else{
      sqlite3_free(zStat);
    }
  }
  sqlite3_free(aStat);
  idxFinalize(&rc, pQuery);
 
  return rc;
}

References sqlite3expert::db, sqlite3expert::dbv, sqlite3expert::hIdx, idxAppendText(), idxFinalize(), idxHashFind(), idxMalloc(), idxPrepareStmt(), sqlite3expert::iSample, sqlite3_bind_text, sqlite3_column_int, sqlite3_column_text, sqlite3_free, sqlite3_mprintf, sqlite3_reset, sqlite3_step, SQLITE_NOMEM, SQLITE_OK, SQLITE_ROW, SQLITE_STATIC, STRLEN, UNIQUE_TABLE_NAME, and IdxHashEntry::zVal2.

Referenced by idxPopulateStat1().

Here is the call graph for this function:

Here is the caller graph for this function:

idxPopulateStat1()

int idxPopulateStat1 ( sqlite3expert * p, char ** pzErr )

static

                                                           {
  int rc = SQLITE_OK;
  int nMax =0;
  struct IdxRemCtx *pCtx = 0;
  struct IdxSampleCtx samplectx; 
  int i;
  i64 iPrev = -100000;
  sqlite3_stmt *pAllIndex = 0;
  sqlite3_stmt *pIndexXInfo = 0;
  sqlite3_stmt *pWrite = 0;
 
  const char *zAllIndex =
    "SELECT s.rowid, s.name, l.name FROM "
    "  sqlite_schema AS s, "
    "  pragma_index_list(s.name) AS l "
    "WHERE s.type = 'table'";
  const char *zIndexXInfo = 
    "SELECT name, coll FROM pragma_index_xinfo(?) WHERE key";
  const char *zWrite = "INSERT INTO sqlite_stat1 VALUES(?, ?, ?)";
 
  /* If iSample==0, no sqlite_stat1 data is required. */
  if( p->iSample==0 ) return SQLITE_OK;
 
  rc = idxLargestIndex(p->dbm, &nMax, pzErr);
  if( nMax<=0 || rc!=SQLITE_OK ) return rc;
 
  rc = sqlite3_exec(p->dbm, "ANALYZE; PRAGMA writable_schema=1", 0, 0, 0);
 
  if( rc==SQLITE_OK ){
    int nByte = sizeof(struct IdxRemCtx) + (sizeof(struct IdxRemSlot) * nMax);
    pCtx = (struct IdxRemCtx*)idxMalloc(&rc, nByte);
  }
 
  if( rc==SQLITE_OK ){
    sqlite3 *dbrem = (p->iSample==100 ? p->db : p->dbv);
    rc = sqlite3_create_function(dbrem, "sqlite_expert_rem", 
        2, SQLITE_UTF8, (void*)pCtx, idxRemFunc, 0, 0
    );
  }
  if( rc==SQLITE_OK ){
    rc = sqlite3_create_function(p->db, "sqlite_expert_sample", 
        0, SQLITE_UTF8, (void*)&samplectx, idxSampleFunc, 0, 0
    );
  }
 
  if( rc==SQLITE_OK ){
    pCtx->nSlot = nMax+1;
    rc = idxPrepareStmt(p->dbm, &pAllIndex, pzErr, zAllIndex);
  }
  if( rc==SQLITE_OK ){
    rc = idxPrepareStmt(p->dbm, &pIndexXInfo, pzErr, zIndexXInfo);
  }
  if( rc==SQLITE_OK ){
    rc = idxPrepareStmt(p->dbm, &pWrite, pzErr, zWrite);
  }
 
  while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pAllIndex) ){
    i64 iRowid = sqlite3_column_int64(pAllIndex, 0);
    const char *zTab = (const char*)sqlite3_column_text(pAllIndex, 1);
    const char *zIdx = (const char*)sqlite3_column_text(pAllIndex, 2);
    if( zTab==0 || zIdx==0 ) continue;
    if( p->iSample<100 && iPrev!=iRowid ){
      samplectx.target = (double)p->iSample / 100.0;
      samplectx.iTarget = p->iSample;
      samplectx.nRow = 0.0;
      samplectx.nRet = 0.0;
      rc = idxBuildSampleTable(p, zTab);
      if( rc!=SQLITE_OK ) break;
    }
    rc = idxPopulateOneStat1(p, pIndexXInfo, pWrite, zTab, zIdx, pzErr);
    iPrev = iRowid;
  }
  if( rc==SQLITE_OK && p->iSample<100 ){
    rc = sqlite3_exec(p->dbv, 
        "DROP TABLE IF EXISTS temp." UNIQUE_TABLE_NAME, 0,0,0
    );
  }
 
  idxFinalize(&rc, pAllIndex);
  idxFinalize(&rc, pIndexXInfo);
  idxFinalize(&rc, pWrite);
 
  if( pCtx ){
    for(i=0; i<pCtx->nSlot; i++){
      sqlite3_free(pCtx->aSlot[i].z);
    }
    sqlite3_free(pCtx);
  }
 
  if( rc==SQLITE_OK ){
    rc = sqlite3_exec(p->dbm, "ANALYZE sqlite_schema", 0, 0, 0);
  }
 
  sqlite3_create_function(p->db, "sqlite_expert_rem", 2, SQLITE_UTF8, 0,0,0,0);
  sqlite3_create_function(p->db, "sqlite_expert_sample", 0,SQLITE_UTF8,0,0,0,0);
 
  sqlite3_exec(p->db, "DROP TABLE IF EXISTS temp."UNIQUE_TABLE_NAME,0,0,0);
  return rc;
}

References IdxRemCtx::aSlot, sqlite3expert::db, sqlite3expert::dbm, sqlite3expert::dbv, idxBuildSampleTable(), idxFinalize(), idxLargestIndex(), idxMalloc(), idxPopulateOneStat1(), idxPrepareStmt(), idxRemFunc(), idxSampleFunc(), sqlite3expert::iSample, IdxSampleCtx::iTarget, IdxSampleCtx::nRet, IdxSampleCtx::nRow, IdxRemCtx::nSlot, sqlite3_column_int64, sqlite3_column_text, sqlite3_create_function, sqlite3_exec, sqlite3_free, sqlite3_step, SQLITE_OK, SQLITE_ROW, SQLITE_UTF8, IdxSampleCtx::target, UNIQUE_TABLE_NAME, and IdxRemCtx::IdxRemSlot::z.

Referenced by sqlite3_expert_analyze().

Here is the call graph for this function:

Here is the caller graph for this function:

idxPrepareStmt()

int idxPrepareStmt ( sqlite3 * db, sqlite3_stmt ** ppStmt, char ** pzErrmsg, const char * zSql )

static

 {
  int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0);
  if( rc!=SQLITE_OK ){
    *ppStmt = 0;
    idxDatabaseError(db, pzErrmsg);
  }
  return rc;
}

References idxDatabaseError(), sqlite3_prepare_v2, and SQLITE_OK.

Referenced by idxCreateVtabSchema(), idxLargestIndex(), idxPopulateOneStat1(), idxPopulateStat1(), idxPrintfPrepareStmt(), and sqlite3_expert_sql().

Here is the call graph for this function:

Here is the caller graph for this function:

idxPrintfPrepareStmt()

int idxPrintfPrepareStmt ( sqlite3 * db, sqlite3_stmt ** ppStmt, char ** pzErrmsg, const char * zFmt, ... )

static

 {
  va_list ap;
  int rc;
  char *zSql;
  va_start(ap, zFmt);
  zSql = sqlite3_vmprintf(zFmt, ap);
  if( zSql==0 ){
    rc = SQLITE_NOMEM;
  }else{
    rc = idxPrepareStmt(db, ppStmt, pzErrmsg, zSql);
    sqlite3_free(zSql);
  }
  va_end(ap);
  return rc;
}

References idxPrepareStmt(), sqlite3_free, sqlite3_vmprintf, and SQLITE_NOMEM.

Referenced by expertFilter(), idxFindCompatible(), idxFindIndexes(), idxGetTableInfo(), idxProcessOneTrigger(), and sqlite3_expert_new().

Here is the call graph for this function:

Here is the caller graph for this function:

idxProcessOneTrigger()

int idxProcessOneTrigger ( sqlite3expert * p, IdxWrite * pWrite, char ** pzErr )

static

 {
  static const char *zInt = UNIQUE_TABLE_NAME;
  static const char *zDrop = "DROP TABLE " UNIQUE_TABLE_NAME;
  IdxTable *pTab = pWrite->pTab;
  const char *zTab = pTab->zName;
  const char *zSql = 
    "SELECT 'CREATE TEMP' || substr(sql, 7) FROM sqlite_schema "
    "WHERE tbl_name = %Q AND type IN ('table', 'trigger') "
    "ORDER BY type;";
  sqlite3_stmt *pSelect = 0;
  int rc = SQLITE_OK;
  char *zWrite = 0;
 
  /* Create the table and its triggers in the temp schema */
  rc = idxPrintfPrepareStmt(p->db, &pSelect, pzErr, zSql, zTab, zTab);
  while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSelect) ){
    const char *zCreate = (const char*)sqlite3_column_text(pSelect, 0);
    if( zCreate==0 ) continue;
    rc = sqlite3_exec(p->dbv, zCreate, 0, 0, pzErr);
  }
  idxFinalize(&rc, pSelect);
 
  /* Rename the table in the temp schema to zInt */
  if( rc==SQLITE_OK ){
    char *z = sqlite3_mprintf("ALTER TABLE temp.%Q RENAME TO %Q", zTab, zInt);
    if( z==0 ){
      rc = SQLITE_NOMEM;
    }else{
      rc = sqlite3_exec(p->dbv, z, 0, 0, pzErr);
      sqlite3_free(z);
    }
  }
 
  switch( pWrite->eOp ){
    case SQLITE_INSERT: {
      int i;
      zWrite = idxAppendText(&rc, zWrite, "INSERT INTO %Q VALUES(", zInt);
      for(i=0; i<pTab->nCol; i++){
        zWrite = idxAppendText(&rc, zWrite, "%s?", i==0 ? "" : ", ");
      }
      zWrite = idxAppendText(&rc, zWrite, ")");
      break;
    }
    case SQLITE_UPDATE: {
      int i;
      zWrite = idxAppendText(&rc, zWrite, "UPDATE %Q SET ", zInt);
      for(i=0; i<pTab->nCol; i++){
        zWrite = idxAppendText(&rc, zWrite, "%s%Q=?", i==0 ? "" : ", ", 
            pTab->aCol[i].zName
        );
      }
      break;
    }
    default: {
      assert( pWrite->eOp==SQLITE_DELETE );
      if( rc==SQLITE_OK ){
        zWrite = sqlite3_mprintf("DELETE FROM %Q", zInt);
        if( zWrite==0 ) rc = SQLITE_NOMEM;
      }
    }
  }
 
  if( rc==SQLITE_OK ){
    sqlite3_stmt *pX = 0;
    rc = sqlite3_prepare_v2(p->dbv, zWrite, -1, &pX, 0);
    idxFinalize(&rc, pX);
    if( rc!=SQLITE_OK ){
      idxDatabaseError(p->dbv, pzErr);
    }
  }
  sqlite3_free(zWrite);
 
  if( rc==SQLITE_OK ){
    rc = sqlite3_exec(p->dbv, zDrop, 0, 0, pzErr);
  }
 
  return rc;
}

References IdxTable::aCol, sqlite3expert::db, sqlite3expert::dbv, IdxWrite::eOp, idxAppendText(), idxDatabaseError(), idxFinalize(), idxPrintfPrepareStmt(), IdxTable::nCol, IdxWrite::pTab, sqlite3_column_text, sqlite3_exec, sqlite3_free, sqlite3_mprintf, sqlite3_prepare_v2, sqlite3_step, SQLITE_DELETE, SQLITE_INSERT, SQLITE_NOMEM, SQLITE_OK, SQLITE_ROW, SQLITE_UPDATE, UNIQUE_TABLE_NAME, IdxColumn::zName, and IdxTable::zName.

Referenced by idxProcessTriggers().

Here is the call graph for this function:

Here is the caller graph for this function:

idxProcessTriggers()

int idxProcessTriggers ( sqlite3expert * p, char ** pzErr )

static

                                                             {
  int rc = SQLITE_OK;
  IdxWrite *pEnd = 0;
  IdxWrite *pFirst = p->pWrite;
 
  while( rc==SQLITE_OK && pFirst!=pEnd ){
    IdxWrite *pIter;
    for(pIter=pFirst; rc==SQLITE_OK && pIter!=pEnd; pIter=pIter->pNext){
      rc = idxProcessOneTrigger(p, pIter, pzErr);
    }
    pEnd = pFirst;
    pFirst = p->pWrite;
  }
 
  return rc;
}

References idxProcessOneTrigger(), IdxWrite::pNext, sqlite3expert::pWrite, and SQLITE_OK.

Referenced by sqlite3_expert_analyze().

Here is the call graph for this function:

Here is the caller graph for this function:

idxRegisterVtab()

int idxRegisterVtab ( sqlite3expert * p )

static

                                            {
  static sqlite3_module expertModule = {
    2,                            /* iVersion */
    expertConnect,                /* xCreate - create a table */
    expertConnect,                /* xConnect - connect to an existing table */
    expertBestIndex,              /* xBestIndex - Determine search strategy */
    expertDisconnect,             /* xDisconnect - Disconnect from a table */
    expertDisconnect,             /* xDestroy - Drop a table */
    expertOpen,                   /* xOpen - open a cursor */
    expertClose,                  /* xClose - close a cursor */
    expertFilter,                 /* xFilter - configure scan constraints */
    expertNext,                   /* xNext - advance a cursor */
    expertEof,                    /* xEof */
    expertColumn,                 /* xColumn - read data */
    expertRowid,                  /* xRowid - read data */
    expertUpdate,                 /* xUpdate - write data */
    0,                            /* xBegin - begin transaction */
    0,                            /* xSync - sync transaction */
    0,                            /* xCommit - commit transaction */
    0,                            /* xRollback - rollback transaction */
    0,                            /* xFindFunction - function overloading */
    0,                            /* xRename - rename the table */
    0,                            /* xSavepoint */
    0,                            /* xRelease */
    0,                            /* xRollbackTo */
    0,                            /* xShadowName */
    0,                            /* xIntegrity */
  };
 
  return sqlite3_create_module(p->dbv, "expert", &expertModule, (void*)p);
}

References sqlite3expert::dbv, expertBestIndex(), expertClose(), expertColumn(), expertConnect(), expertDisconnect(), expertEof(), expertFilter(), expertNext(), expertOpen(), expertRowid(), expertUpdate(), and sqlite3_create_module.

Referenced by idxCreateVtabSchema().

Here is the call graph for this function:

Here is the caller graph for this function:

idxRemFunc()

void idxRemFunc ( sqlite3_context * pCtx, int argc, sqlite3_value ** argv )

static

 {
  struct IdxRemCtx *p = (struct IdxRemCtx*)sqlite3_user_data(pCtx);
  struct IdxRemSlot *pSlot;
  int iSlot;
  assert( argc==2 );
 
  iSlot = sqlite3_value_int(argv[0]);
  assert( iSlot<p->nSlot );
  pSlot = &p->aSlot[iSlot];
 
  switch( pSlot->eType ){
    case SQLITE_NULL:
      /* no-op */
      break;
 
    case SQLITE_INTEGER:
      sqlite3_result_int64(pCtx, pSlot->iVal);
      break;
 
    case SQLITE_FLOAT:
      sqlite3_result_double(pCtx, pSlot->rVal);
      break;
 
    case SQLITE_BLOB:
      sqlite3_result_blob(pCtx, pSlot->z, pSlot->n, SQLITE_TRANSIENT);
      break;
 
    case SQLITE_TEXT:
      sqlite3_result_text(pCtx, pSlot->z, pSlot->n, SQLITE_TRANSIENT);
      break;
  }
 
  pSlot->eType = sqlite3_value_type(argv[1]);
  switch( pSlot->eType ){
    case SQLITE_NULL:
      /* no-op */
      break;
 
    case SQLITE_INTEGER:
      pSlot->iVal = sqlite3_value_int64(argv[1]);
      break;
 
    case SQLITE_FLOAT:
      pSlot->rVal = sqlite3_value_double(argv[1]);
      break;
 
    case SQLITE_BLOB:
    case SQLITE_TEXT: {
      int nByte = sqlite3_value_bytes(argv[1]);
      const void *pData = 0;
      if( nByte>pSlot->nByte ){
        char *zNew = (char*)sqlite3_realloc(pSlot->z, nByte*2);
        if( zNew==0 ){
          sqlite3_result_error_nomem(pCtx);
          return;
        }
        pSlot->nByte = nByte*2;
        pSlot->z = zNew;
      }
      pSlot->n = nByte;
      if( pSlot->eType==SQLITE_BLOB ){
        pData = sqlite3_value_blob(argv[1]);
        if( pData ) memcpy(pSlot->z, pData, nByte);
      }else{
        pData = sqlite3_value_text(argv[1]);
        memcpy(pSlot->z, pData, nByte);
      }
      break;
    }
  }
}

References IdxRemCtx::aSlot, IdxRemCtx::IdxRemSlot::eType, sqlite3_realloc, sqlite3_result_blob, sqlite3_result_double, sqlite3_result_error_nomem, sqlite3_result_int64, sqlite3_result_text, sqlite3_user_data, sqlite3_value_blob, sqlite3_value_bytes, sqlite3_value_double, sqlite3_value_int, sqlite3_value_int64, sqlite3_value_text, sqlite3_value_type, SQLITE_BLOB, SQLITE_FLOAT, SQLITE_INTEGER, SQLITE_NULL, SQLITE_TEXT, and SQLITE_TRANSIENT.

Referenced by idxPopulateStat1().

Here is the caller graph for this function:

idxSampleFunc()

void idxSampleFunc ( sqlite3_context * pCtx, int argc, sqlite3_value ** argv )

static

 {
  struct IdxSampleCtx *p = (struct IdxSampleCtx*)sqlite3_user_data(pCtx);
  int bRet;
 
  (void)argv;
  assert( argc==0 );
  if( p->nRow==0.0 ){
    bRet = 1;
  }else{
    bRet = (p->nRet / p->nRow) <= p->target;
    if( bRet==0 ){
      unsigned short rnd;
      sqlite3_randomness(2, (void*)&rnd);
      bRet = ((int)rnd % 100) <= p->iTarget;
    }
  }
 
  sqlite3_result_int(pCtx, bRet);
  p->nRow += 1.0;
  p->nRet += (double)bRet;
}

References IdxSampleCtx::iTarget, IdxSampleCtx::nRet, IdxSampleCtx::nRow, sqlite3_randomness, sqlite3_result_int, sqlite3_user_data, and IdxSampleCtx::target.

Referenced by idxPopulateStat1().

Here is the caller graph for this function:

idxScanFree()

void idxScanFree ( IdxScan * pScan, IdxScan * pLast )

static

                                                       {
  IdxScan *p;
  IdxScan *pNext;
  for(p=pScan; p!=pLast; p=pNext){
    pNext = p->pNextScan;
    idxConstraintFree(p->pOrder);
    idxConstraintFree(p->pEq);
    idxConstraintFree(p->pRange);
    sqlite3_free(p);
  }
}

References idxConstraintFree(), IdxScan::pEq, IdxScan::pNextScan, IdxScan::pOrder, IdxScan::pRange, and sqlite3_free.

Referenced by sqlite3_expert_destroy(), and sqlite3_expert_sql().

Here is the call graph for this function:

Here is the caller graph for this function:

idxStatementFree()

void idxStatementFree ( IdxStatement * pStatement, IdxStatement * pLast )

static

                                                                           {
  IdxStatement *p;
  IdxStatement *pNext;
  for(p=pStatement; p!=pLast; p=pNext){
    pNext = p->pNext;
    sqlite3_free(p->zEQP);
    sqlite3_free(p->zIdx);
    sqlite3_free(p);
  }
}

References IdxStatement::pNext, sqlite3_free, IdxStatement::zEQP, and IdxStatement::zIdx.

Referenced by sqlite3_expert_destroy(), and sqlite3_expert_sql().

Here is the caller graph for this function:

idxTableFree()

void idxTableFree ( IdxTable * pTab )

static

                                        {
  IdxTable *pIter;
  IdxTable *pNext;
  for(pIter=pTab; pIter; pIter=pNext){
    pNext = pIter->pNext;
    sqlite3_free(pIter);
  }
}

References IdxTable::pNext, and sqlite3_free.

Referenced by sqlite3_expert_destroy().

Here is the caller graph for this function:

idxWriteFree()

void idxWriteFree ( IdxWrite * pTab )

static

                                        {
  IdxWrite *pIter;
  IdxWrite *pNext;
  for(pIter=pTab; pIter; pIter=pNext){
    pNext = pIter->pNext;
    sqlite3_free(pIter);
  }
}

References IdxWrite::pNext, and sqlite3_free.

Referenced by sqlite3_expert_destroy().

Here is the caller graph for this function:

ieee754func()

void ieee754func ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  if( argc==1 ){
    sqlite3_int64 m, a;
    double r;
    int e;
    int isNeg;
    char zResult[100];
    assert( sizeof(m)==sizeof(r) );
    if( sqlite3_value_type(argv[0])==SQLITE_BLOB
     && sqlite3_value_bytes(argv[0])==sizeof(r)
    ){
      const unsigned char *x = sqlite3_value_blob(argv[0]);
      unsigned int i;
      sqlite3_uint64 v = 0;
      for(i=0; i<sizeof(r); i++){
        v = (v<<8) | x[i];
      }
      memcpy(&r, &v, sizeof(r));
    }else{
      r = sqlite3_value_double(argv[0]);
    }
    if( r<0.0 ){
      isNeg = 1;
      r = -r;
    }else{
      isNeg = 0;
    }
    memcpy(&a,&r,sizeof(a));
    if( a==0 ){
      e = 0;
      m = 0;
    }else{
      e = a>>52;
      m = a & ((((sqlite3_int64)1)<<52)-1);
      if( e==0 ){
        m <<= 1;
      }else{
        m |= ((sqlite3_int64)1)<<52;
      }
      while( e<1075 && m>0 && (m&1)==0 ){
        m >>= 1;
        e++;
      }
      if( isNeg ) m = -m;
    }
    switch( *(int*)sqlite3_user_data(context) ){
      case 0:
        sqlite3_snprintf(sizeof(zResult), zResult, "ieee754(%lld,%d)",
                         m, e-1075);
        sqlite3_result_text(context, zResult, -1, SQLITE_TRANSIENT);
        break;
      case 1:
        sqlite3_result_int64(context, m);
        break;
      case 2:
        sqlite3_result_int(context, e-1075);
        break;
    }
  }else{
    sqlite3_int64 m, e, a;
    double r;
    int isNeg = 0;
    m = sqlite3_value_int64(argv[0]);
    e = sqlite3_value_int64(argv[1]);
 
    /* Limit the range of e.  Ticket 22dea1cfdb9151e4 2021-03-02 */
    if( e>10000 ){
      e = 10000;
    }else if( e<-10000 ){
      e = -10000;
    }
 
    if( m<0 ){
      isNeg = 1;
      m = -m;
      if( m<0 ) return;
    }else if( m==0 && e>-1000 && e<1000 ){
      sqlite3_result_double(context, 0.0);
      return;
    }
    while( (m>>32)&0xffe00000 ){
      m >>= 1;
      e++;
    }
    while( m!=0 && ((m>>32)&0xfff00000)==0 ){
      m <<= 1;
      e--;
    }
    e += 1075;
    if( e<=0 ){
      /* Subnormal */
      if( 1-e >= 64 ){
        m = 0;
      }else{
        m >>= 1-e;
      }
      e = 0;
    }else if( e>0x7ff ){
      e = 0x7ff;
    }
    a = m & ((((sqlite3_int64)1)<<52)-1);
    a |= e<<52;
    if( isNeg ) a |= ((sqlite3_uint64)1)<<63;
    memcpy(&r, &a, sizeof(r));
    sqlite3_result_double(context, r);
  }
}

References a, e, sqlite3_result_double, sqlite3_result_int, sqlite3_result_int64, sqlite3_result_text, sqlite3_snprintf, sqlite3_user_data, sqlite3_value_blob, sqlite3_value_bytes, sqlite3_value_double, sqlite3_value_int64, sqlite3_value_type, SQLITE_BLOB, and SQLITE_TRANSIENT.

Referenced by sqlite3_ieee_init().

Here is the caller graph for this function:

ieee754func_from_blob()

void ieee754func_from_blob ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  UNUSED_PARAMETER(argc);
  if( sqlite3_value_type(argv[0])==SQLITE_BLOB
   && sqlite3_value_bytes(argv[0])==sizeof(double)
  ){
    double r;
    const unsigned char *x = sqlite3_value_blob(argv[0]);
    unsigned int i;
    sqlite3_uint64 v = 0;
    for(i=0; i<sizeof(r); i++){
      v = (v<<8) | x[i];
    }
    memcpy(&r, &v, sizeof(r));
    sqlite3_result_double(context, r);
  }
}

References sqlite3_result_double, sqlite3_value_blob, sqlite3_value_bytes, sqlite3_value_type, SQLITE_BLOB, and UNUSED_PARAMETER.

Referenced by sqlite3_ieee_init().

Here is the caller graph for this function:

ieee754func_to_blob()

void ieee754func_to_blob ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  UNUSED_PARAMETER(argc);
  if( sqlite3_value_type(argv[0])==SQLITE_FLOAT
   || sqlite3_value_type(argv[0])==SQLITE_INTEGER
  ){
    double r = sqlite3_value_double(argv[0]);
    sqlite3_uint64 v;
    unsigned char a[sizeof(r)];
    unsigned int i;
    memcpy(&v, &r, sizeof(r));
    for(i=1; i<=sizeof(r); i++){
      a[sizeof(r)-i] = v&0xff;
      v >>= 8;
    }
    sqlite3_result_blob(context, a, sizeof(r), SQLITE_TRANSIENT);
  }
}

References a, sqlite3_result_blob, sqlite3_value_double, sqlite3_value_type, SQLITE_FLOAT, SQLITE_INTEGER, SQLITE_TRANSIENT, and UNUSED_PARAMETER.

Referenced by sqlite3_ieee_init().

Here is the caller graph for this function:

ieee754inc()

void ieee754inc ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  double r;
  sqlite3_int64 N;
  sqlite3_uint64 m1, m2;
  double r2;
  UNUSED_PARAMETER(argc);
  r = sqlite3_value_double(argv[0]);
  N = sqlite3_value_int64(argv[1]);
  memcpy(&m1, &r, 8);
  m2 = m1 + N;
  memcpy(&r2, &m2, 8);
  sqlite3_result_double(context, r2);
}

References sqlite3_result_double, sqlite3_value_double, sqlite3_value_int64, and UNUSED_PARAMETER.

Referenced by sqlite3_ieee_init().

Here is the caller graph for this function:

import_append_char()

void import_append_char ( ImportCtx * p, int c )

static

                                                   {
  if( p->n+1>=p->nAlloc ){
    p->nAlloc += p->nAlloc + 100;
    p->z = sqlite3_realloc64(p->z, p->nAlloc);
    shell_check_oom(p->z);
  }

References c, ImportCtx::n, ImportCtx::nAlloc, shell_check_oom(), sqlite3_realloc64, and ImportCtx::z.

Referenced by ascii_read_one_field(), csv_read_one_field(), and do_meta_command().

Here is the call graph for this function:

Here is the caller graph for this function:

import_cleanup()

void import_cleanup ( ImportCtx * p )

static

                                        {
  if( p->in!=0 && p->xCloser!=0 ){
    p->xCloser(p->in);
    p->in = 0;
  }
  sqlite3_free(p->z);

References ImportCtx::in, sqlite3_free, ImportCtx::xCloser, and ImportCtx::z.

Referenced by do_meta_command().

Here is the caller graph for this function:

initText()

void initText ( ShellText * p )

static

                                  {
  memset(p, 0, sizeof(*p));
}

Referenced by do_meta_command(), dump_callback(), freeText(), and shellFakeSchema().

Here is the caller graph for this function:

intckCheckObjectSql()

char * intckCheckObjectSql ( sqlite3_intck * p, const char * zObj, const char * zPrev, int * pnKeyVal )

static

 {
  char *zRet = 0;
  sqlite3_stmt *pStmt = 0;
  int bAutoIndex = 0;
  int bIsIndex = 0;
 
  const char *zCommon = 
      /* Relation without_rowid also contains just one row. Column "b" is
      ** set to true if the table being examined is a WITHOUT ROWID table,
      ** or false otherwise.  */
      ", without_rowid(b) AS ("
      "  SELECT EXISTS ("
      "    SELECT 1 FROM tabname, pragma_index_list(tab, db) AS l"
      "      WHERE origin='pk' "
      "      AND NOT EXISTS (SELECT 1 FROM sqlite_schema WHERE name=l.name)"
      "  )"
      ")"
      ""
      /* Table idx_cols contains 1 row for each column in each index on the
      ** table being checked. Columns are:
      **
      **   idx_name: Name of the index.
      **   idx_ispk: True if this index is the PK of a WITHOUT ROWID table.
      **   col_name: Name of indexed column, or NULL for index on expression.
      **   col_expr: Indexed expression, including COLLATE clause.
      **   col_alias: Alias used for column in 'intck_wrapper' table.
      */
      ", idx_cols(idx_name, idx_ispk, col_name, col_expr, col_alias) AS ("
      "  SELECT l.name, (l.origin=='pk' AND w.b), i.name, COALESCE(("
      "    SELECT parse_create_index(sql, i.seqno) FROM "
      "    sqlite_schema WHERE name = l.name"
      "  ), format('\"%w\"', i.name) || ' COLLATE ' || quote(i.coll)),"
      "  'c' || row_number() OVER ()"
      "  FROM "
      "      tabname t,"
      "      without_rowid w,"
      "      pragma_index_list(t.tab, t.db) l,"
      "      pragma_index_xinfo(l.name) i"
      "      WHERE i.key"
      "  UNION ALL"
      "  SELECT '', 1, '_rowid_', '_rowid_', 'r1' FROM without_rowid WHERE b=0"
      ")"
      ""
      ""
      /*
      ** For a PK declared as "PRIMARY KEY(a, b) ... WITHOUT ROWID", where
      ** the intck_wrapper aliases of "a" and "b" are "c1" and "c2":
      **
      **   o_pk:   "o.c1, o.c2"
      **   i_pk:   "i.'a', i.'b'"
      **   ...
      **   n_pk:   2
      */ 
      ", tabpk(db, tab, idx, o_pk, i_pk, q_pk, eq_pk, ps_pk, pk_pk, n_pk) AS ("
      "    WITH pkfields(f, a) AS ("
      "      SELECT i.col_name, i.col_alias FROM idx_cols i WHERE i.idx_ispk"
      "    )"
      "    SELECT t.db, t.tab, t.idx, "
      "           group_concat(a, ', '), "
      "           group_concat('i.'||quote(f), ', '), "
      "           group_concat('quote(o.'||a||')', ' || '','' || '),  "
      "           format('(%s)==(%s)',"
      "               group_concat('o.'||a, ', '), "
      "               group_concat(format('\"%w\"', f), ', ')"
      "           ),"
      "           group_concat('%s', ','),"
      "           group_concat('quote('||a||')', ', '),  "
      "           count(*)"
      "    FROM tabname t, pkfields"
      ")"
      ""
      ", idx(name, match_expr, partial, partial_alias, idx_ps, idx_idx) AS ("
      "  SELECT idx_name,"
      "    format('(%s,%s) IS (%s,%s)', "
      "           group_concat(i.col_expr, ', '), i_pk,"
      "           group_concat('o.'||i.col_alias, ', '), o_pk"
      "    ), "
      "    parse_create_index("
      "        (SELECT sql FROM sqlite_schema WHERE name=idx_name), -1"
      "    ),"
      "    'cond' || row_number() OVER ()"
      "    , group_concat('%s', ',')"
      "    , group_concat('quote('||i.col_alias||')', ', ')"
      "  FROM tabpk t, "
      "       without_rowid w,"
      "       idx_cols i"
      "  WHERE i.idx_ispk==0 "
      "  GROUP BY idx_name"
      ")"
      ""
      ", wrapper_with(s) AS ("
      "  SELECT 'intck_wrapper AS (\n  SELECT\n    ' || ("
      "      WITH f(a, b) AS ("
      "        SELECT col_expr, col_alias FROM idx_cols"
      "          UNION ALL "
      "        SELECT partial, partial_alias FROM idx WHERE partial IS NOT NULL"
      "      )"
      "      SELECT group_concat(format('%s AS %s', a, b), ',\n    ') FROM f"
      "    )"
      "    || format('\n  FROM %Q.%Q ', t.db, t.tab)"
           /* If the object being checked is a table, append "NOT INDEXED".
           ** Otherwise, append "INDEXED BY <index>", and then, if the index 
           ** is a partial index " WHERE <condition>".  */
      "    || CASE WHEN t.idx IS NULL THEN "
      "        'NOT INDEXED'"
      "       ELSE"
      "        format('INDEXED BY %Q%s', t.idx, ' WHERE '||i.partial)"
      "       END"
      "    || '\n)'"
      "    FROM tabname t LEFT JOIN idx i ON (i.name=t.idx)"
      ")"
      ""
  ;
 
  bAutoIndex = intckGetAutoIndex(p);
  if( bAutoIndex ) intckExec(p, "PRAGMA automatic_index = 0");
 
  bIsIndex = intckIsIndex(p, zObj);
  if( bIsIndex ){
    pStmt = intckPrepareFmt(p,
      /* Table idxname contains a single row. The first column, "db", contains
      ** the name of the db containing the table (e.g. "main") and the second,
      ** "tab", the name of the table itself.  */
      "WITH tabname(db, tab, idx) AS ("
      "  SELECT %Q, (SELECT tbl_name FROM %Q.sqlite_schema WHERE name=%Q), %Q "
      ")"
      ""
      ", whereclause(w_c) AS (%s)"
      ""
      "%s" /* zCommon */
      ""
      ", case_statement(c) AS ("
      "  SELECT "
      "    'CASE WHEN (' || group_concat(col_alias, ', ') || ', 1) IS (\n' "
      "    || '      SELECT ' || group_concat(col_expr, ', ') || ', 1 FROM '"
      "    || format('%%Q.%%Q NOT INDEXED WHERE %%s\n', t.db, t.tab, p.eq_pk)"
      "    || '    )\n  THEN NULL\n    '"
      "    || 'ELSE format(''surplus entry ('"
      "    ||   group_concat('%%s', ',') || ',' || p.ps_pk"
      "    || ') in index ' || t.idx || ''', ' "
      "    ||   group_concat('quote('||i.col_alias||')', ', ') || ', ' || p.pk_pk"
      "    || ')'"
      "    || '\n  END AS error_message'"
      "  FROM tabname t, tabpk p, idx_cols i WHERE i.idx_name=t.idx"
      ")"
      ""
      ", thiskey(k, n) AS ("
      "    SELECT group_concat(i.col_alias, ', ') || ', ' || p.o_pk, "
      "           count(*) + p.n_pk "
      "    FROM tabpk p, idx_cols i WHERE i.idx_name=p.idx"
      ")"
      ""
      ", main_select(m, n) AS ("
      "  SELECT format("
      "      'WITH %%s\n' ||"
      "      ', idx_checker AS (\n' ||"
      "      '  SELECT %%s,\n' ||"
      "      '  %%s\n' || "
      "      '  FROM intck_wrapper AS o\n' ||"
      "      ')\n',"
      "      ww.s, c, t.k"
      "  ), t.n"
      "  FROM case_statement, wrapper_with ww, thiskey t"
      ")"
 
      "SELECT m || "
      "    group_concat('SELECT * FROM idx_checker ' || w_c, ' UNION ALL '), n"
      " FROM "
      "main_select, whereclause "
      , p->zDb, p->zDb, zObj, zObj
      , zPrev ? zPrev : "VALUES('')", zCommon
      );
  }else{
    pStmt = intckPrepareFmt(p,
      /* Table tabname contains a single row. The first column, "db", contains
      ** the name of the db containing the table (e.g. "main") and the second,
      ** "tab", the name of the table itself.  */
      "WITH tabname(db, tab, idx, prev) AS (SELECT %Q, %Q, NULL, %Q)"
      ""
      "%s" /* zCommon */
 
      /* expr(e) contains one row for each index on table zObj. Value e
      ** is set to an expression that evaluates to NULL if the required
      ** entry is present in the index, or an error message otherwise.  */
      ", expr(e, p) AS ("
      "  SELECT format('CASE WHEN EXISTS \n"
      "    (SELECT 1 FROM %%Q.%%Q AS i INDEXED BY %%Q WHERE %%s%%s)\n"
      "    THEN NULL\n"
      "    ELSE format(''entry (%%s,%%s) missing from index %%s'', %%s, %%s)\n"
      "  END\n'"
      "    , t.db, t.tab, i.name, i.match_expr, ' AND (' || partial || ')',"
      "      i.idx_ps, t.ps_pk, i.name, i.idx_idx, t.pk_pk),"
      "    CASE WHEN partial IS NULL THEN NULL ELSE i.partial_alias END"
      "  FROM tabpk t, idx i"
      ")"
 
      ", numbered(ii, cond, e) AS ("
      "  SELECT 0, 'n.ii=0', 'NULL'"
      "    UNION ALL "
      "  SELECT row_number() OVER (),"
      "      '(n.ii='||row_number() OVER ()||COALESCE(' AND '||p||')', ')'), e"
      "  FROM expr"
      ")"
 
      ", counter_with(w) AS ("
      "    SELECT 'WITH intck_counter(ii) AS (\n  ' || "
      "       group_concat('SELECT '||ii, ' UNION ALL\n  ') "
      "    || '\n)' FROM numbered"
      ")"
      ""
      ", case_statement(c) AS ("
      "    SELECT 'CASE ' || "
      "    group_concat(format('\n  WHEN %%s THEN (%%s)', cond, e), '') ||"
      "    '\nEND AS error_message'"
      "    FROM numbered"
      ")"
      ""
 
      /* This table contains a single row consisting of a single value -
      ** the text of an SQL expression that may be used by the main SQL
      ** statement to output an SQL literal that can be used to resume
      ** the scan if it is suspended. e.g. for a rowid table, an expression
      ** like:
      **
      **     format('(%d,%d)', _rowid_, n.ii)
      */
      ", thiskey(k, n) AS ("
      "    SELECT o_pk || ', ii', n_pk+1 FROM tabpk"
      ")"
      ""
      ", whereclause(w_c) AS ("
      "    SELECT CASE WHEN prev!='' THEN "
      "    '\nWHERE (' || o_pk ||', n.ii) > ' || prev"
      "    ELSE ''"
      "    END"
      "    FROM tabpk, tabname"
      ")"
      ""
      ", main_select(m, n) AS ("
      "  SELECT format("
      "      '%%s, %%s\nSELECT %%s,\n%%s\nFROM intck_wrapper AS o"
               ", intck_counter AS n%%s\nORDER BY %%s', "
      "      w, ww.s, c, thiskey.k, whereclause.w_c, t.o_pk"
      "  ), thiskey.n"
      "  FROM case_statement, tabpk t, counter_with, "
      "       wrapper_with ww, thiskey, whereclause"
      ")"
 
      "SELECT m, n FROM main_select",
      p->zDb, zObj, zPrev, zCommon
    );
  }
 
  while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
    zRet = intckMprintf(p, "%s", (const char*)sqlite3_column_text(pStmt, 0));
    if( pnKeyVal ){
      *pnKeyVal = sqlite3_column_int(pStmt, 1);
    }
  }
  intckFinalize(p, pStmt);
 
  if( bAutoIndex ) intckExec(p, "PRAGMA automatic_index = 1");
  return zRet;
}

References intckExec(), intckFinalize(), intckGetAutoIndex(), intckIsIndex(), intckMprintf(), intckPrepareFmt(), sqlite3_intck::rc, sqlite3_column_int, sqlite3_column_text, sqlite3_step, SQLITE_OK, SQLITE_ROW, and sqlite3_intck::zDb.

Referenced by sqlite3_intck_step(), and sqlite3_intck_test_sql().

Here is the call graph for this function:

Here is the caller graph for this function:

intckDatabaseCmd()

int intckDatabaseCmd ( ShellState * pState, i64 nStepPerUnlock )

static

                                                                   {
  sqlite3_intck *p = 0;
  int rc = SQLITE_OK;
 
  rc = sqlite3_intck_open(pState->db, "main", &p);
  if( rc==SQLITE_OK ){
    i64 nStep = 0;
    i64 nError = 0;
    const char *zErr = 0;
    while( SQLITE_OK==sqlite3_intck_step(p) ){
      const char *zMsg = sqlite3_intck_message(p);
      if( zMsg ){
        sqlite3_fprintf(pState->out, "%s\n", zMsg);
        nError++;
      }
      nStep++;
      if( nStepPerUnlock && (nStep % nStepPerUnlock)==0 ){
        sqlite3_intck_unlock(p);
      }
    }
    rc = sqlite3_intck_error(p, &zErr);
    if( zErr ){
      sqlite3_fprintf(stderr,"%s\n", zErr);
    }
    sqlite3_intck_close(p);
 
    sqlite3_fprintf(pState->out, "%lld steps, %lld errors\n", nStep, nError);
  }
 

References ShellState::db, ShellState::out, sqlite3_fprintf, sqlite3_intck_close(), sqlite3_intck_error(), sqlite3_intck_message(), sqlite3_intck_open(), sqlite3_intck_step(), sqlite3_intck_unlock(), and SQLITE_OK.

Referenced by do_meta_command().

Here is the call graph for this function:

Here is the caller graph for this function:

intckExec()

void intckExec ( sqlite3_intck * p, const char * zSql )

static

                                                         {
  sqlite3_stmt *pStmt = 0;
  pStmt = intckPrepare(p, zSql);
  intckStep(p, pStmt);
  intckFinalize(p, pStmt);
}

References intckFinalize(), intckPrepare(), and intckStep().

Referenced by intckCheckObjectSql().

Here is the call graph for this function:

Here is the caller graph for this function:

intckFinalize()

void intckFinalize ( sqlite3_intck * p, sqlite3_stmt * pStmt )

static

                                                                {
  int rc = sqlite3_finalize(pStmt);
  if( p->rc==SQLITE_OK && rc!=SQLITE_OK ){
    intckSaveErrmsg(p);
  }
}

References intckSaveErrmsg(), sqlite3_intck::rc, sqlite3_finalize, and SQLITE_OK.

Referenced by intckCheckObjectSql(), intckExec(), intckFindObject(), intckGetAutoIndex(), intckIsIndex(), intckSaveKey(), sqlite3_intck_step(), and sqlite3_intck_unlock().

Here is the call graph for this function:

Here is the caller graph for this function:

intckFindObject()

void intckFindObject ( sqlite3_intck * p )

static

                                             {
  sqlite3_stmt *pStmt = 0;
  char *zPrev = p->zObj;
  p->zObj = 0;
 
  assert( p->rc==SQLITE_OK );
  assert( p->pCheck==0 );
 
  pStmt = intckPrepareFmt(p, 
    "WITH tables(table_name) AS (" 
    "  SELECT name"
    "  FROM %Q.sqlite_schema WHERE (type='table' OR type='index') AND rootpage"
    "  UNION ALL "
    "  SELECT 'sqlite_schema'"
    ")"
    "SELECT table_name FROM tables "
    "WHERE ?1 IS NULL OR table_name%s?1 "
    "ORDER BY 1"
    , p->zDb, (p->zKey ? ">=" : ">")
  );
 
  if( p->rc==SQLITE_OK ){
    sqlite3_bind_text(pStmt, 1, zPrev, -1, SQLITE_TRANSIENT);
    if( sqlite3_step(pStmt)==SQLITE_ROW ){
      p->zObj = intckMprintf(p,"%s",(const char*)sqlite3_column_text(pStmt, 0));
    }
  }
  intckFinalize(p, pStmt);
 
  /* If this is a new object, ensure the previous key value is cleared. */
  if( sqlite3_stricmp(p->zObj, zPrev) ){
    sqlite3_free(p->zKey);
    p->zKey = 0;
  }
 
  sqlite3_free(zPrev);
}

References intckFinalize(), intckMprintf(), intckPrepareFmt(), sqlite3_intck::pCheck, sqlite3_intck::rc, sqlite3_bind_text, sqlite3_column_text, sqlite3_free, sqlite3_step, sqlite3_stricmp, SQLITE_OK, SQLITE_ROW, SQLITE_TRANSIENT, sqlite3_intck::zDb, sqlite3_intck::zKey, and sqlite3_intck::zObj.

Referenced by sqlite3_intck_step().

Here is the call graph for this function:

Here is the caller graph for this function:

intckGetAutoIndex()

int intckGetAutoIndex ( sqlite3_intck * p )

static

                                              {
  int bRet = 0;
  sqlite3_stmt *pStmt = 0;
  pStmt = intckPrepare(p, "PRAGMA automatic_index");
  if( SQLITE_ROW==intckStep(p, pStmt) ){
    bRet = sqlite3_column_int(pStmt, 0);
  }
  intckFinalize(p, pStmt);
  return bRet;
}

References intckFinalize(), intckPrepare(), intckStep(), sqlite3_column_int, and SQLITE_ROW.

Referenced by intckCheckObjectSql().

Here is the call graph for this function:

Here is the caller graph for this function:

intckGetToken()

int intckGetToken ( const char * z )

static

                                       {
  char c = z[0];
  int iRet = 1;
  if( c=='\'' || c=='"' || c=='`' ){
    while( 1 ){
      if( z[iRet]==c ){
        iRet++;
        if( z[iRet]!=c ) break;
      }
      iRet++;
    }
  }
  else if( c=='[' ){
    while( z[iRet++]!=']' && z[iRet] );
  }
  else if( (c>='A' && c<='Z') || (c>='a' && c<='z') ){
    while( (z[iRet]>='A' && z[iRet]<='Z') || (z[iRet]>='a' && z[iRet]<='z') ){
      iRet++;
    }
  }
 
  return iRet;
}

References c.

Referenced by intckParseCreateIndex().

Here is the caller graph for this function:

intckIsIndex()

int intckIsIndex ( sqlite3_intck * p, const char * zObj )

static

                                                           {
  int bRet = 0;
  sqlite3_stmt *pStmt = 0;
  pStmt = intckPrepareFmt(p, 
      "SELECT 1 FROM %Q.sqlite_schema WHERE name=%Q AND type='index'",
      p->zDb, zObj
  );
  if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
    bRet = 1;
  }
  intckFinalize(p, pStmt);
  return bRet;
}

References intckFinalize(), intckPrepareFmt(), sqlite3_intck::rc, sqlite3_step, SQLITE_OK, SQLITE_ROW, and sqlite3_intck::zDb.

Referenced by intckCheckObjectSql().

Here is the call graph for this function:

Here is the caller graph for this function:

intckIsSpace()

int intckIsSpace ( char c )

static

                               {
  return (c==' ' || c=='\t' || c=='\n' || c=='\r');
}

References c.

Referenced by intckParseCreateIndex().

Here is the caller graph for this function:

intckMprintf()

char * intckMprintf ( sqlite3_intck * p, const char * zFmt, ... )

static

                                                                  {
  va_list ap;
  char *zRet = 0;
  va_start(ap, zFmt);
  zRet = sqlite3_vmprintf(zFmt, ap);
  if( p->rc==SQLITE_OK ){
    if( zRet==0 ){
      p->rc = SQLITE_NOMEM;
    }
  }else{
    sqlite3_free(zRet);
    zRet = 0;
  }
  return zRet;
}

References sqlite3_intck::rc, sqlite3_free, sqlite3_vmprintf, SQLITE_NOMEM, and SQLITE_OK.

Referenced by intckCheckObjectSql(), intckFindObject(), intckSaveKey(), and sqlite3_intck_step().

Here is the caller graph for this function:

intckParseCreateIndex()

const char * intckParseCreateIndex ( const char * z, int iCol, int * pnByte )

static

                                                                              {
  int iOff = 0;
  int iThisCol = 0;
  int iStart = 0;
  int nOpen = 0;
 
  const char *zRet = 0;
  int nRet = 0;
 
  int iEndOfCol = 0;
 
  /* Skip forward until the first "(" token */
  while( z[iOff]!='(' ){
    iOff += intckGetToken(&z[iOff]);
    if( z[iOff]=='\0' ) return 0;
  }
  assert( z[iOff]=='(' );
 
  nOpen = 1;
  iOff++;
  iStart = iOff;
  while( z[iOff] ){
    const char *zToken = &z[iOff];
    int nToken = 0;
 
    /* Check if this is the end of the current column - either a "," or ")"
    ** when nOpen==1.  */
    if( nOpen==1 ){
      if( z[iOff]==',' || z[iOff]==')' ){
        if( iCol==iThisCol ){
          int iEnd = iEndOfCol ? iEndOfCol : iOff;
          nRet = (iEnd - iStart);
          zRet = &z[iStart];
          break;
        }
        iStart = iOff+1;
        while( intckIsSpace(z[iStart]) ) iStart++;
        iThisCol++;
      }
      if( z[iOff]==')' ) break;
    }
    if( z[iOff]=='(' ) nOpen++;
    if( z[iOff]==')' ) nOpen--;
    nToken = intckGetToken(zToken);
 
    if( (nToken==3 && 0==sqlite3_strnicmp(zToken, "ASC", nToken))
     || (nToken==4 && 0==sqlite3_strnicmp(zToken, "DESC", nToken))
    ){
      iEndOfCol = iOff;
    }else if( 0==intckIsSpace(zToken[0]) ){
      iEndOfCol = 0;
    }
 
    iOff += nToken;
  }
 
  /* iStart is now the byte offset of 1 byte passed the final ')' in the
  ** CREATE INDEX statement. Try to find a WHERE clause to return.  */
  while( zRet==0 && z[iOff] ){
    int n = intckGetToken(&z[iOff]);
    if( n==5 && 0==sqlite3_strnicmp(&z[iOff], "where", 5) ){
      zRet = &z[iOff+5];
      nRet = (int)strlen(zRet);
    }
    iOff += n;
  }
 
  /* Trim any whitespace from the start and end of the returned string. */
  if( zRet ){
    while( intckIsSpace(zRet[0]) ){
      nRet--;
      zRet++;
    }
    while( nRet>0 && intckIsSpace(zRet[nRet-1]) ) nRet--;
  }
 
  *pnByte = nRet;
  return zRet;
}

References intckGetToken(), intckIsSpace(), and sqlite3_strnicmp.

Referenced by intckParseCreateIndexFunc().

Here is the call graph for this function:

Here is the caller graph for this function:

intckParseCreateIndexFunc()

void intckParseCreateIndexFunc ( sqlite3_context * pCtx, int nVal, sqlite3_value ** apVal )

static

 {
  const char *zSql = (const char*)sqlite3_value_text(apVal[0]);
  int idx = sqlite3_value_int(apVal[1]);
  const char *zRes = 0;
  int nRes = 0;
 
  assert( nVal==2 );
  if( zSql ){
    zRes = intckParseCreateIndex(zSql, idx, &nRes);
  }
  sqlite3_result_text(pCtx, zRes, nRes, SQLITE_TRANSIENT);
}

References intckParseCreateIndex(), sqlite3_result_text, sqlite3_value_int, sqlite3_value_text, and SQLITE_TRANSIENT.

Referenced by sqlite3_intck_open().

Here is the call graph for this function:

Here is the caller graph for this function:

intckPrepare()

sqlite3_stmt * intckPrepare ( sqlite3_intck * p, const char * zSql )

static

                                                                     {
  sqlite3_stmt *pRet = 0;
  if( p->rc==SQLITE_OK ){
    p->rc = sqlite3_prepare_v2(p->db, zSql, -1, &pRet, 0);
    if( p->rc!=SQLITE_OK ){
      intckSaveErrmsg(p);
      assert( pRet==0 );
    }
  }
  return pRet;
}

References sqlite3_intck::db, intckSaveErrmsg(), sqlite3_intck::rc, sqlite3_prepare_v2, and SQLITE_OK.

Referenced by intckExec(), intckGetAutoIndex(), intckPrepareFmt(), intckSaveKey(), and sqlite3_intck_step().

Here is the call graph for this function:

Here is the caller graph for this function:

intckPrepareFmt()

sqlite3_stmt * intckPrepareFmt ( sqlite3_intck * p, const char * zFmt, ... )

static

                                                                             {
  sqlite3_stmt *pRet = 0;
  va_list ap;
  char *zSql = 0;
  va_start(ap, zFmt);
  zSql = sqlite3_vmprintf(zFmt, ap);
  if( p->rc==SQLITE_OK && zSql==0 ){
    p->rc = SQLITE_NOMEM;
  }
  pRet = intckPrepare(p, zSql);
  sqlite3_free(zSql);
  va_end(ap);
  return pRet;
}

References intckPrepare(), sqlite3_intck::rc, sqlite3_free, sqlite3_vmprintf, SQLITE_NOMEM, and SQLITE_OK.

Referenced by intckCheckObjectSql(), intckFindObject(), intckIsIndex(), and intckSaveKey().

Here is the call graph for this function:

Here is the caller graph for this function:

intckSaveErrmsg()

void intckSaveErrmsg ( sqlite3_intck * p )

static

                                             {
  p->rc = sqlite3_errcode(p->db);
  sqlite3_free(p->zErr);
  p->zErr = sqlite3_mprintf("%s", sqlite3_errmsg(p->db));
}

References sqlite3_intck::db, sqlite3_intck::rc, sqlite3_errcode, sqlite3_errmsg, sqlite3_free, sqlite3_mprintf, and sqlite3_intck::zErr.

Referenced by intckFinalize(), and intckPrepare().

Here is the caller graph for this function:

intckSaveKey()

void intckSaveKey ( sqlite3_intck * p )

static

                                          {
  int ii;
  char *zSql = 0;
  sqlite3_stmt *pStmt = 0;
  sqlite3_stmt *pXinfo = 0;
  const char *zDir = 0;
 
  assert( p->pCheck );
  assert( p->zKey==0 );
 
  pXinfo = intckPrepareFmt(p, 
      "SELECT group_concat(desc, '') FROM %Q.sqlite_schema s, "
      "pragma_index_xinfo(%Q, %Q) "
      "WHERE s.type='index' AND s.name=%Q",
      p->zDb, p->zObj, p->zDb, p->zObj
  );
  if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXinfo) ){
    zDir = (const char*)sqlite3_column_text(pXinfo, 0);
  }
 
  if( zDir==0 ){
    /* Object is a table, not an index. This is the easy case,as there are 
    ** no DESC columns or NULL values in a primary key.  */
    const char *zSep = "SELECT '(' || ";
    for(ii=0; ii<p->nKeyVal; ii++){
      zSql = intckMprintf(p, "%z%squote(?)", zSql, zSep);
      zSep = " || ', ' || ";
    }
    zSql = intckMprintf(p, "%z || ')'", zSql);
  }else{
 
    /* Object is an index. */
    assert( p->nKeyVal>1 );
    for(ii=p->nKeyVal; ii>0; ii--){
      int bLastIsDesc = zDir[ii-1]=='1';
      int bLastIsNull = sqlite3_column_type(p->pCheck, ii)==SQLITE_NULL;
      const char *zLast = sqlite3_column_name(p->pCheck, ii);
      char *zLhs = 0;
      char *zRhs = 0;
      char *zWhere = 0;
 
      if( bLastIsNull ){
        if( bLastIsDesc ) continue;
        zWhere = intckMprintf(p, "'%s IS NOT NULL'", zLast);
      }else{
        const char *zOp = bLastIsDesc ? "<" : ">";
        zWhere = intckMprintf(p, "'%s %s ' || quote(?%d)", zLast, zOp, ii);
      }
 
      if( ii>1 ){
        const char *zLhsSep = "";
        const char *zRhsSep = "";
        int jj;
        for(jj=0; jj<ii-1; jj++){
          const char *zAlias = (const char*)sqlite3_column_name(p->pCheck,jj+1);
          zLhs = intckMprintf(p, "%z%s%s", zLhs, zLhsSep, zAlias);
          zRhs = intckMprintf(p, "%z%squote(?%d)", zRhs, zRhsSep, jj+1);
          zLhsSep = ",";
          zRhsSep = " || ',' || ";
        }
 
        zWhere = intckMprintf(p, 
            "'(%z) IS (' || %z || ') AND ' || %z",
            zLhs, zRhs, zWhere);
      }
      zWhere = intckMprintf(p, "'WHERE ' || %z", zWhere);
 
      zSql = intckMprintf(p, "%z%s(quote( %z ) )",
          zSql,
          (zSql==0 ? "VALUES" : ",\n      "),
          zWhere
      );
    }
    zSql = intckMprintf(p, 
        "WITH wc(q) AS (\n%z\n)"
        "SELECT 'VALUES' || group_concat('(' || q || ')', ',\n      ') FROM wc"
        , zSql
    );
  }
 
  pStmt = intckPrepare(p, zSql);
  if( p->rc==SQLITE_OK ){
    for(ii=0; ii<p->nKeyVal; ii++){
      sqlite3_bind_value(pStmt, ii+1, sqlite3_column_value(p->pCheck, ii+1));
    }
    if( SQLITE_ROW==sqlite3_step(pStmt) ){
      p->zKey = intckMprintf(p,"%s",(const char*)sqlite3_column_text(pStmt, 0));
    }
    intckFinalize(p, pStmt);
  }
 
  sqlite3_free(zSql);
  intckFinalize(p, pXinfo);
}

References intckFinalize(), intckMprintf(), intckPrepare(), intckPrepareFmt(), sqlite3_intck::nKeyVal, sqlite3_intck::pCheck, sqlite3_intck::rc, sqlite3_bind_value, sqlite3_column_name, sqlite3_column_text, sqlite3_column_type, sqlite3_column_value, sqlite3_free, sqlite3_step, SQLITE_NULL, SQLITE_OK, SQLITE_ROW, sqlite3_intck::zDb, sqlite3_intck::zKey, and sqlite3_intck::zObj.

Referenced by sqlite3_intck_unlock().

Here is the call graph for this function:

Here is the caller graph for this function:

intckStep()

int intckStep ( sqlite3_intck * p, sqlite3_stmt * pStmt )

static

                                                           {
  if( p->rc ) return p->rc;
  return sqlite3_step(pStmt);
}

References sqlite3_intck::rc, and sqlite3_step.

Referenced by intckExec(), and intckGetAutoIndex().

Here is the caller graph for this function:

integerValue()

sqlite3_int64 integerValue ( const char * zArg )

static

                                                   {
  sqlite3_int64 v = 0;
  static const struct { char *zSuffix; int iMult; } aMult[] = {
    { "KiB", 1024 },
    { "MiB", 1024*1024 },
    { "GiB", 1024*1024*1024 },
    { "KB",  1000 },
    { "MB",  1000000 },
    { "GB",  1000000000 },
    { "K",   1000 },
    { "M",   1000000 },
    { "G",   1000000000 },
  };
  int i;
  int isNeg = 0;
  if( zArg[0]=='-' ){
    isNeg = 1;
    zArg++;
  }else if( zArg[0]=='+' ){
    zArg++;
  }
  if( zArg[0]=='0' && zArg[1]=='x' ){
    int x;
    zArg += 2;
    while( (x = hexDigitValue(zArg[0]))>=0 ){
      v = (v<<4) + x;
      zArg++;
    }
  }else{
    while( IsDigit(zArg[0]) ){
      v = v*10 + zArg[0] - '0';
      zArg++;
    }
  }
  for(i=0; i<ArraySize(aMult); i++){
    if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){
      v *= aMult[i].iMult;
      break;
    }
  }
  return isNeg? -v : v;
}

References ArraySize, hexDigitValue(), IsDigit, and sqlite3_stricmp.

Referenced by booleanValue(), do_meta_command(), expertDotCommand(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

interrupt_handler()

void interrupt_handler ( int NotUsed )

static

                                          {
  UNUSED_PARAMETER(NotUsed);
  if( ++seenInterrupt>1 ) exit(1);

References globalDb, seenInterrupt, sqlite3_interrupt, and UNUSED_PARAMETER.

Referenced by main().

Here is the caller graph for this function:

isatty()

int isatty ( int )

extern

Referenced by main().

Here is the caller graph for this function:

isNumber()

int isNumber ( const char * z, int * realnum )

static

                                                {
  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;
}

References IsDigit.

Referenced by shell_callback().

Here is the caller graph for this function:

isVt100()

int isVt100 ( const unsigned char * z )

static

                                          {
  int i;
  if( z[1]!='[' ) return 0;
  i = 2;
  while( z[i]>=0x30 && z[i]<=0x3f ){ i++; }
  while( z[i]>=0x20 && z[i]<=0x2f ){ i++; }
  if( z[i]<0x40 || z[i]>0x7e ) return 0;
  return i+1;
}

Referenced by translateForDisplayAndDup(), and utf8_width_print().

Here is the caller graph for this function:

KeccakF1600Step()

void KeccakF1600Step ( SHA3Context * p )

static

                                           {
  int i;
  u64 b0, b1, b2, b3, b4;
  u64 c0, c1, c2, c3, c4;
  u64 d0, d1, d2, d3, d4;
  static const u64 RC[] = {
    0x0000000000000001ULL,  0x0000000000008082ULL,
    0x800000000000808aULL,  0x8000000080008000ULL,
    0x000000000000808bULL,  0x0000000080000001ULL,
    0x8000000080008081ULL,  0x8000000000008009ULL,
    0x000000000000008aULL,  0x0000000000000088ULL,
    0x0000000080008009ULL,  0x000000008000000aULL,
    0x000000008000808bULL,  0x800000000000008bULL,
    0x8000000000008089ULL,  0x8000000000008003ULL,
    0x8000000000008002ULL,  0x8000000000000080ULL,
    0x000000000000800aULL,  0x800000008000000aULL,
    0x8000000080008081ULL,  0x8000000000008080ULL,
    0x0000000080000001ULL,  0x8000000080008008ULL
  };
# define a00 (p->u.s[0])
# define a01 (p->u.s[1])
# define a02 (p->u.s[2])
# define a03 (p->u.s[3])
# define a04 (p->u.s[4])
# define a10 (p->u.s[5])
# define a11 (p->u.s[6])
# define a12 (p->u.s[7])
# define a13 (p->u.s[8])
# define a14 (p->u.s[9])
# define a20 (p->u.s[10])
# define a21 (p->u.s[11])
# define a22 (p->u.s[12])
# define a23 (p->u.s[13])
# define a24 (p->u.s[14])
# define a30 (p->u.s[15])
# define a31 (p->u.s[16])
# define a32 (p->u.s[17])
# define a33 (p->u.s[18])
# define a34 (p->u.s[19])
# define a40 (p->u.s[20])
# define a41 (p->u.s[21])
# define a42 (p->u.s[22])
# define a43 (p->u.s[23])
# define a44 (p->u.s[24])
# define ROL64(a,x) ((a<<x)|(a>>(64-x)))
 
  for(i=0; i<24; i+=4){
    c0 = a00^a10^a20^a30^a40;
    c1 = a01^a11^a21^a31^a41;
    c2 = a02^a12^a22^a32^a42;
    c3 = a03^a13^a23^a33^a43;
    c4 = a04^a14^a24^a34^a44;
    d0 = c4^ROL64(c1, 1);
    d1 = c0^ROL64(c2, 1);
    d2 = c1^ROL64(c3, 1);
    d3 = c2^ROL64(c4, 1);
    d4 = c3^ROL64(c0, 1);
 
    b0 = (a00^d0);
    b1 = ROL64((a11^d1), 44);
    b2 = ROL64((a22^d2), 43);
    b3 = ROL64((a33^d3), 21);
    b4 = ROL64((a44^d4), 14);
    a00 =   b0 ^((~b1)&  b2 );
    a00 ^= RC[i];
    a11 =   b1 ^((~b2)&  b3 );
    a22 =   b2 ^((~b3)&  b4 );
    a33 =   b3 ^((~b4)&  b0 );
    a44 =   b4 ^((~b0)&  b1 );
 
    b2 = ROL64((a20^d0), 3);
    b3 = ROL64((a31^d1), 45);
    b4 = ROL64((a42^d2), 61);
    b0 = ROL64((a03^d3), 28);
    b1 = ROL64((a14^d4), 20);
    a20 =   b0 ^((~b1)&  b2 );
    a31 =   b1 ^((~b2)&  b3 );
    a42 =   b2 ^((~b3)&  b4 );
    a03 =   b3 ^((~b4)&  b0 );
    a14 =   b4 ^((~b0)&  b1 );
 
    b4 = ROL64((a40^d0), 18);
    b0 = ROL64((a01^d1), 1);
    b1 = ROL64((a12^d2), 6);
    b2 = ROL64((a23^d3), 25);
    b3 = ROL64((a34^d4), 8);
    a40 =   b0 ^((~b1)&  b2 );
    a01 =   b1 ^((~b2)&  b3 );
    a12 =   b2 ^((~b3)&  b4 );
    a23 =   b3 ^((~b4)&  b0 );
    a34 =   b4 ^((~b0)&  b1 );
 
    b1 = ROL64((a10^d0), 36);
    b2 = ROL64((a21^d1), 10);
    b3 = ROL64((a32^d2), 15);
    b4 = ROL64((a43^d3), 56);
    b0 = ROL64((a04^d4), 27);
    a10 =   b0 ^((~b1)&  b2 );
    a21 =   b1 ^((~b2)&  b3 );
    a32 =   b2 ^((~b3)&  b4 );
    a43 =   b3 ^((~b4)&  b0 );
    a04 =   b4 ^((~b0)&  b1 );
 
    b3 = ROL64((a30^d0), 41);
    b4 = ROL64((a41^d1), 2);
    b0 = ROL64((a02^d2), 62);
    b1 = ROL64((a13^d3), 55);
    b2 = ROL64((a24^d4), 39);
    a30 =   b0 ^((~b1)&  b2 );
    a41 =   b1 ^((~b2)&  b3 );
    a02 =   b2 ^((~b3)&  b4 );
    a13 =   b3 ^((~b4)&  b0 );
    a24 =   b4 ^((~b0)&  b1 );
 
    c0 = a00^a20^a40^a10^a30;
    c1 = a11^a31^a01^a21^a41;
    c2 = a22^a42^a12^a32^a02;
    c3 = a33^a03^a23^a43^a13;
    c4 = a44^a14^a34^a04^a24;
    d0 = c4^ROL64(c1, 1);
    d1 = c0^ROL64(c2, 1);
    d2 = c1^ROL64(c3, 1);
    d3 = c2^ROL64(c4, 1);
    d4 = c3^ROL64(c0, 1);
 
    b0 = (a00^d0);
    b1 = ROL64((a31^d1), 44);
    b2 = ROL64((a12^d2), 43);
    b3 = ROL64((a43^d3), 21);
    b4 = ROL64((a24^d4), 14);
    a00 =   b0 ^((~b1)&  b2 );
    a00 ^= RC[i+1];
    a31 =   b1 ^((~b2)&  b3 );
    a12 =   b2 ^((~b3)&  b4 );
    a43 =   b3 ^((~b4)&  b0 );
    a24 =   b4 ^((~b0)&  b1 );
 
    b2 = ROL64((a40^d0), 3);
    b3 = ROL64((a21^d1), 45);
    b4 = ROL64((a02^d2), 61);
    b0 = ROL64((a33^d3), 28);
    b1 = ROL64((a14^d4), 20);
    a40 =   b0 ^((~b1)&  b2 );
    a21 =   b1 ^((~b2)&  b3 );
    a02 =   b2 ^((~b3)&  b4 );
    a33 =   b3 ^((~b4)&  b0 );
    a14 =   b4 ^((~b0)&  b1 );
 
    b4 = ROL64((a30^d0), 18);
    b0 = ROL64((a11^d1), 1);
    b1 = ROL64((a42^d2), 6);
    b2 = ROL64((a23^d3), 25);
    b3 = ROL64((a04^d4), 8);
    a30 =   b0 ^((~b1)&  b2 );
    a11 =   b1 ^((~b2)&  b3 );
    a42 =   b2 ^((~b3)&  b4 );
    a23 =   b3 ^((~b4)&  b0 );
    a04 =   b4 ^((~b0)&  b1 );
 
    b1 = ROL64((a20^d0), 36);
    b2 = ROL64((a01^d1), 10);
    b3 = ROL64((a32^d2), 15);
    b4 = ROL64((a13^d3), 56);
    b0 = ROL64((a44^d4), 27);
    a20 =   b0 ^((~b1)&  b2 );
    a01 =   b1 ^((~b2)&  b3 );
    a32 =   b2 ^((~b3)&  b4 );
    a13 =   b3 ^((~b4)&  b0 );
    a44 =   b4 ^((~b0)&  b1 );
 
    b3 = ROL64((a10^d0), 41);
    b4 = ROL64((a41^d1), 2);
    b0 = ROL64((a22^d2), 62);
    b1 = ROL64((a03^d3), 55);
    b2 = ROL64((a34^d4), 39);
    a10 =   b0 ^((~b1)&  b2 );
    a41 =   b1 ^((~b2)&  b3 );
    a22 =   b2 ^((~b3)&  b4 );
    a03 =   b3 ^((~b4)&  b0 );
    a34 =   b4 ^((~b0)&  b1 );
 
    c0 = a00^a40^a30^a20^a10;
    c1 = a31^a21^a11^a01^a41;
    c2 = a12^a02^a42^a32^a22;
    c3 = a43^a33^a23^a13^a03;
    c4 = a24^a14^a04^a44^a34;
    d0 = c4^ROL64(c1, 1);
    d1 = c0^ROL64(c2, 1);
    d2 = c1^ROL64(c3, 1);
    d3 = c2^ROL64(c4, 1);
    d4 = c3^ROL64(c0, 1);
 
    b0 = (a00^d0);
    b1 = ROL64((a21^d1), 44);
    b2 = ROL64((a42^d2), 43);
    b3 = ROL64((a13^d3), 21);
    b4 = ROL64((a34^d4), 14);
    a00 =   b0 ^((~b1)&  b2 );
    a00 ^= RC[i+2];
    a21 =   b1 ^((~b2)&  b3 );
    a42 =   b2 ^((~b3)&  b4 );
    a13 =   b3 ^((~b4)&  b0 );
    a34 =   b4 ^((~b0)&  b1 );
 
    b2 = ROL64((a30^d0), 3);
    b3 = ROL64((a01^d1), 45);
    b4 = ROL64((a22^d2), 61);
    b0 = ROL64((a43^d3), 28);
    b1 = ROL64((a14^d4), 20);
    a30 =   b0 ^((~b1)&  b2 );
    a01 =   b1 ^((~b2)&  b3 );
    a22 =   b2 ^((~b3)&  b4 );
    a43 =   b3 ^((~b4)&  b0 );
    a14 =   b4 ^((~b0)&  b1 );
 
    b4 = ROL64((a10^d0), 18);
    b0 = ROL64((a31^d1), 1);
    b1 = ROL64((a02^d2), 6);
    b2 = ROL64((a23^d3), 25);
    b3 = ROL64((a44^d4), 8);
    a10 =   b0 ^((~b1)&  b2 );
    a31 =   b1 ^((~b2)&  b3 );
    a02 =   b2 ^((~b3)&  b4 );
    a23 =   b3 ^((~b4)&  b0 );
    a44 =   b4 ^((~b0)&  b1 );
 
    b1 = ROL64((a40^d0), 36);
    b2 = ROL64((a11^d1), 10);
    b3 = ROL64((a32^d2), 15);
    b4 = ROL64((a03^d3), 56);
    b0 = ROL64((a24^d4), 27);
    a40 =   b0 ^((~b1)&  b2 );
    a11 =   b1 ^((~b2)&  b3 );
    a32 =   b2 ^((~b3)&  b4 );
    a03 =   b3 ^((~b4)&  b0 );
    a24 =   b4 ^((~b0)&  b1 );
 
    b3 = ROL64((a20^d0), 41);
    b4 = ROL64((a41^d1), 2);
    b0 = ROL64((a12^d2), 62);
    b1 = ROL64((a33^d3), 55);
    b2 = ROL64((a04^d4), 39);
    a20 =   b0 ^((~b1)&  b2 );
    a41 =   b1 ^((~b2)&  b3 );
    a12 =   b2 ^((~b3)&  b4 );
    a33 =   b3 ^((~b4)&  b0 );
    a04 =   b4 ^((~b0)&  b1 );
 
    c0 = a00^a30^a10^a40^a20;
    c1 = a21^a01^a31^a11^a41;
    c2 = a42^a22^a02^a32^a12;
    c3 = a13^a43^a23^a03^a33;
    c4 = a34^a14^a44^a24^a04;
    d0 = c4^ROL64(c1, 1);
    d1 = c0^ROL64(c2, 1);
    d2 = c1^ROL64(c3, 1);
    d3 = c2^ROL64(c4, 1);
    d4 = c3^ROL64(c0, 1);
 
    b0 = (a00^d0);
    b1 = ROL64((a01^d1), 44);
    b2 = ROL64((a02^d2), 43);
    b3 = ROL64((a03^d3), 21);
    b4 = ROL64((a04^d4), 14);
    a00 =   b0 ^((~b1)&  b2 );
    a00 ^= RC[i+3];
    a01 =   b1 ^((~b2)&  b3 );
    a02 =   b2 ^((~b3)&  b4 );
    a03 =   b3 ^((~b4)&  b0 );
    a04 =   b4 ^((~b0)&  b1 );
 
    b2 = ROL64((a10^d0), 3);
    b3 = ROL64((a11^d1), 45);
    b4 = ROL64((a12^d2), 61);
    b0 = ROL64((a13^d3), 28);
    b1 = ROL64((a14^d4), 20);
    a10 =   b0 ^((~b1)&  b2 );
    a11 =   b1 ^((~b2)&  b3 );
    a12 =   b2 ^((~b3)&  b4 );
    a13 =   b3 ^((~b4)&  b0 );
    a14 =   b4 ^((~b0)&  b1 );
 
    b4 = ROL64((a20^d0), 18);
    b0 = ROL64((a21^d1), 1);
    b1 = ROL64((a22^d2), 6);
    b2 = ROL64((a23^d3), 25);
    b3 = ROL64((a24^d4), 8);
    a20 =   b0 ^((~b1)&  b2 );
    a21 =   b1 ^((~b2)&  b3 );
    a22 =   b2 ^((~b3)&  b4 );
    a23 =   b3 ^((~b4)&  b0 );
    a24 =   b4 ^((~b0)&  b1 );
 
    b1 = ROL64((a30^d0), 36);
    b2 = ROL64((a31^d1), 10);
    b3 = ROL64((a32^d2), 15);
    b4 = ROL64((a33^d3), 56);
    b0 = ROL64((a34^d4), 27);
    a30 =   b0 ^((~b1)&  b2 );
    a31 =   b1 ^((~b2)&  b3 );
    a32 =   b2 ^((~b3)&  b4 );
    a33 =   b3 ^((~b4)&  b0 );
    a34 =   b4 ^((~b0)&  b1 );
 
    b3 = ROL64((a40^d0), 41);
    b4 = ROL64((a41^d1), 2);
    b0 = ROL64((a42^d2), 62);
    b1 = ROL64((a43^d3), 55);
    b2 = ROL64((a44^d4), 39);
    a40 =   b0 ^((~b1)&  b2 );
    a41 =   b1 ^((~b2)&  b3 );
    a42 =   b2 ^((~b3)&  b4 );
    a43 =   b3 ^((~b4)&  b0 );
    a44 =   b4 ^((~b0)&  b1 );
  }
}

References a00, a01, a02, a03, a04, a10, a11, a12, a13, a14, a20, a21, a22, a23, a24, a30, a31, a32, a33, a34, a40, a41, a42, a43, a44, and ROL64.

Referenced by SHA3Update().

Here is the caller graph for this function:

line_is_command_terminator()

int line_is_command_terminator ( char * zLine )

static

                                                  {
  while( IsSpace(zLine[0]) ){ zLine++; };
  if( zLine[0]=='/' )
    zLine += 1; /* Oracle */
  else if ( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o' )
    zLine += 2; /* SQL Server */
  else
    return 0;

References IsSpace, QSS_Start, quickscan(), and ToLower.

Referenced by process_input().

Here is the call graph for this function:

Here is the caller graph for this function:

line_is_complete()

int line_is_complete ( char * zSql, int nSql )

static

                                                 {
  int rc;
  if( zSql==0 ) return 1;
  zSql[nSql] = ';';
  zSql[nSql+1] = 0;
  rc = sqlite3_complete(zSql);
  zSql[nSql] = 0;

References sqlite3_complete.

Referenced by process_input().

Here is the caller graph for this function:

lintDotCommand()

int lintDotCommand ( ShellState * pState, char ** azArg, int nArg )

static

 {
  int n;
  n = (nArg>=2 ? strlen30(azArg[1]) : 0);
  if( n<1 || sqlite3_strnicmp(azArg[1], "fkey-indexes", n) ) goto usage;
  return lintFkeyIndexes(pState, azArg, nArg);
 
 usage:
  sqlite3_fprintf(stderr,"Usage %s sub-command ?switches...?\n", azArg[0]);
  sqlite3_fprintf(stderr, "Where sub-commands are:\n");
  sqlite3_fprintf(stderr, "    fkey-indexes\n");

References lintFkeyIndexes(), sqlite3_fprintf, sqlite3_strnicmp, SQLITE_ERROR, strlen30(), and usage().

Referenced by do_meta_command().

Here is the call graph for this function:

Here is the caller graph for this function:

lintFkeyIndexes()

int lintFkeyIndexes ( ShellState * pState, char ** azArg, int nArg )

static

 {
  sqlite3 *db = pState->db;       /* Database handle to query "main" db of */
  int bVerbose = 0;               /* If -verbose is present */
  int bGroupByParent = 0;         /* If -groupbyparent is present */
  int i;                          /* To iterate through azArg[] */
  const char *zIndent = "";       /* How much to indent CREATE INDEX by */
  int rc;                         /* Return code */
  sqlite3_stmt *pSql = 0;         /* Compiled version of SQL statement below */
  FILE *out = pState->out;        /* Send output here */
 
  /*
  ** This SELECT statement returns one row for each foreign key constraint
  ** in the schema of the main database. The column values are:
  **
  ** 0. The text of an SQL statement similar to:
  **
  **      "EXPLAIN QUERY PLAN SELECT 1 FROM child_table WHERE child_key=?"
  **
  **    This SELECT is similar to the one that the foreign keys implementation
  **    needs to run internally on child tables. If there is an index that can
  **    be used to optimize this query, then it can also be used by the FK
  **    implementation to optimize DELETE or UPDATE statements on the parent
  **    table.
  **
  ** 1. A GLOB pattern suitable for sqlite3_strglob(). If the plan output by
  **    the EXPLAIN QUERY PLAN command matches this pattern, then the schema
  **    contains an index that can be used to optimize the query.
  **
  ** 2. Human readable text that describes the child table and columns. e.g.
  **
  **       "child_table(child_key1, child_key2)"
  **
  ** 3. Human readable text that describes the parent table and columns. e.g.
  **
  **       "parent_table(parent_key1, parent_key2)"
  **
  ** 4. A full CREATE INDEX statement for an index that could be used to
  **    optimize DELETE or UPDATE statements on the parent table. e.g.
  **
  **       "CREATE INDEX child_table_child_key ON child_table(child_key)"
  **
  ** 5. The name of the parent table.
  **
  ** These six values are used by the C logic below to generate the report.
  */
  const char *zSql =
  "SELECT "
    "     'EXPLAIN QUERY PLAN SELECT 1 FROM ' || quote(s.name) || ' WHERE '"
    "  || group_concat(quote(s.name) || '.' || quote(f.[from]) || '=?' "
    "  || fkey_collate_clause("
    "       f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]),' AND ')"
    ", "
    "     'SEARCH ' || s.name || ' USING COVERING INDEX*('"
    "  || group_concat('*=?', ' AND ') || ')'"
    ", "
    "     s.name  || '(' || group_concat(f.[from],  ', ') || ')'"
    ", "
    "     f.[table] || '(' || group_concat(COALESCE(f.[to], p.[name])) || ')'"
    ", "
    "     'CREATE INDEX ' || quote(s.name ||'_'|| group_concat(f.[from], '_'))"
    "  || ' ON ' || quote(s.name) || '('"
    "  || group_concat(quote(f.[from]) ||"
    "        fkey_collate_clause("
    "          f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]), ', ')"
    "  || ');'"
    ", "
    "     f.[table] "
    "FROM sqlite_schema AS s, pragma_foreign_key_list(s.name) AS f "
    "LEFT JOIN pragma_table_info AS p ON (pk-1=seq AND p.arg=f.[table]) "
    "GROUP BY s.name, f.id "
    "ORDER BY (CASE WHEN ? THEN f.[table] ELSE s.name END)"
  ;
  const char *zGlobIPK = "SEARCH * USING INTEGER PRIMARY KEY (rowid=?)";
 
  for(i=2; i<nArg; i++){
    int n = strlen30(azArg[i]);
    if( n>1 && sqlite3_strnicmp("-verbose", azArg[i], n)==0 ){
      bVerbose = 1;
    }
    else if( n>1 && sqlite3_strnicmp("-groupbyparent", azArg[i], n)==0 ){
      bGroupByParent = 1;
      zIndent = "    ";
    }
    else{
      sqlite3_fprintf(stderr,
           "Usage: %s %s ?-verbose? ?-groupbyparent?\n", azArg[0], azArg[1]);
      return SQLITE_ERROR;
    }
  }
 
  /* Register the fkey_collate_clause() SQL function */
  rc = sqlite3_create_function(db, "fkey_collate_clause", 4, SQLITE_UTF8,
      0, shellFkeyCollateClause, 0, 0
  );
 
 
  if( rc==SQLITE_OK ){
    rc = sqlite3_prepare_v2(db, zSql, -1, &pSql, 0);
  }
  if( rc==SQLITE_OK ){
    sqlite3_bind_int(pSql, 1, bGroupByParent);
  }
 
  if( rc==SQLITE_OK ){
    int rc2;
    char *zPrev = 0;
    while( SQLITE_ROW==sqlite3_step(pSql) ){
      int res = -1;
      sqlite3_stmt *pExplain = 0;
      const char *zEQP = (const char*)sqlite3_column_text(pSql, 0);
      const char *zGlob = (const char*)sqlite3_column_text(pSql, 1);
      const char *zFrom = (const char*)sqlite3_column_text(pSql, 2);
      const char *zTarget = (const char*)sqlite3_column_text(pSql, 3);
      const char *zCI = (const char*)sqlite3_column_text(pSql, 4);
      const char *zParent = (const char*)sqlite3_column_text(pSql, 5);
 
      if( zEQP==0 ) continue;
      if( zGlob==0 ) continue;
      rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
      if( rc!=SQLITE_OK ) break;
      if( SQLITE_ROW==sqlite3_step(pExplain) ){
        const char *zPlan = (const char*)sqlite3_column_text(pExplain, 3);
        res = zPlan!=0 && (  0==sqlite3_strglob(zGlob, zPlan)
                          || 0==sqlite3_strglob(zGlobIPK, zPlan));
      }
      rc = sqlite3_finalize(pExplain);
      if( rc!=SQLITE_OK ) break;
 
      if( res<0 ){
        sqlite3_fputs("Error: internal error", stderr);
        break;
      }else{
        if( bGroupByParent
        && (bVerbose || res==0)
        && (zPrev==0 || sqlite3_stricmp(zParent, zPrev))
        ){
          sqlite3_fprintf(out, "-- Parent table %s\n", zParent);
          sqlite3_free(zPrev);
          zPrev = sqlite3_mprintf("%s", zParent);
        }
 
        if( res==0 ){
          sqlite3_fprintf(out, "%s%s --> %s\n", zIndent, zCI, zTarget);
        }else if( bVerbose ){
          sqlite3_fprintf(out,
                "%s/* no extra indexes required for %s -> %s */\n",
                zIndent, zFrom, zTarget
          );
        }
      }
    }
    sqlite3_free(zPrev);
 
    if( rc!=SQLITE_OK ){
      sqlite3_fprintf(stderr,"%s\n", sqlite3_errmsg(db));
    }
 
    rc2 = sqlite3_finalize(pSql);
    if( rc==SQLITE_OK && rc2!=SQLITE_OK ){
      rc = rc2;
      sqlite3_fprintf(stderr,"%s\n", sqlite3_errmsg(db));
    }
  }else{
    sqlite3_fprintf(stderr,"%s\n", sqlite3_errmsg(db));
  }
 

References ShellState::db, ShellState::out, shellFkeyCollateClause(), sqlite3_bind_int, sqlite3_column_text, sqlite3_create_function, sqlite3_errmsg, sqlite3_finalize, sqlite3_fprintf, sqlite3_fputs, sqlite3_free, sqlite3_mprintf, sqlite3_prepare_v2, sqlite3_step, sqlite3_strglob, sqlite3_stricmp, sqlite3_strnicmp, SQLITE_ERROR, SQLITE_OK, SQLITE_ROW, SQLITE_UTF8, and strlen30().

Referenced by lintDotCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

local_getline()

char * local_getline ( char * zLine, FILE * in )

static

                                                 {
  int nLine = zLine==0 ? 0 : 100;
  int n = 0;
 
  while( 1 ){
    if( n+100>nLine ){
      nLine = nLine*2 + 100;
      zLine = realloc(zLine, nLine);
      shell_check_oom(zLine);
    }
    if( sqlite3_fgets(&zLine[n], nLine - n, in)==0 ){
      if( n==0 ){
        free(zLine);
        return 0;
      }
      zLine[n] = 0;
      break;
    }
    while( zLine[n] ) n++;
    if( n>0 && zLine[n-1]=='\n' ){
      n--;
      if( n>0 && zLine[n-1]=='\r' ) n--;
      zLine[n] = 0;
      break;
    }
  }
  return zLine;
}

References shell_check_oom(), and sqlite3_fgets.

Referenced by one_input_line().

Here is the call graph for this function:

Here is the caller graph for this function:

lockName()

const char * lockName ( int eLock )

static

                                      {
  const char *azLockNames[] = {
     "NONE", "SHARED", "RESERVED", "PENDING", "EXCLUSIVE"
  };
  if( eLock<0 || eLock>=(int)(sizeof(azLockNames)/sizeof(azLockNames[0])) ){
    return "???";
  }else{
    return azLockNames[eLock];
  }
}

Referenced by vfstraceLock(), and vfstraceUnlock().

Here is the caller graph for this function:

lsModeFunc()

void lsModeFunc ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  int i;
  int iMode = sqlite3_value_int(argv[0]);
  char z[16];
  (void)argc;
  if( S_ISLNK(iMode) ){
    z[0] = 'l';
  }else if( S_ISREG(iMode) ){
    z[0] = '-';
  }else if( S_ISDIR(iMode) ){
    z[0] = 'd';
  }else{
    z[0] = '?';
  }
  for(i=0; i<3; i++){
    int m = (iMode >> ((2-i)*3));
    char *a = &z[1 + i*3];
    a[0] = (m & 0x4) ? 'r' : '-';
    a[1] = (m & 0x2) ? 'w' : '-';
    a[2] = (m & 0x1) ? 'x' : '-';
  }
  z[10] = '\0';
  sqlite3_result_text(context, z, -1, SQLITE_TRANSIENT);
}

References a, sqlite3_result_text, sqlite3_value_int, and SQLITE_TRANSIENT.

Referenced by sqlite3_fileio_init().

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char **	argv )

                                            {
#else
int SQLITE_CDECL wmain(int argc, wchar_t **wargv){
  char **argv;
#endif
#ifdef SQLITE_DEBUG
  sqlite3_int64 mem_main_enter = 0;
#endif
  char *zErrMsg = 0;
#ifdef SQLITE_SHELL_FIDDLE
#  define data shellState
#else
  ShellState data;
#endif
  const char *zInitFile = 0;
  int i;
  int rc = 0;
  int warnInmemoryDb = 0;
  int readStdin = 1;
  int nCmd = 0;
  int nOptsEnd = argc;
  int bEnableVfstrace = 0;
  char **azCmd = 0;
  const char *zVfs = 0;           /* Value of -vfs command-line option */
#if !SQLITE_SHELL_IS_UTF8
  char **argvToFree = 0;
  int argcToFree = 0;
#endif
  setvbuf(stderr, 0, _IONBF, 0); /* Make sure stderr is unbuffered */
 
#ifdef SQLITE_SHELL_FIDDLE
  stdin_is_interactive = 0;
  stdout_is_console = 1;
  data.wasm.zDefaultDbName = "/fiddle.sqlite3";
#else
  stdin_is_interactive = isatty(0);
  stdout_is_console = isatty(1);
#endif
  atexit(sayAbnormalExit);
#ifdef SQLITE_DEBUG
  mem_main_enter = sqlite3_memory_used();
#endif
#if !defined(_WIN32_WCE)
  if( getenv("SQLITE_DEBUG_BREAK") ){
    if( isatty(0) && isatty(2) ){
      char zLine[100];
      sqlite3_fprintf(stderr,
            "attach debugger to process %d and press ENTER to continue...",
            GETPID());
      if( sqlite3_fgets(zLine, sizeof(zLine), stdin)!=0
       && cli_strcmp(zLine,"stop")==0
      ){
        exit(1);
      }
    }else{
#if defined(_WIN32) || defined(WIN32)
#if SQLITE_OS_WINRT
      __debugbreak();
#else
      DebugBreak();
#endif
#elif defined(SIGTRAP)
      raise(SIGTRAP);
#endif
    }
  }
#endif
  /* Register a valid signal handler early, before much else is done. */
#ifdef SIGINT
  signal(SIGINT, interrupt_handler);
#elif (defined(_WIN32) || defined(WIN32)) && !defined(_WIN32_WCE)
  if( !SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE) ){
    eputz("No ^C handler.\n");
  }
#endif
 
#if USE_SYSTEM_SQLITE+0!=1
  if( cli_strncmp(sqlite3_sourceid(),SQLITE_SOURCE_ID,60)!=0 ){
    sqlite3_fprintf(stderr,
          "SQLite header and source version mismatch\n%s\n%s\n",
          sqlite3_sourceid(), SQLITE_SOURCE_ID);
    exit(1);
  }
#endif
  main_init(&data);
 
  /* On Windows, we must translate command-line arguments into UTF-8.
  ** The SQLite memory allocator subsystem has to be enabled in order to
  ** do this.  But we want to run an sqlite3_shutdown() afterwards so that
  ** subsequent sqlite3_config() calls will work.  So copy all results into
  ** memory that does not come from the SQLite memory allocator.
  */
#if !SQLITE_SHELL_IS_UTF8
  sqlite3_initialize();
  argvToFree = malloc(sizeof(argv[0])*argc*2);
  shell_check_oom(argvToFree);
  argcToFree = argc;
  argv = argvToFree + argc;
  for(i=0; i<argc; i++){
    char *z = sqlite3_win32_unicode_to_utf8(wargv[i]);
    i64 n;
    shell_check_oom(z);
    n = strlen(z);
    argv[i] = malloc( n+1 );
    shell_check_oom(argv[i]);
    memcpy(argv[i], z, n+1);
    argvToFree[i] = argv[i];
    sqlite3_free(z);
  }
  sqlite3_shutdown();
#endif
 
  assert( argc>=1 && argv && argv[0] );
  Argv0 = argv[0];
 
#ifdef SQLITE_SHELL_DBNAME_PROC
  {
    /* If the SQLITE_SHELL_DBNAME_PROC macro is defined, then it is the name
    ** of a C-function that will provide the name of the database file.  Use
    ** this compile-time option to embed this shell program in larger
    ** applications. */
    extern void SQLITE_SHELL_DBNAME_PROC(const char**);
    SQLITE_SHELL_DBNAME_PROC(&data.pAuxDb->zDbFilename);
    warnInmemoryDb = 0;
  }
#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, options affecting commands
  ** or SQL run from the command line, and the first command to execute.
  */
#ifndef SQLITE_SHELL_FIDDLE
  verify_uninitialized();
#endif
  for(i=1; i<argc; i++){
    char *z;
    z = argv[i];
    if( z[0]!='-' || i>nOptsEnd ){
      if( data.aAuxDb->zDbFilename==0 ){
        data.aAuxDb->zDbFilename = z;
      }else{
        /* Excess arguments are interpreted as SQL (or dot-commands) and
        ** mean that nothing is read from stdin */
        readStdin = 0;
        nCmd++;
        azCmd = realloc(azCmd, sizeof(azCmd[0])*nCmd);
        shell_check_oom(azCmd);
        azCmd[nCmd-1] = z;
      }
      continue;
    }
    if( z[1]=='-' ) z++;
    if( cli_strcmp(z, "-")==0 ){
      nOptsEnd = i;
      continue;
    }else if( cli_strcmp(z,"-separator")==0
     || cli_strcmp(z,"-nullvalue")==0
     || cli_strcmp(z,"-newline")==0
     || cli_strcmp(z,"-cmd")==0
    ){
      (void)cmdline_option_value(argc, argv, ++i);
    }else if( cli_strcmp(z,"-init")==0 ){
      zInitFile = cmdline_option_value(argc, argv, ++i);
    }else if( cli_strcmp(z,"-interactive")==0 ){
    }else if( cli_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( cli_strcmp(z,"-utf8")==0 ){
    }else if( cli_strcmp(z,"-no-utf8")==0 ){
    }else if( cli_strcmp(z,"-no-rowid-in-view")==0 ){
      int val = 0;
      sqlite3_config(SQLITE_CONFIG_ROWID_IN_VIEW, &val);
      assert( val==0 );
    }else if( cli_strcmp(z,"-heap")==0 ){
#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
      const char *zSize;
      sqlite3_int64 szHeap;
 
      zSize = cmdline_option_value(argc, argv, ++i);
      szHeap = integerValue(zSize);
      if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000;
      verify_uninitialized();
      sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64);
#else
      (void)cmdline_option_value(argc, argv, ++i);
#endif
    }else if( cli_strcmp(z,"-pagecache")==0 ){
      sqlite3_int64 n, sz;
      sz = integerValue(cmdline_option_value(argc,argv,++i));
      if( sz>70000 ) sz = 70000;
      if( sz<0 ) sz = 0;
      n = integerValue(cmdline_option_value(argc,argv,++i));
      if( sz>0 && n>0 && 0xffffffffffffLL/sz<n ){
        n = 0xffffffffffffLL/sz;
      }
      verify_uninitialized();
      sqlite3_config(SQLITE_CONFIG_PAGECACHE,
                    (n>0 && sz>0) ? malloc(n*sz) : 0, sz, n);
      data.shellFlgs |= SHFLG_Pagecache;
    }else if( cli_strcmp(z,"-lookaside")==0 ){
      int n, sz;
      sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
      if( sz<0 ) sz = 0;
      n = (int)integerValue(cmdline_option_value(argc,argv,++i));
      if( n<0 ) n = 0;
      verify_uninitialized();
      sqlite3_config(SQLITE_CONFIG_LOOKASIDE, sz, n);
      if( sz*n==0 ) data.shellFlgs &= ~SHFLG_Lookaside;
    }else if( cli_strcmp(z,"-threadsafe")==0 ){
      int n;
      n = (int)integerValue(cmdline_option_value(argc,argv,++i));
      verify_uninitialized();
      switch( n ){
         case 0:  sqlite3_config(SQLITE_CONFIG_SINGLETHREAD);  break;
         case 2:  sqlite3_config(SQLITE_CONFIG_MULTITHREAD);   break;
         default: sqlite3_config(SQLITE_CONFIG_SERIALIZED);    break;
      }
    }else if( cli_strcmp(z,"-vfstrace")==0 ){
      bEnableVfstrace = 1;
#ifdef SQLITE_ENABLE_MULTIPLEX
    }else if( cli_strcmp(z,"-multiplex")==0 ){
      extern int sqlite3_multiplex_initialize(const char*,int);
      sqlite3_multiplex_initialize(0, 1);
#endif
    }else if( cli_strcmp(z,"-mmap")==0 ){
      sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));
      verify_uninitialized();
      sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz);
#if defined(SQLITE_ENABLE_SORTER_REFERENCES)
    }else if( cli_strcmp(z,"-sorterref")==0 ){
      sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));
      verify_uninitialized();
      sqlite3_config(SQLITE_CONFIG_SORTERREF_SIZE, (int)sz);
#endif
    }else if( cli_strcmp(z,"-vfs")==0 ){
      zVfs = cmdline_option_value(argc, argv, ++i);
#ifdef SQLITE_HAVE_ZLIB
    }else if( cli_strcmp(z,"-zip")==0 ){
      data.openMode = SHELL_OPEN_ZIPFILE;
#endif
    }else if( cli_strcmp(z,"-append")==0 ){
      data.openMode = SHELL_OPEN_APPENDVFS;
#ifndef SQLITE_OMIT_DESERIALIZE
    }else if( cli_strcmp(z,"-deserialize")==0 ){
      data.openMode = SHELL_OPEN_DESERIALIZE;
    }else if( cli_strcmp(z,"-maxsize")==0 && i+1<argc ){
      data.szMax = integerValue(argv[++i]);
#endif
    }else if( cli_strcmp(z,"-readonly")==0 ){
      data.openMode = SHELL_OPEN_READONLY;
    }else if( cli_strcmp(z,"-nofollow")==0 ){
      data.openFlags = SQLITE_OPEN_NOFOLLOW;
#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB)
    }else if( cli_strncmp(z, "-A",2)==0 ){
      /* All remaining command-line arguments are passed to the ".archive"
      ** command, so ignore them */
      break;
#endif
    }else if( cli_strcmp(z, "-memtrace")==0 ){
      sqlite3MemTraceActivate(stderr);
    }else if( cli_strcmp(z, "-pcachetrace")==0 ){
      sqlite3PcacheTraceActivate(stderr);
    }else if( cli_strcmp(z,"-bail")==0 ){
      bail_on_error = 1;
    }else if( cli_strcmp(z,"-nonce")==0 ){
      free(data.zNonce);
      data.zNonce = strdup(cmdline_option_value(argc, argv, ++i));
    }else if( cli_strcmp(z,"-unsafe-testing")==0 ){
      ShellSetFlag(&data,SHFLG_TestingMode);
    }else if( cli_strcmp(z,"-safe")==0 ){
      /* no-op - catch this on the second pass */
    }else if( cli_strcmp(z,"-escape")==0 && i+1<argc ){
      /* skip over the argument */
      i++;
    }
  }
#ifndef SQLITE_SHELL_FIDDLE
  if( !bEnableVfstrace ) verify_uninitialized();
#endif
 
 
#ifdef SQLITE_SHELL_INIT_PROC
  {
    /* If the SQLITE_SHELL_INIT_PROC macro is defined, then it is the name
    ** of a C-function that will perform initialization actions on SQLite that
    ** occur just before or after sqlite3_initialize(). Use this compile-time
    ** option to embed this shell program in larger applications. */
    extern void SQLITE_SHELL_INIT_PROC(void);
    SQLITE_SHELL_INIT_PROC();
  }
#else
  /* All the sqlite3_config() calls have now been made. So it is safe
  ** to call sqlite3_initialize() and process any command line -vfs option. */
  sqlite3_initialize();
#endif
 
  if( zVfs ){
    sqlite3_vfs *pVfs = sqlite3_vfs_find(zVfs);
    if( pVfs ){
      sqlite3_vfs_register(pVfs, 1);
    }else{
      sqlite3_fprintf(stderr,"no such VFS: \"%s\"\n", zVfs);
      exit(1);
    }
  }
 
  if( data.pAuxDb->zDbFilename==0 ){
#ifndef SQLITE_OMIT_MEMORYDB
    data.pAuxDb->zDbFilename = ":memory:";
    warnInmemoryDb = argc==1;
#else
    sqlite3_fprintf(stderr,
                    "%s: Error: no database filename specified\n", Argv0);
    return 1;
#endif
  }
  data.out = stdout;
  if( bEnableVfstrace ){
    vfstrace_register("trace",0,vfstraceOut, &data, 1);
  }
#ifndef SQLITE_SHELL_FIDDLE
  sqlite3_appendvfs_init(0,0,0);
#endif
 
  /* 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.pAuxDb->zDbFilename, 0)==0 ){
    open_db(&data, 0);
  }
 
  /* 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.
  */
  process_sqliterc(&data,zInitFile);
 
  /* 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]!='-' || i>=nOptsEnd ) continue;
    if( z[1]=='-' ){ z++; }
    if( cli_strcmp(z,"-init")==0 ){
      i++;
    }else if( cli_strcmp(z,"-html")==0 ){
      data.mode = MODE_Html;
    }else if( cli_strcmp(z,"-list")==0 ){
      data.mode = MODE_List;
    }else if( cli_strcmp(z,"-quote")==0 ){
      data.mode = MODE_Quote;
      sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator, SEP_Comma);
      sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator, SEP_Row);
    }else if( cli_strcmp(z,"-line")==0 ){
      data.mode = MODE_Line;
    }else if( cli_strcmp(z,"-column")==0 ){
      data.mode = MODE_Column;
    }else if( cli_strcmp(z,"-json")==0 ){
      data.mode = MODE_Json;
    }else if( cli_strcmp(z,"-markdown")==0 ){
      data.mode = MODE_Markdown;
    }else if( cli_strcmp(z,"-table")==0 ){
      data.mode = MODE_Table;
    }else if( cli_strcmp(z,"-box")==0 ){
      data.mode = MODE_Box;
    }else if( cli_strcmp(z,"-csv")==0 ){
      data.mode = MODE_Csv;
      memcpy(data.colSeparator,",",2);
    }else if( cli_strcmp(z,"-escape")==0 && i+1<argc ){
      /* See similar code at tag-20250224-1 */
      const char *zEsc = argv[++i];
      int k;
      for(k=0; k<ArraySize(shell_EscModeNames); k++){
        if( sqlite3_stricmp(zEsc,shell_EscModeNames[k])==0 ){
          data.eEscMode = k;
          break;
        }
      }
      if( k>=ArraySize(shell_EscModeNames) ){
        sqlite3_fprintf(stderr, "unknown control character escape mode \"%s\""
                                " - choices:", zEsc);
        for(k=0; k<ArraySize(shell_EscModeNames); k++){
          sqlite3_fprintf(stderr, " %s", shell_EscModeNames[k]);
        }
        sqlite3_fprintf(stderr, "\n");
        exit(1);
      }
#ifdef SQLITE_HAVE_ZLIB
    }else if( cli_strcmp(z,"-zip")==0 ){
      data.openMode = SHELL_OPEN_ZIPFILE;
#endif
    }else if( cli_strcmp(z,"-append")==0 ){
      data.openMode = SHELL_OPEN_APPENDVFS;
#ifndef SQLITE_OMIT_DESERIALIZE
    }else if( cli_strcmp(z,"-deserialize")==0 ){
      data.openMode = SHELL_OPEN_DESERIALIZE;
    }else if( cli_strcmp(z,"-maxsize")==0 && i+1<argc ){
      data.szMax = integerValue(argv[++i]);
#endif
    }else if( cli_strcmp(z,"-readonly")==0 ){
      data.openMode = SHELL_OPEN_READONLY;
    }else if( cli_strcmp(z,"-nofollow")==0 ){
      data.openFlags |= SQLITE_OPEN_NOFOLLOW;
    }else if( cli_strcmp(z,"-ascii")==0 ){
      data.mode = MODE_Ascii;
      sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,SEP_Unit);
      sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,SEP_Record);
    }else if( cli_strcmp(z,"-tabs")==0 ){
      data.mode = MODE_List;
      sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,SEP_Tab);
      sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,SEP_Row);
    }else if( cli_strcmp(z,"-separator")==0 ){
      sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
                       "%s",cmdline_option_value(argc,argv,++i));
    }else if( cli_strcmp(z,"-newline")==0 ){
      sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
                       "%s",cmdline_option_value(argc,argv,++i));
    }else if( cli_strcmp(z,"-nullvalue")==0 ){
      sqlite3_snprintf(sizeof(data.nullValue), data.nullValue,
                       "%s",cmdline_option_value(argc,argv,++i));
    }else if( cli_strcmp(z,"-header")==0 ){
      data.showHeader = 1;
      ShellSetFlag(&data, SHFLG_HeaderSet);
     }else if( cli_strcmp(z,"-noheader")==0 ){
      data.showHeader = 0;
      ShellSetFlag(&data, SHFLG_HeaderSet);
    }else if( cli_strcmp(z,"-echo")==0 ){
      ShellSetFlag(&data, SHFLG_Echo);
    }else if( cli_strcmp(z,"-eqp")==0 ){
      data.autoEQP = AUTOEQP_on;
    }else if( cli_strcmp(z,"-eqpfull")==0 ){
      data.autoEQP = AUTOEQP_full;
    }else if( cli_strcmp(z,"-stats")==0 ){
      data.statsOn = 1;
    }else if( cli_strcmp(z,"-scanstats")==0 ){
      data.scanstatsOn = 1;
    }else if( cli_strcmp(z,"-backslash")==0 ){
      /* Undocumented command-line option: -backslash
      ** Causes C-style backslash escapes to be evaluated in SQL statements
      ** prior to sending the SQL into SQLite.  Useful for injecting
      ** crazy bytes in the middle of SQL statements for testing and debugging.
      */
      ShellSetFlag(&data, SHFLG_Backslash);
    }else if( cli_strcmp(z,"-bail")==0 ){
      /* No-op.  The bail_on_error flag should already be set. */
    }else if( cli_strcmp(z,"-version")==0 ){
      sqlite3_fprintf(stdout, "%s %s (%d-bit)\n",
            sqlite3_libversion(), sqlite3_sourceid(), 8*(int)sizeof(char*));
      return 0;
    }else if( cli_strcmp(z,"-interactive")==0 ){
      /* Need to check for interactive override here to so that it can
      ** affect console setup (for Windows only) and testing thereof.
      */
      stdin_is_interactive = 1;
    }else if( cli_strcmp(z,"-batch")==0 ){
      /* already handled */
    }else if( cli_strcmp(z,"-utf8")==0 ){
      /* already handled */
    }else if( cli_strcmp(z,"-no-utf8")==0 ){
      /* already handled */
    }else if( cli_strcmp(z,"-no-rowid-in-view")==0 ){
      /* already handled */
    }else if( cli_strcmp(z,"-heap")==0 ){
      i++;
    }else if( cli_strcmp(z,"-pagecache")==0 ){
      i+=2;
    }else if( cli_strcmp(z,"-lookaside")==0 ){
      i+=2;
    }else if( cli_strcmp(z,"-threadsafe")==0 ){
      i+=2;
    }else if( cli_strcmp(z,"-nonce")==0 ){
      i += 2;
    }else if( cli_strcmp(z,"-mmap")==0 ){
      i++;
    }else if( cli_strcmp(z,"-memtrace")==0 ){
      i++;
    }else if( cli_strcmp(z,"-pcachetrace")==0 ){
      i++;
#ifdef SQLITE_ENABLE_SORTER_REFERENCES
    }else if( cli_strcmp(z,"-sorterref")==0 ){
      i++;
#endif
    }else if( cli_strcmp(z,"-vfs")==0 ){
      i++;
    }else if( cli_strcmp(z,"-vfstrace")==0 ){
      i++;
#ifdef SQLITE_ENABLE_MULTIPLEX
    }else if( cli_strcmp(z,"-multiplex")==0 ){
      i++;
#endif
    }else if( cli_strcmp(z,"-help")==0 ){
      usage(1);
    }else if( cli_strcmp(z,"-cmd")==0 ){
      /* Run commands that follow -cmd first and separately from commands
      ** that simply appear on the command-line.  This seems goofy.  It would
      ** be better if all commands ran in the order that they appear.  But
      ** we retain the goofy behavior for historical compatibility. */
      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==2 ? 0 : rc;
      }else{
        open_db(&data, 0);
        rc = shell_exec(&data, z, &zErrMsg);
        if( zErrMsg!=0 ){
          shellEmitError(zErrMsg);
          if( bail_on_error ) return rc!=0 ? rc : 1;
        }else if( rc!=0 ){
          sqlite3_fprintf(stderr,"Error: unable to process SQL \"%s\"\n", z);
          if( bail_on_error ) return rc;
        }
      }
#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB)
    }else if( cli_strncmp(z, "-A", 2)==0 ){
      if( nCmd>0 ){
        sqlite3_fprintf(stderr,"Error: cannot mix regular SQL or dot-commands"
              " with \"%s\"\n", z);
        return 1;
      }
      open_db(&data, OPEN_DB_ZIPFILE);
      if( z[2] ){
        argv[i] = &z[2];
        arDotCommand(&data, 1, argv+(i-1), argc-(i-1));
      }else{
        arDotCommand(&data, 1, argv+i, argc-i);
      }
      readStdin = 0;
      break;
#endif
    }else if( cli_strcmp(z,"-safe")==0 ){
      data.bSafeMode = data.bSafeModePersist = 1;
    }else if( cli_strcmp(z,"-unsafe-testing")==0 ){
      /* Acted upon in first pass. */
    }else{
      sqlite3_fprintf(stderr,"%s: Error: unknown option: %s\n", Argv0, z);
      eputz("Use -help for a list of options.\n");
      return 1;
    }
    data.cMode = data.mode;
  }
 
  if( !readStdin ){
    /* Run all arguments that do not begin with '-' as if they were separate
    ** command-line inputs, except for the argToSkip argument which contains
    ** the database filename.
    */
    for(i=0; i<nCmd; i++){
      echo_group_input(&data, azCmd[i]);
      if( azCmd[i][0]=='.' ){
        rc = do_meta_command(azCmd[i], &data);
        if( rc ){
          if( rc==2 ) rc = 0;
          goto shell_main_exit;
        }
      }else{
        open_db(&data, 0);
        rc = shell_exec(&data, azCmd[i], &zErrMsg);
        if( zErrMsg || rc ){
          if( zErrMsg!=0 ){
            shellEmitError(zErrMsg);
          }else{
            sqlite3_fprintf(stderr,
                            "Error: unable to process SQL: %s\n", azCmd[i]);
          }
          sqlite3_free(zErrMsg);
          if( rc==0 ) rc = 1;
          goto shell_main_exit;
        }
      }
    }
  }else{
    /* Run commands received from standard input
    */
    if( stdin_is_interactive ){
      char *zHome;
      char *zHistory;
      int nHistory;
      sqlite3_fprintf(stdout,
            "SQLite version %s %.19s\n" /*extra-version-info*/
            "Enter \".help\" for usage hints.\n",
            sqlite3_libversion(), sqlite3_sourceid());
      if( warnInmemoryDb ){
        sputz(stdout, "Connected to a ");
        printBold("transient in-memory database");
        sputz(stdout, ".\nUse \".open FILENAME\" to reopen on a"
              " persistent database.\n");
      }
      zHistory = getenv("SQLITE_HISTORY");
      if( zHistory ){
        zHistory = strdup(zHistory);
      }else if( (zHome = find_home_dir(0))!=0 ){
        nHistory = strlen30(zHome) + 20;
        if( (zHistory = malloc(nHistory))!=0 ){
          sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
        }
      }
      if( zHistory ){ shell_read_history(zHistory); }
#if (HAVE_READLINE || HAVE_EDITLINE) && !defined(SQLITE_OMIT_READLINE_COMPLETION)
      rl_attempted_completion_function = readline_completion;
#elif HAVE_LINENOISE==1
      linenoiseSetCompletionCallback(linenoise_completion);
#elif HAVE_LINENOISE==2
      linenoiseSetCompletionCallback(linenoise_completion, NULL);
#endif
      data.in = 0;
      rc = process_input(&data);
      if( zHistory ){
        shell_stifle_history(2000);
        shell_write_history(zHistory);
        free(zHistory);
      }
    }else{
      data.in = stdin;
      rc = process_input(&data);
    }
  }
#ifndef SQLITE_SHELL_FIDDLE
  /* In WASM mode we have to leave the db state in place so that
  ** client code can "push" SQL into it after this call returns. */
#ifndef SQLITE_OMIT_VIRTUALTABLE
  if( data.expert.pExpert ){
    expertFinish(&data, 1, 0);
  }
#endif
 shell_main_exit:
  free(azCmd);
  set_table_name(&data, 0);
  if( data.db ){
    session_close_all(&data, -1);
    close_db(data.db);
  }
  for(i=0; i<ArraySize(data.aAuxDb); i++){
    sqlite3_free(data.aAuxDb[i].zFreeOnClose);
    if( data.aAuxDb[i].db ){
      session_close_all(&data, i);
      close_db(data.aAuxDb[i].db);
    }
  }
  find_home_dir(1);
  output_reset(&data);
  data.doXdgOpen = 0;
  clearTempFile(&data);
#if !SQLITE_SHELL_IS_UTF8
  for(i=0; i<argcToFree; i++) free(argvToFree[i]);
  free(argvToFree);
#endif
  free(data.colWidth);
  free(data.zNonce);
  /* Clear the global data structure so that valgrind will detect memory
  ** leaks */
  memset(&data, 0, sizeof(data));
  if( bEnableVfstrace ){
    vfstrace_unregister("trace");
  }
#ifdef SQLITE_DEBUG
  if( sqlite3_memory_used()>mem_main_enter ){
    sqlite3_fprintf(stderr,"Memory leaked: %u bytes\n",
          (unsigned int)(sqlite3_memory_used()-mem_main_enter));
  }
#endif
#else /* SQLITE_SHELL_FIDDLE... */
  shell_main_exit:
#endif

References a, ShellState::aAuxDb, Argv0, ArraySize, ShellState::autoEQP, AUTOEQP_full, AUTOEQP_on, b, bail_on_error, ShellState::bSafeMode, ShellState::bSafeModePersist, clearTempFile(), cli_strcmp(), cli_strncmp(), close_db(), cmdline_option_value(), ShellState::cMode, ShellState::colSeparator, ShellState::colWidth, ShellState::AuxDb::db, ShellState::db, do_meta_command(), ShellState::doXdgOpen, echo_group_input(), ShellState::eEscMode, eputz, ShellState::expert, expertFinish(), find_home_dir(), GETPID, globalDb, ShellState::in, integerValue(), interrupt_handler(), isatty(), main_init(), ShellState::mode, MODE_Ascii, MODE_Box, MODE_Column, MODE_Csv, MODE_Html, MODE_Json, MODE_Line, MODE_List, MODE_Markdown, MODE_Quote, MODE_Table, ShellState::nullValue, open_db(), OPEN_DB_ZIPFILE, ShellState::openFlags, ShellState::openMode, ShellState::out, output_reset(), ShellState::pAuxDb, ExpertInfo::pExpert, sqlite3_file::pMethods, printBold(), process_input(), process_sqliterc(), ShellState::rowSeparator, sayAbnormalExit(), ShellState::scanstatsOn, SEP_Comma, SEP_Record, SEP_Row, SEP_Tab, SEP_Unit, session_close_all, set_table_name(), shell_check_oom(), shell_EscModeNames, shell_exec(), SHELL_OPEN_APPENDVFS, SHELL_OPEN_DESERIALIZE, SHELL_OPEN_READONLY, SHELL_OPEN_ZIPFILE, shell_read_history, shell_stifle_history, shell_write_history, shellEmitError(), ShellState::shellFlgs, ShellSetFlag, SHFLG_Backslash, SHFLG_Echo, SHFLG_HeaderSet, SHFLG_Lookaside, SHFLG_Pagecache, SHFLG_TestingMode, ShellState::showHeader, sputz, sqlite3_appendvfs_init(), sqlite3_config(), sqlite3_db_config, sqlite3_db_filename, sqlite3_exec, sqlite3_fgets, sqlite3_file_control, sqlite3_fprintf, sqlite3_fputs, sqlite3_free, sqlite3_initialize(), sqlite3_interrupt, sqlite3_libversion, sqlite3_memory_used, sqlite3_shutdown(), sqlite3_snprintf, sqlite3_sourceid, sqlite3_stricmp, sqlite3_txn_state, sqlite3_vfs_find, sqlite3_vfs_register, sqlite3MemTraceActivate(), sqlite3PcacheTraceActivate(), SQLITE_CDECL, SQLITE_CONFIG_HEAP, SQLITE_CONFIG_LOOKASIDE, SQLITE_CONFIG_MMAP_SIZE, SQLITE_CONFIG_MULTITHREAD, SQLITE_CONFIG_PAGECACHE, SQLITE_CONFIG_ROWID_IN_VIEW, SQLITE_CONFIG_SERIALIZED, SQLITE_CONFIG_SINGLETHREAD, SQLITE_CONFIG_SORTERREF_SIZE, SQLITE_DBCONFIG_RESET_DATABASE, SQLITE_FCNTL_FILE_POINTER, SQLITE_FCNTL_VFS_POINTER, SQLITE_IOERR_SHORT_READ, SQLITE_NOTFOUND, SQLITE_OPEN_NOFOLLOW, SQLITE_SOURCE_ID, ShellState::statsOn, stdin_is_interactive, stdout_is_console, strlen30(), ShellState::szMax, usage(), verify_uninitialized(), vfstrace_register(), vfstrace_unregister(), vfstraceOut(), sqlite3_io_methods::xFileSize, sqlite3_io_methods::xRead, ShellState::AuxDb::zDbFilename, ShellState::AuxDb::zFreeOnClose, and ShellState::zNonce.

Here is the call graph for this function:

main_init()

void main_init ( ShellState * data )

static

                                        {
  memset(data, 0, sizeof(*data));
  data->normalMode = data->cMode = data->mode = MODE_List;
  data->autoExplain = 1;
#ifdef _WIN32
  data->crlfMode = 1;
#endif
  data->pAuxDb = &data->aAuxDb[0];
  memcpy(data->colSeparator,SEP_Column, 2);
  memcpy(data->rowSeparator,SEP_Row, 2);
  data->showHeader = 0;
  data->shellFlgs = SHFLG_Lookaside;
  sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data);
#if !defined(SQLITE_SHELL_FIDDLE)
  verify_uninitialized();
#endif
  sqlite3_config(SQLITE_CONFIG_URI, 1);
  sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
  sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");

References ShellState::aAuxDb, ShellState::autoExplain, ShellState::cMode, ShellState::colSeparator, continuePrompt, ShellState::crlfMode, mainPrompt, ShellState::mode, MODE_List, ShellState::normalMode, ShellState::pAuxDb, ShellState::rowSeparator, SEP_Column, SEP_Row, ShellState::shellFlgs, shellLog(), SHFLG_Lookaside, ShellState::showHeader, sqlite3_config(), sqlite3_snprintf, SQLITE_CONFIG_LOG, SQLITE_CONFIG_MULTITHREAD, SQLITE_CONFIG_URI, and verify_uninitialized().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

makeDirectory()

int makeDirectory ( const char * zFile )

static

 {
  char *zCopy = sqlite3_mprintf("%s", zFile);
  int rc = SQLITE_OK;
 
  if( zCopy==0 ){
    rc = SQLITE_NOMEM;
  }else{
    int nCopy = (int)strlen(zCopy);
    int i = 1;
 
    while( rc==SQLITE_OK ){
      STRUCT_STAT sStat;
      int rc2;
 
      for(; zCopy[i]!='/' && i<nCopy; i++);
      if( i==nCopy ) break;
      zCopy[i] = '\0';
 
      rc2 = fileStat(zCopy, &sStat);
      if( rc2!=0 ){
        if( mkdir(zCopy, 0777) ) rc = SQLITE_ERROR;
      }else{
        if( !S_ISDIR(sStat.st_mode) ) rc = SQLITE_ERROR;
      }
      zCopy[i] = '/';
      i++;
    }
 
    sqlite3_free(zCopy);
  }
 
  return rc;
}

References fileStat(), sqlite3_free, sqlite3_mprintf, SQLITE_ERROR, SQLITE_NOMEM, SQLITE_OK, and STRUCT_STAT.

Referenced by writefileFunc().

Here is the call graph for this function:

Here is the caller graph for this function:

memtraceFree()

void memtraceFree ( void * p )

static

                                 {
  if( p==0 ) return;
  if( memtraceOut ){
    fprintf(memtraceOut, "MEMTRACE: free %d bytes\n", memtraceBase.xSize(p));
  }
  memtraceBase.xFree(p);
}

References memtraceBase, and memtraceOut.

Referenced by memtraceRealloc().

Here is the caller graph for this function:

memtraceInit()

int memtraceInit ( void * p )

static

                                {
  return memtraceBase.xInit(p);
}

References memtraceBase.

memtraceMalloc()

void * memtraceMalloc ( int n )

static

                                  {
  if( memtraceOut ){
    fprintf(memtraceOut, "MEMTRACE: allocate %d bytes\n", 
            memtraceBase.xRoundup(n));
  }
  return memtraceBase.xMalloc(n);
}

References memtraceBase, and memtraceOut.

Referenced by memtraceRealloc().

Here is the caller graph for this function:

memtraceRealloc()

void * memtraceRealloc ( void * p, int n )

static

                                            {
  if( p==0 ) return memtraceMalloc(n);
  if( n==0 ){
    memtraceFree(p);
    return 0;
  }
  if( memtraceOut ){
    fprintf(memtraceOut, "MEMTRACE: resize %d -> %d bytes\n",
            memtraceBase.xSize(p), memtraceBase.xRoundup(n));
  }
  return memtraceBase.xRealloc(p, n);
}

References memtraceBase, memtraceFree(), memtraceMalloc(), and memtraceOut.

Here is the call graph for this function:

memtraceRoundup()

int memtraceRoundup ( int n )

static

                                 {
  return memtraceBase.xRoundup(n);
}

References memtraceBase.

memtraceShutdown()

void memtraceShutdown ( void * p )

static

                                     {
  memtraceBase.xShutdown(p);
}

References memtraceBase.

memtraceSize()

int memtraceSize ( void * p )

static

                                {
  return memtraceBase.xSize(p);
}

References memtraceBase.

needUnistr()

int needUnistr ( const unsigned char * z )

static

                                             {
  unsigned char c;
  if( z==0 ) return 0;
  while( (c = *z)>0x1f || c=='\t' || c=='\n' || (c=='\r' && z[1]=='\n') ){ z++; }

References c.

Referenced by output_quoted_string(), and quoted_column().

Here is the caller graph for this function:

newTempFile()

void newTempFile ( ShellState * p, const char * zSuffix )

static

                                                           {
  clearTempFile(p);
  sqlite3_free(p->zTempFile);
  p->zTempFile = 0;
  if( p->db ){
    sqlite3_file_control(p->db, 0, SQLITE_FCNTL_TEMPFILENAME, &p->zTempFile);
  }
  if( p->zTempFile==0 ){
    /* If p->db is an in-memory database then the TEMPFILENAME file-control
    ** will not work and we will need to fallback to guessing */
    char *zTemp;
    sqlite3_uint64 r;
    sqlite3_randomness(sizeof(r), &r);
    zTemp = getenv("TEMP");
    if( zTemp==0 ) zTemp = getenv("TMP");
    if( zTemp==0 ){
#ifdef _WIN32
      zTemp = "\\tmp";
#else
      zTemp = "/tmp";
#endif
    }
    p->zTempFile = sqlite3_mprintf("%s/temp%llx.%s", zTemp, r, zSuffix);
  }else{
    p->zTempFile = sqlite3_mprintf("%z.%s", p->zTempFile, zSuffix);
  }

References clearTempFile(), ShellState::db, shell_check_oom(), sqlite3_file_control, sqlite3_free, sqlite3_mprintf, sqlite3_randomness, SQLITE_FCNTL_TEMPFILENAME, and ShellState::zTempFile.

Referenced by do_meta_command().

Here is the call graph for this function:

Here is the caller graph for this function:

one_input_line()

char * one_input_line ( FILE * in, char * zPrior, int isContinuation )

static

                                                                       {
  char *zPrompt;
  char *zResult;
  if( in!=0 ){
    zResult = local_getline(zPrior, in);
  }else{
    zPrompt = isContinuation ? CONTINUATION_PROMPT : mainPrompt;
#if SHELL_USE_LOCAL_GETLINE
    sputz(stdout, zPrompt);
    fflush(stdout);
    do{
      zResult = local_getline(zPrior, stdin);
      zPrior = 0;
      /* ^C trap creates a false EOF, so let "interrupt" thread catch up. */
      if( zResult==0 ) sqlite3_sleep(50);
    }while( zResult==0 && seenInterrupt>0 );
#else
    free(zPrior);
    zResult = shell_readline(zPrompt);
    while( zResult==0 ){
      /* ^C trap creates a false EOF, so let "interrupt" thread catch up. */
      sqlite3_sleep(50);
      if( seenInterrupt==0 ) break;
      zResult = shell_readline("");
    }
    if( zResult && *zResult ) shell_add_history(zResult);
#endif
  }
  return zResult;
}

References CONTINUATION_PROMPT, local_getline(), mainPrompt, seenInterrupt, sputz, and sqlite3_sleep.

Referenced by process_input().

Here is the call graph for this function:

Here is the caller graph for this function:

open_db()

void open_db ( ShellState * p, int openFlags )

static

                                                 {
  if( p->db==0 ){
    const char *zDbFilename = p->pAuxDb->zDbFilename;
    if( p->openMode==SHELL_OPEN_UNSPEC ){
      if( zDbFilename==0 || zDbFilename[0]==0 ){
        p->openMode = SHELL_OPEN_NORMAL;
      }else{
        p->openMode = (u8)deduceDatabaseType(zDbFilename,
                             (openFlags & OPEN_DB_ZIPFILE)!=0);
      }
    }
    switch( p->openMode ){
      case SHELL_OPEN_APPENDVFS: {
        sqlite3_open_v2(zDbFilename, &p->db,
           SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|p->openFlags, "apndvfs");
        break;
      }
      case SHELL_OPEN_HEXDB:
      case SHELL_OPEN_DESERIALIZE: {
        sqlite3_open(0, &p->db);
        break;
      }
      case SHELL_OPEN_ZIPFILE: {
        sqlite3_open(":memory:", &p->db);
        break;
      }
      case SHELL_OPEN_READONLY: {
        sqlite3_open_v2(zDbFilename, &p->db,
            SQLITE_OPEN_READONLY|p->openFlags, 0);
        break;
      }
      case SHELL_OPEN_UNSPEC:
      case SHELL_OPEN_NORMAL: {
        sqlite3_open_v2(zDbFilename, &p->db,
           SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|p->openFlags, 0);
        break;
      }
    }
    if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){
      sqlite3_fprintf(stderr,"Error: unable to open database \"%s\": %s\n",
            zDbFilename, sqlite3_errmsg(p->db));
      if( (openFlags & OPEN_DB_KEEPALIVE)==0 ){
        exit(1);
      }
      sqlite3_close(p->db);
      sqlite3_open(":memory:", &p->db);
      if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){
        sqlite3_fputs("Also: unable to open substitute in-memory database.\n",
                      stderr);
        exit(1);
      }else{
        sqlite3_fprintf(stderr,
              "Notice: using substitute in-memory database instead of \"%s\"\n",
              zDbFilename);
      }
    }
    globalDb = p->db;
    sqlite3_db_config(p->db, SQLITE_DBCONFIG_STMT_SCANSTATUS, (int)0, (int*)0);
 
    /* Reflect the use or absence of --unsafe-testing invocation. */
    {
      int testmode_on = ShellHasFlag(p,SHFLG_TestingMode);
      sqlite3_db_config(p->db, SQLITE_DBCONFIG_TRUSTED_SCHEMA, testmode_on,0);
      sqlite3_db_config(p->db, SQLITE_DBCONFIG_DEFENSIVE, !testmode_on,0);
    }
 
#ifndef SQLITE_OMIT_LOAD_EXTENSION
    sqlite3_enable_load_extension(p->db, 1);
#endif
    sqlite3_sha_init(p->db, 0, 0);
    sqlite3_shathree_init(p->db, 0, 0);
    sqlite3_uint_init(p->db, 0, 0);
    sqlite3_stmtrand_init(p->db, 0, 0);
    sqlite3_decimal_init(p->db, 0, 0);
    sqlite3_percentile_init(p->db, 0, 0);
    sqlite3_base64_init(p->db, 0, 0);
    sqlite3_base85_init(p->db, 0, 0);
    sqlite3_regexp_init(p->db, 0, 0);
    sqlite3_ieee_init(p->db, 0, 0);
    sqlite3_series_init(p->db, 0, 0);
#ifndef SQLITE_SHELL_FIDDLE
    sqlite3_fileio_init(p->db, 0, 0);
    sqlite3_completion_init(p->db, 0, 0);
#endif
#ifdef SQLITE_HAVE_ZLIB
    if( !p->bSafeModePersist ){
      sqlite3_zipfile_init(p->db, 0, 0);
      sqlite3_sqlar_init(p->db, 0, 0);
    }
#endif
#ifdef SQLITE_SHELL_EXTFUNCS
    /* Create a preprocessing mechanism for extensions to make
     * their own provisions for being built into the shell.
     * This is a short-span macro. See further below for usage.
     */
#define SHELL_SUB_MACRO(base, variant) base ## _ ## variant
#define SHELL_SUBMACRO(base, variant) SHELL_SUB_MACRO(base, variant)
    /* Let custom-included extensions get their ..._init() called.
     * The WHATEVER_INIT( db, pzErrorMsg, pApi ) macro should cause
     * the extension's sqlite3_*_init( db, pzErrorMsg, pApi )
     * initialization routine to be called.
     */
    {
      int irc = SHELL_SUBMACRO(SQLITE_SHELL_EXTFUNCS, INIT)(p->db);
    /* Let custom-included extensions expose their functionality.
     * The WHATEVER_EXPOSE( db, pzErrorMsg ) macro should cause
     * the SQL functions, virtual tables, collating sequences or
     * VFS's implemented by the extension to be registered.
     */
      if( irc==SQLITE_OK
          || irc==SQLITE_OK_LOAD_PERMANENTLY ){
        SHELL_SUBMACRO(SQLITE_SHELL_EXTFUNCS, EXPOSE)(p->db, 0);
      }
#undef SHELL_SUB_MACRO
#undef SHELL_SUBMACRO
    }
#endif
 
    sqlite3_create_function(p->db, "strtod", 1, SQLITE_UTF8, 0,
                            shellStrtod, 0, 0);
    sqlite3_create_function(p->db, "dtostr", 1, SQLITE_UTF8, 0,
                            shellDtostr, 0, 0);
    sqlite3_create_function(p->db, "dtostr", 2, SQLITE_UTF8, 0,
                            shellDtostr, 0, 0);
    sqlite3_create_function(p->db, "shell_add_schema", 3, SQLITE_UTF8, 0,
                            shellAddSchemaName, 0, 0);
    sqlite3_create_function(p->db, "shell_module_schema", 1, SQLITE_UTF8, p,
                            shellModuleSchema, 0, 0);
    sqlite3_create_function(p->db, "shell_putsnl", 1, SQLITE_UTF8, p,
                            shellPutsFunc, 0, 0);
    sqlite3_create_function(p->db, "usleep",1,SQLITE_UTF8,0,
                            shellUSleepFunc, 0, 0);
#ifndef SQLITE_NOHAVE_SYSTEM
    sqlite3_create_function(p->db, "edit", 1, SQLITE_UTF8, 0,
                            editFunc, 0, 0);
    sqlite3_create_function(p->db, "edit", 2, SQLITE_UTF8, 0,
                            editFunc, 0, 0);
#endif
 
    if( p->openMode==SHELL_OPEN_ZIPFILE ){
      char *zSql = sqlite3_mprintf(
         "CREATE VIRTUAL TABLE zip USING zipfile(%Q);", zDbFilename);
      shell_check_oom(zSql);
      sqlite3_exec(p->db, zSql, 0, 0, 0);
      sqlite3_free(zSql);
    }
#ifndef SQLITE_OMIT_DESERIALIZE
    else
    if( p->openMode==SHELL_OPEN_DESERIALIZE || p->openMode==SHELL_OPEN_HEXDB ){
      int rc;
      int nData = 0;
      unsigned char *aData;
      if( p->openMode==SHELL_OPEN_DESERIALIZE ){
        aData = (unsigned char*)readFile(zDbFilename, &nData);
      }else{
        aData = readHexDb(p, &nData);
      }
      if( aData==0 ){
        return;
      }
      rc = sqlite3_deserialize(p->db, "main", aData, nData, nData,
                   SQLITE_DESERIALIZE_RESIZEABLE |
                   SQLITE_DESERIALIZE_FREEONCLOSE);
      if( rc ){
        sqlite3_fprintf(stderr,"Error: sqlite3_deserialize() returns %d\n", rc);
      }
      if( p->szMax>0 ){
        sqlite3_file_control(p->db, "main", SQLITE_FCNTL_SIZE_LIMIT, &p->szMax);
      }
    }
#endif
  }
  if( p->db!=0 ){
    if( p->bSafeModePersist ){
      sqlite3_set_authorizer(p->db, safeModeAuth, p);
    }
    sqlite3_db_config(
        p->db, SQLITE_DBCONFIG_STMT_SCANSTATUS, p->scanstatsOn, (int*)0
    );

References ShellState::bSafeModePersist, ShellState::db, deduceDatabaseType(), editFunc(), globalDb, OPEN_DB_KEEPALIVE, OPEN_DB_ZIPFILE, ShellState::openFlags, ShellState::openMode, ShellState::pAuxDb, readFile(), readHexDb(), safeModeAuth(), ShellState::scanstatsOn, shell_check_oom(), SHELL_OPEN_APPENDVFS, SHELL_OPEN_DESERIALIZE, SHELL_OPEN_HEXDB, SHELL_OPEN_NORMAL, SHELL_OPEN_READONLY, SHELL_OPEN_UNSPEC, SHELL_OPEN_ZIPFILE, shellAddSchemaName(), shellDtostr(), ShellHasFlag, shellModuleSchema(), shellPutsFunc(), shellStrtod(), shellUSleepFunc(), SHFLG_TestingMode, sqlite3_base64_init(), sqlite3_base85_init(), sqlite3_close, sqlite3_completion_init(), sqlite3_create_function, sqlite3_db_config, sqlite3_decimal_init(), sqlite3_deserialize, sqlite3_enable_load_extension(), sqlite3_errcode, sqlite3_errmsg, sqlite3_exec, sqlite3_file_control, sqlite3_fileio_init(), sqlite3_fprintf, sqlite3_fputs, sqlite3_free, sqlite3_ieee_init(), sqlite3_mprintf, sqlite3_open, sqlite3_open_v2, sqlite3_percentile_init(), sqlite3_regexp_init(), sqlite3_series_init(), sqlite3_set_authorizer, sqlite3_sha_init(), sqlite3_shathree_init(), sqlite3_stmtrand_init(), sqlite3_uint_init(), SQLITE_DBCONFIG_DEFENSIVE, SQLITE_DBCONFIG_STMT_SCANSTATUS, SQLITE_DBCONFIG_TRUSTED_SCHEMA, SQLITE_DESERIALIZE_FREEONCLOSE, SQLITE_DESERIALIZE_RESIZEABLE, SQLITE_FCNTL_SIZE_LIMIT, SQLITE_OK, SQLITE_OK_LOAD_PERMANENTLY, SQLITE_OPEN_CREATE, SQLITE_OPEN_READONLY, SQLITE_OPEN_READWRITE, SQLITE_UTF8, ShellState::szMax, and ShellState::AuxDb::zDbFilename.

Referenced by do_meta_command(), main(), and runOneSqlLine().

Here is the call graph for this function:

Here is the caller graph for this function:

openChrSource()

FILE * openChrSource ( const char * zFile )

static

                                              {
#if defined(_WIN32) || defined(WIN32)
  struct __stat64 x = {0};
# define STAT_CHR_SRC(mode) ((mode & (_S_IFCHR|_S_IFIFO|_S_IFREG))!=0)
  /* On Windows, open first, then check the stream nature. This order
  ** is necessary because _stat() and sibs, when checking a named pipe,
  ** effectively break the pipe as its supplier sees it. */
  FILE *rv = sqlite3_fopen(zFile, "rb");
  if( rv==0 ) return 0;
  if( _fstat64(_fileno(rv), &x) != 0
      || !STAT_CHR_SRC(x.st_mode)){
    fclose(rv);
    rv = 0;
  }
  return rv;
#else
  struct stat x = {0};
  int rc = stat(zFile, &x);
# define STAT_CHR_SRC(mode) (S_ISREG(mode)||S_ISFIFO(mode)||S_ISCHR(mode))
  if( rc!=0 ) return 0;
  if( STAT_CHR_SRC(x.st_mode) ){
    return sqlite3_fopen(zFile, "rb");
  }else{
    return 0;
  }
#endif
#undef STAT_CHR_SRC
}

References sqlite3_fopen, and STAT_CHR_SRC.

Referenced by do_meta_command().

Here is the caller graph for this function:

optionMatch()

int optionMatch ( const char * zStr, const char * zOpt )

static

                                                          {
  if( zStr[0]!='-' ) return 0;
  zStr++;
  if( zStr[0]=='-' ) zStr++;

References cli_strcmp().

Referenced by do_meta_command().

Here is the call graph for this function:

Here is the caller graph for this function:

output_c_string()

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

static

                                                     {
  char c;
  static const char *zq = "\"";
  static long ctrlMask = ~0L;
  static const char *zDQBSRO = "\"\\\x7f"; /* double-quote, backslash, rubout */
  char ace[3] = "\\?";
  char cbsSay;
  sqlite3_fputs(zq, out);
  while( *z!=0 ){
    const char *pcDQBSRO = anyOfInStr(z, zDQBSRO, ~(size_t)0);
    const char *pcPast = zSkipValidUtf8(z, INT_MAX, ctrlMask);
    const char *pcEnd = (pcDQBSRO && pcDQBSRO < pcPast)? pcDQBSRO : pcPast;
    if( pcEnd > z ){
      sqlite3_fprintf(out, "%.*s", (int)(pcEnd-z), z);
    }
    if( (c = *pcEnd)==0 ) break;
    ++pcEnd;
    switch( c ){
    case '\\': case '"':
      cbsSay = (char)c;
      break;
    case '\t': cbsSay = 't'; break;
    case '\n': cbsSay = 'n'; break;
    case '\r': cbsSay = 'r'; break;
    case '\f': cbsSay = 'f'; break;
    default: cbsSay = 0; break;
    }
    if( cbsSay ){
      ace[1] = cbsSay;
      sqlite3_fputs(ace, out);
    }else if( !isprint(c&0xff) ){
      sqlite3_fprintf(out, "\\%03o", c&0xff);
    }else{
      ace[1] = (char)c;
      sqlite3_fputs(ace+1, out);
    }
    z = pcEnd;
  }

References anyOfInStr(), c, sqlite3_fprintf, sqlite3_fputs, and zSkipValidUtf8().

Referenced by do_meta_command(), shell_callback(), and shellAuth().

Here is the call graph for this function:

Here is the caller graph for this function:

output_csv()

void output_csv ( ShellState * p, const char * z, int bSep )

static

                                                              {
  if( z==0 ){
    sqlite3_fprintf(p->out, "%s",p->nullValue);
  }else{
    unsigned i;
    for(i=0; z[i]; i++){
      if( needCsvQuote[((unsigned char*)z)[i]] ){
        i = 0;
        break;
      }
    }
    if( i==0 || strstr(z, p->colSeparator)!=0 ){
      char *zQuoted = sqlite3_mprintf("\"%w\"", z);
      shell_check_oom(zQuoted);
      sqlite3_fputs(zQuoted, p->out);
      sqlite3_free(zQuoted);
    }else{
      sqlite3_fputs(z, p->out);
    }
  }
  if( bSep ){
    sqlite3_fputs(p->colSeparator, p->out);

References ShellState::colSeparator, needCsvQuote, ShellState::nullValue, ShellState::out, shell_check_oom(), sqlite3_fprintf, sqlite3_fputs, sqlite3_free, and sqlite3_mprintf.

Referenced by shell_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

output_file_close()

void output_file_close ( FILE * f )

static

                                      {

Referenced by do_meta_command(), and output_reset().

Here is the caller graph for this function:

output_file_open()

FILE * output_file_open ( const char * zFile )

static

                                                {
  FILE *f;
  if( cli_strcmp(zFile,"stdout")==0 ){
    f = stdout;
  }else if( cli_strcmp(zFile, "stderr")==0 ){
    f = stderr;
  }else if( cli_strcmp(zFile, "off")==0 ){
    f = 0;
  }else{
    f = sqlite3_fopen(zFile, "w");
    if( f==0 ){
      sqlite3_fprintf(stderr,"Error: cannot open \"%s\"\n", zFile);
    }
  }

References cli_strcmp(), sqlite3_fopen, and sqlite3_fprintf.

Referenced by do_meta_command().

Here is the call graph for this function:

Here is the caller graph for this function:

output_hex_blob()

void output_hex_blob ( FILE * out, const void * pBlob, int nBlob )

static

                                                                    {
  int i;
  unsigned char *aBlob = (unsigned char*)pBlob;
 
  char *zStr = sqlite3_malloc(nBlob*2 + 1);
  shell_check_oom(zStr);
 
  for(i=0; i<nBlob; i++){
    static const char aHex[] = {
        '0', '1', '2', '3', '4', '5', '6', '7',
        '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
    };
    zStr[i*2] = aHex[ (aBlob[i] >> 4) ];
    zStr[i*2+1] = aHex[ (aBlob[i] & 0x0F) ];
  }
  zStr[i*2] = '\0';
 
  sqlite3_fprintf(out, "X'%s'", zStr);

References shell_check_oom(), sqlite3_fprintf, sqlite3_free, and sqlite3_malloc.

Referenced by shell_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

output_html_string()

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

static

                                                        {
  int i;
  if( z==0 ) z = "";
  while( *z ){
    for(i=0;   z[i]
            && z[i]!='<'
            && z[i]!='&'
            && z[i]!='>'
            && z[i]!='\"'
            && z[i]!='\'';
        i++){}
    if( i>0 ){
      sqlite3_fprintf(out, "%.*s",i,z);
    }
    if( z[i]=='<' ){
      sqlite3_fputs("&lt;", out);
    }else if( z[i]=='&' ){
      sqlite3_fputs("&amp;", out);
    }else if( z[i]=='>' ){
      sqlite3_fputs("&gt;", out);
    }else if( z[i]=='\"' ){
      sqlite3_fputs("&quot;", out);
    }else if( z[i]=='\'' ){
      sqlite3_fputs("&#39;", out);
    }else{
      break;
    }
    z += i + 1;

References sqlite3_fprintf, and sqlite3_fputs.

Referenced by shell_callback().

Here is the caller graph for this function:

output_json_string()

void output_json_string ( FILE * out, const char * z, i64 n )

static

                                                               {
  unsigned char c;
  static const char *zq = "\"";
  static long ctrlMask = ~0L;
  static const char *zDQBS = "\"\\";
  const char *pcLimit;
  char ace[3] = "\\?";
  char cbsSay;
 
  if( z==0 ) z = "";
  pcLimit = z + ((n<0)? strlen(z) : (size_t)n);
  sqlite3_fputs(zq, out);
  while( z < pcLimit ){
    const char *pcDQBS = anyOfInStr(z, zDQBS, pcLimit-z);
    const char *pcPast = zSkipValidUtf8(z, (int)(pcLimit-z), ctrlMask);
    const char *pcEnd = (pcDQBS && pcDQBS < pcPast)? pcDQBS : pcPast;
    if( pcEnd > z ){
      sqlite3_fprintf(out, "%.*s", (int)(pcEnd-z), z);
      z = pcEnd;
    }
    if( z >= pcLimit ) break;
    c = (unsigned char)*(z++);
    switch( c ){
    case '"': case '\\':
      cbsSay = (char)c;
      break;
    case '\b': cbsSay = 'b'; break;
    case '\f': cbsSay = 'f'; break;
    case '\n': cbsSay = 'n'; break;
    case '\r': cbsSay = 'r'; break;
    case '\t': cbsSay = 't'; break;
    default: cbsSay = 0; break;
    }
    if( cbsSay ){
      ace[1] = cbsSay;
      sqlite3_fputs(ace, out);
    }else if( c<=0x1f || c>=0x7f ){
      sqlite3_fprintf(out, "\\u%04x", c);
    }else{
      ace[1] = (char)c;
      sqlite3_fputs(ace+1, out);
    }
  }

References anyOfInStr(), c, sqlite3_fprintf, sqlite3_fputs, and zSkipValidUtf8().

Referenced by shell_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

output_quoted_escaped_string()

void output_quoted_escaped_string ( ShellState * p, const char * z )

static

                                                                      {
  char *zEscaped;
  sqlite3_fsetmode(p->out, _O_BINARY);
  if( p->eEscMode==SHELL_ESC_OFF ){
    zEscaped = sqlite3_mprintf("%Q", z);
  }else{
    zEscaped = sqlite3_mprintf("%#Q", z);
  }
  sqlite3_fputs(zEscaped, p->out);
  sqlite3_free(zEscaped);

References ShellState::eEscMode, ShellState::out, setCrlfMode(), SHELL_ESC_OFF, sqlite3_fputs, sqlite3_free, sqlite3_fsetmode, and sqlite3_mprintf.

Referenced by shell_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

output_quoted_string()

void output_quoted_string ( ShellState * p, const char * zInX )

static

                                                                 {
  int i;
  int needUnistr = 0;
  int needDblQuote = 0;
  const unsigned char *z = (const unsigned char*)zInX;
  unsigned char c;
  FILE *out = p->out;
  sqlite3_fsetmode(out, _O_BINARY);
  if( z==0 ) return;
  for(i=0; (c = z[i])!=0; i++){
    if( c=='\'' ){ needDblQuote = 1; }
    if( c>0x1f ) continue;
    if( c=='\t' || c=='\n' ) continue;
    if( c=='\r' && z[i+1]=='\n' ) continue;
    needUnistr = 1;
    break;
  }
  if( (needDblQuote==0 && needUnistr==0)
   || (needDblQuote==0 && p->eEscMode==SHELL_ESC_OFF)
  ){
    sqlite3_fprintf(out, "'%s'",z);
  }else if( p->eEscMode==SHELL_ESC_OFF ){
    char *zEncoded = sqlite3_mprintf("%Q", z);
    sqlite3_fputs(zEncoded, out);
    sqlite3_free(zEncoded);
  }else{
    if( needUnistr ){
      sqlite3_fputs("unistr('", out);
    }else{
      sqlite3_fputs("'", out);
    }
    while( *z ){
      for(i=0; (c = z[i])!=0; i++){
        if( c=='\'' ) break;
        if( c>0x1f ) continue;
        if( c=='\t' || c=='\n' ) continue;
        if( c=='\r' && z[i+1]=='\n' ) continue;
        break;
      }
      if( i ){
        sqlite3_fprintf(out, "%.*s", i, z);
        z += i;
      }
      if( c==0 ) break;
      if( c=='\'' ){
        sqlite3_fputs("''", out);
      }else{
        sqlite3_fprintf(out, "\\u%04x", c);
      }
      z++;
    }
    if( needUnistr ){
      sqlite3_fputs("')", out);
    }else{
      sqlite3_fputs("'", out);
    }
  }

References c, ShellState::eEscMode, needUnistr(), ShellState::out, setCrlfMode(), SHELL_ESC_OFF, sqlite3_fprintf, sqlite3_fputs, sqlite3_free, sqlite3_fsetmode, and sqlite3_mprintf.

Referenced by shell_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

output_redir()

void output_redir ( ShellState * p, FILE * pfNew )

static

                                                    {
  if( p->out != stdout ){
    sqlite3_fputs("Output already redirected.\n", stderr);
  }else{
    p->out = pfNew;
    setCrlfMode(p);
    if( p->mode==MODE_Www ){
      sqlite3_fputs(
        "<!DOCTYPE html>\n"
        "<HTML><BODY><PRE>\n",
        p->out
      );
    }

References ShellState::mode, MODE_Www, ShellState::out, setCrlfMode(), and sqlite3_fputs.

Referenced by do_meta_command().

Here is the call graph for this function:

Here is the caller graph for this function:

output_reset()

void output_reset ( ShellState * p )

static

                                       {
  if( p->outfile[0]=='|' ){
#ifndef SQLITE_OMIT_POPEN
    pclose(p->out);
#endif
  }else{
    if( p->mode==MODE_Www ){
      sqlite3_fputs("</PRE></BODY></HTML>\n", p->out);
    }
    output_file_close(p->out);
#ifndef SQLITE_NOHAVE_SYSTEM
    if( p->doXdgOpen ){
      const char *zXdgOpenCmd =
#if defined(_WIN32)
      "start";
#elif defined(__APPLE__)
      "open";
#else
      "xdg-open";
#endif
      char *zCmd;
      zCmd = sqlite3_mprintf("%s %s", zXdgOpenCmd, p->zTempFile);
      if( system(zCmd) ){
        sqlite3_fprintf(stderr,"Failed: [%s]\n", zCmd);
      }else{
        /* Give the start/open/xdg-open command some time to get
        ** going before we continue, and potential delete the
        ** p->zTempFile data file out from under it */
        sqlite3_sleep(2000);
      }
      sqlite3_free(zCmd);
      outputModePop(p);
      p->doXdgOpen = 0;
    }
#endif /* !defined(SQLITE_NOHAVE_SYSTEM) */
  }
  p->outfile[0] = 0;
  p->out = stdout;

References ShellState::doXdgOpen, ShellState::mode, MODE_Www, ShellState::out, ShellState::outfile, output_file_close(), outputModePop(), pclose(), setCrlfMode(), sqlite3_fprintf, sqlite3_fputs, sqlite3_free, sqlite3_mprintf, sqlite3_sleep, and ShellState::zTempFile.

Referenced by do_meta_command(), main(), and process_input().

Here is the call graph for this function:

Here is the caller graph for this function:

outputDumpWarning()

int outputDumpWarning ( ShellState * p, const char * zLike )

static

          : Script requires that SQLITE_DBCONFIG_DEFENSIVE be disabled
*/
static int outputDumpWarning(ShellState *p, const char *zLike){
  int rc = SQLITE_OK;
  sqlite3_stmt *pStmt = 0;
  shellPreparePrintf(p->db, &rc, &pStmt,
    "SELECT 1 FROM sqlite_schema o WHERE "
    "sql LIKE 'CREATE VIRTUAL TABLE%%' AND %s", zLike ? zLike : "true"
  );
  if( rc==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){
    sqlite3_fputs("/* WARNING: "
          "Script requires that SQLITE_DBCONFIG_DEFENSIVE be disabled */\n",
          p->out
    );
  }
  shellFinalize(&rc, pStmt);

References ShellState::db, ShellState::out, shellFinalize(), shellPreparePrintf(), sqlite3_fputs, sqlite3_step, SQLITE_OK, and SQLITE_ROW.

Referenced by do_meta_command().

Here is the call graph for this function:

Here is the caller graph for this function:

outputModePop()

void outputModePop ( ShellState * p )

static

                                        {
  p->mode = p->modePrior;
  p->shellFlgs = p->priorShFlgs;
  memcpy(p->colSeparator, p->colSepPrior, sizeof(p->colSeparator));

Referenced by output_reset().

Here is the caller graph for this function:

outputModePush()

void outputModePush ( ShellState * p )

static

                                         {
  p->modePrior = p->mode;
  p->priorShFlgs = p->shellFlgs;
  memcpy(p->colSepPrior, p->colSeparator, sizeof(p->colSeparator));

References ShellState::colSeparator, ShellState::colSepPrior, ShellState::mode, ShellState::modePrior, ShellState::priorShFlgs, and ShellState::shellFlgs.

Referenced by do_meta_command().

Here is the caller graph for this function:

pcachetraceCachesize()

void pcachetraceCachesize ( sqlite3_pcache * p, int nCachesize )

static

                                                                   {
  if( pcachetraceOut ){
    fprintf(pcachetraceOut, "PCACHETRACE: xCachesize(%p, %d)\n", p, nCachesize);
  }
  pcacheBase.xCachesize(p, nCachesize);
}

References pcacheBase, and pcachetraceOut.

pcachetraceCreate()

sqlite3_pcache * pcachetraceCreate ( int szPage, int szExtra, int bPurge )

static

                                                                             {
  sqlite3_pcache *pRes;
  if( pcachetraceOut ){
    fprintf(pcachetraceOut, "PCACHETRACE: xCreate(%d,%d,%d)\n",
            szPage, szExtra, bPurge);
  }
  pRes = pcacheBase.xCreate(szPage, szExtra, bPurge);
  if( pcachetraceOut ){
    fprintf(pcachetraceOut, "PCACHETRACE: xCreate(%d,%d,%d) -> %p\n",
            szPage, szExtra, bPurge, pRes);
  }
  return pRes;
}

References pcacheBase, and pcachetraceOut.

pcachetraceDestroy()

void pcachetraceDestroy ( sqlite3_pcache * p )

static

                                                 {
  if( pcachetraceOut ){
    fprintf(pcachetraceOut, "PCACHETRACE: xDestroy(%p)\n", p);
  }
  pcacheBase.xDestroy(p);
}

References pcacheBase, and pcachetraceOut.

pcachetraceFetch()

sqlite3_pcache_page * pcachetraceFetch ( sqlite3_pcache * p, unsigned key, int crFg )

static

 {
  sqlite3_pcache_page *pRes;
  if( pcachetraceOut ){
    fprintf(pcachetraceOut, "PCACHETRACE: xFetch(%p,%u,%d)\n", p, key, crFg);
  }
  pRes = pcacheBase.xFetch(p, key, crFg);
  if( pcachetraceOut ){
    fprintf(pcachetraceOut, "PCACHETRACE: xFetch(%p,%u,%d) -> %p\n",
            p, key, crFg, pRes);
  }
  return pRes;
}

References pcacheBase, and pcachetraceOut.

pcachetraceInit()

int pcachetraceInit ( void * pArg )

static

                                      {
  int nRes;
  if( pcachetraceOut ){
    fprintf(pcachetraceOut, "PCACHETRACE: xInit(%p)\n", pArg);
  }
  nRes = pcacheBase.xInit(pArg);
  if( pcachetraceOut ){
    fprintf(pcachetraceOut, "PCACHETRACE: xInit(%p) -> %d\n", pArg, nRes);
  }
  return nRes;
}

References pcacheBase, and pcachetraceOut.

pcachetracePagecount()

int pcachetracePagecount ( sqlite3_pcache * p )

static

                                                  {
  int nRes;
  if( pcachetraceOut ){
    fprintf(pcachetraceOut, "PCACHETRACE: xPagecount(%p)\n", p);
  }
  nRes = pcacheBase.xPagecount(p);
  if( pcachetraceOut ){
    fprintf(pcachetraceOut, "PCACHETRACE: xPagecount(%p) -> %d\n", p, nRes);
  }
  return nRes;
}

References pcacheBase, and pcachetraceOut.

pcachetraceRekey()

void pcachetraceRekey ( sqlite3_pcache * p, sqlite3_pcache_page * pPg, unsigned oldKey, unsigned newKey )

static

 {
  if( pcachetraceOut ){
    fprintf(pcachetraceOut, "PCACHETRACE: xRekey(%p, %p, %u, %u)\n",
        p, pPg, oldKey, newKey);
  }
  pcacheBase.xRekey(p, pPg, oldKey, newKey);
}

References pcacheBase, and pcachetraceOut.

pcachetraceShrink()

void pcachetraceShrink ( sqlite3_pcache * p )

static

                                                {
  if( pcachetraceOut ){
    fprintf(pcachetraceOut, "PCACHETRACE: xShrink(%p)\n", p);
  }
  pcacheBase.xShrink(p);
}

References pcacheBase, and pcachetraceOut.

pcachetraceShutdown()

void pcachetraceShutdown ( void * pArg )

static

                                           {
  if( pcachetraceOut ){
    fprintf(pcachetraceOut, "PCACHETRACE: xShutdown(%p)\n", pArg);
  }
  pcacheBase.xShutdown(pArg);
}

References pcacheBase, and pcachetraceOut.

pcachetraceTruncate()

void pcachetraceTruncate ( sqlite3_pcache * p, unsigned n )

static

                                                              {
  if( pcachetraceOut ){
    fprintf(pcachetraceOut, "PCACHETRACE: xTruncate(%p, %u)\n", p, n);
  }
  pcacheBase.xTruncate(p, n);
}

References pcacheBase, and pcachetraceOut.

pcachetraceUnpin()

void pcachetraceUnpin ( sqlite3_pcache * p, sqlite3_pcache_page * pPg, int bDiscard )

static

 {
  if( pcachetraceOut ){
    fprintf(pcachetraceOut, "PCACHETRACE: xUnpin(%p, %p, %d)\n",
            p, pPg, bDiscard);
  }
  pcacheBase.xUnpin(p, pPg, bDiscard);
}

References pcacheBase, and pcachetraceOut.

pclose()

int pclose ( FILE * )

extern

Referenced by do_meta_command(), and output_reset().

Here is the caller graph for this function:

percentBinarySearch()

int percentBinarySearch ( Percentile * p, double y, int bExact )

static

                                                                   {
  int iFirst = 0;              /* First element of search range */
  int iLast = p->nUsed - 1;    /* Last element of search range */
  while( iLast>=iFirst ){
    int iMid = (iFirst+iLast)/2;
    double x = p->a[iMid];
    if( x<y ){
      iFirst = iMid + 1;
    }else if( x>y ){
      iLast = iMid - 1;
    }else{
      return iMid;
    }
  }
  if( bExact ) return -1;
  return iFirst;
}

References Percentile::a, and Percentile::nUsed.

Referenced by percentInverse(), and percentStep().

Here is the caller graph for this function:

percentCompute()

void percentCompute ( sqlite3_context * pCtx, int bIsFinal )

static

                                                               {
  Percentile *p;
  PercentileFunc *pFunc = (PercentileFunc*)sqlite3_user_data(pCtx);
  unsigned i1, i2;
  double v1, v2;
  double ix, vx;
  p = (Percentile*)sqlite3_aggregate_context(pCtx, 0);
  if( p==0 ) return;
  if( p->a==0 ) return;
  if( p->nUsed ){
    if( p->bSorted==0 ){
      assert( p->nUsed>1 );
      percentSort(p->a, p->nUsed);
      p->bSorted = 1;
    }
    ix = p->rPct*(p->nUsed-1);
    i1 = (unsigned)ix;
    if( pFunc->bDiscrete ){
      vx = p->a[i1];
    }else{
      i2 = ix==(double)i1 || i1==p->nUsed-1 ? i1 : i1+1;
      v1 = p->a[i1];
      v2 = p->a[i2];
      vx = v1 + (v2-v1)*(ix-i1);
    }
    sqlite3_result_double(pCtx, vx);
  }
  if( bIsFinal ){
    sqlite3_free(p->a);
    memset(p, 0, sizeof(*p));
  }else{
    p->bKeepSorted = 1;
  }
}

References Percentile::a, PercentileFunc::bDiscrete, Percentile::bKeepSorted, Percentile::bSorted, Percentile::nUsed, percentSort(), Percentile::rPct, sqlite3_aggregate_context, sqlite3_free, sqlite3_result_double, and sqlite3_user_data.

Referenced by percentFinal(), and percentValue().

Here is the call graph for this function:

Here is the caller graph for this function:

percentError()

void percentError ( sqlite3_context * pCtx, const char * zFormat, ... )

static

                                                                         {
  PercentileFunc *pFunc = (PercentileFunc*)sqlite3_user_data(pCtx);
  char *zMsg1;
  char *zMsg2;
  va_list ap;
 
  va_start(ap, zFormat);
  zMsg1 = sqlite3_vmprintf(zFormat, ap);
  va_end(ap);
  zMsg2 = zMsg1 ? sqlite3_mprintf(zMsg1, pFunc->zName) : 0;
  sqlite3_result_error(pCtx, zMsg2, -1);
  sqlite3_free(zMsg1);
  sqlite3_free(zMsg2);
}

References sqlite3_free, sqlite3_mprintf, sqlite3_result_error, sqlite3_user_data, sqlite3_vmprintf, and PercentileFunc::zName.

Referenced by percentStep().

Here is the caller graph for this function:

percentFinal()

void percentFinal ( sqlite3_context * pCtx )

static

                                               {
  percentCompute(pCtx, 1);
}

References percentCompute().

Referenced by sqlite3_percentile_init().

Here is the call graph for this function:

Here is the caller graph for this function:

percentInverse()

void percentInverse ( sqlite3_context * pCtx, int argc, sqlite3_value ** argv )

static

                                                                               {
  Percentile *p;
  int eType;
  double y;
  int i;
  assert( argc==2 || argc==1 );
 
  /* Allocate the session context. */
  p = (Percentile*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  assert( p!=0 );
 
  /* Ignore rows for which Y is NULL */
  eType = sqlite3_value_type(argv[0]);
  if( eType==SQLITE_NULL ) return;
 
  /* If not NULL, then Y must be numeric.  Otherwise throw an error.
  ** Requirement 4 */
  if( eType!=SQLITE_INTEGER && eType!=SQLITE_FLOAT ){
    return;
  }
 
  /* Ignore the Y value if it is infinity or NaN */
  y = sqlite3_value_double(argv[0]);
  if( percentIsInfinity(y) ){
    return;
  }
  if( p->bSorted==0 ){
    assert( p->nUsed>1 );
    percentSort(p->a, p->nUsed);
    p->bSorted = 1;
  }
  p->bKeepSorted = 1;
 
  /* Find and remove the row */
  i = percentBinarySearch(p, y, 1);
  if( i>=0 ){
    p->nUsed--;
    if( i<(int)p->nUsed ){
      memmove(&p->a[i], &p->a[i+1], (p->nUsed - i)*sizeof(p->a[0]));
    }
  }
}

References Percentile::a, Percentile::bKeepSorted, Percentile::bSorted, Percentile::nUsed, percentBinarySearch(), percentIsInfinity(), percentSort(), sqlite3_aggregate_context, sqlite3_value_double, sqlite3_value_type, SQLITE_FLOAT, SQLITE_INTEGER, and SQLITE_NULL.

Referenced by sqlite3_percentile_init().

Here is the call graph for this function:

Here is the caller graph for this function:

percentIsInfinity()

int percentIsInfinity ( double r )

static

                                      {
  sqlite3_uint64 u;
  assert( sizeof(u)==sizeof(r) );
  memcpy(&u, &r, sizeof(u));
  return ((u>>52)&0x7ff)==0x7ff;
}

Referenced by percentInverse(), and percentStep().

Here is the caller graph for this function:

percentSameValue()

int percentSameValue ( double a, double b )

static

                                               {
  a -= b;
  return a>=-0.001 && a<=0.001;
}

References a, and b.

Referenced by percentStep().

Here is the caller graph for this function:

percentSort()

void percentSort ( double * a, unsigned int n )

static

                                                  {
  int iLt;  /* Entries before a[iLt] are less than rPivot */
  int iGt;  /* Entries at or after a[iGt] are greater than rPivot */
  int i;         /* Loop counter */
  double rPivot; /* The pivot value */
  
  assert( n>=2 );
  if( a[0]>a[n-1] ){
    SWAP_DOUBLE(a[0],a[n-1])
  }
  if( n==2 ) return;
  iGt = n-1;
  i = n/2;
  if( a[0]>a[i] ){
    SWAP_DOUBLE(a[0],a[i])
  }else if( a[i]>a[iGt] ){
    SWAP_DOUBLE(a[i],a[iGt])
  }
  if( n==3 ) return;
  rPivot = a[i];
  iLt = i = 1;
  do{
    if( a[i]<rPivot ){
      if( i>iLt ) SWAP_DOUBLE(a[i],a[iLt])
      iLt++;
      i++;
    }else if( a[i]>rPivot ){
      do{
        iGt--;
      }while( iGt>i && a[iGt]>rPivot );
      SWAP_DOUBLE(a[i],a[iGt])
    }else{
      i++;
    }
  }while( i<iGt );
  if( iLt>=2 ) percentSort(a, iLt);
  if( n-iGt>=2 ) percentSort(a+iGt, n-iGt);
    
/* Uncomment for testing */
#if 0
  for(i=0; i<n-1; i++){
    assert( a[i]<=a[i+1] );
  }
#endif
}

References a, percentSort(), and SWAP_DOUBLE.

Referenced by percentCompute(), percentInverse(), and percentSort().

Here is the call graph for this function:

Here is the caller graph for this function:

percentStep()

void percentStep ( sqlite3_context * pCtx, int argc, sqlite3_value ** argv )

static

                                                                              {
  Percentile *p;
  double rPct;
  int eType;
  double y;
  assert( argc==2 || argc==1 );
 
  if( argc==1 ){
    /* Requirement 13:  median(Y) is the same as percentile(Y,50). */
    rPct = 0.5;
  }else{
    /* Requirement 3:  P must be a number between 0 and 100 */
    PercentileFunc *pFunc = (PercentileFunc*)sqlite3_user_data(pCtx);
    eType = sqlite3_value_numeric_type(argv[1]);
    rPct = sqlite3_value_double(argv[1])/(double)pFunc->mxFrac;
    if( (eType!=SQLITE_INTEGER && eType!=SQLITE_FLOAT)
     || rPct<0.0 || rPct>1.0
    ){
      percentError(pCtx, "the fraction argument to %%s()"
                        " is not between 0.0 and %.1f",
                        (double)pFunc->mxFrac);
      return;
    }
  }
 
  /* Allocate the session context. */
  p = (Percentile*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p==0 ) return;
 
  /* Remember the P value.  Throw an error if the P value is different
  ** from any prior row, per Requirement (2). */
  if( !p->bPctValid ){
    p->rPct = rPct;
    p->bPctValid = 1;
  }else if( !percentSameValue(p->rPct,rPct) ){
    percentError(pCtx, "the fraction argument to %%s()"
                      " is not the same for all input rows");
    return;
  }
 
  /* Ignore rows for which Y is NULL */
  eType = sqlite3_value_type(argv[0]);
  if( eType==SQLITE_NULL ) return;
 
  /* If not NULL, then Y must be numeric.  Otherwise throw an error.
  ** Requirement 4 */
  if( eType!=SQLITE_INTEGER && eType!=SQLITE_FLOAT ){
    percentError(pCtx, "input to %%s() is not numeric");
    return;
  }
 
  /* Throw an error if the Y value is infinity or NaN */
  y = sqlite3_value_double(argv[0]);
  if( percentIsInfinity(y) ){
    percentError(pCtx, "Inf input to %%s()");
    return;
  }
 
  /* Allocate and store the Y */
  if( p->nUsed>=p->nAlloc ){
    unsigned n = p->nAlloc*2 + 250;
    double *a = sqlite3_realloc64(p->a, sizeof(double)*n);
    if( a==0 ){
      sqlite3_free(p->a);
      memset(p, 0, sizeof(*p));
      sqlite3_result_error_nomem(pCtx);
      return;
    }
    p->nAlloc = n;
    p->a = a;
  }
  if( p->nUsed==0 ){
    p->a[p->nUsed++] = y;
    p->bSorted = 1;
  }else if( !p->bSorted || y>=p->a[p->nUsed-1] ){
    p->a[p->nUsed++] = y;
  }else if( p->bKeepSorted ){
    int i;
    i = percentBinarySearch(p, y, 0);
    if( i<(int)p->nUsed ){
      memmove(&p->a[i+1], &p->a[i], (p->nUsed-i)*sizeof(p->a[0]));
    }
    p->a[i] = y;
    p->nUsed++;
  }else{
    p->a[p->nUsed++] = y;
    p->bSorted = 0;
  }
}

References a, Percentile::a, Percentile::bKeepSorted, Percentile::bPctValid, Percentile::bSorted, PercentileFunc::mxFrac, Percentile::nAlloc, Percentile::nUsed, percentBinarySearch(), percentError(), percentIsInfinity(), percentSameValue(), Percentile::rPct, sqlite3_aggregate_context, sqlite3_free, sqlite3_realloc64, sqlite3_result_error_nomem, sqlite3_user_data, sqlite3_value_double, sqlite3_value_numeric_type, sqlite3_value_type, SQLITE_FLOAT, SQLITE_INTEGER, and SQLITE_NULL.

Referenced by sqlite3_percentile_init().

Here is the call graph for this function:

Here is the caller graph for this function:

percentValue()

void percentValue ( sqlite3_context * pCtx )

static

                                               {
  percentCompute(pCtx, 0);
}

References percentCompute().

Referenced by sqlite3_percentile_init().

Here is the call graph for this function:

Here is the caller graph for this function:

popen()

FILE * popen ( const char * , const char *  )

extern

print_box_line()

void print_box_line ( FILE * out, int N )

static

                                            {
  const char zDash[] =
      BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24
      BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24;
  const int nDash = sizeof(zDash) - 1;
  N *= 3;
  while( N>nDash ){
    sqlite3_fputs(zDash, out);
    N -= nDash;
  }

References BOX_24, sqlite3_fprintf, and sqlite3_fputs.

Referenced by print_box_row_separator().

Here is the caller graph for this function:

print_box_row_separator()

void print_box_row_separator ( ShellState * p, int nArg, const char * zSep1, const char * zSep2, const char * zSep3 )

static

 {
  int i;
  if( nArg>0 ){
    sqlite3_fputs(zSep1, p->out);
    print_box_line(p->out, p->actualWidth[0]+2);
    for(i=1; i<nArg; i++){
      sqlite3_fputs(zSep2, p->out);
      print_box_line(p->out, p->actualWidth[i]+2);
    }
    sqlite3_fputs(zSep3, p->out);
  }

References ShellState::actualWidth, ShellState::out, print_box_line(), and sqlite3_fputs.

Referenced by exec_prepared_stmt_columnar().

Here is the call graph for this function:

Here is the caller graph for this function:

print_dashes()

void print_dashes ( FILE * out, int N )

static

                                          {
  const char zDash[] = "--------------------------------------------------";
  const int nDash = sizeof(zDash) - 1;
  while( N>nDash ){
    sqlite3_fputs(zDash, out);
    N -= nDash;
  }

References sqlite3_fprintf, and sqlite3_fputs.

Referenced by exec_prepared_stmt_columnar(), print_row_separator(), and shell_callback().

Here is the caller graph for this function:

print_row_separator()

void print_row_separator ( ShellState * p, int nArg, const char * zSep )

static

 {
  int i;
  if( nArg>0 ){
    sqlite3_fputs(zSep, p->out);
    print_dashes(p->out, p->actualWidth[0]+2);
    for(i=1; i<nArg; i++){
      sqlite3_fputs(zSep, p->out);
      print_dashes(p->out, p->actualWidth[i]+2);
    }
    sqlite3_fputs(zSep, p->out);
  }

References ShellState::actualWidth, ShellState::out, print_dashes(), and sqlite3_fputs.

Referenced by exec_prepared_stmt_columnar().

Here is the call graph for this function:

Here is the caller graph for this function:

printBold()

void printBold ( const char * zText )

static

                                        {

Referenced by main().

Here is the caller graph for this function:

printSchemaLine()

void printSchemaLine ( FILE * out, const char * z, const char * zTail )

static

                              ://sqlite.org/forum/forumpost/d7be961c5c
*/
static void printSchemaLine(FILE *out, const char *z, const char *zTail){
  char *zToFree = 0;
  if( z==0 ) return;
  if( zTail==0 ) return;
  if( zTail[0]==';' && (strstr(z, "/*")!=0 || strstr(z,"--")!=0) ){
    const char *zOrig = z;
    static const char *azTerm[] = { "", "*/", "\n" };
    int i;
    for(i=0; i<ArraySize(azTerm); i++){
      char *zNew = sqlite3_mprintf("%s%s;", zOrig, azTerm[i]);
      shell_check_oom(zNew);
      if( sqlite3_complete(zNew) ){
        size_t n = strlen(zNew);
        zNew[n-1] = 0;
        zToFree = zNew;
        z = zNew;
        break;
      }
      sqlite3_free(zNew);
    }
  }
  if( sqlite3_strglob("CREATE TABLE ['\"]*", z)==0 ){
    sqlite3_fprintf(out, "CREATE TABLE IF NOT EXISTS %s%s", z+13, zTail);
  }else{
    sqlite3_fprintf(out, "%s%s", z, zTail);
  }

References ArraySize, shell_check_oom(), sqlite3_complete, sqlite3_fprintf, sqlite3_free, sqlite3_mprintf, and sqlite3_strglob.

Referenced by dump_callback(), and shell_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

printSchemaLineN()

void printSchemaLineN ( FILE * out, char * z, int n, const char * zTail )

static

                                                                          {
  char c = z[n];
  z[n] = 0;
  printSchemaLine(out, z, zTail);

Referenced by shell_callback().

Here is the caller graph for this function:

process_input()

int process_input ( ShellState * p )

static

                                       {
  char *zLine = 0;          /* A single input line */
  char *zSql = 0;           /* Accumulated SQL text */
  i64 nLine;                /* Length of current line */
  i64 nSql = 0;             /* Bytes of zSql[] used */
  i64 nAlloc = 0;           /* Allocated zSql[] space */
  int rc;                   /* Error code */
  int errCnt = 0;           /* Number of errors seen */
  i64 startline = 0;        /* Line number for start of current input */
  QuickScanState qss = QSS_Start; /* Accumulated line status (so far) */
 
  if( p->inputNesting==MAX_INPUT_NESTING ){
    /* This will be more informative in a later version. */
    sqlite3_fprintf(stderr,"Input nesting limit (%d) reached at line %d."
          " Check recursion.\n", MAX_INPUT_NESTING, p->lineno);
    return 1;
  }
  ++p->inputNesting;
  p->lineno = 0;
  CONTINUE_PROMPT_RESET;
  while( errCnt==0 || !bail_on_error || (p->in==0 && stdin_is_interactive) ){
    fflush(p->out);
    zLine = one_input_line(p->in, zLine, nSql>0);
    if( zLine==0 ){
      /* End of input */
      if( p->in==0 && stdin_is_interactive ) sqlite3_fputs("\n", p->out);
      break;
    }
    if( seenInterrupt ){
      if( p->in!=0 ) break;
      seenInterrupt = 0;
    }
    p->lineno++;
    if( QSS_INPLAIN(qss)
        && line_is_command_terminator(zLine)
        && line_is_complete(zSql, nSql) ){
      memcpy(zLine,";",2);
    }
    qss = quickscan(zLine, qss, CONTINUE_PROMPT_PSTATE);
    if( QSS_PLAINWHITE(qss) && nSql==0 ){
      /* Just swallow single-line whitespace */
      echo_group_input(p, zLine);
      qss = QSS_Start;
      continue;
    }
    if( zLine && (zLine[0]=='.' || zLine[0]=='#') && nSql==0 ){
      CONTINUE_PROMPT_RESET;
      echo_group_input(p, zLine);
      if( zLine[0]=='.' ){
        rc = do_meta_command(zLine, p);
        if( rc==2 ){ /* exit requested */
          break;
        }else if( rc ){
          errCnt++;
        }
      }
      qss = QSS_Start;
      continue;
    }
    /* No single-line dispositions remain; accumulate line(s). */
    nLine = strlen(zLine);
    if( nSql+nLine+2>=nAlloc ){
      /* Grow buffer by half-again increments when big. */
      nAlloc = nSql+(nSql>>1)+nLine+100;
      zSql = realloc(zSql, nAlloc);
      shell_check_oom(zSql);
    }
    if( nSql==0 ){
      i64 i;
      for(i=0; zLine[i] && IsSpace(zLine[i]); i++){}
      assert( nAlloc>0 && zSql!=0 );
      memcpy(zSql, zLine+i, nLine+1-i);
      startline = p->lineno;
      nSql = nLine-i;
    }else{
      zSql[nSql++] = '\n';
      memcpy(zSql+nSql, zLine, nLine+1);
      nSql += nLine;
    }
    if( nSql && QSS_SEMITERM(qss) && sqlite3_complete(zSql) ){
      echo_group_input(p, zSql);
      errCnt += runOneSqlLine(p, zSql, p->in, startline);
      CONTINUE_PROMPT_RESET;
      nSql = 0;
      if( p->outCount ){
        output_reset(p);
        p->outCount = 0;
      }else{
        clearTempFile(p);
      }
      p->bSafeMode = p->bSafeModePersist;
      qss = QSS_Start;
    }else if( nSql && QSS_PLAINWHITE(qss) ){
      echo_group_input(p, zSql);
      nSql = 0;
      qss = QSS_Start;
    }
  }
  if( nSql ){
    /* This may be incomplete. Let the SQL parser deal with that. */
    echo_group_input(p, zSql);
    errCnt += runOneSqlLine(p, zSql, p->in, startline);
    CONTINUE_PROMPT_RESET;
  }
  free(zSql);
  free(zLine);
  --p->inputNesting;

References bail_on_error, ShellState::bSafeMode, ShellState::bSafeModePersist, clearTempFile(), CONTINUE_PROMPT_PSTATE, CONTINUE_PROMPT_RESET, do_meta_command(), echo_group_input(), ShellState::in, ShellState::inputNesting, IsSpace, line_is_command_terminator(), line_is_complete(), ShellState::lineno, MAX_INPUT_NESTING, one_input_line(), ShellState::out, ShellState::outCount, output_reset(), QSS_INPLAIN, QSS_PLAINWHITE, QSS_SEMITERM, QSS_Start, quickscan(), runOneSqlLine(), seenInterrupt, shell_check_oom(), sqlite3_complete, sqlite3_fprintf, sqlite3_fputs, and stdin_is_interactive.

Referenced by do_meta_command(), main(), and process_sqliterc().

Here is the call graph for this function:

Here is the caller graph for this function:

process_sqliterc()

void process_sqliterc ( ShellState * p, const char * sqliterc_override )

static

 {
  char *home_dir = NULL;
  const char *sqliterc = sqliterc_override;
  char *zBuf = 0;
  FILE *inSaved = p->in;
  int savedLineno = p->lineno;
 
  if( sqliterc == NULL ){
    sqliterc = zBuf = find_xdg_config();
  }
  if( sqliterc == NULL ){
    home_dir = find_home_dir(0);
    if( home_dir==0 ){
      eputz("-- warning: cannot find home directory;"
            " cannot read ~/.sqliterc\n");
      return;
    }
    zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir);
    shell_check_oom(zBuf);
    sqliterc = zBuf;
  }
  p->in = sqlite3_fopen(sqliterc,"rb");
  if( p->in ){
    if( stdin_is_interactive ){
      sqlite3_fprintf(stderr,"-- Loading resources from %s\n", sqliterc);
    }
    if( process_input(p) && bail_on_error ) exit(1);
    fclose(p->in);
  }else if( sqliterc_override!=0 ){
    sqlite3_fprintf(stderr,"cannot open: \"%s\"\n", sqliterc);
    if( bail_on_error ) exit(1);
  }
  p->in = inSaved;
  p->lineno = savedLineno;

References bail_on_error, eputz, find_home_dir(), find_xdg_config(), ShellState::in, ShellState::lineno, process_input(), shell_check_oom(), sqlite3_fopen, sqlite3_fprintf, sqlite3_free, sqlite3_mprintf, and stdin_is_interactive.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

progress_handler()

int progress_handler ( void * pClientData )

static

                                               {
  ShellState *p = (ShellState*)pClientData;
  p->nProgress++;
  if( p->nProgress>=p->mxProgress && p->mxProgress>0 ){
    sqlite3_fprintf(p->out, "Progress limit reached (%u)\n", p->nProgress);
    if( p->flgProgress & SHELL_PROGRESS_RESET ) p->nProgress = 0;
    if( p->flgProgress & SHELL_PROGRESS_ONCE ) p->mxProgress = 0;
    return 1;
  }
  if( (p->flgProgress & SHELL_PROGRESS_QUIET)==0 ){
    sqlite3_fprintf(p->out, "Progress %u\n", p->nProgress);
  }

References ShellState::flgProgress, ShellState::mxProgress, ShellState::nProgress, ShellState::out, SHELL_PROGRESS_ONCE, SHELL_PROGRESS_QUIET, SHELL_PROGRESS_RESET, and sqlite3_fprintf.

Referenced by do_meta_command().

Here is the caller graph for this function:

progressSequence()

int progressSequence ( SequenceSpec * pss )

static

                                                {
  if( !pss->isNotEOF ) return 0;
  if( pss->isReversing ){
    if( pss->uSeqIndexNow > 0 ){
      pss->uSeqIndexNow--;
      pss->iValueNow -= pss->iStep;
    }else{
      pss->isNotEOF = 0;
    }
  }else{
    if( pss->uSeqIndexNow < pss->uSeqIndexMax ){
      pss->uSeqIndexNow++;
      pss->iValueNow += pss->iStep;
    }else{
      pss->isNotEOF = 0;
    }
  }
  return pss->isNotEOF;
}

References SequenceSpec::isNotEOF, SequenceSpec::isReversing, SequenceSpec::iStep, SequenceSpec::iValueNow, SequenceSpec::uSeqIndexMax, and SequenceSpec::uSeqIndexNow.

Referenced by seriesNext().

Here is the caller graph for this function:

putcs()

char * putcs ( char * pc, char * s )

static

                                     {
  char c;
  while( (c = *s++)!=0 ) *pc++ = c;
  return pc;
}

References c.

Referenced by toBase85().

Here is the caller graph for this function:

quickscan()

QuickScanState quickscan ( char * zLine, QuickScanState qss, t_DynaPromptRef pst )

static

                                                         {
  char cin;
  char cWait = (char)qss; /* intentional narrowing loss */
  if( cWait==0 ){
  PlainScan:
    while( (cin = *zLine++)!=0 ){
      if( IsSpace(cin) )
        continue;
      switch (cin){
      case '-':
        if( *zLine!='-' )
          break;
        while((cin = *++zLine)!=0 )
          if( cin=='\n')
            goto PlainScan;
        return qss;
      case ';':
        qss |= QSS_EndingSemi;
        continue;
      case '/':
        if( *zLine=='*' ){
          ++zLine;
          cWait = '*';
          CONTINUE_PROMPT_AWAITS(pst, "/*");
          qss = QSS_SETV(qss, cWait);
          goto TermScan;
        }
        break;
      case '[':
        cin = ']';
        deliberate_fall_through; /* FALLTHRU */
      case '`': case '\'': case '"':
        cWait = cin;
        qss = QSS_HasDark | cWait;
        CONTINUE_PROMPT_AWAITC(pst, cin);
        goto TermScan;
      case '(':
        CONTINUE_PAREN_INCR(pst, 1);
        break;
      case ')':
        CONTINUE_PAREN_INCR(pst, -1);
        break;
      default:
        break;
      }
      qss = (qss & ~QSS_EndingSemi) | QSS_HasDark;
    }
  }else{
  TermScan:
    while( (cin = *zLine++)!=0 ){
      if( cin==cWait ){
        switch( cWait ){
        case '*':
          if( *zLine != '/' )
            continue;
          ++zLine;
          CONTINUE_PROMPT_AWAITC(pst, 0);
          qss = QSS_SETV(qss, 0);
          goto PlainScan;
        case '`': case '\'': case '"':
          if(*zLine==cWait){
            /* Swallow doubled end-delimiter.*/
            ++zLine;
            continue;
          }
          deliberate_fall_through; /* FALLTHRU */
        case ']':
          CONTINUE_PROMPT_AWAITC(pst, 0);
          qss = QSS_SETV(qss, 0);
          goto PlainScan;
        default: assert(0);
        }
      }
    }
  }

References CONTINUE_PAREN_INCR, CONTINUE_PROMPT_AWAITC, CONTINUE_PROMPT_AWAITS, deliberate_fall_through, IsSpace, QSS_EndingSemi, QSS_HasDark, QSS_SETV, and SCAN_TRACKER_REFTYPE.

Referenced by line_is_command_terminator(), and process_input().

Here is the caller graph for this function:

quoteChar()

char quoteChar ( const char * zName )

static

                                        {
  int i;
  if( zName==0 ) return '"';
  if( !IsAlpha(zName[0]) && zName[0]!='_' ) return '"';
  for(i=0; zName[i]; i++){
    if( !IsAlnum(zName[i]) && zName[i]!='_' ) return '"';
  }
  return sqlite3_keyword_check(zName, i) ? '"' : 0;
}

References IsAlnum, IsAlpha, and sqlite3_keyword_check.

Referenced by do_meta_command(), dump_callback(), set_table_name(), shell_callback(), shellAddSchemaName(), and shellFakeSchema().

Here is the caller graph for this function:

quoted_column()

char * quoted_column ( sqlite3_stmt * pStmt, int i )

static

                                                      {
  switch( sqlite3_column_type(pStmt, i) ){
    case SQLITE_NULL: {
      return sqlite3_mprintf("NULL");
    }
    case SQLITE_INTEGER:
    case SQLITE_FLOAT: {
      return sqlite3_mprintf("%s",sqlite3_column_text(pStmt,i));
    }
    case SQLITE_TEXT: {
      const unsigned char *zText = sqlite3_column_text(pStmt,i);
      return sqlite3_mprintf(needUnistr(zText)?"%#Q":"%Q",zText);
    }
    case SQLITE_BLOB: {
      int j;
      sqlite3_str *pStr = sqlite3_str_new(0);
      const unsigned char *a = sqlite3_column_blob(pStmt,i);
      int n = sqlite3_column_bytes(pStmt,i);
      sqlite3_str_append(pStr, "x'", 2);
      for(j=0; j<n; j++){
        sqlite3_str_appendf(pStr, "%02x", a[j]);
      }
      sqlite3_str_append(pStr, "'", 1);
      return sqlite3_str_finish(pStr);
    }
  }

References a, needUnistr(), sqlite3_column_blob, sqlite3_column_bytes, sqlite3_column_text, sqlite3_column_type, sqlite3_mprintf, sqlite3_str_append, sqlite3_str_appendf, sqlite3_str_finish, sqlite3_str_new, SQLITE_BLOB, SQLITE_FLOAT, SQLITE_INTEGER, SQLITE_NULL, and SQLITE_TEXT.

Referenced by exec_prepared_stmt_columnar().

Here is the call graph for this function:

Here is the caller graph for this function:

rc_err_oom_die()

void rc_err_oom_die ( int rc )

static

                             :%d\n",rc), assert(0)
#else
static void rc_err_oom_die(int rc){
  if( rc==SQLITE_NOMEM ) shell_check_oom(0);

References shell_check_oom(), SQLITE_DONE, SQLITE_NOMEM, and SQLITE_OK.

Referenced by zAutoColumn().

Here is the call graph for this function:

Here is the caller graph for this function:

re_add_state()

void re_add_state ( ReStateSet * pSet, int newState )

static

                                                        {
  unsigned i;
  for(i=0; i<pSet->nState; i++) if( pSet->aState[i]==newState ) return;
  pSet->aState[pSet->nState++] = (ReStateNumber)newState;
}

References ReStateSet::aState, and ReStateSet::nState.

Referenced by sqlite3re_match().

Here is the caller graph for this function:

re_append()

int re_append ( ReCompiled * p, int op, int arg )

static

                                                    {
  return re_insert(p, p->nState, op, arg);
}

References ReCompiled::nState, and re_insert().

Referenced by re_subcompile_re(), re_subcompile_string(), and sqlite3re_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

re_copy()

void re_copy ( ReCompiled * p, int iStart, int N )

static

                                                     {
  if( p->nState+N>=p->nAlloc && re_resize(p, p->nAlloc*2+N) ) return;
  memcpy(&p->aOp[p->nState], &p->aOp[iStart], N*sizeof(p->aOp[0]));
  memcpy(&p->aArg[p->nState], &p->aArg[iStart], N*sizeof(p->aArg[0]));
  p->nState += N;
}

References ReCompiled::aArg, ReCompiled::aOp, ReCompiled::nAlloc, ReCompiled::nState, and re_resize().

Referenced by re_subcompile_string().

Here is the call graph for this function:

Here is the caller graph for this function:

re_digit_char()

int re_digit_char ( int c )

static

                               {
  return (c>='0' && c<='9');
}

References c.

Referenced by sqlite3re_match().

Here is the caller graph for this function:

re_esc_char()

unsigned re_esc_char ( ReCompiled * p )

static

                                          {
  static const char zEsc[] = "afnrtv\\()*.+?[$^{|}]";
  static const char zTrans[] = "\a\f\n\r\t\v";
  int i, v = 0;
  char c;
  if( p->sIn.i>=p->sIn.mx ) return 0;
  c = p->sIn.z[p->sIn.i];
  if( c=='u' && p->sIn.i+4<p->sIn.mx ){
    const unsigned char *zIn = p->sIn.z + p->sIn.i;
    if( re_hex(zIn[1],&v)
     && re_hex(zIn[2],&v)
     && re_hex(zIn[3],&v)
     && re_hex(zIn[4],&v)
    ){
      p->sIn.i += 5;
      return v;
    }
  }
  if( c=='x' && p->sIn.i+2<p->sIn.mx ){
    const unsigned char *zIn = p->sIn.z + p->sIn.i;
    if( re_hex(zIn[1],&v)
     && re_hex(zIn[2],&v)
    ){
      p->sIn.i += 3;
      return v;
    }
  }
  for(i=0; zEsc[i] && zEsc[i]!=c; i++){}
  if( zEsc[i] ){
    if( i<6 ) c = zTrans[i];
    p->sIn.i++;
  }else{
    p->zErr = "unknown \\ escape";
  }
  return c;
}

References c, ReInput::i, ReInput::mx, re_hex(), ReCompiled::sIn, ReInput::z, and ReCompiled::zErr.

Referenced by re_subcompile_string().

Here is the call graph for this function:

Here is the caller graph for this function:

re_hex()

int re_hex ( int c, int * pV )

static

                                 {
  if( c>='0' && c<='9' ){
    c -= '0';
  }else if( c>='a' && c<='f' ){
    c -= 'a' - 10;
  }else if( c>='A' && c<='F' ){
    c -= 'A' - 10;
  }else{
    return 0;
  }
  *pV = (*pV)*16 + (c & 0xff);
  return 1;
}

References c.

Referenced by re_esc_char().

Here is the caller graph for this function:

re_insert()

int re_insert ( ReCompiled * p, int iBefore, int op, int arg )

static

                                                                 {
  int i;
  if( p->nAlloc<=p->nState && re_resize(p, p->nAlloc*2) ) return 0;
  for(i=p->nState; i>iBefore; i--){
    p->aOp[i] = p->aOp[i-1];
    p->aArg[i] = p->aArg[i-1];
  }
  p->nState++;
  p->aOp[iBefore] = (char)op;
  p->aArg[iBefore] = arg;
  return iBefore;
}

References ReCompiled::aArg, ReCompiled::aOp, ReCompiled::nAlloc, ReCompiled::nState, and re_resize().

Referenced by re_append(), re_subcompile_re(), and re_subcompile_string().

Here is the call graph for this function:

Here is the caller graph for this function:

re_next_char()

unsigned re_next_char ( ReInput * p )

static

                                        {
  unsigned c;
  if( p->i>=p->mx ) return 0;
  c = p->z[p->i++];
  if( c>=0x80 ){
    if( (c&0xe0)==0xc0 && p->i<p->mx && (p->z[p->i]&0xc0)==0x80 ){
      c = (c&0x1f)<<6 | (p->z[p->i++]&0x3f);
      if( c<0x80 ) c = 0xfffd;
    }else if( (c&0xf0)==0xe0 && p->i+1<p->mx && (p->z[p->i]&0xc0)==0x80
           && (p->z[p->i+1]&0xc0)==0x80 ){
      c = (c&0x0f)<<12 | ((p->z[p->i]&0x3f)<<6) | (p->z[p->i+1]&0x3f);
      p->i += 2;
      if( c<=0x7ff || (c>=0xd800 && c<=0xdfff) ) c = 0xfffd;
    }else if( (c&0xf8)==0xf0 && p->i+2<p->mx && (p->z[p->i]&0xc0)==0x80
           && (p->z[p->i+1]&0xc0)==0x80 && (p->z[p->i+2]&0xc0)==0x80 ){
      c = (c&0x07)<<18 | ((p->z[p->i]&0x3f)<<12) | ((p->z[p->i+1]&0x3f)<<6)
                       | (p->z[p->i+2]&0x3f);
      p->i += 3;
      if( c<=0xffff || c>0x10ffff ) c = 0xfffd;
    }else{
      c = 0xfffd;
    }
  }
  return c;
}

References c, ReInput::i, ReInput::mx, and ReInput::z.

Referenced by re_next_char_nocase(), and sqlite3re_compile().

Here is the caller graph for this function:

re_next_char_nocase()

unsigned re_next_char_nocase ( ReInput * p )

static

                                               {
  unsigned c = re_next_char(p);
  if( c>='A' && c<='Z' ) c += 'a' - 'A';
  return c;
}

References c, and re_next_char().

Referenced by sqlite3re_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

re_resize()

int re_resize ( ReCompiled * p, int N )

static

                                          {
  char *aOp;
  int *aArg;
  aOp = sqlite3_realloc64(p->aOp, N*sizeof(p->aOp[0]));
  if( aOp==0 ) return 1;
  p->aOp = aOp;
  aArg = sqlite3_realloc64(p->aArg, N*sizeof(p->aArg[0]));
  if( aArg==0 ) return 1;
  p->aArg = aArg;
  p->nAlloc = N;
  return 0;
}

References ReCompiled::aArg, ReCompiled::aOp, ReCompiled::nAlloc, and sqlite3_realloc64.

Referenced by re_copy(), re_insert(), and sqlite3re_compile().

Here is the caller graph for this function:

re_space_char()

int re_space_char ( int c )

static

                               {
  return c==' ' || c=='\t' || c=='\n' || c=='\r' || c=='\v' || c=='\f';
}

References c.

Referenced by sqlite3re_match().

Here is the caller graph for this function:

re_sql_func()

void re_sql_func ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  ReCompiled *pRe;          /* Compiled regular expression */
  const char *zPattern;     /* The regular expression */
  const unsigned char *zStr;/* String being searched */
  const char *zErr;         /* Compile error message */
  int setAux = 0;           /* True to invoke sqlite3_set_auxdata() */
 
  (void)argc;  /* Unused */
  pRe = sqlite3_get_auxdata(context, 0);
  if( pRe==0 ){
    zPattern = (const char*)sqlite3_value_text(argv[0]);
    if( zPattern==0 ) return;
    zErr = re_compile(&pRe, zPattern, sqlite3_user_data(context)!=0);
    if( zErr ){
      re_free(pRe);
      sqlite3_result_error(context, zErr, -1);
      return;
    }
    if( pRe==0 ){
      sqlite3_result_error_nomem(context);
      return;
    }
    setAux = 1;
  }
  zStr = (const unsigned char*)sqlite3_value_text(argv[1]);
  if( zStr!=0 ){
    sqlite3_result_int(context, re_match(pRe, zStr, -1));
  }
  if( setAux ){
    sqlite3_set_auxdata(context, 0, pRe, (void(*)(void*))re_free);
  }
}

References re_compile, re_free, re_match, sqlite3_get_auxdata, sqlite3_result_error, sqlite3_result_error_nomem, sqlite3_result_int, sqlite3_set_auxdata, sqlite3_user_data, and sqlite3_value_text.

Referenced by sqlite3_regexp_init().

Here is the caller graph for this function:

re_subcompile_re()

const char * re_subcompile_re ( ReCompiled * p )

static

                                                  {
  const char *zErr;
  int iStart, iEnd, iGoto;
  iStart = p->nState;
  zErr = re_subcompile_string(p);
  if( zErr ) return zErr;
  while( rePeek(p)=='|' ){
    iEnd = p->nState;
    re_insert(p, iStart, RE_OP_FORK, iEnd + 2 - iStart);
    iGoto = re_append(p, RE_OP_GOTO, 0);
    p->sIn.i++;
    zErr = re_subcompile_string(p);
    if( zErr ) return zErr;
    p->aArg[iGoto] = p->nState - iGoto;
  }
  return 0;
}

References ReCompiled::aArg, ReInput::i, ReCompiled::nState, re_append(), re_insert(), RE_OP_FORK, RE_OP_GOTO, re_subcompile_string(), rePeek(), and ReCompiled::sIn.

Referenced by re_subcompile_string(), and sqlite3re_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

re_subcompile_string()

const char * re_subcompile_string ( ReCompiled * p )

static

                                                      {
  int iPrev = -1;
  int iStart;
  unsigned c;
  const char *zErr;
  while( (c = p->xNextChar(&p->sIn))!=0 ){
    iStart = p->nState;
    switch( c ){
      case '|':
      case ')': {
        p->sIn.i--;
        return 0;
      }
      case '(': {
        zErr = re_subcompile_re(p);
        if( zErr ) return zErr;
        if( rePeek(p)!=')' ) return "unmatched '('";
        p->sIn.i++;
        break;
      }
      case '.': {
        if( rePeek(p)=='*' ){
          re_append(p, RE_OP_ANYSTAR, 0);
          p->sIn.i++;
        }else{
          re_append(p, RE_OP_ANY, 0);
        }
        break;
      }
      case '*': {
        if( iPrev<0 ) return "'*' without operand";
        re_insert(p, iPrev, RE_OP_GOTO, p->nState - iPrev + 1);
        re_append(p, RE_OP_FORK, iPrev - p->nState + 1);
        break;
      }
      case '+': {
        if( iPrev<0 ) return "'+' without operand";
        re_append(p, RE_OP_FORK, iPrev - p->nState);
        break;
      }
      case '?': {
        if( iPrev<0 ) return "'?' without operand";
        re_insert(p, iPrev, RE_OP_FORK, p->nState - iPrev+1);
        break;
      }
      case '$': {
        re_append(p, RE_OP_MATCH, RE_EOF);
        break;
      }
      case '^': {
        re_append(p, RE_OP_ATSTART, 0);
        break;
      }
      case '{': {
        int m = 0, n = 0;
        int sz, j;
        if( iPrev<0 ) return "'{m,n}' without operand";
        while( (c=rePeek(p))>='0' && c<='9' ){ m = m*10 + c - '0'; p->sIn.i++; }
        n = m;
        if( c==',' ){
          p->sIn.i++;
          n = 0;
          while( (c=rePeek(p))>='0' && c<='9' ){ n = n*10 + c-'0'; p->sIn.i++; }
        }
        if( c!='}' ) return "unmatched '{'";
        if( n>0 && n<m ) return "n less than m in '{m,n}'";
        p->sIn.i++;
        sz = p->nState - iPrev;
        if( m==0 ){
          if( n==0 ) return "both m and n are zero in '{m,n}'";
          re_insert(p, iPrev, RE_OP_FORK, sz+1);
          iPrev++;
          n--;
        }else{
          for(j=1; j<m; j++) re_copy(p, iPrev, sz);
        }
        for(j=m; j<n; j++){
          re_append(p, RE_OP_FORK, sz+1);
          re_copy(p, iPrev, sz);
        }
        if( n==0 && m>0 ){
          re_append(p, RE_OP_FORK, -sz);
        }
        break;
      }
      case '[': {
        unsigned int iFirst = p->nState;
        if( rePeek(p)=='^' ){
          re_append(p, RE_OP_CC_EXC, 0);
          p->sIn.i++;
        }else{
          re_append(p, RE_OP_CC_INC, 0);
        }
        while( (c = p->xNextChar(&p->sIn))!=0 ){
          if( c=='[' && rePeek(p)==':' ){
            return "POSIX character classes not supported";
          }
          if( c=='\\' ) c = re_esc_char(p);
          if( rePeek(p)=='-' ){
            re_append(p, RE_OP_CC_RANGE, c);
            p->sIn.i++;
            c = p->xNextChar(&p->sIn);
            if( c=='\\' ) c = re_esc_char(p);
            re_append(p, RE_OP_CC_RANGE, c);
          }else{
            re_append(p, RE_OP_CC_VALUE, c);
          }
          if( rePeek(p)==']' ){ p->sIn.i++; break; }
        }
        if( c==0 ) return "unclosed '['";
        if( p->nState>iFirst ) p->aArg[iFirst] = p->nState - iFirst;
        break;
      }
      case '\\': {
        int specialOp = 0;
        switch( rePeek(p) ){
          case 'b': specialOp = RE_OP_BOUNDARY;   break;
          case 'd': specialOp = RE_OP_DIGIT;      break;
          case 'D': specialOp = RE_OP_NOTDIGIT;   break;
          case 's': specialOp = RE_OP_SPACE;      break;
          case 'S': specialOp = RE_OP_NOTSPACE;   break;
          case 'w': specialOp = RE_OP_WORD;       break;
          case 'W': specialOp = RE_OP_NOTWORD;    break;
        }
        if( specialOp ){
          p->sIn.i++;
          re_append(p, specialOp, 0);
        }else{
          c = re_esc_char(p);
          re_append(p, RE_OP_MATCH, c);
        }
        break;
      }
      default: {
        re_append(p, RE_OP_MATCH, c);
        break;
      }
    }
    iPrev = iStart;
  }
  return 0;
}

References ReCompiled::aArg, c, ReInput::i, ReCompiled::nState, re_append(), re_copy(), RE_EOF, re_esc_char(), re_insert(), RE_OP_ANY, RE_OP_ANYSTAR, RE_OP_ATSTART, RE_OP_BOUNDARY, RE_OP_CC_EXC, RE_OP_CC_INC, RE_OP_CC_RANGE, RE_OP_CC_VALUE, RE_OP_DIGIT, RE_OP_FORK, RE_OP_GOTO, RE_OP_MATCH, RE_OP_NOTDIGIT, RE_OP_NOTSPACE, RE_OP_NOTWORD, RE_OP_SPACE, RE_OP_WORD, re_subcompile_re(), rePeek(), ReCompiled::sIn, and ReCompiled::xNextChar.

Referenced by re_subcompile_re().

Here is the call graph for this function:

Here is the caller graph for this function:

re_word_char()

int re_word_char ( int c )

static

                              {
  return (c>='0' && c<='9') || (c>='a' && c<='z')
      || (c>='A' && c<='Z') || c=='_';
}

References c.

Referenced by sqlite3re_match().

Here is the caller graph for this function:

readFile()

char * readFile ( const char * zName, int * pnByte )

static

                                                     {
  FILE *in = sqlite3_fopen(zName, "rb");
  long nIn;
  size_t nRead;
  char *pBuf;
  int rc;
  if( in==0 ) return 0;
  rc = fseek(in, 0, SEEK_END);
  if( rc!=0 ){
    sqlite3_fprintf(stderr,"Error: '%s' not seekable\n", zName);
    fclose(in);
    return 0;
  }
  nIn = ftell(in);
  rewind(in);
  pBuf = sqlite3_malloc64( nIn+1 );
  if( pBuf==0 ){
    sqlite3_fputs("Error: out of memory\n", stderr);
    fclose(in);
    return 0;
  }
  nRead = fread(pBuf, nIn, 1, in);
  fclose(in);
  if( nRead!=1 ){
    sqlite3_free(pBuf);
    sqlite3_fprintf(stderr,"Error: cannot read '%s'\n", zName);
    return 0;
  }
  pBuf[nIn] = 0;
  if( pnByte ) *pnByte = nIn;

References sqlite3_fopen, sqlite3_fprintf, sqlite3_fputs, sqlite3_free, and sqlite3_malloc64.

Referenced by do_meta_command(), and open_db().

Here is the caller graph for this function:

readFileContents()

void readFileContents ( sqlite3_context * ctx, const char * zName )

static

                                                                     {
  FILE *in;
  sqlite3_int64 nIn;
  void *pBuf;
  sqlite3 *db;
  int mxBlob;
 
  in = sqlite3_fopen(zName, "rb");
  if( in==0 ){
    /* File does not exist or is unreadable. Leave the result set to NULL. */
    return;
  }
  fseek(in, 0, SEEK_END);
  nIn = ftell(in);
  rewind(in);
  db = sqlite3_context_db_handle(ctx);
  mxBlob = sqlite3_limit(db, SQLITE_LIMIT_LENGTH, -1);
  if( nIn>mxBlob ){
    sqlite3_result_error_code(ctx, SQLITE_TOOBIG);
    fclose(in);
    return;
  }
  pBuf = sqlite3_malloc64( nIn ? nIn : 1 );
  if( pBuf==0 ){
    sqlite3_result_error_nomem(ctx);
    fclose(in);
    return;
  }
  if( nIn==(sqlite3_int64)fread(pBuf, 1, (size_t)nIn, in) ){
    sqlite3_result_blob64(ctx, pBuf, nIn, sqlite3_free);
  }else{
    sqlite3_result_error_code(ctx, SQLITE_IOERR);
    sqlite3_free(pBuf);
  }
  fclose(in);
}

References sqlite3_context_db_handle, sqlite3_fopen, sqlite3_free, sqlite3_limit, sqlite3_malloc64, sqlite3_result_blob64, sqlite3_result_error_code, sqlite3_result_error_nomem, SQLITE_IOERR, SQLITE_LIMIT_LENGTH, and SQLITE_TOOBIG.

Referenced by fsdirColumn(), and readfileFunc().

Here is the caller graph for this function:

readfileFunc()

void readfileFunc ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  const char *zName;
  (void)(argc);  /* Unused parameter */
  zName = (const char*)sqlite3_value_text(argv[0]);
  if( zName==0 ) return;
  readFileContents(context, zName);
}

References readFileContents(), and sqlite3_value_text.

Referenced by sqlite3_fileio_init().

Here is the call graph for this function:

Here is the caller graph for this function:

readHexDb()

unsigned char * readHexDb ( ShellState * p, int * pnData )

static

                                                           {
  unsigned char *a = 0;
  int nLine;
  int n = 0;
  int pgsz = 0;
  int iOffset = 0;
  int j, k;
  int rc;
  FILE *in;
  const char *zDbFilename = p->pAuxDb->zDbFilename;
  unsigned int x[16];
  char zLine[1000];
  if( zDbFilename ){
    in = sqlite3_fopen(zDbFilename, "r");
    if( in==0 ){
      sqlite3_fprintf(stderr,"cannot open \"%s\" for reading\n", zDbFilename);
      return 0;
    }
    nLine = 0;
  }else{
    in = p->in;
    nLine = p->lineno;
    if( in==0 ) in = stdin;
  }
  *pnData = 0;
  nLine++;
  if( sqlite3_fgets(zLine, sizeof(zLine), in)==0 ) goto readHexDb_error;
  rc = sscanf(zLine, "| size %d pagesize %d", &n, &pgsz);
  if( rc!=2 ) goto readHexDb_error;
  if( n<0 ) goto readHexDb_error;
  if( pgsz<512 || pgsz>65536 || (pgsz&(pgsz-1))!=0 ) goto readHexDb_error;
  n = (n+pgsz-1)&~(pgsz-1);  /* Round n up to the next multiple of pgsz */
  a = sqlite3_malloc( n ? n : 1 );
  shell_check_oom(a);
  memset(a, 0, n);
  if( pgsz<512 || pgsz>65536 || (pgsz & (pgsz-1))!=0 ){
    sqlite3_fputs("invalid pagesize\n", stderr);
    goto readHexDb_error;
  }
  for(nLine++; sqlite3_fgets(zLine, sizeof(zLine), in)!=0; nLine++){
    rc = sscanf(zLine, "| page %d offset %d", &j, &k);
    if( rc==2 ){
      iOffset = k;
      continue;
    }
    if( cli_strncmp(zLine, "| end ", 6)==0 ){
      break;
    }
    rc = sscanf(zLine,"| %d: %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x",
                &j, &x[0], &x[1], &x[2], &x[3], &x[4], &x[5], &x[6], &x[7],
                &x[8], &x[9], &x[10], &x[11], &x[12], &x[13], &x[14], &x[15]);
    if( rc==17 ){
      k = iOffset+j;
      if( k+16<=n && k>=0 ){
        int ii;
        for(ii=0; ii<16; ii++) a[k+ii] = x[ii]&0xff;
      }
    }
  }
  *pnData = n;
  if( in!=p->in ){
    fclose(in);
  }else{
    p->lineno = nLine;
  }
  return a;
 
readHexDb_error:
  if( in!=p->in ){
    fclose(in);
  }else{
    while( sqlite3_fgets(zLine, sizeof(zLine), p->in)!=0 ){
      nLine++;
      if(cli_strncmp(zLine, "| end ", 6)==0 ) break;
    }
    p->lineno = nLine;
  }
  sqlite3_free(a);
  sqlite3_fprintf(stderr,"Error on line %d of --hexdb input\n", nLine);

References a, cli_strncmp(), ShellState::in, ShellState::lineno, ShellState::pAuxDb, shell_check_oom(), sqlite3_fgets, sqlite3_fopen, sqlite3_fprintf, sqlite3_fputs, sqlite3_free, sqlite3_malloc, and ShellState::AuxDb::zDbFilename.

Referenced by open_db().

Here is the call graph for this function:

Here is the caller graph for this function:

registerUDFs()

int registerUDFs	(	sqlite3 *	dbSrc,
		sqlite3 *	dbDst )

                                                {
  sqlite3_stmt *pStmt;
  int rc = sqlite3_prepare_v2(dbSrc,
            "SELECT name,type,enc,narg,flags "
            "FROM pragma_function_list() "
            "WHERE builtin==0", -1, &pStmt, 0);
  if( rc==SQLITE_OK ){
    while( SQLITE_ROW==(rc = sqlite3_step(pStmt)) ){
      int nargs = sqlite3_column_int(pStmt,3);
      int flags = sqlite3_column_int(pStmt,4);
      const char *name = (char*)sqlite3_column_text(pStmt,0);
      const char *type = (char*)sqlite3_column_text(pStmt,1);
      const char *enc = (char*)sqlite3_column_text(pStmt,2);
      if( name==0 || type==0 || enc==0 ){
        /* no-op.  Only happens on OOM */
      }else{
        int ienc = SQLITE_UTF8;
        int rcf = SQLITE_ERROR;
        if( strcmp(enc,"utf16le")==0 ) ienc = SQLITE_UTF16LE;
        else if( strcmp(enc,"utf16be")==0 ) ienc = SQLITE_UTF16BE;
        ienc |= (flags & (SQLITE_DETERMINISTIC|SQLITE_DIRECTONLY));
        if( strcmp(type,"w")==0 ){
          rcf = sqlite3_create_window_function(dbDst,name,nargs,ienc,0,
                                               dummyUDF,dummyUDFvalue,0,0,0);
        }else if( strcmp(type,"a")==0 ){
          rcf = sqlite3_create_function(dbDst,name,nargs,ienc,0,
                                        0,dummyUDF,dummyUDFvalue);
        }else if( strcmp(type,"s")==0 ){
          rcf = sqlite3_create_function(dbDst,name,nargs,ienc,0,
                                        dummyUDF,0,0);
        }
        if( rcf!=SQLITE_OK ){
          rc = rcf;
          break;
        }
      }
    }
    sqlite3_finalize(pStmt);
    if( rc==SQLITE_DONE ) rc = SQLITE_OK;
  }
  return rc;
}

References dummyUDF(), dummyUDFvalue(), sqlite3_column_int, sqlite3_column_text, sqlite3_create_function, sqlite3_create_window_function, sqlite3_finalize, sqlite3_prepare_v2, sqlite3_step, SQLITE_DETERMINISTIC, SQLITE_DIRECTONLY, SQLITE_DONE, SQLITE_ERROR, SQLITE_OK, SQLITE_ROW, SQLITE_UTF16BE, SQLITE_UTF16LE, and SQLITE_UTF8.

Referenced by sqlite3_expert_new().

Here is the call graph for this function:

Here is the caller graph for this function:

rePeek()

unsigned char rePeek ( ReCompiled * p )

static

                                          {
  return p->sIn.i<p->sIn.mx ? p->sIn.z[p->sIn.i] : 0;
}

References ReInput::i, ReInput::mx, ReCompiled::sIn, and ReInput::z.

Referenced by re_subcompile_re(), and re_subcompile_string().

Here is the caller graph for this function:

resolve_backslashes()

void resolve_backslashes ( char * z )

static

                                        {
  int i, j;
  char c;
  while( *z && *z!='\\' ) z++;
  for(i=j=0; (c = z[i])!=0; i++, j++){
    if( c=='\\' && z[i+1]!=0 ){
      c = z[++i];
      if( c=='a' ){
        c = '\a';
      }else if( c=='b' ){
        c = '\b';
      }else if( c=='t' ){
        c = '\t';
      }else if( c=='n' ){
        c = '\n';
      }else if( c=='v' ){
        c = '\v';
      }else if( c=='f' ){
        c = '\f';
      }else if( c=='r' ){
        c = '\r';
      }else if( c=='"' ){
        c = '"';
      }else if( c=='\'' ){
        c = '\'';
      }else if( c=='\\' ){
        c = '\\';
      }else if( c=='x' ){
        int nhd = 0, hdv;
        u8 hv = 0;
        while( nhd<2 && (c=z[i+1+nhd])!=0 && (hdv=hexDigitValue(c))>=0 ){
          hv = (u8)((hv<<4)|hdv);
          ++nhd;
        }
        i += nhd;
        c = (u8)hv;
      }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;
  }

References c, and hexDigitValue().

Referenced by do_meta_command(), and runOneSqlLine().

Here is the call graph for this function:

Here is the caller graph for this function:

restore_debug_trace_modes()

void restore_debug_trace_modes ( void )

static

                                           {
  sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 1, &savedSelectTrace);

References SQLITE_TESTCTRL_TRACEFLAGS.

Referenced by shell_exec().

Here is the caller graph for this function:

run_schema_dump_query()

int run_schema_dump_query ( ShellState * p, const char * zQuery )

static

 {
  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);
    sqlite3_fputs("/****** CORRUPTION ERROR *******/\n", p->out);
    if( zErr ){
      sqlite3_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 ){
      sqlite3_fprintf(p->out, "/****** ERROR: %s ******/\n", zErr);
    }else{
      rc = SQLITE_CORRUPT;
    }
    free(zQ2);
  }
  sqlite3_free(zErr);

References ShellState::db, dump_callback(), ShellState::out, sqlite3_exec, sqlite3_fprintf, sqlite3_fputs, sqlite3_free, sqlite3_snprintf, SQLITE_CORRUPT, and strlen30().

Referenced by do_meta_command().

Here is the call graph for this function:

Here is the caller graph for this function:

run_table_dump_query()

int run_table_dump_query ( ShellState * p, const char * zSelect )

static

 {
  sqlite3_stmt *pSelect;
  int rc;
  int nResult;
  int i;
  const char *z;
  rc = sqlite3_prepare_v2(p->db, zSelect, -1, &pSelect, 0);
  if( rc!=SQLITE_OK || !pSelect ){
    char *zContext = shell_error_context(zSelect, p->db);
    sqlite3_fprintf(p->out, "/**** ERROR: (%d) %s *****/\n%s",
          rc, sqlite3_errmsg(p->db), zContext);
    sqlite3_free(zContext);
    if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
    return rc;
  }
  rc = sqlite3_step(pSelect);
  nResult = sqlite3_column_count(pSelect);
  while( rc==SQLITE_ROW ){
    z = (const char*)sqlite3_column_text(pSelect, 0);
    sqlite3_fprintf(p->out, "%s", z);
    for(i=1; i<nResult; i++){
      sqlite3_fprintf(p->out, ",%s", sqlite3_column_text(pSelect, i));
    }
    if( z==0 ) z = "";
    while( z[0] && (z[0]!='-' || z[1]!='-') ) z++;
    if( z[0] ){
      sqlite3_fputs("\n;\n", p->out);
    }else{
      sqlite3_fputs(";\n", p->out);
    }
    rc = sqlite3_step(pSelect);
  }
  rc = sqlite3_finalize(pSelect);
  if( rc!=SQLITE_OK ){
    sqlite3_fprintf(p->out, "/**** ERROR: (%d) %s *****/\n",
                    rc, sqlite3_errmsg(p->db));
    if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
  }

References ShellState::db, ShellState::nErr, ShellState::out, shell_error_context(), sqlite3_column_count, sqlite3_column_text, sqlite3_errmsg, sqlite3_finalize, sqlite3_fprintf, sqlite3_fputs, sqlite3_free, sqlite3_prepare_v2, sqlite3_step, SQLITE_CORRUPT, SQLITE_OK, and SQLITE_ROW.

Referenced by do_meta_command().

Here is the call graph for this function:

Here is the caller graph for this function:

runOneSqlLine()

int runOneSqlLine ( ShellState * p, char * zSql, FILE * in, int startline )

static

                                                                            {
  int rc;
  char *zErrMsg = 0;
 
  open_db(p, 0);
  if( ShellHasFlag(p,SHFLG_Backslash) ) resolve_backslashes(zSql);
  if( p->flgProgress & SHELL_PROGRESS_RESET ) p->nProgress = 0;
  BEGIN_TIMER;
  rc = shell_exec(p, zSql, &zErrMsg);
  END_TIMER(p->out);
  if( rc || zErrMsg ){
    char zPrefix[100];
    const char *zErrorTail;
    const char *zErrorType;
    if( zErrMsg==0 ){
      zErrorType = "Error";
      zErrorTail = sqlite3_errmsg(p->db);
    }else if( cli_strncmp(zErrMsg, "in prepare, ",12)==0 ){
      zErrorType = "Parse error";
      zErrorTail = &zErrMsg[12];
    }else if( cli_strncmp(zErrMsg, "stepping, ", 10)==0 ){
      zErrorType = "Runtime error";
      zErrorTail = &zErrMsg[10];
    }else{
      zErrorType = "Error";
      zErrorTail = zErrMsg;
    }
    if( in!=0 || !stdin_is_interactive ){
      sqlite3_snprintf(sizeof(zPrefix), zPrefix,
                       "%s near line %d:", zErrorType, startline);
    }else{
      sqlite3_snprintf(sizeof(zPrefix), zPrefix, "%s:", zErrorType);
    }
    sqlite3_fprintf(stderr,"%s %s\n", zPrefix, zErrorTail);
    sqlite3_free(zErrMsg);
    zErrMsg = 0;
    return 1;
  }else if( ShellHasFlag(p, SHFLG_CountChanges) ){
    char zLineBuf[2000];
    sqlite3_snprintf(sizeof(zLineBuf), zLineBuf,
            "changes: %lld   total_changes: %lld",
            sqlite3_changes64(p->db), sqlite3_total_changes64(p->db));
    sqlite3_fprintf(p->out, "%s\n", zLineBuf);
  }
 
  if( doAutoDetectRestore(p, zSql) ) return 1;

References BEGIN_TIMER, cli_strncmp(), ShellState::db, doAutoDetectRestore(), END_TIMER, ShellState::flgProgress, ShellState::nProgress, open_db(), ShellState::out, resolve_backslashes(), shell_exec(), SHELL_PROGRESS_RESET, ShellHasFlag, SHFLG_Backslash, SHFLG_CountChanges, sqlite3_changes64, sqlite3_errmsg, sqlite3_fprintf, sqlite3_free, sqlite3_snprintf, sqlite3_total_changes64, and stdin_is_interactive.

Referenced by process_input().

Here is the call graph for this function:

Here is the caller graph for this function:

safeModeAuth()

int safeModeAuth ( void * pClientData, int op, const char * zA1, const char * zA2, const char * zA3, const char * zA4 )

static

 {
  ShellState *p = (ShellState*)pClientData;
  static const char *azProhibitedFunctions[] = {
    "edit",
    "fts3_tokenizer",
    "load_extension",
    "readfile",
    "writefile",
    "zipfile",
    "zipfile_cds",
  };
  UNUSED_PARAMETER(zA1);
  UNUSED_PARAMETER(zA3);
  UNUSED_PARAMETER(zA4);
  switch( op ){
    case SQLITE_ATTACH: {
#ifndef SQLITE_SHELL_FIDDLE
      /* In WASM builds the filesystem is a virtual sandbox, so
      ** there's no harm in using ATTACH. */
      failIfSafeMode(p, "cannot run ATTACH in safe mode");
#endif
      break;
    }
    case SQLITE_FUNCTION: {
      int i;
      for(i=0; i<ArraySize(azProhibitedFunctions); i++){
        if( sqlite3_stricmp(zA2, azProhibitedFunctions[i])==0 ){
          failIfSafeMode(p, "cannot use the %s() function in safe mode",
                         azProhibitedFunctions[i]);
        }
      }
      break;
    }
  }

References ArraySize, failIfSafeMode(), sqlite3_stricmp, SQLITE_ATTACH, SQLITE_FUNCTION, SQLITE_OK, and UNUSED_PARAMETER.

Referenced by do_meta_command(), open_db(), and shellAuth().

Here is the call graph for this function:

Here is the caller graph for this function:

save_err_msg()

char * save_err_msg ( sqlite3 * db, const char * zPhase, int rc, const char * zSql )

static

 {
  char *zErr;
  char *zContext;
  sqlite3_str *pStr = sqlite3_str_new(0);
  sqlite3_str_appendf(pStr, "%s, %s", zPhase, sqlite3_errmsg(db));
  if( rc>1 ){
    sqlite3_str_appendf(pStr, " (%d)", rc);
  }
  zContext = shell_error_context(zSql, db);
  if( zContext ){
    sqlite3_str_appendall(pStr, zContext);
    sqlite3_free(zContext);
  }
  zErr = sqlite3_str_finish(pStr);
  shell_check_oom(zErr);

References shell_check_oom(), shell_error_context(), sqlite3_errmsg, sqlite3_free, sqlite3_str_appendall, sqlite3_str_appendf, sqlite3_str_finish, and sqlite3_str_new.

Referenced by shell_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

sayAbnormalExit()

void sayAbnormalExit ( void )

static

                                 {

Referenced by main().

Here is the caller graph for this function:

seriesBestIndex()

int seriesBestIndex ( sqlite3_vtab * pVTab, sqlite3_index_info * pIdxInfo )

static

 {
  int i, j;              /* Loop over constraints */
  int idxNum = 0;        /* The query plan bitmask */
#ifndef ZERO_ARGUMENT_GENERATE_SERIES
  int bStartSeen = 0;    /* EQ constraint seen on the START column */
#endif
  int unusableMask = 0;  /* Mask of unusable constraints */
  int nArg = 0;          /* Number of arguments that seriesFilter() expects */
  int aIdx[7];           /* Constraints on start, stop, step, LIMIT, OFFSET,
                         ** and value.  aIdx[5] covers value=, value>=, and
                         ** value>,  aIdx[6] covers value<= and value< */
  const struct sqlite3_index_constraint *pConstraint;
 
  /* This implementation assumes that the start, stop, and step columns
  ** are the last three columns in the virtual table. */
  assert( SERIES_COLUMN_STOP == SERIES_COLUMN_START+1 );
  assert( SERIES_COLUMN_STEP == SERIES_COLUMN_START+2 );
 
  aIdx[0] = aIdx[1] = aIdx[2] = aIdx[3] = aIdx[4] = aIdx[5] = aIdx[6] = -1;
  pConstraint = pIdxInfo->aConstraint;
  for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){
    int iCol;    /* 0 for start, 1 for stop, 2 for step */
    int iMask;   /* bitmask for those column */
    int op = pConstraint->op;
    if( op>=SQLITE_INDEX_CONSTRAINT_LIMIT
     && op<=SQLITE_INDEX_CONSTRAINT_OFFSET
    ){
      if( pConstraint->usable==0 ){
        /* do nothing */
      }else if( op==SQLITE_INDEX_CONSTRAINT_LIMIT ){
        aIdx[3] = i;
        idxNum |= 0x20;
      }else{
        assert( op==SQLITE_INDEX_CONSTRAINT_OFFSET );
        aIdx[4] = i;
        idxNum |= 0x40;
      }
      continue;
    }
    if( pConstraint->iColumn<SERIES_COLUMN_START ){
      if( (pConstraint->iColumn==SERIES_COLUMN_VALUE ||
           pConstraint->iColumn==SERIES_COLUMN_ROWID)
       && pConstraint->usable
      ){
        switch( op ){
          case SQLITE_INDEX_CONSTRAINT_EQ:
          case SQLITE_INDEX_CONSTRAINT_IS: {
            idxNum |=  0x0080;
            idxNum &= ~0x3300;
            aIdx[5] = i;
            aIdx[6] = -1;
#ifndef ZERO_ARGUMENT_GENERATE_SERIES
            bStartSeen = 1;
#endif
            break;
          }
          case SQLITE_INDEX_CONSTRAINT_GE: {
            if( idxNum & 0x0080 ) break;
            idxNum |=  0x0100;
            idxNum &= ~0x0200;
            aIdx[5] = i;
#ifndef ZERO_ARGUMENT_GENERATE_SERIES
            bStartSeen = 1;
#endif
            break;
          }
          case SQLITE_INDEX_CONSTRAINT_GT: {
            if( idxNum & 0x0080 ) break;
            idxNum |=  0x0200;
            idxNum &= ~0x0100;
            aIdx[5] = i;
#ifndef ZERO_ARGUMENT_GENERATE_SERIES
            bStartSeen = 1;
#endif
            break;
          }
          case SQLITE_INDEX_CONSTRAINT_LE: {
            if( idxNum & 0x0080 ) break;
            idxNum |=  0x1000;
            idxNum &= ~0x2000;
            aIdx[6] = i;
            break;
          }
          case SQLITE_INDEX_CONSTRAINT_LT: {
            if( idxNum & 0x0080 ) break;
            idxNum |=  0x2000;
            idxNum &= ~0x1000;
            aIdx[6] = i;
            break;
          }
        }
      }
      continue;
    }
    iCol = pConstraint->iColumn - SERIES_COLUMN_START;
    assert( iCol>=0 && iCol<=2 );
    iMask = 1 << iCol;
#ifndef ZERO_ARGUMENT_GENERATE_SERIES
    if( iCol==0 && op==SQLITE_INDEX_CONSTRAINT_EQ ){
      bStartSeen = 1;
    }
#endif
    if( pConstraint->usable==0 ){
      unusableMask |=  iMask;
      continue;
    }else if( op==SQLITE_INDEX_CONSTRAINT_EQ ){
      idxNum |= iMask;
      aIdx[iCol] = i;
    }
  }
  if( aIdx[3]==0 ){
    /* Ignore OFFSET if LIMIT is omitted */
    idxNum &= ~0x60;
    aIdx[4] = 0;
  }
  for(i=0; i<7; i++){
    if( (j = aIdx[i])>=0 ){
      pIdxInfo->aConstraintUsage[j].argvIndex = ++nArg;
      pIdxInfo->aConstraintUsage[j].omit =
         !SQLITE_SERIES_CONSTRAINT_VERIFY || i>=3;
    }
  }
  /* The current generate_column() implementation requires at least one
  ** argument (the START value).  Legacy versions assumed START=0 if the
  ** first argument was omitted.  Compile with -DZERO_ARGUMENT_GENERATE_SERIES
  ** to obtain the legacy behavior */
#ifndef ZERO_ARGUMENT_GENERATE_SERIES
  if( !bStartSeen ){
    sqlite3_free(pVTab->zErrMsg);
    pVTab->zErrMsg = sqlite3_mprintf(
        "first argument to \"generate_series()\" missing or unusable");
    return SQLITE_ERROR;
  }
#endif
  if( (unusableMask & ~idxNum)!=0 ){
    /* The start, stop, and step columns are inputs.  Therefore if there
    ** are unusable constraints on any of start, stop, or step then
    ** this plan is unusable */
    return SQLITE_CONSTRAINT;
  }
  if( (idxNum & 0x03)==0x03 ){
    /* Both start= and stop= boundaries are available.  This is the 
    ** the preferred case */
    pIdxInfo->estimatedCost = (double)(2 - ((idxNum&4)!=0));
    pIdxInfo->estimatedRows = 1000;
    if( pIdxInfo->nOrderBy>=1 && pIdxInfo->aOrderBy[0].iColumn==0 ){
      if( pIdxInfo->aOrderBy[0].desc ){
        idxNum |= 0x08;
      }else{
        idxNum |= 0x10;
      }
      pIdxInfo->orderByConsumed = 1;
    }
  }else if( (idxNum & 0x21)==0x21 ){
    /* We have start= and LIMIT */
    pIdxInfo->estimatedRows = 2500;
  }else{
    /* If either boundary is missing, we have to generate a huge span
    ** of numbers.  Make this case very expensive so that the query
    ** planner will work hard to avoid it. */
    pIdxInfo->estimatedRows = 2147483647;
  }
  pIdxInfo->idxNum = idxNum;
#ifdef SQLITE_INDEX_SCAN_HEX
  pIdxInfo->idxFlags = SQLITE_INDEX_SCAN_HEX;
#endif
  return SQLITE_OK;
}

References sqlite3_index_info::aConstraint, sqlite3_index_info::aConstraintUsage, sqlite3_index_info::aOrderBy, sqlite3_index_info::sqlite3_index_constraint_usage::argvIndex, sqlite3_index_info::sqlite3_index_orderby::desc, sqlite3_index_info::estimatedCost, sqlite3_index_info::estimatedRows, sqlite3_index_info::sqlite3_index_orderby::iColumn, sqlite3_index_info::idxFlags, sqlite3_index_info::idxNum, sqlite3_index_info::nConstraint, sqlite3_index_info::nOrderBy, sqlite3_index_info::sqlite3_index_constraint_usage::omit, sqlite3_index_info::orderByConsumed, SERIES_COLUMN_ROWID, SERIES_COLUMN_START, SERIES_COLUMN_STEP, SERIES_COLUMN_STOP, SERIES_COLUMN_VALUE, sqlite3_free, sqlite3_mprintf, SQLITE_CONSTRAINT, SQLITE_ERROR, SQLITE_INDEX_CONSTRAINT_EQ, SQLITE_INDEX_CONSTRAINT_GE, SQLITE_INDEX_CONSTRAINT_GT, SQLITE_INDEX_CONSTRAINT_IS, SQLITE_INDEX_CONSTRAINT_LE, SQLITE_INDEX_CONSTRAINT_LIMIT, SQLITE_INDEX_CONSTRAINT_LT, SQLITE_INDEX_CONSTRAINT_OFFSET, SQLITE_INDEX_SCAN_HEX, SQLITE_OK, SQLITE_SERIES_CONSTRAINT_VERIFY, and sqlite3_vtab::zErrMsg.

seriesClose()

int seriesClose ( sqlite3_vtab_cursor * cur )

static

                                                {
  sqlite3_free(cur);
  return SQLITE_OK;
}

References sqlite3_free, and SQLITE_OK.

seriesColumn()

int seriesColumn ( sqlite3_vtab_cursor * cur, sqlite3_context * ctx, int i )

static

 {
  series_cursor *pCur = (series_cursor*)cur;
  sqlite3_int64 x = 0;
  switch( i ){
    case SERIES_COLUMN_START:  x = pCur->ss.iOBase;     break;
    case SERIES_COLUMN_STOP:   x = pCur->ss.iOTerm;     break;
    case SERIES_COLUMN_STEP:   x = pCur->ss.iStep;      break;
    default:                   x = pCur->ss.iValueNow;  break;
  }
  sqlite3_result_int64(ctx, x);
  return SQLITE_OK;
}

References SequenceSpec::iOBase, SequenceSpec::iOTerm, SequenceSpec::iStep, SequenceSpec::iValueNow, SERIES_COLUMN_START, SERIES_COLUMN_STEP, SERIES_COLUMN_STOP, sqlite3_result_int64, SQLITE_OK, and series_cursor::ss.

seriesConnect()

int seriesConnect ( sqlite3 * db, void * pUnused, int argcUnused, const char *const * argvUnused, sqlite3_vtab ** ppVtab, char ** pzErrUnused )

static

 {
  sqlite3_vtab *pNew;
  int rc;
 
/* Column numbers */
#define SERIES_COLUMN_ROWID (-1)
#define SERIES_COLUMN_VALUE 0
#define SERIES_COLUMN_START 1
#define SERIES_COLUMN_STOP  2
#define SERIES_COLUMN_STEP  3
 
  (void)pUnused;
  (void)argcUnused;
  (void)argvUnused;
  (void)pzErrUnused;
  rc = sqlite3_declare_vtab(db,
     "CREATE TABLE x(value,start hidden,stop hidden,step hidden)");
  if( rc==SQLITE_OK ){
    pNew = *ppVtab = sqlite3_malloc( sizeof(*pNew) );
    if( pNew==0 ) return SQLITE_NOMEM;
    memset(pNew, 0, sizeof(*pNew));
    sqlite3_vtab_config(db, SQLITE_VTAB_INNOCUOUS);
  }
  return rc;
}

References sqlite3_declare_vtab, sqlite3_malloc, sqlite3_vtab_config, SQLITE_NOMEM, SQLITE_OK, and SQLITE_VTAB_INNOCUOUS.

seriesDisconnect()

int seriesDisconnect ( sqlite3_vtab * pVtab )

static

                                                {
  sqlite3_free(pVtab);
  return SQLITE_OK;
}

References sqlite3_free, and SQLITE_OK.

seriesEof()

int seriesEof ( sqlite3_vtab_cursor * cur )

static

                                              {
  series_cursor *pCur = (series_cursor*)cur;
  return !pCur->ss.isNotEOF;
}

References SequenceSpec::isNotEOF, and series_cursor::ss.

seriesFilter()

int seriesFilter ( sqlite3_vtab_cursor * pVtabCursor, int idxNum, const char * idxStrUnused, int argc, sqlite3_value ** argv )

static

 {
  series_cursor *pCur = (series_cursor *)pVtabCursor;
  int i = 0;
  int returnNoRows = 0;
  sqlite3_int64 iMin = SMALLEST_INT64;
  sqlite3_int64 iMax = LARGEST_INT64;
  sqlite3_int64 iLimit = 0;
  sqlite3_int64 iOffset = 0;
 
  (void)idxStrUnused;
  if( idxNum & 0x01 ){
    pCur->ss.iBase = sqlite3_value_int64(argv[i++]);
  }else{
    pCur->ss.iBase = 0;
  }
  if( idxNum & 0x02 ){
    pCur->ss.iTerm = sqlite3_value_int64(argv[i++]);
  }else{
    pCur->ss.iTerm = 0xffffffff;
  }
  if( idxNum & 0x04 ){
    pCur->ss.iStep = sqlite3_value_int64(argv[i++]);
    if( pCur->ss.iStep==0 ){
      pCur->ss.iStep = 1;
    }else if( pCur->ss.iStep<0 ){
      if( (idxNum & 0x10)==0 ) idxNum |= 0x08;
    }
  }else{
    pCur->ss.iStep = 1;
  }
 
  /* If there are constraints on the value column but there are
  ** no constraints on  the start, stop, and step columns, then
  ** initialize the default range to be the entire range of 64-bit signed
  ** integers.  This range will contracted by the value column constraints
  ** further below.
  */
  if( (idxNum & 0x05)==0 && (idxNum & 0x0380)!=0 ){
    pCur->ss.iBase = SMALLEST_INT64;
  }
  if( (idxNum & 0x06)==0 && (idxNum & 0x3080)!=0 ){
    pCur->ss.iTerm = LARGEST_INT64;
  }
  pCur->ss.iOBase = pCur->ss.iBase;
  pCur->ss.iOTerm = pCur->ss.iTerm;
 
  /* Extract the LIMIT and OFFSET values, but do not apply them yet.
  ** The range must first be constrained by the limits on value.
  */
  if( idxNum & 0x20 ){
    iLimit = sqlite3_value_int64(argv[i++]);
    if( idxNum & 0x40 ){
      iOffset = sqlite3_value_int64(argv[i++]);
    }
  }
 
  if( idxNum & 0x3380 ){
    /* Extract the maximum range of output values determined by
    ** constraints on the "value" column.
    */
    if( idxNum & 0x0080 ){
      if( sqlite3_value_numeric_type(argv[i])==SQLITE_FLOAT ){
        double r = sqlite3_value_double(argv[i++]);
        if( r==ceil(r) ){
          iMin = iMax = (sqlite3_int64)r;
        }else{
          returnNoRows = 1;
        }
      }else{
        iMin = iMax = sqlite3_value_int64(argv[i++]);
      }
    }else{
      if( idxNum & 0x0300 ){
        if( sqlite3_value_numeric_type(argv[i])==SQLITE_FLOAT ){
          double r = sqlite3_value_double(argv[i++]);
          if( idxNum & 0x0200 && r==ceil(r) ){
            iMin = (sqlite3_int64)ceil(r+1.0);
          }else{
            iMin = (sqlite3_int64)ceil(r);
          }
        }else{
          iMin = sqlite3_value_int64(argv[i++]);
          if( idxNum & 0x0200 ){
            if( iMin==LARGEST_INT64 ){
              returnNoRows = 1;
            }else{
              iMin++;
            }
          }
        }
      }
      if( idxNum & 0x3000 ){
        if( sqlite3_value_numeric_type(argv[i])==SQLITE_FLOAT ){
          double r = sqlite3_value_double(argv[i++]);
          if( (idxNum & 0x2000)!=0 && r==floor(r) ){
            iMax = (sqlite3_int64)(r-1.0);
          }else{
            iMax = (sqlite3_int64)floor(r);
          }
        }else{
          iMax = sqlite3_value_int64(argv[i++]);
          if( idxNum & 0x2000 ){
            if( iMax==SMALLEST_INT64 ){
              returnNoRows = 1;
            }else{
              iMax--;
            }
          }
        }
      }
      if( iMin>iMax ){
        returnNoRows = 1;
      }
    }
 
    /* Try to reduce the range of values to be generated based on
    ** constraints on the "value" column.
    */
    if( pCur->ss.iStep>0 ){
      sqlite3_int64 szStep = pCur->ss.iStep;
      if( pCur->ss.iBase<iMin ){
        sqlite3_uint64 d = iMin - pCur->ss.iBase;
        pCur->ss.iBase += ((d+szStep-1)/szStep)*szStep;
      }
      if( pCur->ss.iTerm>iMax ){
        pCur->ss.iTerm = iMax;
      }
    }else{
      sqlite3_int64 szStep = -pCur->ss.iStep;
      assert( szStep>0 );
      if( pCur->ss.iBase>iMax ){
        sqlite3_uint64 d = pCur->ss.iBase - iMax;
        pCur->ss.iBase -= ((d+szStep-1)/szStep)*szStep;
      }
      if( pCur->ss.iTerm<iMin ){
        pCur->ss.iTerm = iMin;
      }
    }
  }
 
  /* Apply LIMIT and OFFSET constraints, if any */
  if( idxNum & 0x20 ){
    if( iOffset>0 ){
      pCur->ss.iBase += pCur->ss.iStep*iOffset;
    }
    if( iLimit>=0 ){
      sqlite3_int64 iTerm;
      iTerm = pCur->ss.iBase + (iLimit - 1)*pCur->ss.iStep;
      if( pCur->ss.iStep<0 ){
        if( iTerm>pCur->ss.iTerm ) pCur->ss.iTerm = iTerm;
      }else{
        if( iTerm<pCur->ss.iTerm ) pCur->ss.iTerm = iTerm;
      }
    }
  }
 
 
  for(i=0; i<argc; i++){
    if( sqlite3_value_type(argv[i])==SQLITE_NULL ){
      /* If any of the constraints have a NULL value, then return no rows.
      ** See ticket https://sqlite.org/src/info/fac496b61722daf2 */
      returnNoRows = 1;
      break;
    }
  }
  if( returnNoRows ){
    pCur->ss.iBase = 1;
    pCur->ss.iTerm = 0;
    pCur->ss.iStep = 1;
  }
  if( idxNum & 0x08 ){
    pCur->ss.isReversing = pCur->ss.iStep > 0;
  }else{
    pCur->ss.isReversing = pCur->ss.iStep < 0;
  }
  setupSequence( &pCur->ss );
  return SQLITE_OK;
}

References d, SequenceSpec::iBase, SequenceSpec::iOBase, SequenceSpec::iOTerm, SequenceSpec::isReversing, SequenceSpec::iStep, SequenceSpec::iTerm, LARGEST_INT64, setupSequence(), SMALLEST_INT64, sqlite3_value_double, sqlite3_value_int64, sqlite3_value_numeric_type, sqlite3_value_type, SQLITE_FLOAT, SQLITE_NULL, SQLITE_OK, and series_cursor::ss.

Here is the call graph for this function:

seriesNext()

int seriesNext ( sqlite3_vtab_cursor * cur )

static

                                               {
  series_cursor *pCur = (series_cursor*)cur;
  progressSequence( & pCur->ss );
  return SQLITE_OK;
}

References progressSequence(), SQLITE_OK, and series_cursor::ss.

Here is the call graph for this function:

seriesOpen()

int seriesOpen ( sqlite3_vtab * pUnused, sqlite3_vtab_cursor ** ppCursor )

static

                                                                            {
  series_cursor *pCur;
  (void)pUnused;
  pCur = sqlite3_malloc( sizeof(*pCur) );
  if( pCur==0 ) return SQLITE_NOMEM;
  memset(pCur, 0, sizeof(*pCur));
  *ppCursor = &pCur->base;
  return SQLITE_OK;
}

References series_cursor::base, sqlite3_malloc, SQLITE_NOMEM, and SQLITE_OK.

seriesRowid()

int seriesRowid ( sqlite3_vtab_cursor * cur, sqlite_int64 * pRowid )

static

                                                                      {
  series_cursor *pCur = (series_cursor*)cur;
  *pRowid = pCur->ss.iValueNow;
  return SQLITE_OK;
}

References SequenceSpec::iValueNow, SQLITE_OK, and series_cursor::ss.

set_table_name()

void set_table_name ( ShellState * p, const char * zName )

static

                                                            {
  int i, n;
  char cQuote;
  char *z;
 
  if( p->zDestTable ){
    free(p->zDestTable);
    p->zDestTable = 0;
  }
  if( zName==0 ) return;
  cQuote = quoteChar(zName);
  n = strlen30(zName);
  if( cQuote ) n += n+2;
  z = p->zDestTable = malloc( n+1 );
  shell_check_oom(z);
  n = 0;
  if( cQuote ) z[n++] = cQuote;
  for(i=0; zName[i]; i++){
    z[n++] = zName[i];
    if( zName[i]==cQuote ) z[n++] = cQuote;
  }
  if( cQuote ) z[n++] = cQuote;

References quoteChar(), shell_check_oom(), strlen30(), and ShellState::zDestTable.

Referenced by do_meta_command(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

setCrlfMode()

void setCrlfMode ( ShellState * p )

static

                                      {
#ifdef _WIN32
  if( p->crlfMode ){
    sqlite3_fsetmode(p->out, _O_TEXT);
  }else{
    sqlite3_fsetmode(p->out, _O_BINARY);
  }
#else
  UNUSED_PARAMETER(p);

References ShellState::crlfMode, ShellState::out, sqlite3_fsetmode, and UNUSED_PARAMETER.

Referenced by output_quoted_escaped_string(), output_quoted_string(), output_redir(), output_reset(), and shell_callback().

Here is the caller graph for this function:

setLexemeOpen()

void setLexemeOpen ( struct DynaPrompt * p, char * s, char c )

static

                                                                {
  if( s!=0 || c==0 ){
    p->zScannerAwaits = s;
    p->acAwait[0] = 0;
  }else{
    p->acAwait[0] = c;
    p->zScannerAwaits = p->acAwait;
  }
}

References DynaPrompt::acAwait, c, and DynaPrompt::zScannerAwaits.

setOrClearFlag()

void setOrClearFlag ( ShellState * p, unsigned mFlag, const char * zArg )

static

                                                                           {
  if( booleanValue(zArg) ){
    ShellSetFlag(p, mFlag);
  }else{
    ShellClearFlag(p, mFlag);

References booleanValue(), ShellClearFlag, and ShellSetFlag.

Referenced by do_meta_command().

Here is the call graph for this function:

Here is the caller graph for this function:

setupSequence()

void setupSequence ( SequenceSpec * pss )

static

                                              {
  int bSameSigns;
  pss->uSeqIndexMax = 0;
  pss->isNotEOF = 0;
  bSameSigns = (pss->iBase < 0)==(pss->iTerm < 0);
  if( pss->iTerm < pss->iBase ){
    sqlite3_uint64 nuspan = 0;
    if( bSameSigns ){
      nuspan = (sqlite3_uint64)(pss->iBase - pss->iTerm);
    }else{
      /* Under UBSAN (or on 1's complement machines), must do this in steps.
       * In this clause, iBase>=0 and iTerm<0 . */
      nuspan = 1;
      nuspan += pss->iBase;
      nuspan += -(pss->iTerm+1);
    }
    if( pss->iStep<0 ){
      pss->isNotEOF = 1;
      if( nuspan==ULONG_MAX ){
        pss->uSeqIndexMax = ( pss->iStep>LLONG_MIN )? nuspan/-pss->iStep : 1;
      }else if( pss->iStep>LLONG_MIN ){
        pss->uSeqIndexMax = nuspan/-pss->iStep;
      }
    }
  }else if( pss->iTerm > pss->iBase ){
    sqlite3_uint64 puspan = 0;
    if( bSameSigns ){
      puspan = (sqlite3_uint64)(pss->iTerm - pss->iBase);
    }else{
      /* Under UBSAN (or on 1's complement machines), must do this in steps.
       * In this clause, iTerm>=0 and iBase<0 . */
      puspan = 1;
      puspan += pss->iTerm;
      puspan += -(pss->iBase+1);
    }
    if( pss->iStep>0 ){
      pss->isNotEOF = 1;
      pss->uSeqIndexMax = puspan/pss->iStep;
    }
  }else if( pss->iTerm == pss->iBase ){
      pss->isNotEOF = 1;
      pss->uSeqIndexMax = 0;
  }
  pss->uSeqIndexNow = (pss->isReversing)? pss->uSeqIndexMax : 0;
  pss->iValueNow = (pss->isReversing)
    ? genSeqMember(pss->iBase, pss->iStep, pss->uSeqIndexMax)
    : pss->iBase;
}

References genSeqMember(), SequenceSpec::iBase, SequenceSpec::isNotEOF, SequenceSpec::isReversing, SequenceSpec::iStep, SequenceSpec::iTerm, SequenceSpec::iValueNow, SequenceSpec::uSeqIndexMax, and SequenceSpec::uSeqIndexNow.

Referenced by seriesFilter().

Here is the call graph for this function:

Here is the caller graph for this function:

sha1Func()

void sha1Func ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  SHA1Context cx;
  int eType = sqlite3_value_type(argv[0]);
  int nByte = sqlite3_value_bytes(argv[0]);
  char zOut[44];
 
  assert( argc==1 );
  if( eType==SQLITE_NULL ) return;
  hash_init(&cx);
  if( eType==SQLITE_BLOB ){
    hash_step(&cx, sqlite3_value_blob(argv[0]), nByte);
  }else{
    hash_step(&cx, sqlite3_value_text(argv[0]), nByte);
  }
  if( sqlite3_user_data(context)!=0 ){
    hash_finish(&cx, zOut, 1);
    sqlite3_result_blob(context, zOut, 20, SQLITE_TRANSIENT);
  }else{
    hash_finish(&cx, zOut, 0);
    sqlite3_result_blob(context, zOut, 40, SQLITE_TRANSIENT);
  }
}

References hash_finish(), hash_init(), hash_step(), sqlite3_result_blob, sqlite3_user_data, sqlite3_value_blob, sqlite3_value_bytes, sqlite3_value_text, sqlite3_value_type, SQLITE_BLOB, SQLITE_NULL, and SQLITE_TRANSIENT.

Referenced by sqlite3_sha_init().

Here is the call graph for this function:

Here is the caller graph for this function:

sha1QueryFunc()

void sha1QueryFunc ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  sqlite3 *db = sqlite3_context_db_handle(context);
  const char *zSql = (const char*)sqlite3_value_text(argv[0]);
  sqlite3_stmt *pStmt = 0;
  int nCol;                   /* Number of columns in the result set */
  int i;                      /* Loop counter */
  int rc;
  int n;
  const char *z;
  SHA1Context cx;
  char zOut[44];
 
  assert( argc==1 );
  if( zSql==0 ) return;
  hash_init(&cx);
  while( zSql[0] ){
    rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zSql);
    if( rc ){
      char *zMsg = sqlite3_mprintf("error SQL statement [%s]: %s",
                                   zSql, sqlite3_errmsg(db));
      sqlite3_finalize(pStmt);
      sqlite3_result_error(context, zMsg, -1);
      sqlite3_free(zMsg);
      return;
    }
    if( !sqlite3_stmt_readonly(pStmt) ){
      char *zMsg = sqlite3_mprintf("non-query: [%s]", sqlite3_sql(pStmt));
      sqlite3_finalize(pStmt);
      sqlite3_result_error(context, zMsg, -1);
      sqlite3_free(zMsg);
      return;
    }
    nCol = sqlite3_column_count(pStmt);
    z = sqlite3_sql(pStmt);
    n = (int)strlen(z);
    hash_step_vformat(&cx,"S%d:",n);
    hash_step(&cx,(unsigned char*)z,n);
 
    /* Compute a hash over the result of the query */
    while( SQLITE_ROW==sqlite3_step(pStmt) ){
      hash_step(&cx,(const unsigned char*)"R",1);
      for(i=0; i<nCol; i++){
        switch( sqlite3_column_type(pStmt,i) ){
          case SQLITE_NULL: {
            hash_step(&cx, (const unsigned char*)"N",1);
            break;
          }
          case SQLITE_INTEGER: {
            sqlite3_uint64 u;
            int j;
            unsigned char x[9];
            sqlite3_int64 v = sqlite3_column_int64(pStmt,i);
            memcpy(&u, &v, 8);
            for(j=8; j>=1; j--){
              x[j] = u & 0xff;
              u >>= 8;
            }
            x[0] = 'I';
            hash_step(&cx, x, 9);
            break;
          }
          case SQLITE_FLOAT: {
            sqlite3_uint64 u;
            int j;
            unsigned char x[9];
            double r = sqlite3_column_double(pStmt,i);
            memcpy(&u, &r, 8);
            for(j=8; j>=1; j--){
              x[j] = u & 0xff;
              u >>= 8;
            }
            x[0] = 'F';
            hash_step(&cx,x,9);
            break;
          }
          case SQLITE_TEXT: {
            int n2 = sqlite3_column_bytes(pStmt, i);
            const unsigned char *z2 = sqlite3_column_text(pStmt, i);
            hash_step_vformat(&cx,"T%d:",n2);
            hash_step(&cx, z2, n2);
            break;
          }
          case SQLITE_BLOB: {
            int n2 = sqlite3_column_bytes(pStmt, i);
            const unsigned char *z2 = sqlite3_column_blob(pStmt, i);
            hash_step_vformat(&cx,"B%d:",n2);
            hash_step(&cx, z2, n2);
            break;
          }
        }
      }
    }
    sqlite3_finalize(pStmt);
  }
  hash_finish(&cx, zOut, 0);
  sqlite3_result_text(context, zOut, 40, SQLITE_TRANSIENT);
}

References hash_finish(), hash_init(), hash_step(), hash_step_vformat(), sqlite3_column_blob, sqlite3_column_bytes, sqlite3_column_count, sqlite3_column_double, sqlite3_column_int64, sqlite3_column_text, sqlite3_column_type, sqlite3_context_db_handle, sqlite3_errmsg, sqlite3_finalize, sqlite3_free, sqlite3_mprintf, sqlite3_prepare_v2, sqlite3_result_error, sqlite3_result_text, sqlite3_sql, sqlite3_step, sqlite3_stmt_readonly, sqlite3_value_text, SQLITE_BLOB, SQLITE_FLOAT, SQLITE_INTEGER, SQLITE_NULL, SQLITE_ROW, SQLITE_TEXT, and SQLITE_TRANSIENT.

Referenced by sqlite3_sha_init().

Here is the call graph for this function:

Here is the caller graph for this function:

SHA1Transform()

void SHA1Transform ( unsigned int state[5], const unsigned char buffer[64] )

static

                                                                                {
  unsigned int qq[5]; /* a, b, c, d, e; */
  static int one = 1;
  unsigned int block[16];
  memcpy(block, buffer, 64);
  memcpy(qq,state,5*sizeof(unsigned int));
 
#define a qq[0]
#define b qq[1]
#define c qq[2]
#define d qq[3]
#define e qq[4]
 
  /* Copy p->state[] to working vars */
  /*
  a = state[0];
  b = state[1];
  c = state[2];
  d = state[3];
  e = state[4];
  */
 
  /* 4 rounds of 20 operations each. Loop unrolled. */
  if( 1 == *(unsigned char*)&one ){
    Rl0(a,b,c,d,e, 0); Rl0(e,a,b,c,d, 1); Rl0(d,e,a,b,c, 2); Rl0(c,d,e,a,b, 3);
    Rl0(b,c,d,e,a, 4); Rl0(a,b,c,d,e, 5); Rl0(e,a,b,c,d, 6); Rl0(d,e,a,b,c, 7);
    Rl0(c,d,e,a,b, 8); Rl0(b,c,d,e,a, 9); Rl0(a,b,c,d,e,10); Rl0(e,a,b,c,d,11);
    Rl0(d,e,a,b,c,12); Rl0(c,d,e,a,b,13); Rl0(b,c,d,e,a,14); Rl0(a,b,c,d,e,15);
  }else{
    Rb0(a,b,c,d,e, 0); Rb0(e,a,b,c,d, 1); Rb0(d,e,a,b,c, 2); Rb0(c,d,e,a,b, 3);
    Rb0(b,c,d,e,a, 4); Rb0(a,b,c,d,e, 5); Rb0(e,a,b,c,d, 6); Rb0(d,e,a,b,c, 7);
    Rb0(c,d,e,a,b, 8); Rb0(b,c,d,e,a, 9); Rb0(a,b,c,d,e,10); Rb0(e,a,b,c,d,11);
    Rb0(d,e,a,b,c,12); Rb0(c,d,e,a,b,13); Rb0(b,c,d,e,a,14); Rb0(a,b,c,d,e,15);
  }
  R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
  R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
  R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
  R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
  R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
  R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
  R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
  R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
  R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
  R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
  R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
  R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
  R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
  R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
  R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
  R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
 
  /* Add the working vars back into context.state[] */
  state[0] += a;
  state[1] += b;
  state[2] += c;
  state[3] += d;
  state[4] += e;
 
#undef a
#undef b
#undef c
#undef d
#undef e
}

References a, b, c, d, e, R1, R2, R3, R4, Rb0, and Rl0.

Referenced by hash_step().

Here is the caller graph for this function:

sha3_step_vformat()

void sha3_step_vformat ( SHA3Context * p, const char * zFormat, ... )

static

 {
  va_list ap;
  int n;
  char zBuf[50];
  va_start(ap, zFormat);
  sqlite3_vsnprintf(sizeof(zBuf),zBuf,zFormat,ap);
  va_end(ap);
  n = (int)strlen(zBuf);
  SHA3Update(p, (unsigned char*)zBuf, n);
}

References SHA3Update(), and sqlite3_vsnprintf.

Referenced by sha3QueryFunc(), and sha3UpdateFromValue().

Here is the call graph for this function:

Here is the caller graph for this function:

sha3AggFinal()

void sha3AggFinal ( sqlite3_context * context )

static

                                                  {
  SHA3Context *p;
  p = (SHA3Context*)sqlite3_aggregate_context(context, sizeof(*p));
  if( p==0 ) return;
  if( p->iSize ){
    sqlite3_result_blob(context, SHA3Final(p), p->iSize/8, SQLITE_TRANSIENT);
  }
}

References SHA3Context::iSize, SHA3Final(), sqlite3_aggregate_context, sqlite3_result_blob, and SQLITE_TRANSIENT.

Referenced by sqlite3_shathree_init().

Here is the call graph for this function:

Here is the caller graph for this function:

sha3AggStep()

void sha3AggStep ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  SHA3Context *p;
  p = (SHA3Context*)sqlite3_aggregate_context(context, sizeof(*p));
  if( p==0 ) return;
  if( p->nRate==0 ){
    int sz = 256;
    if( argc==2 ){
      sz = sqlite3_value_int(argv[1]);
      if( sz!=224 && sz!=384 && sz!=512 ){
        sz = 256;
      }
    }
    SHA3Init(p, sz);
  }
  sha3UpdateFromValue(p, argv[0]);
}

References SHA3Context::nRate, SHA3Init(), sha3UpdateFromValue(), sqlite3_aggregate_context, and sqlite3_value_int.

Referenced by sqlite3_shathree_init().

Here is the call graph for this function:

Here is the caller graph for this function:

SHA3Final()

unsigned char * SHA3Final ( SHA3Context * p )

static

                                               {
  unsigned int i;
  if( p->nLoaded==p->nRate-1 ){
    const unsigned char c1 = 0x86;
    SHA3Update(p, &c1, 1);
  }else{
    const unsigned char c2 = 0x06;
    const unsigned char c3 = 0x80;
    SHA3Update(p, &c2, 1);
    p->nLoaded = p->nRate - 1;
    SHA3Update(p, &c3, 1);
  }
  for(i=0; i<p->nRate; i++){
    p->u.x[i+p->nRate] = p->u.x[i^p->ixMask];
  }
  return &p->u.x[p->nRate];
}

References SHA3Context::ixMask, SHA3Context::nLoaded, SHA3Context::nRate, SHA3Update(), and SHA3Context::u.

Referenced by sha3AggFinal(), sha3Func(), and sha3QueryFunc().

Here is the call graph for this function:

Here is the caller graph for this function:

sha3Func()

void sha3Func ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  SHA3Context cx;
  int eType = sqlite3_value_type(argv[0]);
  int nByte = sqlite3_value_bytes(argv[0]);
  int iSize;
  if( argc==1 ){
    iSize = 256;
  }else{
    iSize = sqlite3_value_int(argv[1]);
    if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){
      sqlite3_result_error(context, "SHA3 size should be one of: 224 256 "
                                    "384 512", -1);
      return;
    }
  }
  if( eType==SQLITE_NULL ) return;
  SHA3Init(&cx, iSize);
  if( eType==SQLITE_BLOB ){
    SHA3Update(&cx, sqlite3_value_blob(argv[0]), nByte);
  }else{
    SHA3Update(&cx, sqlite3_value_text(argv[0]), nByte);
  }
  sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT);
}

References SHA3Final(), SHA3Init(), SHA3Update(), sqlite3_result_blob, sqlite3_result_error, sqlite3_value_blob, sqlite3_value_bytes, sqlite3_value_int, sqlite3_value_text, sqlite3_value_type, SQLITE_BLOB, SQLITE_NULL, and SQLITE_TRANSIENT.

Referenced by sqlite3_shathree_init().

Here is the call graph for this function:

Here is the caller graph for this function:

SHA3Init()

void SHA3Init ( SHA3Context * p, int iSize )

static

                                               {
  memset(p, 0, sizeof(*p));
  p->iSize = iSize;
  if( iSize>=128 && iSize<=512 ){
    p->nRate = (1600 - ((iSize + 31)&~31)*2)/8;
  }else{
    p->nRate = (1600 - 2*256)/8;
  }
#if SHA3_BYTEORDER==1234
  /* Known to be little-endian at compile-time. No-op */
#elif SHA3_BYTEORDER==4321
  p->ixMask = 7;  /* Big-endian */
#else
  {
    static unsigned int one = 1;
    if( 1==*(unsigned char*)&one ){
      /* Little endian.  No byte swapping. */
      p->ixMask = 0;
    }else{
      /* Big endian.  Byte swap. */
      p->ixMask = 7;
    }
  }
#endif
}

References SHA3Context::iSize, SHA3Context::ixMask, and SHA3Context::nRate.

Referenced by sha3AggStep(), sha3Func(), and sha3QueryFunc().

Here is the caller graph for this function:

sha3QueryFunc()

void sha3QueryFunc ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  sqlite3 *db = sqlite3_context_db_handle(context);
  const char *zSql = (const char*)sqlite3_value_text(argv[0]);
  sqlite3_stmt *pStmt = 0;
  int nCol;                   /* Number of columns in the result set */
  int i;                      /* Loop counter */
  int rc;
  int n;
  const char *z;
  SHA3Context cx;
  int iSize;
 
  if( argc==1 ){
    iSize = 256;
  }else{
    iSize = sqlite3_value_int(argv[1]);
    if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){
      sqlite3_result_error(context, "SHA3 size should be one of: 224 256 "
                                    "384 512", -1);
      return;
    }
  }
  if( zSql==0 ) return;
  SHA3Init(&cx, iSize);
  while( zSql[0] ){
    rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zSql);
    if( rc ){
      char *zMsg = sqlite3_mprintf("error SQL statement [%s]: %s",
                                   zSql, sqlite3_errmsg(db));
      sqlite3_finalize(pStmt);
      sqlite3_result_error(context, zMsg, -1);
      sqlite3_free(zMsg);
      return;
    }
    if( !sqlite3_stmt_readonly(pStmt) ){
      char *zMsg = sqlite3_mprintf("non-query: [%s]", sqlite3_sql(pStmt));
      sqlite3_finalize(pStmt);
      sqlite3_result_error(context, zMsg, -1);
      sqlite3_free(zMsg);
      return;
    }
    nCol = sqlite3_column_count(pStmt);
    z = sqlite3_sql(pStmt);
    if( z ){
      n = (int)strlen(z);
      sha3_step_vformat(&cx,"S%d:",n);
      SHA3Update(&cx,(unsigned char*)z,n);
    }
 
    /* Compute a hash over the result of the query */
    while( SQLITE_ROW==sqlite3_step(pStmt) ){
      SHA3Update(&cx,(const unsigned char*)"R",1);
      for(i=0; i<nCol; i++){
        sha3UpdateFromValue(&cx, sqlite3_column_value(pStmt,i));
      }
    }
    sqlite3_finalize(pStmt);
  }
  sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT);
}

References sha3_step_vformat(), SHA3Final(), SHA3Init(), SHA3Update(), sha3UpdateFromValue(), sqlite3_column_count, sqlite3_column_value, sqlite3_context_db_handle, sqlite3_errmsg, sqlite3_finalize, sqlite3_free, sqlite3_mprintf, sqlite3_prepare_v2, sqlite3_result_blob, sqlite3_result_error, sqlite3_sql, sqlite3_step, sqlite3_stmt_readonly, sqlite3_value_int, sqlite3_value_text, SQLITE_ROW, and SQLITE_TRANSIENT.

Referenced by sqlite3_shathree_init().

Here is the call graph for this function:

Here is the caller graph for this function:

SHA3Update()

void SHA3Update ( SHA3Context * p, const unsigned char * aData, unsigned int nData )

static

 {
  unsigned int i = 0;
  if( aData==0 ) return;
#if SHA3_BYTEORDER==1234
  if( (p->nLoaded % 8)==0 && ((aData - (const unsigned char*)0)&7)==0 ){
    for(; i+7<nData; i+=8){
      p->u.s[p->nLoaded/8] ^= *(u64*)&aData[i];
      p->nLoaded += 8;
      if( p->nLoaded>=p->nRate ){
        KeccakF1600Step(p);
        p->nLoaded = 0;
      }
    }
  }
#endif
  for(; i<nData; i++){
#if SHA3_BYTEORDER==1234
    p->u.x[p->nLoaded] ^= aData[i];
#elif SHA3_BYTEORDER==4321
    p->u.x[p->nLoaded^0x07] ^= aData[i];
#else
    p->u.x[p->nLoaded^p->ixMask] ^= aData[i];
#endif
    p->nLoaded++;
    if( p->nLoaded==p->nRate ){
      KeccakF1600Step(p);
      p->nLoaded = 0;
    }
  }
}

References SHA3Context::ixMask, KeccakF1600Step(), SHA3Context::nLoaded, SHA3Context::nRate, and SHA3Context::u.

Referenced by sha3_step_vformat(), SHA3Final(), sha3Func(), sha3QueryFunc(), and sha3UpdateFromValue().

Here is the call graph for this function:

Here is the caller graph for this function:

sha3UpdateFromValue()

void sha3UpdateFromValue ( SHA3Context * p, sqlite3_value * pVal )

static

                                                                    {
  switch( sqlite3_value_type(pVal) ){
    case SQLITE_NULL: {
      SHA3Update(p, (const unsigned char*)"N",1);
      break;
    }
    case SQLITE_INTEGER: {
      sqlite3_uint64 u;
      int j;
      unsigned char x[9];
      sqlite3_int64 v = sqlite3_value_int64(pVal);
      memcpy(&u, &v, 8);
      for(j=8; j>=1; j--){
        x[j] = u & 0xff;
        u >>= 8;
      }
      x[0] = 'I';
      SHA3Update(p, x, 9);
      break;
    }
    case SQLITE_FLOAT: {
      sqlite3_uint64 u;
      int j;
      unsigned char x[9];
      double r = sqlite3_value_double(pVal);
      memcpy(&u, &r, 8);
      for(j=8; j>=1; j--){
        x[j] = u & 0xff;
        u >>= 8;
      }
      x[0] = 'F';
      SHA3Update(p,x,9);
      break;
    }
    case SQLITE_TEXT: {
      int n2 = sqlite3_value_bytes(pVal);
      const unsigned char *z2 = sqlite3_value_text(pVal);
      sha3_step_vformat(p,"T%d:",n2);
      SHA3Update(p, z2, n2);
      break;
    }
    case SQLITE_BLOB: {
      int n2 = sqlite3_value_bytes(pVal);
      const unsigned char *z2 = sqlite3_value_blob(pVal);
      sha3_step_vformat(p,"B%d:",n2);
      SHA3Update(p, z2, n2);
      break;
    }
  }
}

References sha3_step_vformat(), SHA3Update(), sqlite3_value_blob, sqlite3_value_bytes, sqlite3_value_double, sqlite3_value_int64, sqlite3_value_text, sqlite3_value_type, SQLITE_BLOB, SQLITE_FLOAT, SQLITE_INTEGER, SQLITE_NULL, and SQLITE_TEXT.

Referenced by sha3AggStep(), and sha3QueryFunc().

Here is the call graph for this function:

Here is the caller graph for this function:

shell_callback()

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

static

 {
  int i;
  ShellState *p = (ShellState*)pArg;
 
  if( azArg==0 ) return 0;
  switch( p->cMode ){
    case MODE_Count:
    case MODE_Off: {
      break;
    }
    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 ) sqlite3_fputs(p->rowSeparator, p->out);
      for(i=0; i<nArg; i++){
        char *pFree = 0;
        const char *pDisplay;
        pDisplay = escapeOutput(p, azArg[i] ? azArg[i] : p->nullValue, &pFree);
        sqlite3_fprintf(p->out, "%*s = %s%s", w, azCol[i],
                        pDisplay, p->rowSeparator);
        if( pFree ) sqlite3_free(pFree);
      }
      break;
    }
    case MODE_ScanExp:
    case MODE_Explain: {
      static const int aExplainWidth[] = {4,       13, 4, 4, 4, 13, 2, 13};
      static const int aExplainMap[] =   {0,       1,  2, 3, 4, 5,  6, 7 };
      static const int aScanExpWidth[] = {4, 15, 6, 13, 4, 4, 4, 13, 2, 13};
      static const int aScanExpMap[] =   {0, 9, 8, 1,  2, 3, 4, 5,  6, 7 };
 
      const int *aWidth = aExplainWidth;
      const int *aMap = aExplainMap;
      int nWidth = ArraySize(aExplainWidth);
      int iIndent = 1;
 
      if( p->cMode==MODE_ScanExp ){
        aWidth = aScanExpWidth;
        aMap = aScanExpMap;
        nWidth = ArraySize(aScanExpWidth);
        iIndent = 3;
      }
      if( nArg>nWidth ) nArg = nWidth;
 
      /* If this is the first row seen, print out the headers */
      if( p->cnt++==0 ){
        for(i=0; i<nArg; i++){
          utf8_width_print(p->out, aWidth[i], azCol[ aMap[i] ]);
          sqlite3_fputs(i==nArg-1 ? "\n" : "  ", p->out);
        }
        for(i=0; i<nArg; i++){
          print_dashes(p->out, aWidth[i]);
          sqlite3_fputs(i==nArg-1 ? "\n" : "  ", p->out);
        }
      }
 
      /* If there is no data, exit early. */
      if( azArg==0 ) break;
 
      for(i=0; i<nArg; i++){
        const char *zSep = "  ";
        int w = aWidth[i];
        const char *zVal = azArg[ aMap[i] ];
        if( i==nArg-1 ) w = 0;
        if( zVal && strlenChar(zVal)>w ){
          w = strlenChar(zVal);
          zSep = " ";
        }
        if( i==iIndent && p->aiIndent && p->pStmt ){
          if( p->iIndent<p->nIndent ){
            sqlite3_fprintf(p->out, "%*.s", p->aiIndent[p->iIndent], "");
          }
          p->iIndent++;
        }
        utf8_width_print(p->out, w, zVal ? zVal : p->nullValue);
        sqlite3_fputs(i==nArg-1 ? "\n" : zSep, p->out);
      }
      break;
    }
    case MODE_Semi: {   /* .schema and .fullschema output */
      printSchemaLine(p->out, azArg[0], ";\n");
      break;
    }
    case MODE_Pretty: {  /* .schema and .fullschema with --indent */
      char *z;
      int j;
      int nParen = 0;
      char cEnd = 0;
      char c;
      int nLine = 0;
      int isIndex;
      int isWhere = 0;
      assert( nArg==1 );
      if( azArg[0]==0 ) break;
      if( sqlite3_strlike("CREATE VIEW%", azArg[0], 0)==0
       || sqlite3_strlike("CREATE TRIG%", azArg[0], 0)==0
      ){
        sqlite3_fprintf(p->out, "%s;\n", azArg[0]);
        break;
      }
      isIndex = sqlite3_strlike("CREATE INDEX%", azArg[0], 0)==0
             || sqlite3_strlike("CREATE UNIQUE INDEX%", azArg[0], 0)==0;
      z = sqlite3_mprintf("%s", azArg[0]);
      shell_check_oom(z);
      j = 0;
      for(i=0; IsSpace(z[i]); i++){}
      for(; (c = z[i])!=0; i++){
        if( IsSpace(c) ){
          if( z[j-1]=='\r' ) z[j-1] = '\n';
          if( IsSpace(z[j-1]) || z[j-1]=='(' ) continue;
        }else if( (c=='(' || c==')') && j>0 && IsSpace(z[j-1]) ){
          j--;
        }
        z[j++] = c;
      }
      while( j>0 && IsSpace(z[j-1]) ){ j--; }
      z[j] = 0;
      if( strlen30(z)>=79 ){
        for(i=j=0; (c = z[i])!=0; i++){ /* Copy from z[i] back to z[j] */
          if( c==cEnd ){
            cEnd = 0;
          }else if( c=='"' || c=='\'' || c=='`' ){
            cEnd = c;
          }else if( c=='[' ){
            cEnd = ']';
          }else if( c=='-' && z[i+1]=='-' ){
            cEnd = '\n';
          }else if( c=='(' ){
            nParen++;
          }else if( c==')' ){
            nParen--;
            if( nLine>0 && nParen==0 && j>0 && !isWhere ){
              printSchemaLineN(p->out, z, j, "\n");
              j = 0;
            }
          }else if( (c=='w' || c=='W')
                 && nParen==0 && isIndex
                 && sqlite3_strnicmp("WHERE",&z[i],5)==0
                 && !IsAlnum(z[i+5]) && z[i+5]!='_' ){
            isWhere = 1;
          }else if( isWhere && (c=='A' || c=='a')
                 && nParen==0
                 && sqlite3_strnicmp("AND",&z[i],3)==0
                 && !IsAlnum(z[i+3]) && z[i+3]!='_' ){
            printSchemaLineN(p->out, z, j, "\n    ");
            j = 0;
          }
          z[j++] = c;
          if( nParen==1 && cEnd==0
           && (c=='(' || c=='\n' || (c==',' && !wsToEol(z+i+1)))
           && !isWhere
          ){
            if( c=='\n' ) j--;
            printSchemaLineN(p->out, z, j, "\n  ");
            j = 0;
            nLine++;
            while( IsSpace(z[i+1]) ){ i++; }
          }
        }
        z[j] = 0;
      }
      printSchemaLine(p->out, z, ";\n");
      sqlite3_free(z);
      break;
    }
    case MODE_List: {
      if( p->cnt++==0 && p->showHeader ){
        for(i=0; i<nArg; i++){
          char *z = azCol[i];
          char *pFree;
          const char *zOut = escapeOutput(p, z, &pFree);
          sqlite3_fprintf(p->out, "%s%s", zOut,
                          i==nArg-1 ? p->rowSeparator : p->colSeparator);
          if( pFree ) sqlite3_free(pFree);
        }
      }
      if( azArg==0 ) break;
      for(i=0; i<nArg; i++){
        char *z = azArg[i];
        char *pFree;
        const char *zOut;
        if( z==0 ) z = p->nullValue;
        zOut = escapeOutput(p, z, &pFree);
        sqlite3_fputs(zOut, p->out);
        if( pFree ) sqlite3_free(pFree);
        sqlite3_fputs((i<nArg-1)? p->colSeparator : p->rowSeparator, p->out);
      }
      break;
    }
    case MODE_Www:
    case MODE_Html: {
      if( p->cnt==0 && p->cMode==MODE_Www ){
        sqlite3_fputs(
          "</PRE>\n"
          "<TABLE border='1' cellspacing='0' cellpadding='2'>\n"
          ,p->out
        );
      }
      if( p->cnt==0 && (p->showHeader || p->cMode==MODE_Www) ){
        sqlite3_fputs("<TR>", p->out);
        for(i=0; i<nArg; i++){
          sqlite3_fputs("<TH>", p->out);
          output_html_string(p->out, azCol[i]);
          sqlite3_fputs("</TH>\n", p->out);
        }
        sqlite3_fputs("</TR>\n", p->out);
      }
      p->cnt++;
      if( azArg==0 ) break;
      sqlite3_fputs("<TR>", p->out);
      for(i=0; i<nArg; i++){
        sqlite3_fputs("<TD>", p->out);
        output_html_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
        sqlite3_fputs("</TD>\n", p->out);
      }
      sqlite3_fputs("</TR>\n", p->out);
      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) sqlite3_fputs(p->colSeparator, p->out);
        }
        sqlite3_fputs(p->rowSeparator, p->out);
      }
      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) sqlite3_fputs(p->colSeparator, p->out);
      }
      sqlite3_fputs(p->rowSeparator, p->out);
      break;
    }
    case MODE_Csv: {
      sqlite3_fsetmode(p->out, _O_BINARY);
      if( p->cnt++==0 && p->showHeader ){
        for(i=0; i<nArg; i++){
          output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
        }
        sqlite3_fputs(p->rowSeparator, p->out);
      }
      if( nArg>0 ){
        for(i=0; i<nArg; i++){
          output_csv(p, azArg[i], i<nArg-1);
        }
        sqlite3_fputs(p->rowSeparator, p->out);
      }
      setCrlfMode(p);
      break;
    }
    case MODE_Insert: {
      if( azArg==0 ) break;
      sqlite3_fprintf(p->out, "INSERT INTO %s",p->zDestTable);
      if( p->showHeader ){
        sqlite3_fputs("(", p->out);
        for(i=0; i<nArg; i++){
          if( i>0 ) sqlite3_fputs(",", p->out);
          if( quoteChar(azCol[i]) ){
            char *z = sqlite3_mprintf("\"%w\"", azCol[i]);
            shell_check_oom(z);
            sqlite3_fputs(z, p->out);
            sqlite3_free(z);
          }else{
            sqlite3_fprintf(p->out, "%s", azCol[i]);
          }
        }
        sqlite3_fputs(")", p->out);
      }
      p->cnt++;
      for(i=0; i<nArg; i++){
        sqlite3_fputs(i>0 ? "," : " VALUES(", p->out);
        if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
          sqlite3_fputs("NULL", p->out);
        }else if( aiType && aiType[i]==SQLITE_TEXT ){
          if( ShellHasFlag(p, SHFLG_Newlines) ){
            output_quoted_string(p, azArg[i]);
          }else{
            output_quoted_escaped_string(p, azArg[i]);
          }
        }else if( aiType && aiType[i]==SQLITE_INTEGER ){
          sqlite3_fputs(azArg[i], p->out);
        }else if( aiType && aiType[i]==SQLITE_FLOAT ){
          char z[50];
          double r = sqlite3_column_double(p->pStmt, i);
          sqlite3_uint64 ur;
          memcpy(&ur,&r,sizeof(r));
          if( ur==0x7ff0000000000000LL ){
            sqlite3_fputs("9.0e+999", p->out);
          }else if( ur==0xfff0000000000000LL ){
            sqlite3_fputs("-9.0e+999", p->out);
          }else{
            sqlite3_int64 ir = (sqlite3_int64)r;
            if( r==(double)ir ){
              sqlite3_snprintf(50,z,"%lld.0", ir);
            }else{
              sqlite3_snprintf(50,z,"%!.20g", r);
            }
            sqlite3_fputs(z, p->out);
          }
        }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);
          output_hex_blob(p->out, pBlob, nBlob);
        }else if( isNumber(azArg[i], 0) ){
          sqlite3_fputs(azArg[i], p->out);
        }else if( ShellHasFlag(p, SHFLG_Newlines) ){
          output_quoted_string(p, azArg[i]);
        }else{
          output_quoted_escaped_string(p, azArg[i]);
        }
      }
      sqlite3_fputs(");\n", p->out);
      break;
    }
    case MODE_Json: {
      if( azArg==0 ) break;
      if( p->cnt==0 ){
        sqlite3_fputs("[{", p->out);
      }else{
        sqlite3_fputs(",\n{", p->out);
      }
      p->cnt++;
      for(i=0; i<nArg; i++){
        output_json_string(p->out, azCol[i], -1);
        sqlite3_fputs(":", p->out);
        if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
          sqlite3_fputs("null", p->out);
        }else if( aiType && aiType[i]==SQLITE_FLOAT ){
          char z[50];
          double r = sqlite3_column_double(p->pStmt, i);
          sqlite3_uint64 ur;
          memcpy(&ur,&r,sizeof(r));
          if( ur==0x7ff0000000000000LL ){
            sqlite3_fputs("9.0e+999", p->out);
          }else if( ur==0xfff0000000000000LL ){
            sqlite3_fputs("-9.0e+999", p->out);
          }else{
            sqlite3_snprintf(50,z,"%!.20g", r);
            sqlite3_fputs(z, p->out);
          }
        }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);
          output_json_string(p->out, pBlob, nBlob);
        }else if( aiType && aiType[i]==SQLITE_TEXT ){
          output_json_string(p->out, azArg[i], -1);
        }else{
          sqlite3_fputs(azArg[i], p->out);
        }
        if( i<nArg-1 ){
          sqlite3_fputs(",", p->out);
        }
      }
      sqlite3_fputs("}", p->out);
      break;
    }
    case MODE_Quote: {
      if( azArg==0 ) break;
      if( p->cnt==0 && p->showHeader ){
        for(i=0; i<nArg; i++){
          if( i>0 ) sqlite3_fputs(p->colSeparator, p->out);
          output_quoted_string(p, azCol[i]);
        }
        sqlite3_fputs(p->rowSeparator, p->out);
      }
      p->cnt++;
      for(i=0; i<nArg; i++){
        if( i>0 ) sqlite3_fputs(p->colSeparator, p->out);
        if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
          sqlite3_fputs("NULL", p->out);
        }else if( aiType && aiType[i]==SQLITE_TEXT ){
          output_quoted_string(p, azArg[i]);
        }else if( aiType && aiType[i]==SQLITE_INTEGER ){
          sqlite3_fputs(azArg[i], p->out);
        }else if( aiType && aiType[i]==SQLITE_FLOAT ){
          char z[50];
          double r = sqlite3_column_double(p->pStmt, i);
          sqlite3_snprintf(50,z,"%!.20g", r);
          sqlite3_fputs(z, p->out);
        }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);
          output_hex_blob(p->out, pBlob, nBlob);
        }else if( isNumber(azArg[i], 0) ){
          sqlite3_fputs(azArg[i], p->out);
        }else{
          output_quoted_string(p, azArg[i]);
        }
      }
      sqlite3_fputs(p->rowSeparator, p->out);
      break;
    }
    case MODE_Ascii: {
      if( p->cnt++==0 && p->showHeader ){
        for(i=0; i<nArg; i++){
          if( i>0 ) sqlite3_fputs(p->colSeparator, p->out);
          sqlite3_fputs(azCol[i] ? azCol[i] : "", p->out);
        }
        sqlite3_fputs(p->rowSeparator, p->out);
      }
      if( azArg==0 ) break;
      for(i=0; i<nArg; i++){
        if( i>0 ) sqlite3_fputs(p->colSeparator, p->out);
        sqlite3_fputs(azArg[i] ? azArg[i] : p->nullValue, p->out);
      }
      sqlite3_fputs(p->rowSeparator, p->out);
      break;
    }
    case MODE_EQP: {
      eqp_append(p, atoi(azArg[0]), atoi(azArg[1]), azArg[3]);
      break;
    }
  }

References ShellState::aiIndent, ArraySize, c, ShellState::cMode, ShellState::cnt, ShellState::colSeparator, eqp_append(), escapeOutput(), ShellState::iIndent, IsAlnum, isNumber(), IsSpace, MODE_Ascii, MODE_Count, MODE_Csv, MODE_EQP, MODE_Explain, MODE_Html, MODE_Insert, MODE_Json, MODE_Line, MODE_List, MODE_Off, MODE_Pretty, MODE_Quote, MODE_ScanExp, MODE_Semi, MODE_Tcl, MODE_Www, ShellState::nIndent, ShellState::nullValue, ShellState::out, output_c_string(), output_csv(), output_hex_blob(), output_html_string(), output_json_string(), output_quoted_escaped_string(), output_quoted_string(), print_dashes(), printSchemaLine(), printSchemaLineN(), ShellState::pStmt, quoteChar(), ShellState::rowSeparator, setCrlfMode(), shell_check_oom(), ShellHasFlag, SHFLG_Newlines, ShellState::showHeader, sqlite3_column_blob, sqlite3_column_bytes, sqlite3_column_double, sqlite3_fprintf, sqlite3_fputs, sqlite3_free, sqlite3_fsetmode, sqlite3_mprintf, sqlite3_snprintf, sqlite3_strlike, sqlite3_strnicmp, SQLITE_BLOB, SQLITE_FLOAT, SQLITE_INTEGER, SQLITE_NULL, SQLITE_TEXT, strlen30(), strlenChar(), utf8_width_print(), wsToEol(), and ShellState::zDestTable.

Referenced by callback(), and exec_prepared_stmt().

Here is the call graph for this function:

Here is the caller graph for this function:

shell_check_oom()

void shell_check_oom ( const void * p )

static

                                          {
  if( p==0 ) shell_out_of_memory();
}

References shell_out_of_memory().

Referenced by appendText(), do_meta_command(), dump_callback(), eqp_append(), escapeOutput(), exec_prepared_stmt_columnar(), explain_data_prepare(), find_xdg_config(), import_append_char(), local_getline(), main(), newTempFile(), open_db(), output_csv(), output_hex_blob(), printSchemaLine(), process_input(), process_sqliterc(), rc_err_oom_die(), readHexDb(), save_err_msg(), set_table_name(), shell_callback(), shell_dbtotxt_command(), shell_error_context(), shellFakeSchema(), showHelp(), tableColumnList(), translateForDisplayAndDup(), tryToCloneData(), and tryToCloneSchema().

Here is the call graph for this function:

Here is the caller graph for this function:

shell_dbtotxt_command()

int shell_dbtotxt_command ( ShellState * p, int nArg, char ** azArg )

static

                                                                       {
  sqlite3_stmt *pStmt = 0;
  sqlite3_int64 nPage = 0;
  int pgSz = 0;
  const char *zTail;
  char *zName = 0;
  int rc, i, j;
  unsigned char bShow[256];   /* Characters ok to display */
 
  UNUSED_PARAMETER(nArg);
  UNUSED_PARAMETER(azArg);
  memset(bShow, '.', sizeof(bShow));
  for(i=' '; i<='~'; i++){
    if( i!='{' && i!='}' && i!='"' && i!='\\' ) bShow[i] = (unsigned char)i;
  }
  rc = sqlite3_prepare_v2(p->db, "PRAGMA page_size", -1, &pStmt, 0);
  if( rc ) goto dbtotxt_error;
  rc = 0;
  if( sqlite3_step(pStmt)!=SQLITE_ROW ) goto dbtotxt_error;
  pgSz = sqlite3_column_int(pStmt, 0);
  sqlite3_finalize(pStmt);
  pStmt = 0;
  if( pgSz<512 || pgSz>65536 || (pgSz&(pgSz-1))!=0 ) goto dbtotxt_error;
  rc = sqlite3_prepare_v2(p->db, "PRAGMA page_count", -1, &pStmt, 0);
  if( rc ) goto dbtotxt_error;
  rc = 0;
  if( sqlite3_step(pStmt)!=SQLITE_ROW ) goto dbtotxt_error;
  nPage = sqlite3_column_int64(pStmt, 0);
  sqlite3_finalize(pStmt);
  pStmt = 0;
  if( nPage<1 ) goto dbtotxt_error;
  rc = sqlite3_prepare_v2(p->db, "PRAGMA databases", -1, &pStmt, 0);
  if( rc ) goto dbtotxt_error;
  if( sqlite3_step(pStmt)!=SQLITE_ROW ){
    zTail = "unk.db";
  }else{
    const char *zFilename = (const char*)sqlite3_column_text(pStmt, 2);
    if( zFilename==0 || zFilename[0]==0 ) zFilename = "unk.db";
    zTail = strrchr(zFilename, '/');
#if defined(_WIN32)
    if( zTail==0 ) zTail = strrchr(zFilename, '\\');
#endif
  }
  zName = strdup(zTail);
  shell_check_oom(zName);
  sqlite3_fprintf(p->out, "| size %lld pagesize %d filename %s\n",
                  nPage*pgSz, pgSz, zName);
  sqlite3_finalize(pStmt);
  pStmt = 0;
  rc = sqlite3_prepare_v2(p->db,
           "SELECT pgno, data FROM sqlite_dbpage ORDER BY pgno", -1, &pStmt, 0);
  if( rc ) goto dbtotxt_error;
  while( sqlite3_step(pStmt)==SQLITE_ROW ){
    sqlite3_int64 pgno = sqlite3_column_int64(pStmt, 0);
    const u8 *aData = sqlite3_column_blob(pStmt, 1);
    int seenPageLabel = 0;
    for(i=0; i<pgSz; i+=16){
      const u8 *aLine = aData+i;
      for(j=0; j<16 && aLine[j]==0; j++){}
      if( j==16 ) continue;
      if( !seenPageLabel ){
        sqlite3_fprintf(p->out, "| page %lld offset %lld\n",pgno,(pgno-1)*pgSz);
        seenPageLabel = 1;
      }
      sqlite3_fprintf(p->out, "|  %5d:", i);
      for(j=0; j<16; j++) sqlite3_fprintf(p->out, " %02x", aLine[j]);
      sqlite3_fprintf(p->out, "   ");
      for(j=0; j<16; j++){
        unsigned char c = (unsigned char)aLine[j];
        sqlite3_fprintf(p->out, "%c", bShow[c]);
      }
      sqlite3_fprintf(p->out, "\n");
    }
  }
  sqlite3_finalize(pStmt);
  sqlite3_fprintf(p->out, "| end %s\n", zName);
  free(zName);
  return 0;
 
dbtotxt_error:
  if( rc ){
    sqlite3_fprintf(stderr, "ERROR: %s\n", sqlite3_errmsg(p->db));
  }
  sqlite3_finalize(pStmt);
  free(zName);

References c, ShellState::db, ShellState::out, shell_check_oom(), sqlite3_column_blob, sqlite3_column_int, sqlite3_column_int64, sqlite3_column_text, sqlite3_errmsg, sqlite3_finalize, sqlite3_fprintf, sqlite3_prepare_v2, sqlite3_step, SQLITE_ROW, and UNUSED_PARAMETER.

Referenced by do_meta_command().

Here is the call graph for this function:

Here is the caller graph for this function:

shell_error_context()

char * shell_error_context ( const char * zSql, sqlite3 * db )

static

                                                               {
  int iOffset;
  size_t len;
  char *zCode;
  char *zMsg;
  int i;
  if( db==0
   || zSql==0
   || (iOffset = sqlite3_error_offset(db))<0
   || iOffset>=(int)strlen(zSql)
  ){
    return sqlite3_mprintf("");
  }
  while( iOffset>50 ){
    iOffset--;
    zSql++;
    while( (zSql[0]&0xc0)==0x80 ){ zSql++; iOffset--; }
  }
  len = strlen(zSql);
  if( len>78 ){
    len = 78;
    while( len>0 && (zSql[len]&0xc0)==0x80 ) len--;
  }
  zCode = sqlite3_mprintf("%.*s", len, zSql);
  shell_check_oom(zCode);
  for(i=0; zCode[i]; i++){ if( IsSpace(zSql[i]) ) zCode[i] = ' '; }
  if( iOffset<25 ){
    zMsg = sqlite3_mprintf("\n  %z\n  %*s^--- error here", zCode,iOffset,"");
  }else{
    zMsg = sqlite3_mprintf("\n  %z\n  %*serror here ---^", zCode,iOffset-14,"");
  }

References IsSpace, shell_check_oom(), sqlite3_error_offset, and sqlite3_mprintf.

Referenced by run_table_dump_query(), and save_err_msg().

Here is the call graph for this function:

Here is the caller graph for this function:

shell_exec()

int shell_exec ( ShellState * pArg, const char * zSql, char ** pzErrMsg )

static

 {
  sqlite3_stmt *pStmt = NULL;     /* Statement to execute. */
  int rc = SQLITE_OK;             /* Return Code */
  int rc2;
  const char *zLeftover;          /* Tail of unprocessed SQL */
  sqlite3 *db = pArg->db;
 
  if( pzErrMsg ){
    *pzErrMsg = NULL;
  }
 
#ifndef SQLITE_OMIT_VIRTUALTABLE
  if( pArg->expert.pExpert ){
    rc = expertHandleSQL(pArg, zSql, pzErrMsg);
    return expertFinish(pArg, (rc!=SQLITE_OK), pzErrMsg);
  }
#endif
 
  while( zSql[0] && (SQLITE_OK == rc) ){
    static const char *zStmtSql;
    rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
    if( SQLITE_OK != rc ){
      if( pzErrMsg ){
        *pzErrMsg = save_err_msg(db, "in prepare", rc, zSql);
      }
    }else{
      if( !pStmt ){
        /* this happens for a comment or white-space */
        zSql = zLeftover;
        while( IsSpace(zSql[0]) ) zSql++;
        continue;
      }
      zStmtSql = sqlite3_sql(pStmt);
      if( zStmtSql==0 ) zStmtSql = "";
      while( IsSpace(zStmtSql[0]) ) zStmtSql++;
 
      /* save off the prepared statement handle and reset row count */
      if( pArg ){
        pArg->pStmt = pStmt;
        pArg->cnt = 0;
      }
 
      /* Show the EXPLAIN QUERY PLAN if .eqp is on */
      if( pArg && pArg->autoEQP && sqlite3_stmt_isexplain(pStmt)==0 ){
        sqlite3_stmt *pExplain;
        int triggerEQP = 0;
        disable_debug_trace_modes();
        sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, -1, &triggerEQP);
        if( pArg->autoEQP>=AUTOEQP_trigger ){
          sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, 1, 0);
        }
        pExplain = pStmt;
        sqlite3_reset(pExplain);
        rc = sqlite3_stmt_explain(pExplain, 2);
        if( rc==SQLITE_OK ){
          bind_prepared_stmt(pArg, pExplain);
          while( sqlite3_step(pExplain)==SQLITE_ROW ){
            const char *zEQPLine = (const char*)sqlite3_column_text(pExplain,3);
            int iEqpId = sqlite3_column_int(pExplain, 0);
            int iParentId = sqlite3_column_int(pExplain, 1);
            if( zEQPLine==0 ) zEQPLine = "";
            if( zEQPLine[0]=='-' ) eqp_render(pArg, 0);
            eqp_append(pArg, iEqpId, iParentId, zEQPLine);
          }
          eqp_render(pArg, 0);
        }
        if( pArg->autoEQP>=AUTOEQP_full ){
          /* Also do an EXPLAIN for ".eqp full" mode */
          sqlite3_reset(pExplain);
          rc = sqlite3_stmt_explain(pExplain, 1);
          if( rc==SQLITE_OK ){
            pArg->cMode = MODE_Explain;
            assert( sqlite3_stmt_isexplain(pExplain)==1 );
            bind_prepared_stmt(pArg, pExplain);
            explain_data_prepare(pArg, pExplain);
            exec_prepared_stmt(pArg, pExplain);
            explain_data_delete(pArg);
          }
        }
        if( pArg->autoEQP>=AUTOEQP_trigger && triggerEQP==0 ){
          sqlite3_db_config(db, SQLITE_DBCONFIG_TRIGGER_EQP, 0, 0);
        }
        sqlite3_reset(pStmt);
        sqlite3_stmt_explain(pStmt, 0);
        restore_debug_trace_modes();
      }
 
      if( pArg ){
        int bIsExplain = (sqlite3_stmt_isexplain(pStmt)==1);
        pArg->cMode = pArg->mode;
        if( pArg->autoExplain ){
          if( bIsExplain ){
            pArg->cMode = MODE_Explain;
          }
          if( sqlite3_stmt_isexplain(pStmt)==2 ){
            pArg->cMode = MODE_EQP;
          }
        }
 
        /* If the shell is currently in ".explain" mode, gather the extra
        ** data required to add indents to the output.*/
        if( pArg->cMode==MODE_Explain && bIsExplain ){
          explain_data_prepare(pArg, pStmt);
        }
      }
 
      bind_prepared_stmt(pArg, pStmt);
      exec_prepared_stmt(pArg, pStmt);
      explain_data_delete(pArg);
      eqp_render(pArg, 0);
 
      /* print usage stats if stats on */
      if( pArg && pArg->statsOn ){
        display_stats(db, pArg, 0);
      }
 
      /* print loop-counters if required */
      if( pArg && pArg->scanstatsOn ){
        display_scanstats(db, pArg);
      }
 
      /* 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, "stepping", rc, 0);
      }
 
      /* clear saved stmt handle */
      if( pArg ){
        pArg->pStmt = NULL;
      }
    }
  } /* end while */
 

References ShellState::autoEQP, AUTOEQP_full, AUTOEQP_trigger, ShellState::autoExplain, bind_prepared_stmt(), ShellState::cMode, ShellState::cnt, ShellState::db, disable_debug_trace_modes(), display_scanstats(), display_stats(), eqp_append(), eqp_render(), exec_prepared_stmt(), ShellState::expert, expertFinish(), expertHandleSQL(), explain_data_delete(), explain_data_prepare(), IsSpace, ShellState::mode, MODE_EQP, MODE_Explain, ExpertInfo::pExpert, ShellState::pStmt, restore_debug_trace_modes(), save_err_msg(), ShellState::scanstatsOn, sqlite3_column_int, sqlite3_column_text, sqlite3_db_config, sqlite3_finalize, sqlite3_prepare_v2, sqlite3_reset, sqlite3_sql, sqlite3_step, sqlite3_stmt_explain, sqlite3_stmt_isexplain, SQLITE_DBCONFIG_TRIGGER_EQP, SQLITE_NOMEM, SQLITE_OK, SQLITE_ROW, and ShellState::statsOn.

Referenced by do_meta_command(), dump_callback(), main(), and runOneSqlLine().

Here is the call graph for this function:

Here is the caller graph for this function:

shell_out_of_memory()

void shell_out_of_memory ( void )

static

                                     {
  eputz("Error: out of memory\n");
  exit(1);
}

References eputz.

Referenced by do_meta_command(), exec_prepared_stmt(), and shell_check_oom().

Here is the caller graph for this function:

shell_strcpy()

void shell_strcpy ( char * dest, const char * src )

static

                                                     {
  while( (*(dest++) = *(src++))!=0 ){}
}

Referenced by dynamicContinuePrompt().

Here is the caller graph for this function:

shell_strncpy()

char * shell_strncpy ( char * dest, const char * src, size_t n )

static

                                                                 {
  size_t i;
  for(i=0; i<n-1 && src[i]!=0; i++) dest[i] = src[i];
  dest[i] = 0;
  return dest;
}

Referenced by do_meta_command(), and dynamicContinuePrompt().

Here is the caller graph for this function:

shellAddSchemaName()

void shellAddSchemaName ( sqlite3_context * pCtx, int nVal, sqlite3_value ** apVal )

static

 {
  static const char *aPrefix[] = {
     "TABLE",
     "INDEX",
     "UNIQUE INDEX",
     "VIEW",
     "TRIGGER",
     "VIRTUAL TABLE"
  };
  int i = 0;
  const char *zIn = (const char*)sqlite3_value_text(apVal[0]);
  const char *zSchema = (const char*)sqlite3_value_text(apVal[1]);
  const char *zName = (const char*)sqlite3_value_text(apVal[2]);
  sqlite3 *db = sqlite3_context_db_handle(pCtx);
  UNUSED_PARAMETER(nVal);
  if( zIn!=0 && cli_strncmp(zIn, "CREATE ", 7)==0 ){
    for(i=0; i<ArraySize(aPrefix); i++){
      int n = strlen30(aPrefix[i]);
      if( cli_strncmp(zIn+7, aPrefix[i], n)==0 && zIn[n+7]==' ' ){
        char *z = 0;
        char *zFake = 0;
        if( zSchema ){
          char cQuote = quoteChar(zSchema);
          if( cQuote && sqlite3_stricmp(zSchema,"temp")!=0 ){
            z = sqlite3_mprintf("%.*s \"%w\".%s", n+7, zIn, zSchema, zIn+n+8);
          }else{
            z = sqlite3_mprintf("%.*s %s.%s", n+7, zIn, zSchema, zIn+n+8);
          }
        }
        if( zName
         && aPrefix[i][0]=='V'
         && (zFake = shellFakeSchema(db, zSchema, zName))!=0
        ){
          if( z==0 ){
            z = sqlite3_mprintf("%s\n/* %s */", zIn, zFake);
          }else{
            z = sqlite3_mprintf("%z\n/* %s */", z, zFake);
          }
          free(zFake);
        }
        if( z ){
          sqlite3_result_text(pCtx, z, -1, sqlite3_free);
          return;
        }
      }
    }
  }
  sqlite3_result_value(pCtx, apVal[0]);
}

References aPrefix, ArraySize, cli_strncmp(), quoteChar(), shellFakeSchema(), sqlite3_context_db_handle, sqlite3_free, sqlite3_mprintf, sqlite3_result_text, sqlite3_result_value, sqlite3_stricmp, sqlite3_value_text, strlen30(), and UNUSED_PARAMETER.

Referenced by open_db().

Here is the call graph for this function:

Here is the caller graph for this function:

shellAuth()

int shellAuth ( void * pClientData, int op, const char * zA1, const char * zA2, const char * zA3, const char * zA4 )

static

 {
  ShellState *p = (ShellState*)pClientData;
  static const char *azAction[] = { 0,
     "CREATE_INDEX",         "CREATE_TABLE",         "CREATE_TEMP_INDEX",
     "CREATE_TEMP_TABLE",    "CREATE_TEMP_TRIGGER",  "CREATE_TEMP_VIEW",
     "CREATE_TRIGGER",       "CREATE_VIEW",          "DELETE",
     "DROP_INDEX",           "DROP_TABLE",           "DROP_TEMP_INDEX",
     "DROP_TEMP_TABLE",      "DROP_TEMP_TRIGGER",    "DROP_TEMP_VIEW",
     "DROP_TRIGGER",         "DROP_VIEW",            "INSERT",
     "PRAGMA",               "READ",                 "SELECT",
     "TRANSACTION",          "UPDATE",               "ATTACH",
     "DETACH",               "ALTER_TABLE",          "REINDEX",
     "ANALYZE",              "CREATE_VTABLE",        "DROP_VTABLE",
     "FUNCTION",             "SAVEPOINT",            "RECURSIVE"
  };
  int i;
  const char *az[4];
  az[0] = zA1;
  az[1] = zA2;
  az[2] = zA3;
  az[3] = zA4;
  sqlite3_fprintf(p->out, "authorizer: %s", azAction[op]);
  for(i=0; i<4; i++){
    sqlite3_fputs(" ", p->out);
    if( az[i] ){
      output_c_string(p->out, az[i]);
    }else{
      sqlite3_fputs("NULL", p->out);
    }
  }
  sqlite3_fputs("\n", p->out);
  if( p->bSafeMode ) (void)safeModeAuth(pClientData, op, zA1, zA2, zA3, zA4);

References ShellState::bSafeMode, ShellState::out, output_c_string(), safeModeAuth(), sqlite3_fprintf, sqlite3_fputs, and SQLITE_OK.

Referenced by do_meta_command().

Here is the call graph for this function:

Here is the caller graph for this function:

shellDatabaseError()

int shellDatabaseError ( sqlite3 * db )

static

                                          {
  shellEmitError(sqlite3_errmsg(db));

References shellEmitError(), and sqlite3_errmsg.

Referenced by do_meta_command().

Here is the call graph for this function:

Here is the caller graph for this function:

shellDeleteFile()

int shellDeleteFile

(

const char *

zFilename

)

                                          {
  int rc;
#ifdef _WIN32
  wchar_t *z = sqlite3_win32_utf8_to_unicode(zFilename);
  rc = _wunlink(z);
  sqlite3_free(z);
#else
  rc = unlink(zFilename);
#endif

References sqlite3_free.

Referenced by clearTempFile(), and do_meta_command().

Here is the caller graph for this function:

shellDtostr()

void shellDtostr ( sqlite3_context * pCtx, int nVal, sqlite3_value ** apVal )

static

 {
  double r = sqlite3_value_double(apVal[0]);
  int n = nVal>=2 ? sqlite3_value_int(apVal[1]) : 26;
  char z[400];
  if( n<1 ) n = 1;
  if( n>350 ) n = 350;
  sqlite3_snprintf(sizeof(z), z, "%#+.*e", n, r);
  sqlite3_result_text(pCtx, z, -1, SQLITE_TRANSIENT);
}

References sqlite3_result_text, sqlite3_snprintf, sqlite3_value_double, sqlite3_value_int, and SQLITE_TRANSIENT.

Referenced by open_db().

Here is the caller graph for this function:

shellEmitError()

void shellEmitError ( const char * zErr )

static

                                            {

References sqlite3_fprintf.

Referenced by do_meta_command(), main(), and shellDatabaseError().

Here is the caller graph for this function:

shellFakeSchema()

char * shellFakeSchema ( sqlite3 * db, const char * zSchema, const char * zName )

static

 {
  sqlite3_stmt *pStmt = 0;
  char *zSql;
  ShellText s;
  char cQuote;
  char *zDiv = "(";
  int nRow = 0;
 
  zSql = sqlite3_mprintf("PRAGMA \"%w\".table_info=%Q;",
                         zSchema ? zSchema : "main", zName);
  shell_check_oom(zSql);
  sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
  sqlite3_free(zSql);
  initText(&s);
  if( zSchema ){
    cQuote = quoteChar(zSchema);
    if( cQuote && sqlite3_stricmp(zSchema,"temp")==0 ) cQuote = 0;
    appendText(&s, zSchema, cQuote);
    appendText(&s, ".", 0);
  }
  cQuote = quoteChar(zName);
  appendText(&s, zName, cQuote);
  while( sqlite3_step(pStmt)==SQLITE_ROW ){
    const char *zCol = (const char*)sqlite3_column_text(pStmt, 1);
    nRow++;
    appendText(&s, zDiv, 0);
    zDiv = ",";
    if( zCol==0 ) zCol = "";
    cQuote = quoteChar(zCol);
    appendText(&s, zCol, cQuote);
  }
  appendText(&s, ")", 0);
  sqlite3_finalize(pStmt);
  if( nRow==0 ){
    freeText(&s);
    s.z = 0;
  }
  return s.z;
}

References appendText(), freeText(), initText(), quoteChar(), shell_check_oom(), sqlite3_column_text, sqlite3_finalize, sqlite3_free, sqlite3_mprintf, sqlite3_prepare_v2, sqlite3_step, sqlite3_stricmp, SQLITE_ROW, and ShellText::z.

Referenced by shellAddSchemaName(), and shellModuleSchema().

Here is the call graph for this function:

Here is the caller graph for this function:

shellFinalize()

void shellFinalize ( int * pRc, sqlite3_stmt * pStmt )

static

 {
  if( pStmt ){
    sqlite3 *db = sqlite3_db_handle(pStmt);
    int rc = sqlite3_finalize(pStmt);
    if( *pRc==SQLITE_OK ){
      if( rc!=SQLITE_OK ){
        sqlite3_fprintf(stderr,"SQL error: %s\n", sqlite3_errmsg(db));
      }
      *pRc = rc;
    }

References sqlite3_db_handle, sqlite3_errmsg, sqlite3_finalize, sqlite3_fprintf, and SQLITE_OK.

Referenced by doAutoDetectRestore(), and outputDumpWarning().

Here is the caller graph for this function:

shellFkeyCollateClause()

void shellFkeyCollateClause ( sqlite3_context * pCtx, int nVal, sqlite3_value ** apVal )

static

 {
  sqlite3 *db = sqlite3_context_db_handle(pCtx);
  const char *zParent;
  const char *zParentCol;
  const char *zParentSeq;
  const char *zChild;
  const char *zChildCol;
  const char *zChildSeq = 0;  /* Initialize to avoid false-positive warning */
  int rc;
 
  assert( nVal==4 );
  zParent = (const char*)sqlite3_value_text(apVal[0]);
  zParentCol = (const char*)sqlite3_value_text(apVal[1]);
  zChild = (const char*)sqlite3_value_text(apVal[2]);
  zChildCol = (const char*)sqlite3_value_text(apVal[3]);
 
  sqlite3_result_text(pCtx, "", -1, SQLITE_STATIC);
  rc = sqlite3_table_column_metadata(
      db, "main", zParent, zParentCol, 0, &zParentSeq, 0, 0, 0
  );
  if( rc==SQLITE_OK ){
    rc = sqlite3_table_column_metadata(
        db, "main", zChild, zChildCol, 0, &zChildSeq, 0, 0, 0
    );
  }
 
  if( rc==SQLITE_OK && sqlite3_stricmp(zParentSeq, zChildSeq) ){
    char *z = sqlite3_mprintf(" COLLATE %s", zParentSeq);
    sqlite3_result_text(pCtx, z, -1, SQLITE_TRANSIENT);
    sqlite3_free(z);

References sqlite3_context_db_handle, sqlite3_free, sqlite3_mprintf, sqlite3_result_text, sqlite3_stricmp, sqlite3_table_column_metadata, sqlite3_value_text, SQLITE_OK, SQLITE_STATIC, and SQLITE_TRANSIENT.

Referenced by lintFkeyIndexes().

Here is the caller graph for this function:

shellLog()

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

static

                                                                {
  ShellState *p = (ShellState*)pArg;
  if( p->pLog==0 ) return;
  sqlite3_fprintf(p->pLog, "(%d) %s\n", iErrCode, zMsg);

References ShellState::pLog, and sqlite3_fprintf.

Referenced by main_init().

Here is the caller graph for this function:

shellModuleSchema()

void shellModuleSchema ( sqlite3_context * pCtx, int nVal, sqlite3_value ** apVal )

static

 {
  const char *zName;
  char *zFake;
  ShellState *p = (ShellState*)sqlite3_user_data(pCtx);
  FILE *pSavedLog = p->pLog;
  UNUSED_PARAMETER(nVal);
  zName = (const char*)sqlite3_value_text(apVal[0]);
 
  /* Temporarily disable the ".log" when calling shellFakeSchema() because
  ** shellFakeSchema() might generate failures for some ephemeral virtual
  ** tables due to missing arguments.  Example: fts4aux.
  ** https://sqlite.org/forum/forumpost/42fe6520b803be51 */
  p->pLog = 0;
  zFake = zName? shellFakeSchema(sqlite3_context_db_handle(pCtx), 0, zName) : 0;
  p->pLog = pSavedLog;
 
  if( zFake ){
    sqlite3_result_text(pCtx, sqlite3_mprintf("/* %s */", zFake),
                        -1, sqlite3_free);
    free(zFake);

References ShellState::pLog, shellFakeSchema(), sqlite3_context_db_handle, sqlite3_free, sqlite3_mprintf, sqlite3_result_text, sqlite3_user_data, sqlite3_value_text, and UNUSED_PARAMETER.

Referenced by open_db().

Here is the call graph for this function:

Here is the caller graph for this function:

shellPrepare()

void shellPrepare ( sqlite3 * db, int * pRc, const char * zSql, sqlite3_stmt ** ppStmt )

static

 {
  *ppStmt = 0;
  if( *pRc==SQLITE_OK ){
    int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0);
    if( rc!=SQLITE_OK ){
      sqlite3_fprintf(stderr,
         "sql error: %s (%d)\n", sqlite3_errmsg(db), sqlite3_errcode(db));
      *pRc = rc;
    }

Referenced by doAutoDetectRestore(), and shellPreparePrintf().

Here is the caller graph for this function:

shellPreparePrintf()

void shellPreparePrintf ( sqlite3 * db, int * pRc, sqlite3_stmt ** ppStmt, const char * zFmt, ... )

static

 {
  *ppStmt = 0;
  if( *pRc==SQLITE_OK ){
    va_list ap;
    char *z;
    va_start(ap, zFmt);
    z = sqlite3_vmprintf(zFmt, ap);
    va_end(ap);
    if( z==0 ){
      *pRc = SQLITE_NOMEM;
    }else{
      shellPrepare(db, pRc, z, ppStmt);
      sqlite3_free(z);
    }

References shellPrepare(), sqlite3_free, sqlite3_vmprintf, SQLITE_NOMEM, and SQLITE_OK.

Referenced by outputDumpWarning().

Here is the call graph for this function:

Here is the caller graph for this function:

shellPutsFunc()

void shellPutsFunc ( sqlite3_context * pCtx, int nVal, sqlite3_value ** apVal )

static

 {
  ShellState *p = (ShellState*)sqlite3_user_data(pCtx);
  (void)nVal;
  sqlite3_fprintf(p->out, "%s\n", sqlite3_value_text(apVal[0]));

References ShellState::out, sqlite3_fprintf, sqlite3_result_value, sqlite3_user_data, and sqlite3_value_text.

Referenced by open_db().

Here is the caller graph for this function:

shellReset()

void shellReset	(	int *	pRc,
		sqlite3_stmt *	pStmt )

 {
  int rc = sqlite3_reset(pStmt);
  if( *pRc==SQLITE_OK ){
    if( rc!=SQLITE_OK ){
      sqlite3 *db = sqlite3_db_handle(pStmt);
      sqlite3_fprintf(stderr,"SQL error: %s\n", sqlite3_errmsg(db));
    }
    *pRc = rc;

References sqlite3_db_handle, sqlite3_errmsg, sqlite3_fprintf, sqlite3_reset, and SQLITE_OK.

shellStrtod()

void shellStrtod ( sqlite3_context * pCtx, int nVal, sqlite3_value ** apVal )

static

 {
  char *z = (char*)sqlite3_value_text(apVal[0]);
  UNUSED_PARAMETER(nVal);
  if( z==0 ) return;
  sqlite3_result_double(pCtx, strtod(z,0));
}

References sqlite3_result_double, sqlite3_value_text, and UNUSED_PARAMETER.

Referenced by open_db().

Here is the caller graph for this function:

shellUSleepFunc()

void shellUSleepFunc ( sqlite3_context * context, int argcUnused, sqlite3_value ** argv )

static

 {
  int sleep = sqlite3_value_int(argv[0]);
  (void)argcUnused;
  sqlite3_sleep(sleep/1000);

References sqlite3_result_int, sqlite3_sleep, and sqlite3_value_int.

Referenced by open_db().

Here is the caller graph for this function:

showHelp()

int showHelp ( FILE * out, const char * zPattern )

static

                                                    {
  int i = 0;
  int j = 0;
  int n = 0;
  char *zPat;
  if( zPattern==0 ){
    /* Show just the first line for all help topics */
    zPattern = "[a-z]";
  }else if( cli_strcmp(zPattern,"-a")==0
         || cli_strcmp(zPattern,"-all")==0
         || cli_strcmp(zPattern,"--all")==0
  ){
    /* Show everything except undocumented commands */
    zPattern = ".";
  }else if( cli_strcmp(zPattern,"0")==0 ){
    /* Show complete help text of undocumented commands */
    int show = 0;
    for(i=0; i<ArraySize(azHelp); i++){
      if( azHelp[i][0]=='.' ){
        show = 0;
      }else if( azHelp[i][0]==',' ){
        show = 1;
        sqlite3_fprintf(out, ".%s\n", &azHelp[i][1]);
        n++;
      }else if( show ){
        sqlite3_fprintf(out, "%s\n", azHelp[i]);
      }
    }
    return n;
  }
 
  /* Seek documented commands for which zPattern is an exact prefix */
  zPat = sqlite3_mprintf(".%s*", zPattern);
  shell_check_oom(zPat);
  for(i=0; i<ArraySize(azHelp); i++){
    if( sqlite3_strglob(zPat, azHelp[i])==0 ){
      sqlite3_fprintf(out, "%s\n", azHelp[i]);
      j = i+1;
      n++;
    }
  }
  sqlite3_free(zPat);
  if( n ){
    if( n==1 ){
      /* when zPattern is a prefix of exactly one command, then include
      ** the details of that command, which should begin at offset j */
      while( j<ArraySize(azHelp)-1 && azHelp[j][0]==' ' ){
        sqlite3_fprintf(out, "%s\n", azHelp[j]);
        j++;
      }
    }
    return n;
  }
 
  /* Look for documented commands that contain zPattern anywhere.
  ** Show complete text of all documented commands that match. */
  zPat = sqlite3_mprintf("%%%s%%", zPattern);
  shell_check_oom(zPat);
  for(i=0; i<ArraySize(azHelp); i++){
    if( azHelp[i][0]==',' ){
      while( i<ArraySize(azHelp)-1 && azHelp[i+1][0]==' ' ) ++i;
      continue;
    }
    if( azHelp[i][0]=='.' ) j = i;
    if( sqlite3_strlike(zPat, azHelp[i], 0)==0 ){
      sqlite3_fprintf(out, "%s\n", azHelp[j]);
      while( j<ArraySize(azHelp)-1 && azHelp[j+1][0]==' ' ){
        j++;
        sqlite3_fprintf(out, "%s\n", azHelp[j]);
      }
      i = j;
      n++;
    }
  }
  sqlite3_free(zPat);

References ArraySize, azHelp, cli_strcmp(), shell_check_oom(), sqlite3_fprintf, sqlite3_free, sqlite3_mprintf, sqlite3_strglob, and sqlite3_strlike.

Referenced by do_meta_command().

Here is the call graph for this function:

Here is the caller graph for this function:

skipNonB64()

char * skipNonB64 ( char * s, int nc )

static

                                           {
  char c;
  while( nc-- > 0 && (c = *s) && !IS_BX_DIGIT(BX_DV_PROTO(c)) ) ++s;
  return s;
}

References BX_DV_PROTO, c, and IS_BX_DIGIT.

Referenced by fromBase64().

Here is the caller graph for this function:

skipNonB85()

char * skipNonB85 ( char * s, int nc )

static

                                           {
  char c;
  while( nc-- > 0 && (c = *s) && !IS_B85(c) ) ++s;
  return s;
}

References c, and IS_B85.

Referenced by fromBase85().

Here is the caller graph for this function:

sql_trace_callback()

int sql_trace_callback ( unsigned mType, void * pArg, void * pP, void * pX )

static

 {
  ShellState *p = (ShellState*)pArg;
  sqlite3_stmt *pStmt;
  const char *zSql;
  i64 nSql;
  if( p->traceOut==0 ) return 0;
  if( mType==SQLITE_TRACE_CLOSE ){
    sputz(p->traceOut, "-- closing database connection\n");
    return 0;
  }
  if( mType!=SQLITE_TRACE_ROW && pX!=0 && ((const char*)pX)[0]=='-' ){
    zSql = (const char*)pX;
  }else{
    pStmt = (sqlite3_stmt*)pP;
    switch( p->eTraceType ){
      case SHELL_TRACE_EXPANDED: {
        zSql = sqlite3_expanded_sql(pStmt);
        break;
      }
#ifdef SQLITE_ENABLE_NORMALIZE
      case SHELL_TRACE_NORMALIZED: {
        zSql = sqlite3_normalized_sql(pStmt);
        break;
      }
#endif
      default: {
        zSql = sqlite3_sql(pStmt);
        break;
      }
    }
  }
  if( zSql==0 ) return 0;
  nSql = strlen(zSql);
  if( nSql>1000000000 ) nSql = 1000000000;
  while( nSql>0 && zSql[nSql-1]==';' ){ nSql--; }
  switch( mType ){
    case SQLITE_TRACE_ROW:
    case SQLITE_TRACE_STMT: {
      sqlite3_fprintf(p->traceOut, "%.*s;\n", (int)nSql, zSql);
      break;
    }
    case SQLITE_TRACE_PROFILE: {
      sqlite3_int64 nNanosec = pX ? *(sqlite3_int64*)pX : 0;
      sqlite3_fprintf(p->traceOut,
                      "%.*s; -- %lld ns\n", (int)nSql, zSql, nNanosec);
      break;
    }
  }

References ShellState::eTraceType, SHELL_TRACE_EXPANDED, SHELL_TRACE_NORMALIZED, sputz, sqlite3_expanded_sql, sqlite3_fprintf, sqlite3_normalized_sql, sqlite3_sql, SQLITE_TRACE_CLOSE, SQLITE_TRACE_PROFILE, SQLITE_TRACE_ROW, SQLITE_TRACE_STMT, and ShellState::traceOut.

Referenced by do_meta_command().

Here is the caller graph for this function:

sqlite3_appendvfs_init()

int sqlite3_appendvfs_init	(	sqlite3 *	db,
		char **	pzErrMsg,
		const sqlite3_api_routines *	pApi )

 {
  int rc = SQLITE_OK;
  sqlite3_vfs *pOrig;
  SQLITE_EXTENSION_INIT2(pApi);
  (void)pzErrMsg;
  (void)db;
  pOrig = sqlite3_vfs_find(0);
  if( pOrig==0 ) return SQLITE_ERROR;
  apnd_vfs.iVersion = pOrig->iVersion;
  apnd_vfs.pAppData = pOrig;
  apnd_vfs.szOsFile = pOrig->szOsFile + sizeof(ApndFile);
  rc = sqlite3_vfs_register(&apnd_vfs, 0);
#ifdef APPENDVFS_TEST
  if( rc==SQLITE_OK ){
    rc = sqlite3_auto_extension((void(*)(void))apndvfsRegister);
  }
#endif
  if( rc==SQLITE_OK ) rc = SQLITE_OK_LOAD_PERMANENTLY;
  return rc;
}

References apnd_vfs, sqlite3_vfs::iVersion, sqlite3_auto_extension, sqlite3_vfs_find, sqlite3_vfs_register, SQLITE_ERROR, SQLITE_EXTENSION_INIT2, SQLITE_OK, SQLITE_OK_LOAD_PERMANENTLY, and sqlite3_vfs::szOsFile.

Referenced by main().

Here is the caller graph for this function:

sqlite3_base64_init()

int sqlite3_base64_init	(	sqlite3 *	db,
		char **	pzErr,
		const sqlite3_api_routines *	pApi )

                                                             {
  SQLITE_EXTENSION_INIT2(pApi);
  (void)pzErr;
  return sqlite3_create_function
    (db, "base64", 1,
     SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS|SQLITE_DIRECTONLY|SQLITE_UTF8,
     0, base64, 0, 0);
}

References base64(), sqlite3_base64_init(), sqlite3_base_init, sqlite3_create_function, SQLITE_DETERMINISTIC, SQLITE_DIRECTONLY, SQLITE_EXTENSION_INIT2, SQLITE_INNOCUOUS, and SQLITE_UTF8.

Referenced by open_db(), and sqlite3_base64_init().

Here is the call graph for this function:

Here is the caller graph for this function:

sqlite3_base85_init()

int sqlite3_base85_init	(	sqlite3 *	db,
		char **	pzErr,
		const sqlite3_api_routines *	pApi )

                                                             {
  SQLITE_EXTENSION_INIT2(pApi);
  (void)pzErr;
# ifndef OMIT_BASE85_CHECKER
  {
    int rc = sqlite3_create_function
      (db, "is_base85", 1,
       SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS|SQLITE_UTF8,
       0, is_base85, 0, 0);
    if( rc!=SQLITE_OK ) return rc;
  }
# endif
  return sqlite3_create_function
    (db, "base85", 1,
     SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS|SQLITE_DIRECTONLY|SQLITE_UTF8,
     0, base85, 0, 0);
}

References base85(), sqlite3_base85_init(), sqlite3_base_init, sqlite3_create_function, SQLITE_DETERMINISTIC, SQLITE_DIRECTONLY, SQLITE_EXTENSION_INIT2, SQLITE_INNOCUOUS, SQLITE_OK, and SQLITE_UTF8.

Referenced by open_db(), and sqlite3_base85_init().

Here is the call graph for this function:

Here is the caller graph for this function:

sqlite3_completion_init()

int sqlite3_completion_init	(	sqlite3 *	db,
		char **	pzErrMsg,
		const sqlite3_api_routines *	pApi )

 {
  int rc = SQLITE_OK;
  SQLITE_EXTENSION_INIT2(pApi);
  (void)(pzErrMsg);  /* Unused parameter */
#ifndef SQLITE_OMIT_VIRTUALTABLE
  rc = sqlite3CompletionVtabInit(db);
#endif
  return rc;
}

References sqlite3CompletionVtabInit(), SQLITE_EXTENSION_INIT2, and SQLITE_OK.

Referenced by open_db().

Here is the call graph for this function:

Here is the caller graph for this function:

sqlite3_decimal_init()

int sqlite3_decimal_init	(	sqlite3 *	db,
		char **	pzErrMsg,
		const sqlite3_api_routines *	pApi )

 {
  int rc = SQLITE_OK;
  static const struct {
    const char *zFuncName;
    int nArg;
    int iArg;
    void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
  } aFunc[] = {
    { "decimal",       1, 0,  decimalFunc        },
    { "decimal_exp",   1, 1,  decimalFunc        },
    { "decimal_cmp",   2, 0,  decimalCmpFunc     },
    { "decimal_add",   2, 0,  decimalAddFunc     },
    { "decimal_sub",   2, 0,  decimalSubFunc     },
    { "decimal_mul",   2, 0,  decimalMulFunc     },
    { "decimal_pow2",  1, 0,  decimalPow2Func    },
  };
  unsigned int i;
  (void)pzErrMsg;  /* Unused parameter */
 
  SQLITE_EXTENSION_INIT2(pApi);
 
  for(i=0; i<(int)(sizeof(aFunc)/sizeof(aFunc[0])) && rc==SQLITE_OK; i++){
    rc = sqlite3_create_function(db, aFunc[i].zFuncName, aFunc[i].nArg,
                   SQLITE_UTF8|SQLITE_INNOCUOUS|SQLITE_DETERMINISTIC,
                   aFunc[i].iArg ? db : 0, aFunc[i].xFunc, 0, 0);
  }
  if( rc==SQLITE_OK ){
    rc = sqlite3_create_window_function(db, "decimal_sum", 1,
                   SQLITE_UTF8|SQLITE_INNOCUOUS|SQLITE_DETERMINISTIC, 0,
                   decimalSumStep, decimalSumFinalize,
                   decimalSumValue, decimalSumInverse, 0);
  }
  if( rc==SQLITE_OK ){
    rc = sqlite3_create_collation(db, "decimal", SQLITE_UTF8,
                                  0, decimalCollFunc);
  }
  return rc;
}

References decimalAddFunc(), decimalCmpFunc(), decimalCollFunc(), decimalFunc(), decimalMulFunc(), decimalPow2Func(), decimalSubFunc(), decimalSumFinalize(), decimalSumInverse(), decimalSumStep(), decimalSumValue(), sqlite3_create_collation, sqlite3_create_function, sqlite3_create_window_function, SQLITE_DETERMINISTIC, SQLITE_EXTENSION_INIT2, SQLITE_INNOCUOUS, SQLITE_OK, and SQLITE_UTF8.

Referenced by open_db().

Here is the call graph for this function:

Here is the caller graph for this function:

sqlite3_expert_analyze()

int sqlite3_expert_analyze	(	sqlite3expert *	p,
		char **	pzErr )

                                                          {
  int rc;
  IdxHashEntry *pEntry;
 
  /* Do trigger processing to collect any extra IdxScan structures */
  rc = idxProcessTriggers(p, pzErr);
 
  /* Create candidate indexes within the in-memory database file */
  if( rc==SQLITE_OK ){
    rc = idxCreateCandidates(p);
  }else if ( rc==SQLITE_BUSY_TIMEOUT ){
    if( pzErr )
      *pzErr = sqlite3_mprintf("Cannot find a unique index name to propose.");
    return rc;
  }
 
  /* Generate the stat1 data */
  if( rc==SQLITE_OK ){
    rc = idxPopulateStat1(p, pzErr);
  }
 
  /* Formulate the EXPERT_REPORT_CANDIDATES text */
  for(pEntry=p->hIdx.pFirst; pEntry; pEntry=pEntry->pNext){
    p->zCandidates = idxAppendText(&rc, p->zCandidates, 
        "%s;%s%s\n", pEntry->zVal, 
        pEntry->zVal2 ? " -- stat1: " : "", pEntry->zVal2
    );
  }
 
  /* Figure out which of the candidate indexes are preferred by the query
  ** planner and report the results to the user.  */
  if( rc==SQLITE_OK ){
    rc = idxFindIndexes(p, pzErr);
  }
 
  if( rc==SQLITE_OK ){
    p->bRun = 1;
  }
  return rc;
}

References sqlite3expert::bRun, sqlite3expert::hIdx, idxAppendText(), idxCreateCandidates(), idxFindIndexes(), idxPopulateStat1(), idxProcessTriggers(), IdxHash::pFirst, IdxHashEntry::pNext, sqlite3_mprintf, SQLITE_BUSY_TIMEOUT, SQLITE_OK, sqlite3expert::zCandidates, IdxHashEntry::zVal, and IdxHashEntry::zVal2.

Referenced by expertFinish().

Here is the call graph for this function:

Here is the caller graph for this function:

sqlite3_expert_config()

int sqlite3_expert_config	(	sqlite3expert *	p,
		int	op,
			... )

                                                        {
  int rc = SQLITE_OK;
  va_list ap;
  va_start(ap, op);
  switch( op ){
    case EXPERT_CONFIG_SAMPLE: {
      int iVal = va_arg(ap, int);
      if( iVal<0 ) iVal = 0;
      if( iVal>100 ) iVal = 100;
      p->iSample = iVal;
      break;
    }
    default:
      rc = SQLITE_NOTFOUND;
      break;
  }
 
  va_end(ap);
  return rc;
}

References EXPERT_CONFIG_SAMPLE, sqlite3expert::iSample, SQLITE_NOTFOUND, and SQLITE_OK.

Referenced by expertDotCommand().

Here is the caller graph for this function:

sqlite3_expert_count()

int sqlite3_expert_count

(

sqlite3expert *

p

)

                                          {
  int nRet = 0;
  if( p->pStatement ) nRet = p->pStatement->iId+1;
  return nRet;
}

References IdxStatement::iId, and sqlite3expert::pStatement.

Referenced by expertFinish().

Here is the caller graph for this function:

sqlite3_expert_destroy()

void sqlite3_expert_destroy

(

sqlite3expert *

p

)

                                             {
  if( p ){
    sqlite3_close(p->dbm);
    sqlite3_close(p->dbv);
    idxScanFree(p->pScan, 0);
    idxStatementFree(p->pStatement, 0);
    idxTableFree(p->pTable);
    idxWriteFree(p->pWrite);
    idxHashClear(&p->hIdx);
    sqlite3_free(p->zCandidates);
    sqlite3_free(p);
  }
}

References sqlite3expert::dbm, sqlite3expert::dbv, sqlite3expert::hIdx, idxHashClear(), idxScanFree(), idxStatementFree(), idxTableFree(), idxWriteFree(), sqlite3expert::pScan, sqlite3expert::pStatement, sqlite3expert::pTable, sqlite3expert::pWrite, sqlite3_close, sqlite3_free, and sqlite3expert::zCandidates.

Referenced by expertFinish(), and sqlite3_expert_new().

Here is the call graph for this function:

Here is the caller graph for this function:

sqlite3_expert_new()

sqlite3expert * sqlite3_expert_new	(	sqlite3 *	db,
		char **	pzErr )

                                                               {
  int rc = SQLITE_OK;
  sqlite3expert *pNew;
 
  pNew = (sqlite3expert*)idxMalloc(&rc, sizeof(sqlite3expert));
 
  /* Open two in-memory databases to work with. The "vtab database" (dbv)
  ** will contain a virtual table corresponding to each real table in
  ** the user database schema, and a copy of each view. It is used to
  ** collect information regarding the WHERE, ORDER BY and other clauses
  ** of the user's query.
  */
  if( rc==SQLITE_OK ){
    pNew->db = db;
    pNew->iSample = 100;
    rc = sqlite3_open(":memory:", &pNew->dbv);
  }
  if( rc==SQLITE_OK ){
    rc = sqlite3_open(":memory:", &pNew->dbm);
    if( rc==SQLITE_OK ){
      sqlite3_db_config(pNew->dbm, SQLITE_DBCONFIG_TRIGGER_EQP, 1, (int*)0);
    }
  }
 
  /* Allow custom collations to be dealt with through prepare. */
  if( rc==SQLITE_OK ) rc = sqlite3_collation_needed(pNew->dbm,0,useDummyCS);
  if( rc==SQLITE_OK ) rc = sqlite3_collation_needed(pNew->dbv,0,useDummyCS);
 
#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) \
  && !defined(SQLITE_OMIT_INTROSPECTION_PRAGMAS)
  /* Register UDFs from database [db] with [dbm] and [dbv]. */
  if( rc==SQLITE_OK ){
    rc = registerUDFs(pNew->db, pNew->dbm);
  }
  if( rc==SQLITE_OK ){
    rc = registerUDFs(pNew->db, pNew->dbv);
  }
#endif
 
  /* Copy the entire schema of database [db] into [dbm]. */
  if( rc==SQLITE_OK ){
    sqlite3_stmt *pSql = 0;
    rc = idxPrintfPrepareStmt(pNew->db, &pSql, pzErrmsg, 
        "SELECT sql, name, substr(sql,1,14)=='create virtual' COLLATE nocase"
        " FROM sqlite_schema WHERE substr(name,1,7)!='sqlite_' COLLATE nocase"
        " ORDER BY 3 DESC, rowid"
    );
    while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){
      const char *zSql = (const char*)sqlite3_column_text(pSql, 0);
      const char *zName = (const char*)sqlite3_column_text(pSql, 1);
      int bExists = 0;
      rc = expertDbContainsObject(pNew->dbm, zName, &bExists);
      if( rc==SQLITE_OK && zSql && bExists==0 ){
        rc = expertSchemaSql(pNew->dbm, zSql, pzErrmsg);
      }
    }
    idxFinalize(&rc, pSql);
  }
 
  /* Create the vtab schema */
  if( rc==SQLITE_OK ){
    rc = idxCreateVtabSchema(pNew, pzErrmsg);
  }
 
  /* Register the auth callback with dbv */
  if( rc==SQLITE_OK ){
    sqlite3_set_authorizer(pNew->dbv, idxAuthCallback, (void*)pNew);
  }
 
  /* If an error has occurred, free the new object and return NULL. Otherwise,
  ** return the new sqlite3expert handle.  */
  if( rc!=SQLITE_OK ){
    sqlite3_expert_destroy(pNew);
    pNew = 0;
  }
  return pNew;
}

References sqlite3expert::db, sqlite3expert::dbm, sqlite3expert::dbv, expertDbContainsObject(), expertSchemaSql(), idxAuthCallback(), idxCreateVtabSchema(), idxFinalize(), idxMalloc(), idxPrintfPrepareStmt(), sqlite3expert::iSample, registerUDFs(), sqlite3_collation_needed, sqlite3_column_text, sqlite3_db_config, sqlite3_expert_destroy(), sqlite3_open, sqlite3_set_authorizer, sqlite3_step, SQLITE_DBCONFIG_TRIGGER_EQP, SQLITE_OK, SQLITE_ROW, and useDummyCS().

Referenced by expertDotCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

sqlite3_expert_report()

const char * sqlite3_expert_report	(	sqlite3expert *	p,
		int	iStmt,
		int	eReport )

                                                                           {
  const char *zRet = 0;
  IdxStatement *pStmt;
 
  if( p->bRun==0 ) return 0;
  for(pStmt=p->pStatement; pStmt && pStmt->iId!=iStmt; pStmt=pStmt->pNext);
  switch( eReport ){
    case EXPERT_REPORT_SQL:
      if( pStmt ) zRet = pStmt->zSql;
      break;
    case EXPERT_REPORT_INDEXES:
      if( pStmt ) zRet = pStmt->zIdx;
      break;
    case EXPERT_REPORT_PLAN:
      if( pStmt ) zRet = pStmt->zEQP;
      break;
    case EXPERT_REPORT_CANDIDATES:
      zRet = p->zCandidates;
      break;
  }
  return zRet;
}

References sqlite3expert::bRun, EXPERT_REPORT_CANDIDATES, EXPERT_REPORT_INDEXES, EXPERT_REPORT_PLAN, EXPERT_REPORT_SQL, IdxStatement::iId, IdxStatement::pNext, sqlite3expert::pStatement, sqlite3expert::zCandidates, IdxStatement::zEQP, IdxStatement::zIdx, and IdxStatement::zSql.

Referenced by expertFinish().

Here is the caller graph for this function:

sqlite3_expert_sql()

int sqlite3_expert_sql	(	sqlite3expert *	p,
		const char *	zSql,
		char **	pzErr )

 {
  IdxScan *pScanOrig = p->pScan;
  IdxStatement *pStmtOrig = p->pStatement;
  int rc = SQLITE_OK;
  const char *zStmt = zSql;
 
  if( p->bRun ) return SQLITE_MISUSE;
 
  while( rc==SQLITE_OK && zStmt && zStmt[0] ){
    sqlite3_stmt *pStmt = 0;
    /* Ensure that the provided statement compiles against user's DB. */
    rc = idxPrepareStmt(p->db, &pStmt, pzErr, zStmt);
    if( rc!=SQLITE_OK ) break;
    sqlite3_finalize(pStmt);
    rc = sqlite3_prepare_v2(p->dbv, zStmt, -1, &pStmt, &zStmt);
    if( rc==SQLITE_OK ){
      if( pStmt ){
        IdxStatement *pNew;
        const char *z = sqlite3_sql(pStmt);
        int n = STRLEN(z);
        pNew = (IdxStatement*)idxMalloc(&rc, sizeof(IdxStatement) + n+1);
        if( rc==SQLITE_OK ){
          pNew->zSql = (char*)&pNew[1];
          memcpy(pNew->zSql, z, n+1);
          pNew->pNext = p->pStatement;
          if( p->pStatement ) pNew->iId = p->pStatement->iId+1;
          p->pStatement = pNew;
        }
        sqlite3_finalize(pStmt);
      }
    }else{
      idxDatabaseError(p->dbv, pzErr);
    }
  }
 
  if( rc!=SQLITE_OK ){
    idxScanFree(p->pScan, pScanOrig);
    idxStatementFree(p->pStatement, pStmtOrig);
    p->pScan = pScanOrig;
    p->pStatement = pStmtOrig;
  }
 
  return rc;
}

References sqlite3expert::bRun, sqlite3expert::db, sqlite3expert::dbv, idxDatabaseError(), idxMalloc(), idxPrepareStmt(), idxScanFree(), idxStatementFree(), IdxStatement::iId, IdxStatement::pNext, sqlite3expert::pScan, sqlite3expert::pStatement, sqlite3_finalize, sqlite3_prepare_v2, sqlite3_sql, SQLITE_MISUSE, SQLITE_OK, STRLEN, and IdxStatement::zSql.

Referenced by expertHandleSQL().

Here is the call graph for this function:

Here is the caller graph for this function:

sqlite3_fileio_init()

int sqlite3_fileio_init	(	sqlite3 *	db,
		char **	pzErrMsg,
		const sqlite3_api_routines *	pApi )

 {
  int rc = SQLITE_OK;
  SQLITE_EXTENSION_INIT2(pApi);
  (void)pzErrMsg;  /* Unused parameter */
  rc = sqlite3_create_function(db, "readfile", 1, 
                               SQLITE_UTF8|SQLITE_DIRECTONLY, 0,
                               readfileFunc, 0, 0);
  if( rc==SQLITE_OK ){
    rc = sqlite3_create_function(db, "writefile", -1,
                                 SQLITE_UTF8|SQLITE_DIRECTONLY, 0,
                                 writefileFunc, 0, 0);
  }
  if( rc==SQLITE_OK ){
    rc = sqlite3_create_function(db, "lsmode", 1, SQLITE_UTF8, 0,
                                 lsModeFunc, 0, 0);
  }
  if( rc==SQLITE_OK ){
    rc = fsdirRegister(db);
  }
  return rc;
}

References fsdirRegister(), lsModeFunc(), readfileFunc(), sqlite3_create_function, SQLITE_DIRECTONLY, SQLITE_EXTENSION_INIT2, SQLITE_OK, SQLITE_UTF8, and writefileFunc().

Referenced by open_db().

Here is the call graph for this function:

Here is the caller graph for this function:

sqlite3_ieee_init()

int sqlite3_ieee_init	(	sqlite3 *	db,
		char **	pzErrMsg,
		const sqlite3_api_routines *	pApi )

 {
  static const struct {
    char *zFName;
    int nArg;
    int iAux;
    void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
  } aFunc[] = {
    { "ieee754",           1,   0, ieee754func },
    { "ieee754",           2,   0, ieee754func },
    { "ieee754_mantissa",  1,   1, ieee754func },
    { "ieee754_exponent",  1,   2, ieee754func },
    { "ieee754_to_blob",   1,   0, ieee754func_to_blob },
    { "ieee754_from_blob", 1,   0, ieee754func_from_blob },
    { "ieee754_inc",       2,   0, ieee754inc  },
  };
  unsigned int i;
  int rc = SQLITE_OK;
  SQLITE_EXTENSION_INIT2(pApi);
  (void)pzErrMsg;  /* Unused parameter */
  for(i=0; i<sizeof(aFunc)/sizeof(aFunc[0]) && rc==SQLITE_OK; i++){
    rc = sqlite3_create_function(db, aFunc[i].zFName, aFunc[i].nArg,
                               SQLITE_UTF8|SQLITE_INNOCUOUS,
                               (void*)&aFunc[i].iAux,
                               aFunc[i].xFunc, 0, 0);
  }
  return rc;
}

References ieee754func(), ieee754func_from_blob(), ieee754func_to_blob(), ieee754inc(), sqlite3_create_function, SQLITE_EXTENSION_INIT2, SQLITE_INNOCUOUS, SQLITE_OK, and SQLITE_UTF8.

Referenced by open_db().

Here is the call graph for this function:

Here is the caller graph for this function:

sqlite3_intck_close()

void sqlite3_intck_close

(

sqlite3_intck *

pCk

)

                                          {
  if( p ){
    sqlite3_finalize(p->pCheck);
    sqlite3_create_function(
        p->db, "parse_create_index", 1, SQLITE_UTF8, 0, 0, 0, 0
    );
    sqlite3_free(p->zObj);
    sqlite3_free(p->zKey);
    sqlite3_free(p->zTestSql);
    sqlite3_free(p->zErr);
    sqlite3_free(p->zMessage);
    sqlite3_free(p);
  }
}

References sqlite3_intck::db, sqlite3_intck::pCheck, sqlite3_create_function, sqlite3_finalize, sqlite3_free, SQLITE_UTF8, sqlite3_intck::zErr, sqlite3_intck::zKey, sqlite3_intck::zMessage, sqlite3_intck::zObj, and sqlite3_intck::zTestSql.

Referenced by intckDatabaseCmd(), and sqlite3_intck_open().

Here is the caller graph for this function:

sqlite3_intck_error()

int sqlite3_intck_error	(	sqlite3_intck *	pCk,
		const char **	pzErr )

                                                             {
  if( pzErr ) *pzErr = p->zErr;
  return (p->rc==SQLITE_DONE ? SQLITE_OK : p->rc);
}

References sqlite3_intck::rc, SQLITE_DONE, SQLITE_OK, and sqlite3_intck::zErr.

Referenced by intckDatabaseCmd().

Here is the caller graph for this function:

sqlite3_intck_message()

const char * sqlite3_intck_message

(

sqlite3_intck *

pCk

)

                                                   {
  assert( p->pCheck==0 || p->zMessage==0 );
  if( p->zMessage ){
    return p->zMessage;
  }
  if( p->pCheck ){
    return (const char*)sqlite3_column_text(p->pCheck, 0);
  }
  return 0;
}

References sqlite3_intck::pCheck, sqlite3_column_text, and sqlite3_intck::zMessage.

Referenced by intckDatabaseCmd().

Here is the caller graph for this function:

sqlite3_intck_open()

int sqlite3_intck_open	(	sqlite3 *	db,
		const char *	zDb,
		sqlite3_intck **	ppOut )

 {
  sqlite3_intck *pNew = 0;
  int rc = SQLITE_OK;
  const char *zDb = zDbArg ? zDbArg : "main";
  int nDb = (int)strlen(zDb);
 
  pNew = (sqlite3_intck*)sqlite3_malloc(sizeof(*pNew) + nDb + 1);
  if( pNew==0 ){
    rc = SQLITE_NOMEM;
  }else{
    memset(pNew, 0, sizeof(*pNew));
    pNew->db = db;
    pNew->zDb = (const char*)&pNew[1];
    memcpy(&pNew[1], zDb, nDb+1);
    rc = sqlite3_create_function(db, "parse_create_index", 
        2, SQLITE_UTF8, 0, intckParseCreateIndexFunc, 0, 0
    );
    if( rc!=SQLITE_OK ){
      sqlite3_intck_close(pNew);
      pNew = 0;
    }
  }
 
  *ppOut = pNew;
  return rc;
}

References sqlite3_intck::db, intckParseCreateIndexFunc(), sqlite3_create_function, sqlite3_intck_close(), sqlite3_malloc, SQLITE_NOMEM, SQLITE_OK, SQLITE_UTF8, and sqlite3_intck::zDb.

Referenced by intckDatabaseCmd().

Here is the call graph for this function:

Here is the caller graph for this function:

sqlite3_intck_step()

int sqlite3_intck_step

(

sqlite3_intck *

pCk

)

                                        {
  if( p->rc==SQLITE_OK ){
 
    if( p->zMessage ){
      sqlite3_free(p->zMessage);
      p->zMessage = 0;
    }
 
    if( p->bCorruptSchema ){
      p->rc = SQLITE_DONE;
    }else
    if( p->pCheck==0 ){
      intckFindObject(p);
      if( p->rc==SQLITE_OK ){
        if( p->zObj ){
          char *zSql = 0;
          zSql = intckCheckObjectSql(p, p->zObj, p->zKey, &p->nKeyVal);
          p->pCheck = intckPrepare(p, zSql);
          sqlite3_free(zSql);
          sqlite3_free(p->zKey);
          p->zKey = 0;
        }else{
          p->rc = SQLITE_DONE;
        }
      }else if( p->rc==SQLITE_CORRUPT ){
        p->rc = SQLITE_OK;
        p->zMessage = intckMprintf(p, "%s",
            "corruption found while reading database schema"
        );
        p->bCorruptSchema = 1;
      }
    }
 
    if( p->pCheck ){
      assert( p->rc==SQLITE_OK );
      if( sqlite3_step(p->pCheck)==SQLITE_ROW ){
        /* Normal case, do nothing. */
      }else{
        intckFinalize(p, p->pCheck);
        p->pCheck = 0;
        p->nKeyVal = 0;
        if( p->rc==SQLITE_CORRUPT ){
          p->rc = SQLITE_OK;
          p->zMessage = intckMprintf(p, 
              "corruption found while scanning database object %s", p->zObj
          );
        }
      }
    }
  }
 
  return p->rc;
}

References sqlite3_intck::bCorruptSchema, intckCheckObjectSql(), intckFinalize(), intckFindObject(), intckMprintf(), intckPrepare(), sqlite3_intck::nKeyVal, sqlite3_intck::pCheck, sqlite3_intck::rc, sqlite3_free, sqlite3_step, SQLITE_CORRUPT, SQLITE_DONE, SQLITE_OK, SQLITE_ROW, sqlite3_intck::zKey, sqlite3_intck::zMessage, and sqlite3_intck::zObj.

Referenced by intckDatabaseCmd().

Here is the call graph for this function:

Here is the caller graph for this function:

sqlite3_intck_test_sql()

const char * sqlite3_intck_test_sql	(	sqlite3_intck *	pCk,
		const char *	zObj )

                                                                      {
  sqlite3_free(p->zTestSql);
  if( zObj ){
    p->zTestSql = intckCheckObjectSql(p, zObj, 0, 0);
  }else{
    if( p->zObj ){
      p->zTestSql = intckCheckObjectSql(p, p->zObj, p->zKey, 0);
    }else{
      sqlite3_free(p->zTestSql);
      p->zTestSql = 0;
    }
  }
  return p->zTestSql;
}

References intckCheckObjectSql(), sqlite3_free, sqlite3_intck::zKey, sqlite3_intck::zObj, and sqlite3_intck::zTestSql.

Here is the call graph for this function:

sqlite3_intck_unlock()

int sqlite3_intck_unlock

(

sqlite3_intck *

pCk

)

                                          {
  if( p->rc==SQLITE_OK && p->pCheck ){
    assert( p->zKey==0 && p->nKeyVal>0 );
    intckSaveKey(p);
    intckFinalize(p, p->pCheck);
    p->pCheck = 0;
  }
  return p->rc;
}

References intckFinalize(), intckSaveKey(), sqlite3_intck::nKeyVal, sqlite3_intck::pCheck, sqlite3_intck::rc, SQLITE_OK, and sqlite3_intck::zKey.

Referenced by intckDatabaseCmd().

Here is the call graph for this function:

Here is the caller graph for this function:

sqlite3_percentile_init()

int sqlite3_percentile_init	(	sqlite3 *	db,
		char **	pzErrMsg,
		const sqlite3_api_routines *	pApi )

 {
  int rc = SQLITE_OK;
  unsigned int i;
#ifdef SQLITE3EXT_H
  SQLITE_EXTENSION_INIT2(pApi);
#else
  (void)pApi;      /* Unused parameter */
#endif
  (void)pzErrMsg;  /* Unused parameter */
  for(i=0; i<sizeof(aPercentFunc)/sizeof(aPercentFunc[0]); i++){
    rc = sqlite3_create_window_function(db,
            aPercentFunc[i].zName,
            aPercentFunc[i].nArg,
            SQLITE_UTF8|SQLITE_INNOCUOUS|SQLITE_SELFORDER1,
            (void*)&aPercentFunc[i],
            percentStep, percentFinal, percentValue, percentInverse, 0);
    if( rc ) break;
  }
  return rc;
}

References aPercentFunc, percentFinal(), percentInverse(), percentStep(), percentValue(), sqlite3_create_window_function, SQLITE_EXTENSION_INIT2, SQLITE_INNOCUOUS, SQLITE_OK, SQLITE_SELFORDER1, and SQLITE_UTF8.

Referenced by open_db().

Here is the call graph for this function:

Here is the caller graph for this function:

sqlite3_regexp_init()

int sqlite3_regexp_init	(	sqlite3 *	db,
		char **	pzErrMsg,
		const sqlite3_api_routines *	pApi )

 {
  int rc = SQLITE_OK;
  SQLITE_EXTENSION_INIT2(pApi);
  (void)pzErrMsg;  /* Unused */
  rc = sqlite3_create_function(db, "regexp", 2, 
                            SQLITE_UTF8|SQLITE_INNOCUOUS|SQLITE_DETERMINISTIC,
                            0, re_sql_func, 0, 0);
  if( rc==SQLITE_OK ){
    /* The regexpi(PATTERN,STRING) function is a case-insensitive version
    ** of regexp(PATTERN,STRING). */
    rc = sqlite3_create_function(db, "regexpi", 2,
                            SQLITE_UTF8|SQLITE_INNOCUOUS|SQLITE_DETERMINISTIC,
                            (void*)db, re_sql_func, 0, 0);
#if defined(SQLITE_DEBUG)
    if( rc==SQLITE_OK ){
      rc = sqlite3_create_function(db, "regexp_bytecode", 1,
                            SQLITE_UTF8|SQLITE_INNOCUOUS|SQLITE_DETERMINISTIC,
                            0, re_bytecode_func, 0, 0);
    }
#endif /* SQLITE_DEBUG */
  }
  return rc;
}

References re_sql_func(), sqlite3_create_function, SQLITE_DETERMINISTIC, SQLITE_EXTENSION_INIT2, SQLITE_INNOCUOUS, SQLITE_OK, and SQLITE_UTF8.

Referenced by open_db().

Here is the call graph for this function:

Here is the caller graph for this function:

sqlite3_series_init()

int sqlite3_series_init	(	sqlite3 *	db,
		char **	pzErrMsg,
		const sqlite3_api_routines *	pApi )

 {
  int rc = SQLITE_OK;
  SQLITE_EXTENSION_INIT2(pApi);
#ifndef SQLITE_OMIT_VIRTUALTABLE
  if( sqlite3_libversion_number()<3008012 && pzErrMsg!=0 ){
    *pzErrMsg = sqlite3_mprintf(
        "generate_series() requires SQLite 3.8.12 or later");
    return SQLITE_ERROR;
  }
  rc = sqlite3_create_module(db, "generate_series", &seriesModule, 0);
#endif
  return rc;
}

References seriesModule, sqlite3_create_module, sqlite3_libversion_number, sqlite3_mprintf, SQLITE_ERROR, SQLITE_EXTENSION_INIT2, and SQLITE_OK.

Referenced by open_db().

Here is the caller graph for this function:

sqlite3_sha_init()

int sqlite3_sha_init	(	sqlite3 *	db,
		char **	pzErrMsg,
		const sqlite3_api_routines *	pApi )

 {
  int rc = SQLITE_OK;
  static int one = 1;
  SQLITE_EXTENSION_INIT2(pApi);
  (void)pzErrMsg;  /* Unused parameter */
  rc = sqlite3_create_function(db, "sha1", 1, 
                       SQLITE_UTF8 | SQLITE_INNOCUOUS | SQLITE_DETERMINISTIC,
                                0, sha1Func, 0, 0);
  if( rc==SQLITE_OK ){
    rc = sqlite3_create_function(db, "sha1b", 1, 
                       SQLITE_UTF8 | SQLITE_INNOCUOUS | SQLITE_DETERMINISTIC,
                          (void*)&one, sha1Func, 0, 0);
  }
  if( rc==SQLITE_OK ){
    rc = sqlite3_create_function(db, "sha1_query", 1, 
                                 SQLITE_UTF8|SQLITE_DIRECTONLY, 0,
                                 sha1QueryFunc, 0, 0);
  }
  return rc;
}

References sha1Func(), sha1QueryFunc(), sqlite3_create_function, SQLITE_DETERMINISTIC, SQLITE_DIRECTONLY, SQLITE_EXTENSION_INIT2, SQLITE_INNOCUOUS, SQLITE_OK, and SQLITE_UTF8.

Referenced by open_db().

Here is the call graph for this function:

Here is the caller graph for this function:

sqlite3_shathree_init()

int sqlite3_shathree_init	(	sqlite3 *	db,
		char **	pzErrMsg,
		const sqlite3_api_routines *	pApi )

 {
  int rc = SQLITE_OK;
  SQLITE_EXTENSION_INIT2(pApi);
  (void)pzErrMsg;  /* Unused parameter */
  rc = sqlite3_create_function(db, "sha3", 1,
                      SQLITE_UTF8 | SQLITE_INNOCUOUS | SQLITE_DETERMINISTIC,
                      0, sha3Func, 0, 0);
  if( rc==SQLITE_OK ){
    rc = sqlite3_create_function(db, "sha3", 2,
                      SQLITE_UTF8 | SQLITE_INNOCUOUS | SQLITE_DETERMINISTIC,
                      0, sha3Func, 0, 0);
  }
  if( rc==SQLITE_OK ){
    rc = sqlite3_create_function(db, "sha3_agg", 1,
                      SQLITE_UTF8 | SQLITE_INNOCUOUS | SQLITE_DETERMINISTIC,
                      0, 0, sha3AggStep, sha3AggFinal);
  }
  if( rc==SQLITE_OK ){
    rc = sqlite3_create_function(db, "sha3_agg", 2,
                      SQLITE_UTF8 | SQLITE_INNOCUOUS | SQLITE_DETERMINISTIC,
                      0, 0, sha3AggStep, sha3AggFinal);
  }
  if( rc==SQLITE_OK ){
    rc = sqlite3_create_function(db, "sha3_query", 1,
                      SQLITE_UTF8 | SQLITE_DIRECTONLY,
                      0, sha3QueryFunc, 0, 0);
  }
  if( rc==SQLITE_OK ){
    rc = sqlite3_create_function(db, "sha3_query", 2,
                      SQLITE_UTF8 | SQLITE_DIRECTONLY,
                      0, sha3QueryFunc, 0, 0);
  }
  return rc;
}

References sha3AggFinal(), sha3AggStep(), sha3Func(), sha3QueryFunc(), sqlite3_create_function, SQLITE_DETERMINISTIC, SQLITE_DIRECTONLY, SQLITE_EXTENSION_INIT2, SQLITE_INNOCUOUS, SQLITE_OK, and SQLITE_UTF8.

Referenced by open_db().

Here is the call graph for this function:

Here is the caller graph for this function:

sqlite3_stmtrand_init()

int sqlite3_stmtrand_init	(	sqlite3 *	db,
		char **	pzErrMsg,
		const sqlite3_api_routines *	pApi )

 {
  int rc = SQLITE_OK;
  SQLITE_EXTENSION_INIT2(pApi);
  (void)pzErrMsg;  /* Unused parameter */
  rc = sqlite3_create_function(db, "stmtrand", 1, SQLITE_UTF8, 0,
                               stmtrandFunc, 0, 0);
  if( rc==SQLITE_OK ){
    rc = sqlite3_create_function(db, "stmtrand", 0, SQLITE_UTF8, 0,
                                 stmtrandFunc, 0, 0);
  }
  return rc;
}

References sqlite3_create_function, SQLITE_EXTENSION_INIT2, SQLITE_OK, SQLITE_UTF8, and stmtrandFunc().

Referenced by open_db().

Here is the call graph for this function:

Here is the caller graph for this function:

sqlite3_uint_init()

int sqlite3_uint_init	(	sqlite3 *	db,
		char **	pzErrMsg,
		const sqlite3_api_routines *	pApi )

 {
  SQLITE_EXTENSION_INIT2(pApi);
  (void)pzErrMsg;  /* Unused parameter */
  return sqlite3_create_collation(db, "uint", SQLITE_UTF8, 0, uintCollFunc);
}

References sqlite3_create_collation, SQLITE_EXTENSION_INIT2, SQLITE_UTF8, and uintCollFunc().

Referenced by open_db().

Here is the call graph for this function:

Here is the caller graph for this function:

sqlite3CompletionVtabInit()

int sqlite3CompletionVtabInit

(

sqlite3 *

db

)

                                          {
  int rc = SQLITE_OK;
#ifndef SQLITE_OMIT_VIRTUALTABLE
  rc = sqlite3_create_module(db, "completion", &completionModule, 0);
#endif
  return rc;
}

References completionModule, sqlite3_create_module, and SQLITE_OK.

Referenced by sqlite3_completion_init().

Here is the caller graph for this function:

sqlite3MemTraceActivate()

int sqlite3MemTraceActivate

(

FILE *

out

)

                                      {
  int rc = SQLITE_OK;
  if( memtraceBase.xMalloc==0 ){
    rc = sqlite3_config(SQLITE_CONFIG_GETMALLOC, &memtraceBase);
    if( rc==SQLITE_OK ){
      rc = sqlite3_config(SQLITE_CONFIG_MALLOC, &ersaztMethods);
    }
  }
  memtraceOut = out;
  return rc;
}

References ersaztMethods, memtraceBase, memtraceOut, sqlite3_config(), SQLITE_CONFIG_GETMALLOC, SQLITE_CONFIG_MALLOC, and SQLITE_OK.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

sqlite3MemTraceDeactivate()

int sqlite3MemTraceDeactivate

(

void

)

                                   {
  int rc = SQLITE_OK;
  if( memtraceBase.xMalloc!=0 ){
    rc = sqlite3_config(SQLITE_CONFIG_MALLOC, &memtraceBase);
    if( rc==SQLITE_OK ){
      memset(&memtraceBase, 0, sizeof(memtraceBase));
    }
  }
  memtraceOut = 0;
  return rc;
}

References memtraceBase, memtraceOut, sqlite3_config(), SQLITE_CONFIG_MALLOC, and SQLITE_OK.

Here is the call graph for this function:

sqlite3PcacheTraceActivate()

int sqlite3PcacheTraceActivate

(

FILE *

out

)

                                         {
  int rc = SQLITE_OK;
  if( pcacheBase.xFetch==0 ){
    rc = sqlite3_config(SQLITE_CONFIG_GETPCACHE2, &pcacheBase);
    if( rc==SQLITE_OK ){
      rc = sqlite3_config(SQLITE_CONFIG_PCACHE2, &ersaztPcacheMethods);
    }
  }
  pcachetraceOut = out;
  return rc;
}

References ersaztPcacheMethods, pcacheBase, pcachetraceOut, sqlite3_config(), SQLITE_CONFIG_GETPCACHE2, SQLITE_CONFIG_PCACHE2, and SQLITE_OK.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

sqlite3PcacheTraceDeactivate()

int sqlite3PcacheTraceDeactivate

(

void

)

                                      {
  int rc = SQLITE_OK;
  if( pcacheBase.xFetch!=0 ){
    rc = sqlite3_config(SQLITE_CONFIG_PCACHE2, &pcacheBase);
    if( rc==SQLITE_OK ){
      memset(&pcacheBase, 0, sizeof(pcacheBase));
    }
  }
  pcachetraceOut = 0;
  return rc;
}

References pcacheBase, pcachetraceOut, sqlite3_config(), SQLITE_CONFIG_PCACHE2, and SQLITE_OK.

Here is the call graph for this function:

sqlite3re_compile()

const char * sqlite3re_compile ( ReCompiled ** ppRe, const char * zIn, int noCase )

static

                                                                             {
  ReCompiled *pRe;
  const char *zErr;
  int i, j;
 
  *ppRe = 0;
  pRe = sqlite3_malloc( sizeof(*pRe) );
  if( pRe==0 ){
    return "out of memory";
  }
  memset(pRe, 0, sizeof(*pRe));
  pRe->xNextChar = noCase ? re_next_char_nocase : re_next_char;
  if( re_resize(pRe, 30) ){
    re_free(pRe);
    return "out of memory";
  }
  if( zIn[0]=='^' ){
    zIn++;
  }else{
    re_append(pRe, RE_OP_ANYSTAR, 0);
  }
  pRe->sIn.z = (unsigned char*)zIn;
  pRe->sIn.i = 0;
  pRe->sIn.mx = (int)strlen(zIn);
  zErr = re_subcompile_re(pRe);
  if( zErr ){
    re_free(pRe);
    return zErr;
  }
  if( pRe->sIn.i>=pRe->sIn.mx ){
    re_append(pRe, RE_OP_ACCEPT, 0);
    *ppRe = pRe;
  }else{
    re_free(pRe);
    return "unrecognized character";
  }
 
  /* The following is a performance optimization.  If the regex begins with
  ** ".*" (if the input regex lacks an initial "^") and afterwards there are
  ** one or more matching characters, enter those matching characters into
  ** zInit[].  The re_match() routine can then search ahead in the input 
  ** string looking for the initial match without having to run the whole
  ** regex engine over the string.  Do not worry about trying to match
  ** unicode characters beyond plane 0 - those are very rare and this is
  ** just an optimization. */
  if( pRe->aOp[0]==RE_OP_ANYSTAR && !noCase ){
    for(j=0, i=1; j<(int)sizeof(pRe->zInit)-2 && pRe->aOp[i]==RE_OP_MATCH; i++){
      unsigned x = pRe->aArg[i];
      if( x<=0x7f ){
        pRe->zInit[j++] = (unsigned char)x;
      }else if( x<=0x7ff ){
        pRe->zInit[j++] = (unsigned char)(0xc0 | (x>>6));
        pRe->zInit[j++] = 0x80 | (x&0x3f);
      }else if( x<=0xffff ){
        pRe->zInit[j++] = (unsigned char)(0xe0 | (x>>12));
        pRe->zInit[j++] = 0x80 | ((x>>6)&0x3f);
        pRe->zInit[j++] = 0x80 | (x&0x3f);
      }else{
        break;
      }
    }
    if( j>0 && pRe->zInit[j-1]==0 ) j--;
    pRe->nInit = j;
  }
  return pRe->zErr;
}

References ReCompiled::aArg, ReCompiled::aOp, ReInput::i, ReInput::mx, ReCompiled::nInit, re_append(), re_free, re_next_char(), re_next_char_nocase(), RE_OP_ACCEPT, RE_OP_ANYSTAR, RE_OP_MATCH, re_resize(), re_subcompile_re(), ReCompiled::sIn, sqlite3_malloc, ReCompiled::xNextChar, ReInput::z, ReCompiled::zErr, and ReCompiled::zInit.

Here is the call graph for this function:

sqlite3re_free()

void sqlite3re_free ( void * p )

static

                            {
  ReCompiled *pRe = (ReCompiled*)p;
  if( pRe ){
    sqlite3_free(pRe->aOp);
    sqlite3_free(pRe->aArg);
    sqlite3_free(pRe);
  }
}

References ReCompiled::aArg, ReCompiled::aOp, and sqlite3_free.

sqlite3re_match()

int sqlite3re_match ( ReCompiled * pRe, const unsigned char * zIn, int nIn )

static

                                                                       {
  ReStateSet aStateSet[2], *pThis, *pNext;
  ReStateNumber aSpace[100];
  ReStateNumber *pToFree;
  unsigned int i = 0;
  unsigned int iSwap = 0;
  int c = RE_START;
  int cPrev = 0;
  int rc = 0;
  ReInput in;
 
  in.z = zIn;
  in.i = 0;
  in.mx = nIn>=0 ? nIn : (int)strlen((char const*)zIn);
 
  /* Look for the initial prefix match, if there is one. */
  if( pRe->nInit ){
    unsigned char x = pRe->zInit[0];
    while( in.i+pRe->nInit<=in.mx 
     && (zIn[in.i]!=x ||
         strncmp((const char*)zIn+in.i, (const char*)pRe->zInit, pRe->nInit)!=0)
    ){
      in.i++;
    }
    if( in.i+pRe->nInit>in.mx ) return 0;
    c = RE_START-1;
  }
 
  if( pRe->nState<=(sizeof(aSpace)/(sizeof(aSpace[0])*2)) ){
    pToFree = 0;
    aStateSet[0].aState = aSpace;
  }else{
    pToFree = sqlite3_malloc64( sizeof(ReStateNumber)*2*pRe->nState );
    if( pToFree==0 ) return -1;
    aStateSet[0].aState = pToFree;
  }
  aStateSet[1].aState = &aStateSet[0].aState[pRe->nState];
  pNext = &aStateSet[1];
  pNext->nState = 0;
  re_add_state(pNext, 0);
  while( c!=RE_EOF && pNext->nState>0 ){
    cPrev = c;
    c = pRe->xNextChar(&in);
    pThis = pNext;
    pNext = &aStateSet[iSwap];
    iSwap = 1 - iSwap;
    pNext->nState = 0;
    for(i=0; i<pThis->nState; i++){
      int x = pThis->aState[i];
      switch( pRe->aOp[x] ){
        case RE_OP_MATCH: {
          if( pRe->aArg[x]==c ) re_add_state(pNext, x+1);
          break;
        }
        case RE_OP_ATSTART: {
          if( cPrev==RE_START ) re_add_state(pThis, x+1);
          break;
        }
        case RE_OP_ANY: {
          if( c!=0 ) re_add_state(pNext, x+1);
          break;
        }
        case RE_OP_WORD: {
          if( re_word_char(c) ) re_add_state(pNext, x+1);
          break;
        }
        case RE_OP_NOTWORD: {
          if( !re_word_char(c) && c!=0 ) re_add_state(pNext, x+1);
          break;
        }
        case RE_OP_DIGIT: {
          if( re_digit_char(c) ) re_add_state(pNext, x+1);
          break;
        }
        case RE_OP_NOTDIGIT: {
          if( !re_digit_char(c) && c!=0 ) re_add_state(pNext, x+1);
          break;
        }
        case RE_OP_SPACE: {
          if( re_space_char(c) ) re_add_state(pNext, x+1);
          break;
        }
        case RE_OP_NOTSPACE: {
          if( !re_space_char(c) && c!=0 ) re_add_state(pNext, x+1);
          break;
        }
        case RE_OP_BOUNDARY: {
          if( re_word_char(c)!=re_word_char(cPrev) ) re_add_state(pThis, x+1);
          break;
        }
        case RE_OP_ANYSTAR: {
          re_add_state(pNext, x);
          re_add_state(pThis, x+1);
          break;
        }
        case RE_OP_FORK: {
          re_add_state(pThis, x+pRe->aArg[x]);
          re_add_state(pThis, x+1);
          break;
        }
        case RE_OP_GOTO: {
          re_add_state(pThis, x+pRe->aArg[x]);
          break;
        }
        case RE_OP_ACCEPT: {
          rc = 1;
          goto re_match_end;
        }
        case RE_OP_CC_EXC: {
          if( c==0 ) break;
          /* fall-through */ goto re_op_cc_inc;
        }
        case RE_OP_CC_INC: re_op_cc_inc: {
          int j = 1;
          int n = pRe->aArg[x];
          int hit = 0;
          for(j=1; j>0 && j<n; j++){
            if( pRe->aOp[x+j]==RE_OP_CC_VALUE ){
              if( pRe->aArg[x+j]==c ){
                hit = 1;
                j = -1;
              }
            }else{
              if( pRe->aArg[x+j]<=c && pRe->aArg[x+j+1]>=c ){
                hit = 1;
                j = -1;
              }else{
                j++;
              }
            }
          }
          if( pRe->aOp[x]==RE_OP_CC_EXC ) hit = !hit;
          if( hit ) re_add_state(pNext, x+n);
          break;
        }
      }
    }
  }
  for(i=0; i<pNext->nState; i++){
    int x = pNext->aState[i];
    while( pRe->aOp[x]==RE_OP_GOTO ) x += pRe->aArg[x];
    if( pRe->aOp[x]==RE_OP_ACCEPT ){ rc = 1; break; }
  }
re_match_end:
  sqlite3_free(pToFree);
  return rc;
}

References ReCompiled::aArg, ReCompiled::aOp, ReStateSet::aState, c, ReInput::i, ReInput::mx, ReCompiled::nInit, ReCompiled::nState, ReStateSet::nState, re_add_state(), re_digit_char(), RE_EOF, RE_OP_ACCEPT, RE_OP_ANY, RE_OP_ANYSTAR, RE_OP_ATSTART, RE_OP_BOUNDARY, RE_OP_CC_EXC, RE_OP_CC_INC, RE_OP_CC_VALUE, RE_OP_DIGIT, RE_OP_FORK, RE_OP_GOTO, RE_OP_MATCH, RE_OP_NOTDIGIT, RE_OP_NOTSPACE, RE_OP_NOTWORD, RE_OP_SPACE, RE_OP_WORD, re_space_char(), RE_START, re_word_char(), sqlite3_free, sqlite3_malloc64, ReCompiled::xNextChar, ReInput::z, and ReCompiled::zInit.

Here is the call graph for this function:

stmtrandFunc()

void stmtrandFunc ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  Stmtrand *p;
 
  p = (Stmtrand*)sqlite3_get_auxdata(context, STMTRAND_KEY);
  if( p==0 ){
    unsigned int seed;
    p = sqlite3_malloc( sizeof(*p) );
    if( p==0 ){
      sqlite3_result_error_nomem(context);
      return;
    }
    if( argc>=1 ){
      seed = (unsigned int)sqlite3_value_int(argv[0]);
    }else{
      seed = 0;
    }
    p->x = seed | 1;
    p->y = seed;
    sqlite3_set_auxdata(context, STMTRAND_KEY, p, sqlite3_free);
    p = (Stmtrand*)sqlite3_get_auxdata(context, STMTRAND_KEY);
    if( p==0 ){
      sqlite3_result_error_nomem(context);
      return;
    }
  }
  p->x = (p->x>>1) ^ ((1+~(p->x&1)) & 0xd0000001);
  p->y = p->y*1103515245 + 12345;
  sqlite3_result_int(context, (int)((p->x ^ p->y)&0x7fffffff));
}

References sqlite3_free, sqlite3_get_auxdata, sqlite3_malloc, sqlite3_result_error_nomem, sqlite3_result_int, sqlite3_set_auxdata, sqlite3_value_int, STMTRAND_KEY, Stmtrand::x, and Stmtrand::y.

Referenced by sqlite3_stmtrand_init().

Here is the caller graph for this function:

str_in_array()

int str_in_array ( const char * zStr, const char ** azArray )

static

                                                               {
  int i;
  for(i=0; azArray[i]; i++){
    if( 0==cli_strcmp(zStr, azArray[i]) ) return 1;
  }

References cli_strcmp().

Referenced by explain_data_prepare().

Here is the call graph for this function:

Here is the caller graph for this function:

strappend()

void strappend ( char * z, int * pI, const char * zAppend )

static

                                                            {
  int i = *pI;
  while( zAppend[0] ){ z[i++] = *(zAppend++); }
  z[i] = 0;
  *pI = i;
}

Referenced by vfstraceShmLock(), and vfstraceSync().

Here is the caller graph for this function:

strlen30()

int strlen30 ( const char * z )

static

                                  {
  const char *z2 = z;
  while( *z2 ){ z2++; }
  return 0x3fffffff & (int)(z2 - z);
}

Referenced by appendText(), do_meta_command(), expertDotCommand(), find_home_dir(), lintDotCommand(), lintFkeyIndexes(), main(), run_schema_dump_query(), set_table_name(), shell_callback(), shellAddSchemaName(), and tryToCloneData().

Here is the caller graph for this function:

strlenChar()

int strlenChar ( const char * z )

static

                                    {
  int n = 0;
  while( *z ){
    if( (0xc0&*(z++))!=0x80 ) n++;
  }
  return n;
}

Referenced by exec_prepared_stmt_columnar(), and shell_callback().

Here is the caller graph for this function:

tableColumnList()

char ** tableColumnList ( ShellState * p, const char * zTab )

static

                                                              {
  char **azCol = 0;
  sqlite3_stmt *pStmt;
  char *zSql;
  int nCol = 0;
  int nAlloc = 0;
  int nPK = 0;       /* Number of PRIMARY KEY columns seen */
  int isIPK = 0;     /* True if one PRIMARY KEY column of type INTEGER */
  int preserveRowid = ShellHasFlag(p, SHFLG_PreserveRowid);
  int rc;
 
  zSql = sqlite3_mprintf("PRAGMA table_info=%Q", zTab);
  shell_check_oom(zSql);
  rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
  sqlite3_free(zSql);
  if( rc ) return 0;
  while( sqlite3_step(pStmt)==SQLITE_ROW ){
    if( nCol>=nAlloc-2 ){
      nAlloc = nAlloc*2 + nCol + 10;
      azCol = sqlite3_realloc(azCol, nAlloc*sizeof(azCol[0]));
      shell_check_oom(azCol);
    }
    azCol[++nCol] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 1));
    shell_check_oom(azCol[nCol]);
    if( sqlite3_column_int(pStmt, 5) ){
      nPK++;
      if( nPK==1
       && sqlite3_stricmp((const char*)sqlite3_column_text(pStmt,2),
                          "INTEGER")==0
      ){
        isIPK = 1;
      }else{
        isIPK = 0;
      }
    }
  }
  sqlite3_finalize(pStmt);
  if( azCol==0 ) return 0;
  azCol[0] = 0;
  azCol[nCol+1] = 0;
 
  /* The decision of whether or not a rowid really needs to be preserved
  ** is tricky.  We never need to preserve a rowid for a WITHOUT ROWID table
  ** or a table with an INTEGER PRIMARY KEY.  We are unable to preserve
  ** rowids on tables where the rowid is inaccessible because there are other
  ** columns in the table named "rowid", "_rowid_", and "oid".
  */
  if( preserveRowid && isIPK ){
    /* If a single PRIMARY KEY column with type INTEGER was seen, then it
    ** might be an alias for the ROWID.  But it might also be a WITHOUT ROWID
    ** table or a INTEGER PRIMARY KEY DESC column, neither of which are
    ** ROWID aliases.  To distinguish these cases, check to see if
    ** there is a "pk" entry in "PRAGMA index_list".  There will be
    ** no "pk" index if the PRIMARY KEY really is an alias for the ROWID.
    */
    zSql = sqlite3_mprintf("SELECT 1 FROM pragma_index_list(%Q)"
                           " WHERE origin='pk'", zTab);
    shell_check_oom(zSql);
    rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
    sqlite3_free(zSql);
    if( rc ){
      freeColumnList(azCol);
      return 0;
    }
    rc = sqlite3_step(pStmt);
    sqlite3_finalize(pStmt);
    preserveRowid = rc==SQLITE_ROW;
  }
  if( preserveRowid ){
    /* Only preserve the rowid if we can find a name to use for the
    ** rowid */
    static char *azRowid[] = { "rowid", "_rowid_", "oid" };
    int i, j;
    for(j=0; j<3; j++){
      for(i=1; i<=nCol; i++){
        if( sqlite3_stricmp(azRowid[j],azCol[i])==0 ) break;
      }
      if( i>nCol ){
        /* At this point, we know that azRowid[j] is not the name of any
        ** ordinary column in the table.  Verify that azRowid[j] is a valid
        ** name for the rowid before adding it to azCol[0].  WITHOUT ROWID
        ** tables will fail this last check */
        rc = sqlite3_table_column_metadata(p->db,0,zTab,azRowid[j],0,0,0,0,0);
        if( rc==SQLITE_OK ) azCol[0] = azRowid[j];
        break;
      }
    }
  }

References ShellState::db, freeColumnList(), shell_check_oom(), ShellHasFlag, SHFLG_PreserveRowid, sqlite3_column_int, sqlite3_column_text, sqlite3_finalize, sqlite3_free, sqlite3_mprintf, sqlite3_prepare_v2, sqlite3_realloc, sqlite3_step, sqlite3_stricmp, sqlite3_table_column_metadata, SQLITE_OK, and SQLITE_ROW.

Referenced by dump_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

test_breakpoint()

void test_breakpoint ( void )

static

                                 {
  static unsigned int nCall = 0;

Referenced by do_meta_command().

Here is the caller graph for this function:

testcase_glob()

int testcase_glob ( const char * zGlob, const char * z )

static

                                                          {
  int c, c2;
  int invert;
  int seen;
 
  while( (c = (*(zGlob++)))!=0 ){
    if( IsSpace(c) ){
      if( !IsSpace(*z) ) return 0;
      while( IsSpace(*zGlob) ) zGlob++;
      while( IsSpace(*z) ) z++;
    }else if( c=='*' ){
      while( (c=(*(zGlob++))) == '*' || c=='?' ){
        if( c=='?' && (*(z++))==0 ) return 0;
      }
      if( c==0 ){
        return 1;
      }else if( c=='[' ){
        while( *z && testcase_glob(zGlob-1,z)==0 ){
          z++;
        }
        return (*z)!=0;
      }
      while( (c2 = (*(z++)))!=0 ){
        while( c2!=c ){
          c2 = *(z++);
          if( c2==0 ) return 0;
        }
        if( testcase_glob(zGlob,z) ) return 1;
      }
      return 0;
    }else if( c=='?' ){
      if( (*(z++))==0 ) return 0;
    }else if( c=='[' ){
      int prior_c = 0;
      seen = 0;
      invert = 0;
      c = *(z++);
      if( c==0 ) return 0;
      c2 = *(zGlob++);
      if( c2=='^' ){
        invert = 1;
        c2 = *(zGlob++);
      }
      if( c2==']' ){
        if( c==']' ) seen = 1;
        c2 = *(zGlob++);
      }
      while( c2 && c2!=']' ){
        if( c2=='-' && zGlob[0]!=']' && zGlob[0]!=0 && prior_c>0 ){
          c2 = *(zGlob++);
          if( c>=prior_c && c<=c2 ) seen = 1;
          prior_c = 0;
        }else{
          if( c==c2 ){
            seen = 1;
          }
          prior_c = c2;
        }
        c2 = *(zGlob++);
      }
      if( c2==0 || (seen ^ invert)==0 ) return 0;
    }else if( c=='#' ){
      if( (z[0]=='-' || z[0]=='+') && IsDigit(z[1]) ) z++;
      if( !IsDigit(z[0]) ) return 0;
      z++;
      while( IsDigit(z[0]) ){ z++; }
    }else{
      if( c!=(*(z++)) ) return 0;
    }
  }
  while( IsSpace(*z) ){ z++; }

References c, IsDigit, IsSpace, and testcase_glob().

Referenced by do_meta_command(), and testcase_glob().

Here is the call graph for this function:

Here is the caller graph for this function:

timeDiff()

double timeDiff ( struct timeval * pStart, struct timeval * pEnd )

static

                                                                    {
  return (pEnd->tv_usec - pStart->tv_usec)*0.000001 +
         (double)(pEnd->tv_sec - pStart->tv_sec);
}

Referenced by endTimer().

Here is the caller graph for this function:

timeOfDay()

sqlite3_int64 timeOfDay ( void )

static

                                    {
  static sqlite3_vfs *clockVfs = 0;
  sqlite3_int64 t;
  if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0);
  if( clockVfs==0 ) return 0;  /* Never actually happens */
  if( clockVfs->iVersion>=2 && clockVfs->xCurrentTimeInt64!=0 ){
    clockVfs->xCurrentTimeInt64(clockVfs, &t);
  }else{
    double r;
    clockVfs->xCurrentTime(clockVfs, &r);
    t = (sqlite3_int64)(r*86400000.0);
  }
  return t;
}

References sqlite3_vfs::iVersion, sqlite3_vfs_find, sqlite3_vfs::xCurrentTime, and sqlite3_vfs::xCurrentTimeInt64.

Referenced by beginTimer(), and endTimer().

Here is the caller graph for this function:

toBase64()

char * toBase64 ( u8 * pIn, int nbIn, char * pOut )

static

                                                      {
  int nCol = 0;
  while( nbIn >= 3 ){
    /* Do the bit-shuffle, exploiting unsigned input to avoid masking. */
    pOut[0] = BX_NUMERAL(pIn[0]>>2);
    pOut[1] = BX_NUMERAL(((pIn[0]<<4)|(pIn[1]>>4))&0x3f);
    pOut[2] = BX_NUMERAL(((pIn[1]&0xf)<<2)|(pIn[2]>>6));
    pOut[3] = BX_NUMERAL(pIn[2]&0x3f);
    pOut += 4;
    nbIn -= 3;
    pIn += 3;
    if( (nCol += 4)>=B64_DARK_MAX || nbIn<=0 ){
      *pOut++ = '\n';
      nCol = 0;
    }
  }
  if( nbIn > 0 ){
    signed char nco = nbIn+1;
    int nbe;
    unsigned long qv = *pIn++;
    for( nbe=1; nbe<3; ++nbe ){
      qv <<= 8;
      if( nbe<nbIn ) qv |= *pIn++;
    }
    for( nbe=3; nbe>=0; --nbe ){
      char ce = (nbe<nco)? BX_NUMERAL((u8)(qv & 0x3f)) : PAD_CHAR;
      qv >>= 6;
      pOut[nbe] = ce;
    }
    pOut += 4;
    *pOut++ = '\n';
  }
  *pOut = 0;
  return pOut;
}

References B64_DARK_MAX, BX_NUMERAL, and PAD_CHAR.

Referenced by base64().

Here is the caller graph for this function:

toBase85()

char * toBase85 ( u8 * pIn, int nbIn, char * pOut, char * pSep )

static

                                                                  {
  int nCol = 0;
  while( nbIn >= 4 ){
    int nco = 5;
    unsigned long qbv = (((unsigned long)pIn[0])<<24) |
                        (pIn[1]<<16) | (pIn[2]<<8) | pIn[3];
    while( nco > 0 ){
      unsigned nqv = (unsigned)(qbv/85UL);
      unsigned char dv = qbv - 85UL*nqv;
      qbv = nqv;
      pOut[--nco] = base85Numeral(dv);
    }
    nbIn -= 4;
    pIn += 4;
    pOut += 5;
    if( pSep && (nCol += 5)>=B85_DARK_MAX ){
      pOut = putcs(pOut, pSep);
      nCol = 0;
    }
  }
  if( nbIn > 0 ){
    int nco = nbIn + 1;
    unsigned long qv = *pIn++;
    int nbe = 1;
    while( nbe++ < nbIn ){
      qv = (qv<<8) | *pIn++;
    }
    nCol += nco;
    while( nco > 0 ){
      u8 dv = (u8)(qv % 85);
      qv /= 85;
      pOut[--nco] = base85Numeral(dv);
    }
    pOut += (nbIn+1);
  }
  if( pSep && nCol>0 ) pOut = putcs(pOut, pSep);
  *pOut = 0;
  return pOut;
}

References B85_DARK_MAX, base85Numeral, and putcs().

Referenced by base85().

Here is the call graph for this function:

Here is the caller graph for this function:

toggleSelectOrder()

void toggleSelectOrder ( sqlite3 * db )

static

                                          {
  sqlite3_stmt *pStmt = 0;
  int iSetting = 0;
  char zStmt[100];
  sqlite3_prepare_v2(db, "PRAGMA reverse_unordered_selects", -1, &pStmt, 0);
  if( sqlite3_step(pStmt)==SQLITE_ROW ){
    iSetting = sqlite3_column_int(pStmt, 0);
  }
  sqlite3_finalize(pStmt);
  sqlite3_snprintf(sizeof(zStmt), zStmt,
       "PRAGMA reverse_unordered_selects(%d)", !iSetting);

References sqlite3_column_int, sqlite3_exec, sqlite3_finalize, sqlite3_prepare_v2, sqlite3_snprintf, sqlite3_step, and SQLITE_ROW.

Referenced by dump_callback().

Here is the caller graph for this function:

trackParenLevel()

void trackParenLevel ( struct DynaPrompt * p, int ni )

static

                                                         {
  p->inParenLevel += ni;
  if( ni==0 ) p->inParenLevel = 0;
  p->zScannerAwaits = 0;
}

References DynaPrompt::inParenLevel, and DynaPrompt::zScannerAwaits.

translateForDisplayAndDup()

char * translateForDisplayAndDup ( ShellState * p, const unsigned char * z, const unsigned char ** pzTail, int mxWidth, u8 bWordWrap )

static

 {
  int i;                 /* Input bytes consumed */
  int j;                 /* Output bytes generated */
  int k;                 /* Input bytes to be displayed */
  int n;                 /* Output column number */
  unsigned char *zOut;   /* Output text */
 
  if( z==0 ){
    *pzTail = 0;
    return 0;
  }
  if( mxWidth<0 ) mxWidth = -mxWidth;
  if( mxWidth==0 ) mxWidth = 1000000;
  i = j = n = 0;
  while( n<mxWidth ){
    unsigned char c = z[i];
    if( c>=0xc0 ){
      int u;
      int len = decodeUtf8(&z[i], &u);
      i += len;
      j += len;
      n += cli_wcwidth(u);
      continue;
    }
    if( c>=' ' ){
      n++;
      i++;
      j++;
      continue;
    }
    if( c==0 || c=='\n' || (c=='\r' && z[i+1]=='\n') ) break;
    if( c=='\t' ){
      do{
        n++;
        j++;
      }while( (n&7)!=0 && n<mxWidth );
      i++;
      continue;
    }
    if( c==0x1b && p->eEscMode==SHELL_ESC_OFF && (k = isVt100(&z[i]))>0 ){
      i += k;
      j += k;
    }else{
      n++;
      j += 3;
      i++;
    }
  }
  if( n>=mxWidth && bWordWrap  ){
    /* Perhaps try to back up to a better place to break the line */
    for(k=i; k>i/2; k--){
      if( IsSpace(z[k-1]) ) break;
    }
    if( k<=i/2 ){
      for(k=i; k>i/2; k--){
        if( IsAlnum(z[k-1])!=IsAlnum(z[k]) && (z[k]&0xc0)!=0x80 ) break;
      }
    }
    if( k<=i/2 ){
      k = i;
    }else{
      i = k;
      while( z[i]==' ' ) i++;
    }
  }else{
    k = i;
  }
  if( n>=mxWidth && z[i]>=' ' ){
   *pzTail = &z[i];
  }else if( z[i]=='\r' && z[i+1]=='\n' ){
    *pzTail = z[i+2] ? &z[i+2] : 0;
  }else if( z[i]==0 || z[i+1]==0 ){
    *pzTail = 0;
  }else{
    *pzTail = &z[i+1];
  }
  zOut = malloc( j+1 );
  shell_check_oom(zOut);
  i = j = n = 0;
  while( i<k ){
    unsigned char c = z[i];
    if( c>=0xc0 ){
      int u;
      int len = decodeUtf8(&z[i], &u);
      do{ zOut[j++] = z[i++]; }while( (--len)>0 );
      n += cli_wcwidth(u);
      continue;
    }
    if( c>=' ' ){
      n++;
      zOut[j++] = z[i++];
      continue;
    }
    if( c==0 ) break;
    if( z[i]=='\t' ){
      do{
        n++;
        zOut[j++] = ' ';
      }while( (n&7)!=0 && n<mxWidth );
      i++;
      continue;
    }
    switch( p->eEscMode ){
      case SHELL_ESC_SYMBOL:
        zOut[j++] = 0xe2;
        zOut[j++] = 0x90;
        zOut[j++] = 0x80 + c;
        break;
      case SHELL_ESC_ASCII:
        zOut[j++] = '^';
        zOut[j++] = 0x40 + c;
        break;
      case SHELL_ESC_OFF: {
        int nn;
        if( c==0x1b && (nn = isVt100(&z[i]))>0 ){
          memcpy(&zOut[j], &z[i], nn);
          j += nn;
          i += nn - 1;
        }else{
          zOut[j++] = c;
        }
        break;
      }
    }
    i++;
  }
  zOut[j] = 0;

References c, cli_wcwidth(), decodeUtf8(), ShellState::eEscMode, IsAlnum, IsSpace, isVt100(), shell_check_oom(), SHELL_ESC_ASCII, SHELL_ESC_OFF, and SHELL_ESC_SYMBOL.

Referenced by exec_prepared_stmt_columnar().

Here is the call graph for this function:

Here is the caller graph for this function:

tryToClone()

void tryToClone ( ShellState * p, const char * zNewDb )

static

                                                         {
  int rc;
  sqlite3 *newDb = 0;
  if( access(zNewDb,0)==0 ){
    sqlite3_fprintf(stderr,"File \"%s\" already exists.\n", zNewDb);
    return;
  }
  rc = sqlite3_open(zNewDb, &newDb);
  if( rc ){
    sqlite3_fprintf(stderr,
        "Cannot create output database: %s\n", sqlite3_errmsg(newDb));
  }else{
    sqlite3_exec(p->db, "PRAGMA writable_schema=ON;", 0, 0, 0);
    sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0);
    tryToCloneSchema(p, newDb, "type='table'", tryToCloneData);
    tryToCloneSchema(p, newDb, "type!='table'", 0);
    sqlite3_exec(newDb, "COMMIT;", 0, 0, 0);
    sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
  }

References close_db(), ShellState::db, sqlite3_errmsg, sqlite3_exec, sqlite3_fprintf, sqlite3_open, tryToCloneData(), and tryToCloneSchema().

Referenced by do_meta_command().

Here is the call graph for this function:

Here is the caller graph for this function:

tryToCloneData()

void tryToCloneData ( ShellState * p, sqlite3 * newDb, const char * zTable )

static

 {
  sqlite3_stmt *pQuery = 0;
  sqlite3_stmt *pInsert = 0;
  char *zQuery = 0;
  char *zInsert = 0;
  int rc;
  int i, j, n;
  int nTable = strlen30(zTable);
  int k = 0;
  int cnt = 0;
  const int spinRate = 10000;
 
  zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable);
  shell_check_oom(zQuery);
  rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
  if( rc ){
    sqlite3_fprintf(stderr,"Error %d: %s on [%s]\n",
          sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), zQuery);
    goto end_data_xfer;
  }
  n = sqlite3_column_count(pQuery);
  zInsert = sqlite3_malloc64(200 + nTable + n*3);
  shell_check_oom(zInsert);
  sqlite3_snprintf(200+nTable,zInsert,
                   "INSERT OR IGNORE INTO \"%s\" VALUES(?", zTable);
  i = strlen30(zInsert);
  for(j=1; j<n; j++){
    memcpy(zInsert+i, ",?", 2);
    i += 2;
  }
  memcpy(zInsert+i, ");", 3);
  rc = sqlite3_prepare_v2(newDb, zInsert, -1, &pInsert, 0);
  if( rc ){
    sqlite3_fprintf(stderr,"Error %d: %s on [%s]\n",
          sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb), zInsert);
    goto end_data_xfer;
  }
  for(k=0; k<2; k++){
    while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
      for(i=0; i<n; i++){
        switch( sqlite3_column_type(pQuery, i) ){
          case SQLITE_NULL: {
            sqlite3_bind_null(pInsert, i+1);
            break;
          }
          case SQLITE_INTEGER: {
            sqlite3_bind_int64(pInsert, i+1, sqlite3_column_int64(pQuery,i));
            break;
          }
          case SQLITE_FLOAT: {
            sqlite3_bind_double(pInsert, i+1, sqlite3_column_double(pQuery,i));
            break;
          }
          case SQLITE_TEXT: {
            sqlite3_bind_text(pInsert, i+1,
                             (const char*)sqlite3_column_text(pQuery,i),
                             -1, SQLITE_STATIC);
            break;
          }
          case SQLITE_BLOB: {
            sqlite3_bind_blob(pInsert, i+1, sqlite3_column_blob(pQuery,i),
                                            sqlite3_column_bytes(pQuery,i),
                                            SQLITE_STATIC);
            break;
          }
        }
      } /* End for */
      rc = sqlite3_step(pInsert);
      if( rc!=SQLITE_OK && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
        sqlite3_fprintf(stderr,"Error %d: %s\n",
              sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb));
      }
      sqlite3_reset(pInsert);
      cnt++;
      if( (cnt%spinRate)==0 ){
        printf("%c\b", "|/-\\"[(cnt/spinRate)%4]);
        fflush(stdout);
      }
    } /* End while */
    if( rc==SQLITE_DONE ) break;
    sqlite3_finalize(pQuery);
    sqlite3_free(zQuery);
    zQuery = sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;",
                             zTable);
    shell_check_oom(zQuery);
    rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
    if( rc ){
      sqlite3_fprintf(stderr,"Warning: cannot step \"%s\" backwards", zTable);
      break;
    }
  } /* End for(k=0...) */
 
end_data_xfer:
  sqlite3_finalize(pQuery);
  sqlite3_finalize(pInsert);
  sqlite3_free(zQuery);

References ShellState::db, shell_check_oom(), sqlite3_bind_blob, sqlite3_bind_double, sqlite3_bind_int64, sqlite3_bind_null, sqlite3_bind_text, sqlite3_column_blob, sqlite3_column_bytes, sqlite3_column_count, sqlite3_column_double, sqlite3_column_int64, sqlite3_column_text, sqlite3_column_type, sqlite3_errmsg, sqlite3_extended_errcode, sqlite3_finalize, sqlite3_fprintf, sqlite3_free, sqlite3_malloc64, sqlite3_mprintf, sqlite3_prepare_v2, sqlite3_reset, sqlite3_snprintf, sqlite3_step, SQLITE_BLOB, SQLITE_DONE, SQLITE_FLOAT, SQLITE_INTEGER, SQLITE_NULL, SQLITE_OK, SQLITE_ROW, SQLITE_STATIC, SQLITE_TEXT, and strlen30().

Referenced by tryToClone().

Here is the call graph for this function:

Here is the caller graph for this function:

tryToCloneSchema()

void tryToCloneSchema ( ShellState * p, sqlite3 * newDb, const char * zWhere, void(* xForEach )(ShellState *, sqlite3 *, const char *) )

static

 {
  sqlite3_stmt *pQuery = 0;
  char *zQuery = 0;
  int rc;
  const unsigned char *zName;
  const unsigned char *zSql;
  char *zErrMsg = 0;
 
  zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_schema"
                           " WHERE %s ORDER BY rowid ASC", zWhere);
  shell_check_oom(zQuery);
  rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
  if( rc ){
    sqlite3_fprintf(stderr,
          "Error: (%d) %s on [%s]\n", sqlite3_extended_errcode(p->db),
          sqlite3_errmsg(p->db), zQuery);
    goto end_schema_xfer;
  }
  while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
    zName = sqlite3_column_text(pQuery, 0);
    zSql = sqlite3_column_text(pQuery, 1);
    if( zName==0 || zSql==0 ) continue;
    if( sqlite3_stricmp((char*)zName, "sqlite_sequence")!=0 ){
      sqlite3_fprintf(stdout, "%s... ", zName); fflush(stdout);
      sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
      if( zErrMsg ){
        sqlite3_fprintf(stderr,"Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
        sqlite3_free(zErrMsg);
        zErrMsg = 0;
      }
    }
    if( xForEach ){
      xForEach(p, newDb, (const char*)zName);
    }
    sputz(stdout, "done\n");
  }
  if( rc!=SQLITE_DONE ){
    sqlite3_finalize(pQuery);
    sqlite3_free(zQuery);
    zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_schema"
                             " WHERE %s ORDER BY rowid DESC", zWhere);
    shell_check_oom(zQuery);
    rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
    if( rc ){
      sqlite3_fprintf(stderr,"Error: (%d) %s on [%s]\n",
            sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), zQuery);
      goto end_schema_xfer;
    }
    while( sqlite3_step(pQuery)==SQLITE_ROW ){
      zName = sqlite3_column_text(pQuery, 0);
      zSql = sqlite3_column_text(pQuery, 1);
      if( zName==0 || zSql==0 ) continue;
      if( sqlite3_stricmp((char*)zName, "sqlite_sequence")==0 ) continue;
      sqlite3_fprintf(stdout, "%s... ", zName); fflush(stdout);
      sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
      if( zErrMsg ){
        sqlite3_fprintf(stderr,"Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
        sqlite3_free(zErrMsg);
        zErrMsg = 0;
      }
      if( xForEach ){
        xForEach(p, newDb, (const char*)zName);
      }
      sputz(stdout, "done\n");
    }
  }
end_schema_xfer:
  sqlite3_finalize(pQuery);

References ShellState::db, shell_check_oom(), sputz, sqlite3_column_text, sqlite3_errmsg, sqlite3_exec, sqlite3_extended_errcode, sqlite3_finalize, sqlite3_fprintf, sqlite3_free, sqlite3_mprintf, sqlite3_prepare_v2, sqlite3_step, sqlite3_stricmp, SQLITE_DONE, and SQLITE_ROW.

Referenced by tryToClone().

Here is the call graph for this function:

Here is the caller graph for this function:

uintCollFunc()

int uintCollFunc ( void * notUsed, int nKey1, const void * pKey1, int nKey2, const void * pKey2 )

static

 {
  const unsigned char *zA = (const unsigned char*)pKey1;
  const unsigned char *zB = (const unsigned char*)pKey2;
  int i=0, j=0, x;
  (void)notUsed;
  while( i<nKey1 && j<nKey2 ){
    x = zA[i] - zB[j];
    if( isdigit(zA[i]) ){
      int k;
      if( !isdigit(zB[j]) ) return x;
      while( i<nKey1 && zA[i]=='0' ){ i++; }
      while( j<nKey2 && zB[j]=='0' ){ j++; }
      k = 0;
      while( i+k<nKey1 && isdigit(zA[i+k])
             && j+k<nKey2 && isdigit(zB[j+k]) ){
        k++;
      }
      if( i+k<nKey1 && isdigit(zA[i+k]) ){
        return +1;
      }else if( j+k<nKey2 && isdigit(zB[j+k]) ){
        return -1;
      }else{
        x = memcmp(zA+i, zB+j, k);
        if( x ) return x;
        i += k;
        j += k;
      }
    }else if( x ){
      return x;
    }else{
      i++;
      j++;
    }
  }
  return (nKey1 - i) - (nKey2 - j);
}

Referenced by sqlite3_uint_init().

Here is the caller graph for this function:

usage()

void usage ( int showDetail )

static

                                 {
  sqlite3_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. Defaults to :memory:.\n", Argv0);
  if( showDetail ){
    sqlite3_fprintf(stderr,"OPTIONS include:\n%s", zOptions);
  }else{
    eputz("Use the -help option for additional information\n");
  }

References Argv0, eputz, sqlite3_fprintf, and zOptions.

Referenced by lintDotCommand(), and main().

Here is the caller graph for this function:

useDummyCS()

void useDummyCS	(	void *	up1,
		sqlite3 *	db,
		int	etr,
		const char *	zName )

                                                                   {
  (void)up1;
  sqlite3_create_collation_v2(db, zName, etr, 0, dummyCompare, 0);
}

References dummyCompare(), and sqlite3_create_collation_v2.

Referenced by sqlite3_expert_new().

Here is the call graph for this function:

Here is the caller graph for this function:

utf8_width_print()

void utf8_width_print ( FILE * out, int w, const char * zUtf )

static

                                                                {
  const unsigned char *a = (const unsigned char*)zUtf;
  unsigned char c;
  int i = 0;
  int n = 0;
  int k;
  int aw = w<0 ? -w : w;
  if( zUtf==0 ) zUtf = "";
  while( (c = a[i])!=0 ){
    if( (c&0xc0)==0xc0 ){
      int u;
      int len = decodeUtf8(a+i, &u);
      int x = cli_wcwidth(u);
      if( x+n>aw ){
        break;
      }
      i += len;
      n += x;
    }else if( c==0x1b && (k = isVt100(&a[i]))>0 ){
      i += k;       
    }else if( n>=aw ){
      break;
    }else{
      n++;
      i++;
    }
  }
  if( n>=aw ){
    sqlite3_fprintf(out, "%.*s", i, zUtf);
  }else if( w<0 ){
    sqlite3_fprintf(out, "%*s%s", aw-n, "", zUtf);
  }else{
    sqlite3_fprintf(out, "%s%*s", zUtf, aw-n, "");
  }
}

References a, c, cli_wcwidth(), decodeUtf8(), isVt100(), and sqlite3_fprintf.

Referenced by exec_prepared_stmt_columnar(), and shell_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

verify_uninitialized()

void verify_uninitialized ( void )

static

                                      {
  if( sqlite3_config(-1)==SQLITE_MISUSE ){
    sputz(stdout, "WARNING: attempt to configure SQLite after"
          " initialization.\n");

References sputz, sqlite3_config(), and SQLITE_MISUSE.

Referenced by main(), and main_init().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstrace_errcode_name()

const char * vfstrace_errcode_name ( int rc )

static

                                                 {
  const char *zVal = 0;
  switch( rc ){
    case SQLITE_OK:                 zVal = "SQLITE_OK";                 break;
    case SQLITE_INTERNAL:           zVal = "SQLITE_INTERNAL";           break;
    case SQLITE_ERROR:              zVal = "SQLITE_ERROR";              break;
    case SQLITE_PERM:               zVal = "SQLITE_PERM";               break;
    case SQLITE_ABORT:              zVal = "SQLITE_ABORT";              break;
    case SQLITE_BUSY:               zVal = "SQLITE_BUSY";               break;
    case SQLITE_LOCKED:             zVal = "SQLITE_LOCKED";             break;
    case SQLITE_NOMEM:              zVal = "SQLITE_NOMEM";              break;
    case SQLITE_READONLY:           zVal = "SQLITE_READONLY";           break;
    case SQLITE_INTERRUPT:          zVal = "SQLITE_INTERRUPT";          break;
    case SQLITE_IOERR:              zVal = "SQLITE_IOERR";              break;
    case SQLITE_CORRUPT:            zVal = "SQLITE_CORRUPT";            break;
    case SQLITE_NOTFOUND:           zVal = "SQLITE_NOTFOUND";           break;
    case SQLITE_FULL:               zVal = "SQLITE_FULL";               break;
    case SQLITE_CANTOPEN:           zVal = "SQLITE_CANTOPEN";           break;
    case SQLITE_PROTOCOL:           zVal = "SQLITE_PROTOCOL";           break;
    case SQLITE_EMPTY:              zVal = "SQLITE_EMPTY";              break;
    case SQLITE_SCHEMA:             zVal = "SQLITE_SCHEMA";             break;
    case SQLITE_TOOBIG:             zVal = "SQLITE_TOOBIG";             break;
    case SQLITE_CONSTRAINT:         zVal = "SQLITE_CONSTRAINT";         break;
    case SQLITE_MISMATCH:           zVal = "SQLITE_MISMATCH";           break;
    case SQLITE_MISUSE:             zVal = "SQLITE_MISUSE";             break;
    case SQLITE_NOLFS:              zVal = "SQLITE_NOLFS";              break;
    case SQLITE_IOERR_READ:         zVal = "SQLITE_IOERR_READ";         break;
    case SQLITE_IOERR_SHORT_READ:   zVal = "SQLITE_IOERR_SHORT_READ";   break;
    case SQLITE_IOERR_WRITE:        zVal = "SQLITE_IOERR_WRITE";        break;
    case SQLITE_IOERR_FSYNC:        zVal = "SQLITE_IOERR_FSYNC";        break;
    case SQLITE_IOERR_DIR_FSYNC:    zVal = "SQLITE_IOERR_DIR_FSYNC";    break;
    case SQLITE_IOERR_TRUNCATE:     zVal = "SQLITE_IOERR_TRUNCATE";     break;
    case SQLITE_IOERR_FSTAT:        zVal = "SQLITE_IOERR_FSTAT";        break;
    case SQLITE_IOERR_UNLOCK:       zVal = "SQLITE_IOERR_UNLOCK";       break;
    case SQLITE_IOERR_RDLOCK:       zVal = "SQLITE_IOERR_RDLOCK";       break;
    case SQLITE_IOERR_DELETE:       zVal = "SQLITE_IOERR_DELETE";       break;
    case SQLITE_IOERR_BLOCKED:      zVal = "SQLITE_IOERR_BLOCKED";      break;
    case SQLITE_IOERR_NOMEM:        zVal = "SQLITE_IOERR_NOMEM";        break;
    case SQLITE_IOERR_ACCESS:       zVal = "SQLITE_IOERR_ACCESS";       break;
    case SQLITE_IOERR_CHECKRESERVEDLOCK:
                               zVal = "SQLITE_IOERR_CHECKRESERVEDLOCK"; break;
    case SQLITE_IOERR_LOCK:         zVal = "SQLITE_IOERR_LOCK";         break;
    case SQLITE_IOERR_CLOSE:        zVal = "SQLITE_IOERR_CLOSE";        break;
    case SQLITE_IOERR_DIR_CLOSE:    zVal = "SQLITE_IOERR_DIR_CLOSE";    break;
    case SQLITE_IOERR_SHMOPEN:      zVal = "SQLITE_IOERR_SHMOPEN";      break;
    case SQLITE_IOERR_SHMSIZE:      zVal = "SQLITE_IOERR_SHMSIZE";      break;
    case SQLITE_IOERR_SHMLOCK:      zVal = "SQLITE_IOERR_SHMLOCK";      break;
    case SQLITE_IOERR_SHMMAP:       zVal = "SQLITE_IOERR_SHMMAP";       break;
    case SQLITE_IOERR_SEEK:         zVal = "SQLITE_IOERR_SEEK";         break;
    case SQLITE_IOERR_GETTEMPPATH:  zVal = "SQLITE_IOERR_GETTEMPPATH";  break;
    case SQLITE_IOERR_CONVPATH:     zVal = "SQLITE_IOERR_CONVPATH";     break;
    case SQLITE_READONLY_DBMOVED:   zVal = "SQLITE_READONLY_DBMOVED";   break;
    case SQLITE_LOCKED_SHAREDCACHE: zVal = "SQLITE_LOCKED_SHAREDCACHE"; break;
    case SQLITE_BUSY_RECOVERY:      zVal = "SQLITE_BUSY_RECOVERY";      break;
    case SQLITE_CANTOPEN_NOTEMPDIR: zVal = "SQLITE_CANTOPEN_NOTEMPDIR"; break;
  }
  return zVal;
}

References SQLITE_ABORT, SQLITE_BUSY, SQLITE_BUSY_RECOVERY, SQLITE_CANTOPEN, SQLITE_CANTOPEN_NOTEMPDIR, SQLITE_CONSTRAINT, SQLITE_CORRUPT, SQLITE_EMPTY, SQLITE_ERROR, SQLITE_FULL, SQLITE_INTERNAL, SQLITE_INTERRUPT, SQLITE_IOERR, SQLITE_IOERR_ACCESS, SQLITE_IOERR_BLOCKED, SQLITE_IOERR_CHECKRESERVEDLOCK, SQLITE_IOERR_CLOSE, SQLITE_IOERR_CONVPATH, SQLITE_IOERR_DELETE, SQLITE_IOERR_DIR_CLOSE, SQLITE_IOERR_DIR_FSYNC, SQLITE_IOERR_FSTAT, SQLITE_IOERR_FSYNC, SQLITE_IOERR_GETTEMPPATH, SQLITE_IOERR_LOCK, SQLITE_IOERR_NOMEM, SQLITE_IOERR_RDLOCK, SQLITE_IOERR_READ, SQLITE_IOERR_SEEK, SQLITE_IOERR_SHMLOCK, SQLITE_IOERR_SHMMAP, SQLITE_IOERR_SHMOPEN, SQLITE_IOERR_SHMSIZE, SQLITE_IOERR_SHORT_READ, SQLITE_IOERR_TRUNCATE, SQLITE_IOERR_UNLOCK, SQLITE_IOERR_WRITE, SQLITE_LOCKED, SQLITE_LOCKED_SHAREDCACHE, SQLITE_MISMATCH, SQLITE_MISUSE, SQLITE_NOLFS, SQLITE_NOMEM, SQLITE_NOTFOUND, SQLITE_OK, SQLITE_PERM, SQLITE_PROTOCOL, SQLITE_READONLY, SQLITE_READONLY_DBMOVED, SQLITE_SCHEMA, and SQLITE_TOOBIG.

Referenced by vfstrace_print_errcode().

Here is the caller graph for this function:

vfstrace_print_errcode()

void vfstrace_print_errcode ( vfstrace_info * pInfo, const char * zFormat, int rc )

static

 {
  const char *zVal;
  char zBuf[50];
  zVal = vfstrace_errcode_name(rc);
  if( zVal==0 ){
    zVal = vfstrace_errcode_name(rc&0xff);
    if( zVal ){
      sqlite3_snprintf(sizeof(zBuf), zBuf, "%s | 0x%x", zVal, rc&0xffff00);
    }else{
      sqlite3_snprintf(sizeof(zBuf), zBuf, "%d (0x%x)", rc, rc);
    }
    zVal = zBuf;
  }
  vfstrace_printf(pInfo, zFormat, zVal);
}

References sqlite3_snprintf, vfstrace_errcode_name(), and vfstrace_printf().

Referenced by vfstraceAccess(), vfstraceCheckReservedLock(), vfstraceClose(), vfstraceDelete(), vfstraceFetch(), vfstraceFileControl(), vfstraceFileSize(), vfstraceFullPathname(), vfstraceLock(), vfstraceOpen(), vfstraceRead(), vfstraceShmLock(), vfstraceShmMap(), vfstraceShmUnmap(), vfstraceUnfetch(), vfstraceUnlock(), and vfstraceWrite().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstrace_printf()

void vfstrace_printf ( vfstrace_info * pInfo, const char * zFormat, ... )

static

 {
  va_list ap;
  char *zMsg;
  if( pInfo->bOn ){
    va_start(ap, zFormat);
    zMsg = sqlite3_vmprintf(zFormat, ap);
    va_end(ap);
    pInfo->xOut(zMsg, pInfo->pOutArg);
    sqlite3_free(zMsg);
  }
}

References vfstrace_info::bOn, vfstrace_info::pOutArg, sqlite3_free, sqlite3_vmprintf, and vfstrace_info::xOut.

Referenced by vfstrace_print_errcode(), vfstrace_register(), vfstraceAccess(), vfstraceCheckReservedLock(), vfstraceClose(), vfstraceCurrentTime(), vfstraceCurrentTimeInt64(), vfstraceDelete(), vfstraceDeviceCharacteristics(), vfstraceDlClose(), vfstraceDlError(), vfstraceDlOpen(), vfstraceFetch(), vfstraceFileControl(), vfstraceFileSize(), vfstraceFullPathname(), vfstraceGetLastError(), vfstraceLock(), vfstraceOpen(), vfstraceRandomness(), vfstraceRead(), vfstraceSectorSize(), vfstraceShmBarrier(), vfstraceShmLock(), vfstraceShmMap(), vfstraceShmUnmap(), vfstraceSleep(), vfstraceSync(), vfstraceTruncate(), vfstraceUnfetch(), vfstraceUnlock(), and vfstraceWrite().

Here is the caller graph for this function:

vfstrace_register()

int vfstrace_register	(	const char *	zTraceName,
		const char *	zOldVfsName,
		int(*	xOut )(const char *, void *),
		void *	pOutArg,
		int	makeDefault )

 {
  sqlite3_vfs *pNew;
  sqlite3_vfs *pRoot;
  vfstrace_info *pInfo;
  size_t nName;
  size_t nByte;
 
  pRoot = sqlite3_vfs_find(zOldVfsName);
  if( pRoot==0 ) return SQLITE_NOTFOUND;
  nName = strlen(zTraceName);
  nByte = sizeof(*pNew) + sizeof(*pInfo) + nName + 1;
  pNew = sqlite3_malloc64( nByte );
  if( pNew==0 ) return SQLITE_NOMEM;
  memset(pNew, 0, nByte);
  pInfo = (vfstrace_info*)&pNew[1];
  pNew->iVersion = pRoot->iVersion;
  pNew->szOsFile = pRoot->szOsFile + sizeof(vfstrace_file);
  pNew->mxPathname = pRoot->mxPathname;
  pNew->zName = (char*)&pInfo[1];
  memcpy((char*)&pInfo[1], zTraceName, nName+1);
  pNew->pAppData = pInfo;
  pNew->xOpen = vfstraceOpen;
  pNew->xDelete = vfstraceDelete;
  pNew->xAccess = vfstraceAccess;
  pNew->xFullPathname = vfstraceFullPathname;
  pNew->xDlOpen = pRoot->xDlOpen==0 ? 0 : vfstraceDlOpen;
  pNew->xDlError = pRoot->xDlError==0 ? 0 : vfstraceDlError;
  pNew->xDlSym = pRoot->xDlSym==0 ? 0 : vfstraceDlSym;
  pNew->xDlClose = pRoot->xDlClose==0 ? 0 : vfstraceDlClose;
  pNew->xRandomness = vfstraceRandomness;
  pNew->xSleep = vfstraceSleep;
  pNew->xCurrentTime = vfstraceCurrentTime;
  pNew->xGetLastError = pRoot->xGetLastError==0 ? 0 : vfstraceGetLastError;
  if( pNew->iVersion>=2 ){
    pNew->xCurrentTimeInt64 = pRoot->xCurrentTimeInt64==0 ? 0 :
                                   vfstraceCurrentTimeInt64;
    if( pNew->iVersion>=3 ){
      pNew->xSetSystemCall = pRoot->xSetSystemCall==0 ? 0 : 
                                   vfstraceSetSystemCall;
      pNew->xGetSystemCall = pRoot->xGetSystemCall==0 ? 0 : 
                                   vfstraceGetSystemCall;
      pNew->xNextSystemCall = pRoot->xNextSystemCall==0 ? 0 : 
                                   vfstraceNextSystemCall;
    }
  }
  pInfo->pRootVfs = pRoot;
  pInfo->xOut = xOut;
  pInfo->pOutArg = pOutArg;
  pInfo->zVfsName = pNew->zName;
  pInfo->pTraceVfs = pNew;
  pInfo->mTrace = 0xffffffff;
  pInfo->bOn = 1;
  vfstrace_printf(pInfo, "%s.enabled_for(\"%s\")\n",
       pInfo->zVfsName, pRoot->zName);
  return sqlite3_vfs_register(pNew, makeDefault);
}

References vfstrace_info::bOn, sqlite3_vfs::iVersion, vfstrace_info::mTrace, sqlite3_vfs::mxPathname, sqlite3_vfs::pAppData, vfstrace_info::pOutArg, vfstrace_info::pRootVfs, vfstrace_info::pTraceVfs, sqlite3_malloc64, sqlite3_vfs_find, sqlite3_vfs_register, SQLITE_NOMEM, SQLITE_NOTFOUND, sqlite3_vfs::szOsFile, vfstrace_printf(), vfstraceAccess(), vfstraceCurrentTime(), vfstraceCurrentTimeInt64(), vfstraceDelete(), vfstraceDlClose(), vfstraceDlError(), vfstraceDlOpen(), vfstraceDlSym, vfstraceFullPathname(), vfstraceGetLastError(), vfstraceGetSystemCall(), vfstraceNextSystemCall(), vfstraceOpen(), vfstraceRandomness(), vfstraceSetSystemCall(), vfstraceSleep(), sqlite3_vfs::xAccess, sqlite3_vfs::xCurrentTime, sqlite3_vfs::xCurrentTimeInt64, sqlite3_vfs::xDelete, sqlite3_vfs::xDlClose, sqlite3_vfs::xDlError, sqlite3_vfs::xDlOpen, sqlite3_vfs::xDlSym, sqlite3_vfs::xFullPathname, sqlite3_vfs::xGetLastError, sqlite3_vfs::xGetSystemCall, sqlite3_vfs::xNextSystemCall, sqlite3_vfs::xOpen, vfstrace_info::xOut, sqlite3_vfs::xRandomness, sqlite3_vfs::xSetSystemCall, sqlite3_vfs::xSleep, sqlite3_vfs::zName, and vfstrace_info::zVfsName.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstrace_unregister()

void vfstrace_unregister

(

const char *

zTraceName

)

                                                {
  sqlite3_vfs *pVfs = sqlite3_vfs_find(zTraceName);
  if( pVfs==0 ) return;
  if( pVfs->xOpen!=vfstraceOpen ) return;
  sqlite3_vfs_unregister(pVfs);
  sqlite3_free(pVfs);
}

References sqlite3_free, sqlite3_vfs_find, sqlite3_vfs_unregister, vfstraceOpen(), and sqlite3_vfs::xOpen.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceAccess()

int vfstraceAccess ( sqlite3_vfs * pVfs, const char * zName, int flags, int * pResOut )

static

 {
  vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
  sqlite3_vfs *pRoot = pInfo->pRootVfs;
  int rc;
  vfstraceOnOff(pInfo, VTR_ACCESS);
  vfstrace_printf(pInfo, "%s.xAccess(\"%s\",%d)",
                  pInfo->zVfsName, zPath, flags);
  rc = pRoot->xAccess(pRoot, zPath, flags, pResOut);
  vfstrace_print_errcode(pInfo, " -> %s", rc);
  vfstrace_printf(pInfo, ", out=%d\n", *pResOut);
  return rc;
}

References sqlite3_vfs::pAppData, vfstrace_info::pRootVfs, vfstrace_print_errcode(), vfstrace_printf(), vfstraceOnOff(), VTR_ACCESS, sqlite3_vfs::xAccess, and vfstrace_info::zVfsName.

Referenced by vfstrace_register().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceCheckReservedLock()

int vfstraceCheckReservedLock ( sqlite3_file * pFile, int * pResOut )

static

                                                                       {
  vfstrace_file *p = (vfstrace_file *)pFile;
  vfstrace_info *pInfo = p->pInfo;
  int rc;
  vfstraceOnOff(pInfo, VTR_CRL);
  vfstrace_printf(pInfo, "%s.xCheckReservedLock(%s,%d)", 
                  pInfo->zVfsName, p->zFName);
  rc = p->pReal->pMethods->xCheckReservedLock(p->pReal, pResOut);
  vfstrace_print_errcode(pInfo, " -> %s", rc);
  vfstrace_printf(pInfo, ", out=%d\n", *pResOut);
  return rc;
}

References vfstrace_file::pInfo, sqlite3_file::pMethods, vfstrace_file::pReal, vfstrace_print_errcode(), vfstrace_printf(), vfstraceOnOff(), VTR_CRL, sqlite3_io_methods::xCheckReservedLock, vfstrace_file::zFName, and vfstrace_info::zVfsName.

Referenced by vfstraceOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceClose()

int vfstraceClose ( sqlite3_file * pFile )

static

                                             {
  vfstrace_file *p = (vfstrace_file *)pFile;
  vfstrace_info *pInfo = p->pInfo;
  int rc;
  vfstraceOnOff(pInfo, VTR_CLOSE);
  vfstrace_printf(pInfo, "%s.xClose(%s)", pInfo->zVfsName, p->zFName);
  rc = p->pReal->pMethods->xClose(p->pReal);
  vfstrace_print_errcode(pInfo, " -> %s\n", rc);
  if( rc==SQLITE_OK ){
    sqlite3_free((void*)p->base.pMethods);
    p->base.pMethods = 0;
  }
  return rc;
}

References vfstrace_file::base, vfstrace_file::pInfo, sqlite3_file::pMethods, vfstrace_file::pReal, sqlite3_free, SQLITE_OK, vfstrace_print_errcode(), vfstrace_printf(), vfstraceOnOff(), VTR_CLOSE, sqlite3_io_methods::xClose, vfstrace_file::zFName, and vfstrace_info::zVfsName.

Referenced by vfstraceOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceCurrentTime()

int vfstraceCurrentTime ( sqlite3_vfs * pVfs, double * pTimeOut )

static

                                                                   {
  vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
  sqlite3_vfs *pRoot = pInfo->pRootVfs;
  int rc;
  vfstraceOnOff(pInfo, VTR_CURTIME);
  vfstrace_printf(pInfo, "%s.xCurrentTime()", pInfo->zVfsName);
  rc = pRoot->xCurrentTime(pRoot, pTimeOut);
  vfstrace_printf(pInfo, " -> %.17g\n", *pTimeOut);
  return rc;
}

References sqlite3_vfs::pAppData, vfstrace_info::pRootVfs, vfstrace_printf(), vfstraceOnOff(), VTR_CURTIME, sqlite3_vfs::xCurrentTime, and vfstrace_info::zVfsName.

Referenced by vfstrace_register().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceCurrentTimeInt64()

int vfstraceCurrentTimeInt64 ( sqlite3_vfs * pVfs, sqlite3_int64 * pTimeOut )

static

                                                                               {
  vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
  sqlite3_vfs *pRoot = pInfo->pRootVfs;
  int rc;
  vfstraceOnOff(pInfo, VTR_CURTIME);
  vfstrace_printf(pInfo, "%s.xCurrentTimeInt64()", pInfo->zVfsName);
  rc = pRoot->xCurrentTimeInt64(pRoot, pTimeOut);
  vfstrace_printf(pInfo, " -> %lld\n", *pTimeOut);
  return rc;
}

References sqlite3_vfs::pAppData, vfstrace_info::pRootVfs, vfstrace_printf(), vfstraceOnOff(), VTR_CURTIME, sqlite3_vfs::xCurrentTimeInt64, and vfstrace_info::zVfsName.

Referenced by vfstrace_register().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceDelete()

int vfstraceDelete ( sqlite3_vfs * pVfs, const char * zName, int syncDir )

static

                                                                            {
  vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
  sqlite3_vfs *pRoot = pInfo->pRootVfs;
  int rc;
  vfstraceOnOff(pInfo, VTR_DELETE);
  vfstrace_printf(pInfo, "%s.xDelete(\"%s\",%d)",
                  pInfo->zVfsName, zPath, dirSync);
  rc = pRoot->xDelete(pRoot, zPath, dirSync);
  vfstrace_print_errcode(pInfo, " -> %s\n", rc);
  return rc;
}

References sqlite3_vfs::pAppData, vfstrace_info::pRootVfs, vfstrace_print_errcode(), vfstrace_printf(), vfstraceOnOff(), VTR_DELETE, sqlite3_vfs::xDelete, and vfstrace_info::zVfsName.

Referenced by vfstrace_register().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceDeviceCharacteristics()

int vfstraceDeviceCharacteristics ( sqlite3_file * pFile )

static

                                                             {
  vfstrace_file *p = (vfstrace_file *)pFile;
  vfstrace_info *pInfo = p->pInfo;
  int rc;
  vfstraceOnOff(pInfo, VTR_DEVCHAR);
  vfstrace_printf(pInfo, "%s.xDeviceCharacteristics(%s)",
                  pInfo->zVfsName, p->zFName);
  rc = p->pReal->pMethods->xDeviceCharacteristics(p->pReal);
  vfstrace_printf(pInfo, " -> 0x%08x\n", rc);
  return rc;
}

References vfstrace_file::pInfo, sqlite3_file::pMethods, vfstrace_file::pReal, vfstrace_printf(), vfstraceOnOff(), VTR_DEVCHAR, sqlite3_io_methods::xDeviceCharacteristics, vfstrace_file::zFName, and vfstrace_info::zVfsName.

Referenced by vfstraceOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceDlClose()

void vfstraceDlClose ( sqlite3_vfs * pVfs, void * pHandle )

static

                                                             {
  vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
  sqlite3_vfs *pRoot = pInfo->pRootVfs;
  vfstraceOnOff(pInfo, VTR_DLCLOSE);
  vfstrace_printf(pInfo, "%s.xDlClose()\n", pInfo->zVfsName);
  pRoot->xDlClose(pRoot, pHandle);
}

References sqlite3_vfs::pAppData, vfstrace_info::pRootVfs, vfstrace_printf(), vfstraceOnOff(), VTR_DLCLOSE, sqlite3_vfs::xDlClose, and vfstrace_info::zVfsName.

Referenced by vfstrace_register().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceDlError()

void vfstraceDlError ( sqlite3_vfs * pVfs, int nByte, char * zErrMsg )

static

                                                                        {
  vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
  sqlite3_vfs *pRoot = pInfo->pRootVfs;
  vfstraceOnOff(pInfo, VTR_DLERR);
  vfstrace_printf(pInfo, "%s.xDlError(%d)", pInfo->zVfsName, nByte);
  pRoot->xDlError(pRoot, nByte, zErrMsg);
  vfstrace_printf(pInfo, " -> \"%s\"", zErrMsg);
}

References sqlite3_vfs::pAppData, vfstrace_info::pRootVfs, vfstrace_printf(), vfstraceOnOff(), VTR_DLERR, sqlite3_vfs::xDlError, and vfstrace_info::zVfsName.

Referenced by vfstrace_register().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceDlOpen()

void * vfstraceDlOpen ( sqlite3_vfs * pVfs, const char * zFilename )

static

                                                                 {
  vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
  sqlite3_vfs *pRoot = pInfo->pRootVfs;
  vfstraceOnOff(pInfo, VTR_DLOPEN);
  vfstrace_printf(pInfo, "%s.xDlOpen(\"%s\")\n", pInfo->zVfsName, zPath);
  return pRoot->xDlOpen(pRoot, zPath);
}

References sqlite3_vfs::pAppData, vfstrace_info::pRootVfs, vfstrace_printf(), vfstraceOnOff(), VTR_DLOPEN, sqlite3_vfs::xDlOpen, and vfstrace_info::zVfsName.

Referenced by vfstrace_register().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceFetch()

int vfstraceFetch ( sqlite3_file * pFile, i64 iOff, int nAmt, void ** pptr )

static

                                                                              {
  vfstrace_file *p = (vfstrace_file *)pFile;
  vfstrace_info *pInfo = p->pInfo;
  int rc;
  vfstraceOnOff(pInfo, VTR_FETCH);
  vfstrace_printf(pInfo, "%s.xFetch(%s,iOff=%lld,nAmt=%d,p=%p)",
                  pInfo->zVfsName, p->zFName, iOff, nAmt, *pptr);
  rc = p->pReal->pMethods->xFetch(p->pReal, iOff, nAmt, pptr);
  vfstrace_print_errcode(pInfo, " -> %s\n", rc);
  return rc;
}

References vfstrace_file::pInfo, sqlite3_file::pMethods, vfstrace_file::pReal, vfstrace_print_errcode(), vfstrace_printf(), vfstraceOnOff(), VTR_FETCH, sqlite3_io_methods::xFetch, vfstrace_file::zFName, and vfstrace_info::zVfsName.

Referenced by vfstraceOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceFileControl()

int vfstraceFileControl ( sqlite3_file * pFile, int op, void * pArg )

static

                                                                       {
  vfstrace_file *p = (vfstrace_file *)pFile;
  vfstrace_info *pInfo = p->pInfo;
  int rc;
  char zBuf[100];
  char zBuf2[100];
  char *zOp;
  char *zRVal = 0;
  vfstraceOnOff(pInfo, VTR_FCTRL);
  switch( op ){
    case SQLITE_FCNTL_LOCKSTATE:           zOp = "LOCKSTATE";           break;
    case SQLITE_GET_LOCKPROXYFILE:         zOp = "GET_LOCKPROXYFILE";   break;
    case SQLITE_SET_LOCKPROXYFILE:         zOp = "SET_LOCKPROXYFILE";   break;
    case SQLITE_LAST_ERRNO:                zOp = "LAST_ERRNO";          break;
    case SQLITE_FCNTL_SIZE_HINT: {
      sqlite3_snprintf(sizeof(zBuf), zBuf, "SIZE_HINT,%lld",
                       *(sqlite3_int64*)pArg);
      zOp = zBuf;
      break;
    }
    case SQLITE_FCNTL_CHUNK_SIZE: {
      sqlite3_snprintf(sizeof(zBuf), zBuf, "CHUNK_SIZE,%d", *(int*)pArg);
      zOp = zBuf;
      break;
    }
    case SQLITE_FCNTL_FILE_POINTER:        zOp = "FILE_POINTER";        break;
    case SQLITE_FCNTL_WIN32_AV_RETRY:      zOp = "WIN32_AV_RETRY";      break;
    case SQLITE_FCNTL_PERSIST_WAL: {
       sqlite3_snprintf(sizeof(zBuf), zBuf, "PERSIST_WAL,%d", *(int*)pArg);
       zOp = zBuf;
       break;
    }
    case SQLITE_FCNTL_OVERWRITE:           zOp = "OVERWRITE";           break;
    case SQLITE_FCNTL_VFSNAME:             zOp = "VFSNAME";             break;
    case SQLITE_FCNTL_POWERSAFE_OVERWRITE: zOp = "POWERSAFE_OVERWRITE"; break;
    case SQLITE_FCNTL_PRAGMA: {
      const char *const* a = (const char*const*)pArg;
      if( a[1] && strcmp(a[1],"vfstrace")==0 && a[2] ){
        const u8 *zArg = (const u8*)a[2];
        if( zArg[0]>='0' && zArg[0]<='9' ){
          pInfo->mTrace = (sqlite3_uint64)strtoll(a[2], 0, 0);
        }else{
          static const struct {
            const char *z;
            unsigned int m;
          } aKw[] = {
            { "all",                   0xffffffff   },
            { "close",                 VTR_CLOSE    },
            { "read",                  VTR_READ     },
            { "write",                 VTR_WRITE    },
            { "truncate",              VTR_TRUNC    },
            { "sync",                  VTR_SYNC     },
            { "filesize",              VTR_FSIZE    },
            { "lock",                  VTR_LOCK     },
            { "unlock",                VTR_UNLOCK   },
            { "checkreservedlock",     VTR_CRL      },
            { "filecontrol",           VTR_FCTRL    },
            { "sectorsize",            VTR_SECSZ    },
            { "devicecharacteristics", VTR_DEVCHAR  },
            { "shmlock",               VTR_SHMLOCK  },
            { "shmmap",                VTR_SHMMAP   },
            { "shmummap",              VTR_SHMUNMAP },
            { "shmbarrier",            VTR_SHMBAR   },
            { "open",                  VTR_OPEN     },
            { "delete",                VTR_DELETE   },
            { "access",                VTR_ACCESS   },
            { "fullpathname",          VTR_FULLPATH },
            { "dlopen",                VTR_DLOPEN   },
            { "dlerror",               VTR_DLERR    },
            { "dlsym",                 VTR_DLSYM    },
            { "dlclose",               VTR_DLCLOSE  },
            { "randomness",            VTR_RAND     },
            { "sleep",                 VTR_SLEEP    },
            { "currenttime",           VTR_CURTIME  },
            { "currenttimeint64",      VTR_CURTIME  },
            { "getlasterror",          VTR_LASTERR  },
            { "fetch",                 VTR_FETCH    },
          };
          int onOff = 1;
          while( zArg[0] ){
            int jj, n;
            while( zArg[0]!=0 && zArg[0]!='-' && zArg[0]!='+'
                   && !isalpha(zArg[0]) ) zArg++;
            if( zArg[0]==0 ) break;
            if( zArg[0]=='-' ){
              onOff = 0;
              zArg++;
            }else if( zArg[0]=='+' ){
              onOff = 1;
              zArg++;
            }
            while( !isalpha(zArg[0]) ){
              if( zArg[0]==0 ) break;
              zArg++;
            }
            if( zArg[0]=='x' && isalpha(zArg[1]) ) zArg++;
            for(n=0; isalpha(zArg[n]); n++){}
            for(jj=0; jj<(int)(sizeof(aKw)/sizeof(aKw[0])); jj++){
              if( sqlite3_strnicmp(aKw[jj].z,(const char*)zArg,n)==0 ){
                if( onOff ){
                  pInfo->mTrace |= aKw[jj].m;
                }else{
                  pInfo->mTrace &= ~aKw[jj].m;
                }
                break;
              }
            }
            zArg += n;
          }
        }
      }
      sqlite3_snprintf(sizeof(zBuf), zBuf, "PRAGMA,[%s,%s]",a[1],a[2]);
      zOp = zBuf;
      break;
    }
    case SQLITE_FCNTL_BUSYHANDLER:         zOp = "BUSYHANDLER";         break;
    case SQLITE_FCNTL_TEMPFILENAME:        zOp = "TEMPFILENAME";        break;
    case SQLITE_FCNTL_MMAP_SIZE: {
      sqlite3_int64 iMMap = *(sqlite3_int64*)pArg;
      sqlite3_snprintf(sizeof(zBuf), zBuf, "MMAP_SIZE,%lld",iMMap);
      zOp = zBuf;
      break;
    }
    case SQLITE_FCNTL_TRACE:               zOp = "TRACE";               break;
    case SQLITE_FCNTL_HAS_MOVED:           zOp = "HAS_MOVED";           break;
    case SQLITE_FCNTL_SYNC:                zOp = "SYNC";                break;
    case SQLITE_FCNTL_COMMIT_PHASETWO:     zOp = "COMMIT_PHASETWO";     break;
    case SQLITE_FCNTL_WIN32_SET_HANDLE:    zOp = "WIN32_SET_HANDLE";    break;
    case SQLITE_FCNTL_WAL_BLOCK:           zOp = "WAL_BLOCK";           break;
    case SQLITE_FCNTL_ZIPVFS:              zOp = "ZIPVFS";              break; 
    case SQLITE_FCNTL_RBU:                 zOp = "RBU";                 break;
    case SQLITE_FCNTL_VFS_POINTER:         zOp = "VFS_POINTER";         break;
    case SQLITE_FCNTL_JOURNAL_POINTER:     zOp = "JOURNAL_POINTER";     break;
    case SQLITE_FCNTL_WIN32_GET_HANDLE:    zOp = "WIN32_GET_HANDLE";    break;
    case SQLITE_FCNTL_PDB:                 zOp = "PDB";                 break;
    case SQLITE_FCNTL_BEGIN_ATOMIC_WRITE:  zOp = "BEGIN_ATOMIC_WRITE";  break;
    case SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: zOp = "COMMIT_ATOMIC_WRITE"; break;
    case SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: {
       zOp = "ROLLBACK_ATOMIC_WRITE";
       break;
    }
    case SQLITE_FCNTL_LOCK_TIMEOUT: {
       sqlite3_snprintf(sizeof(zBuf), zBuf, "LOCK_TIMEOUT,%d", *(int*)pArg);
       zOp = zBuf;
       break;
    }
    case SQLITE_FCNTL_DATA_VERSION:        zOp = "DATA_VERSION";        break;
    case SQLITE_FCNTL_SIZE_LIMIT:          zOp = "SIZE_LIMIT";          break;
    case SQLITE_FCNTL_CKPT_DONE:           zOp = "CKPT_DONE";           break;
    case SQLITE_FCNTL_RESERVE_BYTES:       zOp = "RESERVED_BYTES";      break;
    case SQLITE_FCNTL_CKPT_START:          zOp = "CKPT_START";          break;
    case SQLITE_FCNTL_EXTERNAL_READER:     zOp = "EXTERNAL_READER";     break;
    case SQLITE_FCNTL_CKSM_FILE:           zOp = "CKSM_FILE";           break;
    case SQLITE_FCNTL_RESET_CACHE:         zOp = "RESET_CACHE";         break;
    case 0xca093fa0:                       zOp = "DB_UNCHANGED";        break;
    default: {
      sqlite3_snprintf(sizeof zBuf, zBuf, "%d", op);
      zOp = zBuf;
      break;
    }
  }
  vfstrace_printf(pInfo, "%s.xFileControl(%s,%s)",
                  pInfo->zVfsName, p->zFName, zOp);
  rc = p->pReal->pMethods->xFileControl(p->pReal, op, pArg);
  if( rc==SQLITE_OK ){
    switch( op ){
      case SQLITE_FCNTL_VFSNAME: {
        *(char**)pArg = sqlite3_mprintf("vfstrace.%s/%z",
                                    pInfo->zVfsName, *(char**)pArg);
        zRVal = *(char**)pArg;
        break;
      }
      case SQLITE_FCNTL_MMAP_SIZE: {
        sqlite3_snprintf(sizeof(zBuf2), zBuf2, "%lld", *(sqlite3_int64*)pArg);
        zRVal = zBuf2;
        break;
      }
      case SQLITE_FCNTL_HAS_MOVED:
      case SQLITE_FCNTL_PERSIST_WAL: {
        sqlite3_snprintf(sizeof(zBuf2), zBuf2, "%d", *(int*)pArg);
        zRVal = zBuf2;
        break;
      }
      case SQLITE_FCNTL_PRAGMA:
      case SQLITE_FCNTL_TEMPFILENAME: {
        zRVal = *(char**)pArg;
        break;
      }
    }
  }
  if( zRVal ){
    vfstrace_print_errcode(pInfo, " -> %s", rc);
    vfstrace_printf(pInfo, ", %s\n", zRVal);
  }else{
    vfstrace_print_errcode(pInfo, " -> %s\n", rc);
  }
  return rc;
}

References a, vfstrace_info::mTrace, vfstrace_file::pInfo, sqlite3_file::pMethods, vfstrace_file::pReal, sqlite3_mprintf, sqlite3_snprintf, sqlite3_strnicmp, SQLITE_FCNTL_BEGIN_ATOMIC_WRITE, SQLITE_FCNTL_BUSYHANDLER, SQLITE_FCNTL_CHUNK_SIZE, SQLITE_FCNTL_CKPT_DONE, SQLITE_FCNTL_CKPT_START, SQLITE_FCNTL_CKSM_FILE, SQLITE_FCNTL_COMMIT_ATOMIC_WRITE, SQLITE_FCNTL_COMMIT_PHASETWO, SQLITE_FCNTL_DATA_VERSION, SQLITE_FCNTL_EXTERNAL_READER, SQLITE_FCNTL_FILE_POINTER, SQLITE_FCNTL_HAS_MOVED, SQLITE_FCNTL_JOURNAL_POINTER, SQLITE_FCNTL_LOCK_TIMEOUT, SQLITE_FCNTL_LOCKSTATE, SQLITE_FCNTL_MMAP_SIZE, SQLITE_FCNTL_OVERWRITE, SQLITE_FCNTL_PDB, SQLITE_FCNTL_PERSIST_WAL, SQLITE_FCNTL_POWERSAFE_OVERWRITE, SQLITE_FCNTL_PRAGMA, SQLITE_FCNTL_RBU, SQLITE_FCNTL_RESERVE_BYTES, SQLITE_FCNTL_RESET_CACHE, SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE, SQLITE_FCNTL_SIZE_HINT, SQLITE_FCNTL_SIZE_LIMIT, SQLITE_FCNTL_SYNC, SQLITE_FCNTL_TEMPFILENAME, SQLITE_FCNTL_TRACE, SQLITE_FCNTL_VFS_POINTER, SQLITE_FCNTL_VFSNAME, SQLITE_FCNTL_WAL_BLOCK, SQLITE_FCNTL_WIN32_AV_RETRY, SQLITE_FCNTL_WIN32_GET_HANDLE, SQLITE_FCNTL_WIN32_SET_HANDLE, SQLITE_FCNTL_ZIPVFS, SQLITE_GET_LOCKPROXYFILE, SQLITE_LAST_ERRNO, SQLITE_OK, SQLITE_SET_LOCKPROXYFILE, vfstrace_print_errcode(), vfstrace_printf(), vfstraceOnOff(), VTR_ACCESS, VTR_CLOSE, VTR_CRL, VTR_CURTIME, VTR_DELETE, VTR_DEVCHAR, VTR_DLCLOSE, VTR_DLERR, VTR_DLOPEN, VTR_DLSYM, VTR_FCTRL, VTR_FETCH, VTR_FSIZE, VTR_FULLPATH, VTR_LASTERR, VTR_LOCK, VTR_OPEN, VTR_RAND, VTR_READ, VTR_SECSZ, VTR_SHMBAR, VTR_SHMLOCK, VTR_SHMMAP, VTR_SHMUNMAP, VTR_SLEEP, VTR_SYNC, VTR_TRUNC, VTR_UNLOCK, VTR_WRITE, sqlite3_io_methods::xFileControl, vfstrace_file::zFName, and vfstrace_info::zVfsName.

Referenced by vfstraceOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceFileSize()

int vfstraceFileSize ( sqlite3_file * pFile, sqlite3_int64 * pSize )

static

                                                                     {
  vfstrace_file *p = (vfstrace_file *)pFile;
  vfstrace_info *pInfo = p->pInfo;
  int rc;
  vfstraceOnOff(pInfo, VTR_FSIZE);
  vfstrace_printf(pInfo, "%s.xFileSize(%s)", pInfo->zVfsName, p->zFName);
  rc = p->pReal->pMethods->xFileSize(p->pReal, pSize);
  vfstrace_print_errcode(pInfo, " -> %s,", rc);
  vfstrace_printf(pInfo, " size=%lld\n", *pSize);
  return rc;
}

References vfstrace_file::pInfo, sqlite3_file::pMethods, vfstrace_file::pReal, vfstrace_print_errcode(), vfstrace_printf(), vfstraceOnOff(), VTR_FSIZE, sqlite3_io_methods::xFileSize, vfstrace_file::zFName, and vfstrace_info::zVfsName.

Referenced by vfstraceOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceFullPathname()

int vfstraceFullPathname ( sqlite3_vfs * pVfs, const char * zName, int nOut, char * zOut )

static

 {
  vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
  sqlite3_vfs *pRoot = pInfo->pRootVfs;
  int rc;
  vfstraceOnOff(pInfo, VTR_FULLPATH);
  vfstrace_printf(pInfo, "%s.xFullPathname(\"%s\")",
                  pInfo->zVfsName, zPath);
  rc = pRoot->xFullPathname(pRoot, zPath, nOut, zOut);
  vfstrace_print_errcode(pInfo, " -> %s", rc);
  vfstrace_printf(pInfo, ", out=\"%.*s\"\n", nOut, zOut);
  return rc;
}

References sqlite3_vfs::pAppData, vfstrace_info::pRootVfs, vfstrace_print_errcode(), vfstrace_printf(), vfstraceOnOff(), VTR_FULLPATH, sqlite3_vfs::xFullPathname, and vfstrace_info::zVfsName.

Referenced by vfstrace_register().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceGetLastError()

int vfstraceGetLastError ( sqlite3_vfs * pVfs, int nErr, char * zErr )

static

                                                                        {
  vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
  sqlite3_vfs *pRoot = pInfo->pRootVfs;
  int rc;
  vfstraceOnOff(pInfo, VTR_LASTERR);
  vfstrace_printf(pInfo, "%s.xGetLastError(%d,zBuf)", pInfo->zVfsName, nErr);
  if( nErr ) zErr[0] = 0;
  rc = pRoot->xGetLastError(pRoot, nErr, zErr);
  vfstrace_printf(pInfo, " -> zBuf[] = \"%s\", rc = %d\n", nErr?zErr:"", rc);
  return rc;
}

References sqlite3_vfs::pAppData, vfstrace_info::pRootVfs, vfstrace_printf(), vfstraceOnOff(), VTR_LASTERR, sqlite3_vfs::xGetLastError, and vfstrace_info::zVfsName.

Referenced by vfstrace_register().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceGetSystemCall()

sqlite3_syscall_ptr vfstraceGetSystemCall ( sqlite3_vfs * pVfs, const char * zName )

static

 {
  vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
  sqlite3_vfs *pRoot = pInfo->pRootVfs;
  return pRoot->xGetSystemCall(pRoot, zName);
}

References sqlite3_vfs::pAppData, vfstrace_info::pRootVfs, and sqlite3_vfs::xGetSystemCall.

Referenced by vfstrace_register().

Here is the caller graph for this function:

vfstraceLock()

int vfstraceLock ( sqlite3_file * pFile, int eLock )

static

                                                       {
  vfstrace_file *p = (vfstrace_file *)pFile;
  vfstrace_info *pInfo = p->pInfo;
  int rc;
  vfstraceOnOff(pInfo, VTR_LOCK);
  vfstrace_printf(pInfo, "%s.xLock(%s,%s)", pInfo->zVfsName, p->zFName,
                  lockName(eLock));
  rc = p->pReal->pMethods->xLock(p->pReal, eLock);
  vfstrace_print_errcode(pInfo, " -> %s\n", rc);
  return rc;
}

References lockName(), vfstrace_file::pInfo, sqlite3_file::pMethods, vfstrace_file::pReal, vfstrace_print_errcode(), vfstrace_printf(), vfstraceOnOff(), VTR_LOCK, sqlite3_io_methods::xLock, vfstrace_file::zFName, and vfstrace_info::zVfsName.

Referenced by vfstraceOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceNextSystemCall()

const char * vfstraceNextSystemCall ( sqlite3_vfs * pVfs, const char * zName )

static

                                                                               {
  vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
  sqlite3_vfs *pRoot = pInfo->pRootVfs;
  return pRoot->xNextSystemCall(pRoot, zName);
}

References sqlite3_vfs::pAppData, vfstrace_info::pRootVfs, and sqlite3_vfs::xNextSystemCall.

Referenced by vfstrace_register().

Here is the caller graph for this function:

vfstraceOnOff()

void vfstraceOnOff ( vfstrace_info * pInfo, unsigned int mMask )

static

                                                                   {
  pInfo->bOn = (pInfo->mTrace & mMask)!=0;
}

References vfstrace_info::bOn, and vfstrace_info::mTrace.

Referenced by vfstraceAccess(), vfstraceCheckReservedLock(), vfstraceClose(), vfstraceCurrentTime(), vfstraceCurrentTimeInt64(), vfstraceDelete(), vfstraceDeviceCharacteristics(), vfstraceDlClose(), vfstraceDlError(), vfstraceDlOpen(), vfstraceFetch(), vfstraceFileControl(), vfstraceFileSize(), vfstraceFullPathname(), vfstraceGetLastError(), vfstraceLock(), vfstraceOpen(), vfstraceRandomness(), vfstraceRead(), vfstraceSectorSize(), vfstraceShmBarrier(), vfstraceShmLock(), vfstraceShmMap(), vfstraceShmUnmap(), vfstraceSleep(), vfstraceSync(), vfstraceTruncate(), vfstraceUnfetch(), vfstraceUnlock(), and vfstraceWrite().

Here is the caller graph for this function:

vfstraceOpen()

int vfstraceOpen ( sqlite3_vfs * pVfs, const char * zName, sqlite3_file * pFile, int flags, int * pOutFlags )

static

 {
  int rc;
  vfstrace_file *p = (vfstrace_file *)pFile;
  vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
  sqlite3_vfs *pRoot = pInfo->pRootVfs;
  p->pInfo = pInfo;
  p->zFName = zName ? fileTail(zName) : "<temp>";
  p->pReal = (sqlite3_file *)&p[1];
  rc = pRoot->xOpen(pRoot, zName, p->pReal, flags, pOutFlags);
  vfstraceOnOff(pInfo, VTR_OPEN);
  vfstrace_printf(pInfo, "%s.xOpen(%s,flags=0x%x)",
                  pInfo->zVfsName, p->zFName, flags);
  if( p->pReal->pMethods ){
    sqlite3_io_methods *pNew = sqlite3_malloc( sizeof(*pNew) );
    const sqlite3_io_methods *pSub = p->pReal->pMethods;
    memset(pNew, 0, sizeof(*pNew));
    pNew->iVersion = pSub->iVersion;
    pNew->xClose = vfstraceClose;
    pNew->xRead = vfstraceRead;
    pNew->xWrite = vfstraceWrite;
    pNew->xTruncate = vfstraceTruncate;
    pNew->xSync = vfstraceSync;
    pNew->xFileSize = vfstraceFileSize;
    pNew->xLock = vfstraceLock;
    pNew->xUnlock = vfstraceUnlock;
    pNew->xCheckReservedLock = vfstraceCheckReservedLock;
    pNew->xFileControl = vfstraceFileControl;
    pNew->xSectorSize = vfstraceSectorSize;
    pNew->xDeviceCharacteristics = vfstraceDeviceCharacteristics;
    if( pNew->iVersion>=2 ){
      pNew->xShmMap = pSub->xShmMap ? vfstraceShmMap : 0;
      pNew->xShmLock = pSub->xShmLock ? vfstraceShmLock : 0;
      pNew->xShmBarrier = pSub->xShmBarrier ? vfstraceShmBarrier : 0;
      pNew->xShmUnmap = pSub->xShmUnmap ? vfstraceShmUnmap : 0;
    }
    if( pNew->iVersion>=3 ){
      pNew->xFetch = pSub->xFetch ? vfstraceFetch : 0;
      pNew->xUnfetch = pSub->xUnfetch ? vfstraceUnfetch : 0;
    }
    pFile->pMethods = pNew;
  }
  vfstrace_print_errcode(pInfo, " -> %s", rc);
  if( pOutFlags ){
    vfstrace_printf(pInfo, ", outFlags=0x%x\n", *pOutFlags);
  }else{
    vfstrace_printf(pInfo, "\n");
  }
  return rc;
}

References fileTail(), sqlite3_io_methods::iVersion, sqlite3_vfs::pAppData, vfstrace_file::pInfo, sqlite3_file::pMethods, vfstrace_file::pReal, vfstrace_info::pRootVfs, sqlite3_malloc, vfstrace_print_errcode(), vfstrace_printf(), vfstraceCheckReservedLock(), vfstraceClose(), vfstraceDeviceCharacteristics(), vfstraceFetch(), vfstraceFileControl(), vfstraceFileSize(), vfstraceLock(), vfstraceOnOff(), vfstraceRead(), vfstraceSectorSize(), vfstraceShmBarrier(), vfstraceShmLock(), vfstraceShmMap(), vfstraceShmUnmap(), vfstraceSync(), vfstraceTruncate(), vfstraceUnfetch(), vfstraceUnlock(), vfstraceWrite(), VTR_OPEN, sqlite3_io_methods::xCheckReservedLock, sqlite3_io_methods::xClose, sqlite3_io_methods::xDeviceCharacteristics, sqlite3_io_methods::xFetch, sqlite3_io_methods::xFileControl, sqlite3_io_methods::xFileSize, sqlite3_io_methods::xLock, sqlite3_vfs::xOpen, sqlite3_io_methods::xRead, sqlite3_io_methods::xSectorSize, sqlite3_io_methods::xShmBarrier, sqlite3_io_methods::xShmLock, sqlite3_io_methods::xShmMap, sqlite3_io_methods::xShmUnmap, sqlite3_io_methods::xSync, sqlite3_io_methods::xTruncate, sqlite3_io_methods::xUnfetch, sqlite3_io_methods::xUnlock, sqlite3_io_methods::xWrite, vfstrace_file::zFName, and vfstrace_info::zVfsName.

Referenced by vfstrace_register(), and vfstrace_unregister().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceOut()

int vfstraceOut ( const char * z, void * pArg )

static

                                                 {
  ShellState *p = (ShellState*)pArg;
  sqlite3_fputs(z, p->out);
  fflush(p->out);

References ShellState::out, and sqlite3_fputs.

Referenced by main().

Here is the caller graph for this function:

vfstraceRandomness()

int vfstraceRandomness ( sqlite3_vfs * pVfs, int nByte, char * zOut )

static

                                                                          {
  vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
  sqlite3_vfs *pRoot = pInfo->pRootVfs;
  vfstraceOnOff(pInfo, VTR_RAND);
  vfstrace_printf(pInfo, "%s.xRandomness(%d)\n", pInfo->zVfsName, nByte);
  return pRoot->xRandomness(pRoot, nByte, zBufOut);
}

References sqlite3_vfs::pAppData, vfstrace_info::pRootVfs, vfstrace_printf(), vfstraceOnOff(), VTR_RAND, sqlite3_vfs::xRandomness, and vfstrace_info::zVfsName.

Referenced by vfstrace_register().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceRead()

int vfstraceRead ( sqlite3_file * pFile, void * zBuf, int iAmt, sqlite3_int64 iOfst )

static

 {
  vfstrace_file *p = (vfstrace_file *)pFile;
  vfstrace_info *pInfo = p->pInfo;
  int rc;
  vfstraceOnOff(pInfo, VTR_READ);
  vfstrace_printf(pInfo, "%s.xRead(%s,n=%d,ofst=%lld)",
                  pInfo->zVfsName, p->zFName, iAmt, iOfst);
  rc = p->pReal->pMethods->xRead(p->pReal, zBuf, iAmt, iOfst);
  vfstrace_print_errcode(pInfo, " -> %s\n", rc);
  return rc;
}

References vfstrace_file::pInfo, sqlite3_file::pMethods, vfstrace_file::pReal, vfstrace_print_errcode(), vfstrace_printf(), vfstraceOnOff(), VTR_READ, sqlite3_io_methods::xRead, vfstrace_file::zFName, and vfstrace_info::zVfsName.

Referenced by vfstraceOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceSectorSize()

int vfstraceSectorSize ( sqlite3_file * pFile )

static

                                                  {
  vfstrace_file *p = (vfstrace_file *)pFile;
  vfstrace_info *pInfo = p->pInfo;
  int rc;
  vfstraceOnOff(pInfo, VTR_SECSZ);
  vfstrace_printf(pInfo, "%s.xSectorSize(%s)", pInfo->zVfsName, p->zFName);
  rc = p->pReal->pMethods->xSectorSize(p->pReal);
  vfstrace_printf(pInfo, " -> %d\n", rc);
  return rc;
}

References vfstrace_file::pInfo, sqlite3_file::pMethods, vfstrace_file::pReal, vfstrace_printf(), vfstraceOnOff(), VTR_SECSZ, sqlite3_io_methods::xSectorSize, vfstrace_file::zFName, and vfstrace_info::zVfsName.

Referenced by vfstraceOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceSetSystemCall()

int vfstraceSetSystemCall ( sqlite3_vfs * pVfs, const char * zName, sqlite3_syscall_ptr pFunc )

static

 {
  vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
  sqlite3_vfs *pRoot = pInfo->pRootVfs;
  return pRoot->xSetSystemCall(pRoot, zName, pFunc);
}

References sqlite3_vfs::pAppData, vfstrace_info::pRootVfs, and sqlite3_vfs::xSetSystemCall.

Referenced by vfstrace_register().

Here is the caller graph for this function:

vfstraceShmBarrier()

void vfstraceShmBarrier ( sqlite3_file * pFile )

static

                                                   {
  vfstrace_file *p = (vfstrace_file *)pFile;
  vfstrace_info *pInfo = p->pInfo;
  vfstraceOnOff(pInfo, VTR_SHMBAR);
  vfstrace_printf(pInfo, "%s.xShmBarrier(%s)\n", pInfo->zVfsName, p->zFName);
  p->pReal->pMethods->xShmBarrier(p->pReal);
}

References vfstrace_file::pInfo, sqlite3_file::pMethods, vfstrace_file::pReal, vfstrace_printf(), vfstraceOnOff(), VTR_SHMBAR, sqlite3_io_methods::xShmBarrier, vfstrace_file::zFName, and vfstrace_info::zVfsName.

Referenced by vfstraceOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceShmLock()

int vfstraceShmLock ( sqlite3_file * pFile, int ofst, int n, int flags )

static

                                                                           {
  static const char *azLockName[] = {
     "WRITE",
     "CKPT",
     "RECOVER",
     "READ0",
     "READ1",
     "READ2",
     "READ3",
     "READ4",
  };
  vfstrace_file *p = (vfstrace_file *)pFile;
  vfstrace_info *pInfo = p->pInfo;
  int rc;
  char zLck[100];
  int i = 0;
  vfstraceOnOff(pInfo, VTR_SHMLOCK);
  memcpy(zLck, "|0", 3);
  if( flags & SQLITE_SHM_UNLOCK )    strappend(zLck, &i, "|UNLOCK");
  if( flags & SQLITE_SHM_LOCK )      strappend(zLck, &i, "|LOCK");
  if( flags & SQLITE_SHM_SHARED )    strappend(zLck, &i, "|SHARED");
  if( flags & SQLITE_SHM_EXCLUSIVE ) strappend(zLck, &i, "|EXCLUSIVE");
  if( flags & ~(0xf) ){
     sqlite3_snprintf(sizeof(zLck)-i, &zLck[i], "|0x%x", flags);
  }
  if( ofst>=0 && ofst<(int)(sizeof(azLockName)/sizeof(azLockName[0])) ){
    vfstrace_printf(pInfo, "%s.xShmLock(%s,ofst=%d(%s),n=%d,%s)",
                  pInfo->zVfsName, p->zFName, ofst, azLockName[ofst],
                  n, &zLck[1]);
  }else{
    vfstrace_printf(pInfo, "%s.xShmLock(%s,ofst=5d,n=%d,%s)",
                  pInfo->zVfsName, p->zFName, ofst,
                  n, &zLck[1]);
  }
  rc = p->pReal->pMethods->xShmLock(p->pReal, ofst, n, flags);
  vfstrace_print_errcode(pInfo, " -> %s\n", rc);
  return rc;
}

References vfstrace_file::pInfo, sqlite3_file::pMethods, vfstrace_file::pReal, sqlite3_snprintf, SQLITE_SHM_EXCLUSIVE, SQLITE_SHM_LOCK, SQLITE_SHM_SHARED, SQLITE_SHM_UNLOCK, strappend(), vfstrace_print_errcode(), vfstrace_printf(), vfstraceOnOff(), VTR_SHMLOCK, sqlite3_io_methods::xShmLock, vfstrace_file::zFName, and vfstrace_info::zVfsName.

Referenced by vfstraceOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceShmMap()

int vfstraceShmMap ( sqlite3_file * pFile, int iRegion, int szRegion, int isWrite, void volatile ** pp )

static

 {
  vfstrace_file *p = (vfstrace_file *)pFile;
  vfstrace_info *pInfo = p->pInfo;
  int rc;
  vfstraceOnOff(pInfo, VTR_SHMMAP);
  vfstrace_printf(pInfo, "%s.xShmMap(%s,iRegion=%d,szRegion=%d,isWrite=%d,*)",
                  pInfo->zVfsName, p->zFName, iRegion, szRegion, isWrite);
  rc = p->pReal->pMethods->xShmMap(p->pReal, iRegion, szRegion, isWrite, pp);
  vfstrace_print_errcode(pInfo, " -> %s\n", rc);
  return rc;
}

References vfstrace_file::pInfo, sqlite3_file::pMethods, vfstrace_file::pReal, vfstrace_print_errcode(), vfstrace_printf(), vfstraceOnOff(), VTR_SHMMAP, sqlite3_io_methods::xShmMap, vfstrace_file::zFName, and vfstrace_info::zVfsName.

Referenced by vfstraceOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceShmUnmap()

int vfstraceShmUnmap ( sqlite3_file * pFile, int delFlag )

static

                                                             {
  vfstrace_file *p = (vfstrace_file *)pFile;
  vfstrace_info *pInfo = p->pInfo;
  int rc;
  vfstraceOnOff(pInfo, VTR_SHMUNMAP);
  vfstrace_printf(pInfo, "%s.xShmUnmap(%s,delFlag=%d)",
                  pInfo->zVfsName, p->zFName, delFlag);
  rc = p->pReal->pMethods->xShmUnmap(p->pReal, delFlag);
  vfstrace_print_errcode(pInfo, " -> %s\n", rc);
  return rc;
}

References vfstrace_file::pInfo, sqlite3_file::pMethods, vfstrace_file::pReal, vfstrace_print_errcode(), vfstrace_printf(), vfstraceOnOff(), VTR_SHMUNMAP, sqlite3_io_methods::xShmUnmap, vfstrace_file::zFName, and vfstrace_info::zVfsName.

Referenced by vfstraceOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceSleep()

int vfstraceSleep ( sqlite3_vfs * pVfs, int microseconds )

static

                                                       {
  vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData;
  sqlite3_vfs *pRoot = pInfo->pRootVfs;
  vfstraceOnOff(pInfo, VTR_SLEEP);
  vfstrace_printf(pInfo, "%s.xSleep(%d)\n", pInfo->zVfsName, nMicro);
  return pRoot->xSleep(pRoot, nMicro);
}

References sqlite3_vfs::pAppData, vfstrace_info::pRootVfs, vfstrace_printf(), vfstraceOnOff(), VTR_SLEEP, sqlite3_vfs::xSleep, and vfstrace_info::zVfsName.

Referenced by vfstrace_register().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceSync()

int vfstraceSync ( sqlite3_file * pFile, int flags )

static

                                                       {
  vfstrace_file *p = (vfstrace_file *)pFile;
  vfstrace_info *pInfo = p->pInfo;
  int rc;
  int i;
  char zBuf[100];
  memcpy(zBuf, "|0", 3);
  i = 0;
  if( flags & SQLITE_SYNC_FULL )        strappend(zBuf, &i, "|FULL");
  else if( flags & SQLITE_SYNC_NORMAL ) strappend(zBuf, &i, "|NORMAL");
  if( flags & SQLITE_SYNC_DATAONLY )    strappend(zBuf, &i, "|DATAONLY");
  if( flags & ~(SQLITE_SYNC_FULL|SQLITE_SYNC_DATAONLY) ){
    sqlite3_snprintf(sizeof(zBuf)-i, &zBuf[i], "|0x%x", flags);
  }
  vfstraceOnOff(pInfo, VTR_SYNC);
  vfstrace_printf(pInfo, "%s.xSync(%s,%s)", pInfo->zVfsName, p->zFName,
                  &zBuf[1]);
  rc = p->pReal->pMethods->xSync(p->pReal, flags);
  vfstrace_printf(pInfo, " -> %d\n", rc);
  return rc;
}

References vfstrace_file::pInfo, sqlite3_file::pMethods, vfstrace_file::pReal, sqlite3_snprintf, SQLITE_SYNC_DATAONLY, SQLITE_SYNC_FULL, SQLITE_SYNC_NORMAL, strappend(), vfstrace_printf(), vfstraceOnOff(), VTR_SYNC, sqlite3_io_methods::xSync, vfstrace_file::zFName, and vfstrace_info::zVfsName.

Referenced by vfstraceOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceTruncate()

int vfstraceTruncate ( sqlite3_file * pFile, sqlite3_int64 size )

static

                                                                   {
  vfstrace_file *p = (vfstrace_file *)pFile;
  vfstrace_info *pInfo = p->pInfo;
  int rc;
  vfstraceOnOff(pInfo, VTR_TRUNC);
  vfstrace_printf(pInfo, "%s.xTruncate(%s,%lld)", pInfo->zVfsName, p->zFName,
                  size);
  rc = p->pReal->pMethods->xTruncate(p->pReal, size);
  vfstrace_printf(pInfo, " -> %d\n", rc);
  return rc;
}

References vfstrace_file::pInfo, sqlite3_file::pMethods, vfstrace_file::pReal, vfstrace_printf(), vfstraceOnOff(), VTR_TRUNC, sqlite3_io_methods::xTruncate, vfstrace_file::zFName, and vfstrace_info::zVfsName.

Referenced by vfstraceOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceUnfetch()

int vfstraceUnfetch ( sqlite3_file * pFile, i64 iOff, void * ptr )

static

                                                                    {
  vfstrace_file *p = (vfstrace_file *)pFile;
  vfstrace_info *pInfo = p->pInfo;
  int rc;
  vfstraceOnOff(pInfo, VTR_FETCH);
  vfstrace_printf(pInfo, "%s.xUnfetch(%s,iOff=%lld,p=%p)",
                  pInfo->zVfsName, p->zFName, iOff, ptr);
  rc = p->pReal->pMethods->xUnfetch(p->pReal, iOff, ptr);
  vfstrace_print_errcode(pInfo, " -> %s\n", rc);
  return rc;
}

References vfstrace_file::pInfo, sqlite3_file::pMethods, vfstrace_file::pReal, vfstrace_print_errcode(), vfstrace_printf(), vfstraceOnOff(), VTR_FETCH, sqlite3_io_methods::xUnfetch, vfstrace_file::zFName, and vfstrace_info::zVfsName.

Referenced by vfstraceOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceUnlock()

int vfstraceUnlock ( sqlite3_file * pFile, int eLock )

static

                                                         {
  vfstrace_file *p = (vfstrace_file *)pFile;
  vfstrace_info *pInfo = p->pInfo;
  int rc;
  vfstraceOnOff(pInfo, VTR_UNLOCK);
  vfstrace_printf(pInfo, "%s.xUnlock(%s,%s)", pInfo->zVfsName, p->zFName,
                  lockName(eLock));
  rc = p->pReal->pMethods->xUnlock(p->pReal, eLock);
  vfstrace_print_errcode(pInfo, " -> %s\n", rc);
  return rc;
}

References lockName(), vfstrace_file::pInfo, sqlite3_file::pMethods, vfstrace_file::pReal, vfstrace_print_errcode(), vfstrace_printf(), vfstraceOnOff(), VTR_UNLOCK, sqlite3_io_methods::xUnlock, vfstrace_file::zFName, and vfstrace_info::zVfsName.

Referenced by vfstraceOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstraceWrite()

int vfstraceWrite ( sqlite3_file * pFile, const void * zBuf, int iAmt, sqlite3_int64 iOfst )

static

 {
  vfstrace_file *p = (vfstrace_file *)pFile;
  vfstrace_info *pInfo = p->pInfo;
  int rc;
  vfstraceOnOff(pInfo, VTR_WRITE);
  vfstrace_printf(pInfo, "%s.xWrite(%s,n=%d,ofst=%lld)",
                  pInfo->zVfsName, p->zFName, iAmt, iOfst);
  rc = p->pReal->pMethods->xWrite(p->pReal, zBuf, iAmt, iOfst);
  vfstrace_print_errcode(pInfo, " -> %s\n", rc);
  return rc;
}

References vfstrace_file::pInfo, sqlite3_file::pMethods, vfstrace_file::pReal, vfstrace_print_errcode(), vfstrace_printf(), vfstraceOnOff(), VTR_WRITE, sqlite3_io_methods::xWrite, vfstrace_file::zFName, and vfstrace_info::zVfsName.

Referenced by vfstraceOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

writeFile()

int writeFile ( sqlite3_context * pCtx, const char * zFile, sqlite3_value * pData, mode_t mode, sqlite3_int64 mtime )

static

 {
  if( zFile==0 ) return 1;
#if !defined(_WIN32) && !defined(WIN32)
  if( S_ISLNK(mode) ){
    const char *zTo = (const char*)sqlite3_value_text(pData);
    if( zTo==0 ) return 1;
    unlink(zFile);
    if( symlink(zTo, zFile)<0 ) return 1;
  }else
#endif
  {
    if( S_ISDIR(mode) ){
      if( mkdir(zFile, mode) ){
        /* The mkdir() call to create the directory failed. This might not
        ** be an error though - if there is already a directory at the same
        ** path and either the permissions already match or can be changed
        ** to do so using chmod(), it is not an error.  */
        STRUCT_STAT sStat;
        if( errno!=EEXIST
         || 0!=fileStat(zFile, &sStat)
         || !S_ISDIR(sStat.st_mode)
         || ((sStat.st_mode&0777)!=(mode&0777) && 0!=chmod(zFile, mode&0777))
        ){
          return 1;
        }
      }
    }else{
      sqlite3_int64 nWrite = 0;
      const char *z;
      int rc = 0;
      FILE *out = sqlite3_fopen(zFile, "wb");
      if( out==0 ) return 1;
      z = (const char*)sqlite3_value_blob(pData);
      if( z ){
        sqlite3_int64 n = fwrite(z, 1, sqlite3_value_bytes(pData), out);
        nWrite = sqlite3_value_bytes(pData);
        if( nWrite!=n ){
          rc = 1;
        }
      }
      fclose(out);
      if( rc==0 && mode && chmod(zFile, mode & 0777) ){
        rc = 1;
      }
      if( rc ) return 2;
      sqlite3_result_int64(pCtx, nWrite);
    }
  }
 
  if( mtime>=0 ){
#if defined(_WIN32)
#if !SQLITE_OS_WINRT
    /* Windows */
    FILETIME lastAccess;
    FILETIME lastWrite;
    SYSTEMTIME currentTime;
    LONGLONG intervals;
    HANDLE hFile;
    LPWSTR zUnicodeName;
    extern LPWSTR sqlite3_win32_utf8_to_unicode(const char*);
 
    GetSystemTime(&currentTime);
    SystemTimeToFileTime(&currentTime, &lastAccess);
    intervals = (mtime*10000000) + 116444736000000000;
    lastWrite.dwLowDateTime = (DWORD)intervals;
    lastWrite.dwHighDateTime = intervals >> 32;
    zUnicodeName = sqlite3_win32_utf8_to_unicode(zFile);
    if( zUnicodeName==0 ){
      return 1;
    }
    hFile = CreateFileW(
      zUnicodeName, FILE_WRITE_ATTRIBUTES, 0, NULL, OPEN_EXISTING,
      FILE_FLAG_BACKUP_SEMANTICS, NULL
    );
    sqlite3_free(zUnicodeName);
    if( hFile!=INVALID_HANDLE_VALUE ){
      BOOL bResult = SetFileTime(hFile, NULL, &lastAccess, &lastWrite);
      CloseHandle(hFile);
      return !bResult;
    }else{
      return 1;
    }
#endif
#elif defined(AT_FDCWD) && 0 /* utimensat() is not universally available */
    /* Recent unix */
    struct timespec times[2];
    times[0].tv_nsec = times[1].tv_nsec = 0;
    times[0].tv_sec = time(0);
    times[1].tv_sec = mtime;
    if( utimensat(AT_FDCWD, zFile, times, AT_SYMLINK_NOFOLLOW) ){
      return 1;
    }
#else
    /* Legacy unix. 
    **
    ** Do not use utimes() on a symbolic link - it sees through the link and
    ** modifies the timestamps on the target. Or fails if the target does 
    ** not exist.  */
    if( 0==S_ISLNK(mode) ){
      struct timeval times[2];
      times[0].tv_usec = times[1].tv_usec = 0;
      times[0].tv_sec = time(0);
      times[1].tv_sec = mtime;
      if( utimes(zFile, times) ){
        return 1;
      }
    }
#endif
  }
 
  return 0;
}

References fileStat(), sqlite3_fopen, sqlite3_free, sqlite3_result_int64, sqlite3_value_blob, sqlite3_value_bytes, sqlite3_value_text, and STRUCT_STAT.

Referenced by writefileFunc().

Here is the call graph for this function:

Here is the caller graph for this function:

writefileFunc()

void writefileFunc ( sqlite3_context * context, int argc, sqlite3_value ** argv )

static

 {
  const char *zFile;
  mode_t mode = 0;
  int res;
  sqlite3_int64 mtime = -1;
 
  if( argc<2 || argc>4 ){
    sqlite3_result_error(context, 
        "wrong number of arguments to function writefile()", -1
    );
    return;
  }
 
  zFile = (const char*)sqlite3_value_text(argv[0]);
  if( zFile==0 ) return;
  if( argc>=3 ){
    mode = (mode_t)sqlite3_value_int(argv[2]);
  }
  if( argc==4 ){
    mtime = sqlite3_value_int64(argv[3]);
  }
 
  res = writeFile(context, zFile, argv[1], mode, mtime);
  if( res==1 && errno==ENOENT ){
    if( makeDirectory(zFile)==SQLITE_OK ){
      res = writeFile(context, zFile, argv[1], mode, mtime);
    }
  }
 
  if( argc>2 && res!=0 ){
    if( S_ISLNK(mode) ){
      ctxErrorMsg(context, "failed to create symlink: %s", zFile);
    }else if( S_ISDIR(mode) ){
      ctxErrorMsg(context, "failed to create directory: %s", zFile);
    }else{
      ctxErrorMsg(context, "failed to write file: %s", zFile);
    }
  }
}

References ctxErrorMsg(), makeDirectory(), sqlite3_result_error, sqlite3_value_int, sqlite3_value_int64, sqlite3_value_text, SQLITE_OK, and writeFile().

Referenced by sqlite3_fileio_init().

Here is the call graph for this function:

Here is the caller graph for this function:

wsToEol()

int wsToEol ( const char * z )

static

                                 {
  int i;
  for(i=0; z[i]; i++){
    if( z[i]=='\n' ) return 1;
    if( IsSpace(z[i]) ) continue;
    if( z[i]=='-' && z[i+1]=='-' ) return 1;
    return 0;
  }

References IsSpace.

Referenced by shell_callback().

Here is the caller graph for this function:

zAutoColumn()

char * zAutoColumn ( const char * zColNew, sqlite3 ** pDb, char ** pzRenamed )

static

                                                                              {
  /* Queries and D{D,M}L used here */
  static const char * const zTabMake = "\
CREATE TABLE ColNames(\
 cpos INTEGER PRIMARY KEY,\
 name TEXT, nlen INT, chop INT, reps INT, suff TEXT);\
CREATE VIEW RepeatedNames AS \
SELECT DISTINCT t.name FROM ColNames t \
WHERE t.name COLLATE NOCASE IN (\
 SELECT o.name FROM ColNames o WHERE o.cpos<>t.cpos\
);\
";
  static const char * const zTabFill = "\
INSERT INTO ColNames(name,nlen,chop,reps,suff)\
 VALUES(iif(length(?1)>0,?1,'?'),max(length(?1),1),0,0,'')\
";
  static const char * const zHasDupes = "\
SELECT count(DISTINCT (substring(name,1,nlen-chop)||suff) COLLATE NOCASE)\
 <count(name) FROM ColNames\
";
#ifdef SHELL_COLUMN_RENAME_CLEAN
  static const char * const zDedoctor = "\
UPDATE ColNames SET chop=iif(\
  (substring(name,nlen,1) BETWEEN '0' AND '9')\
  AND (rtrim(name,'0123456790') glob '*"AUTOCOLUMN_SEP"'),\
 nlen-length(rtrim(name, '"AUTOCOLUMN_SEP"0123456789')),\
 0\
)\
";
#endif
  static const char * const zSetReps = "\
UPDATE ColNames AS t SET reps=\
(SELECT count(*) FROM ColNames d \
 WHERE substring(t.name,1,t.nlen-t.chop)=substring(d.name,1,d.nlen-d.chop)\
 COLLATE NOCASE\
)\
";
#ifdef SQLITE_ENABLE_MATH_FUNCTIONS
  static const char * const zColDigits = "\
SELECT CAST(ceil(log(count(*)+0.5)) AS INT) FROM ColNames \
";
#else
  /* Counting on SQLITE_MAX_COLUMN < 100,000 here. (32767 is the hard limit.) */
  static const char * const zColDigits = "\
SELECT CASE WHEN (nc < 10) THEN 1 WHEN (nc < 100) THEN 2 \
 WHEN (nc < 1000) THEN 3 WHEN (nc < 10000) THEN 4 \
 ELSE 5 FROM (SELECT count(*) AS nc FROM ColNames) \
";
#endif
  static const char * const zRenameRank =
#ifdef SHELL_COLUMN_RENAME_CLEAN
    "UPDATE ColNames AS t SET suff="
    "iif(reps>1, printf('%c%0*d', '"AUTOCOLUMN_SEP"', $1, cpos), '')"
#else /* ...RENAME_MINIMAL_ONE_PASS */
"WITH Lzn(nlz) AS (" /* Find minimum extraneous leading 0's for uniqueness */
"  SELECT 0 AS nlz"
"  UNION"
"  SELECT nlz+1 AS nlz FROM Lzn"
"  WHERE EXISTS("
"   SELECT 1"
"   FROM ColNames t, ColNames o"
"   WHERE"
"    iif(t.name IN (SELECT * FROM RepeatedNames),"
"     printf('%s"AUTOCOLUMN_SEP"%s',"
"      t.name, substring(printf('%.*c%0.*d',nlz+1,'0',$1,t.cpos),2)),"
"     t.name"
"    )"
"    ="
"    iif(o.name IN (SELECT * FROM RepeatedNames),"
"     printf('%s"AUTOCOLUMN_SEP"%s',"
"      o.name, substring(printf('%.*c%0.*d',nlz+1,'0',$1,o.cpos),2)),"
"     o.name"
"    )"
"    COLLATE NOCASE"
"    AND o.cpos<>t.cpos"
"   GROUP BY t.cpos"
"  )"
") UPDATE Colnames AS t SET"
" chop = 0," /* No chopping, never touch incoming names. */
" suff = iif(name IN (SELECT * FROM RepeatedNames),"
"  printf('"AUTOCOLUMN_SEP"%s', substring("
"   printf('%.*c%0.*d',(SELECT max(nlz) FROM Lzn)+1,'0',1,t.cpos),2)),"
"  ''"
" )"
#endif
    ;
  static const char * const zCollectVar = "\
SELECT\
 '('||x'0a'\
 || group_concat(\
  cname||' TEXT',\
  ','||iif((cpos-1)%4>0, ' ', x'0a'||' '))\
 ||')' AS ColsSpec \
FROM (\
 SELECT cpos, printf('\"%w\"',printf('%!.*s%s', nlen-chop,name,suff)) AS cname \
 FROM ColNames ORDER BY cpos\
)";
  static const char * const zRenamesDone =
    "SELECT group_concat("
    " printf('\"%w\" to \"%w\"',name,printf('%!.*s%s', nlen-chop, name, suff)),"
    " ','||x'0a')"
    "FROM ColNames WHERE suff<>'' OR chop!=0"
    ;
  int rc;
  sqlite3_stmt *pStmt = 0;
  assert(pDb!=0);
  if( zColNew ){
    /* Add initial or additional column. Init db if necessary. */
    if( *pDb==0 ){
      if( SQLITE_OK!=sqlite3_open(zCOL_DB, pDb) ) return 0;
#ifdef SHELL_COLFIX_DB
      if(*zCOL_DB!=':')
        sqlite3_exec(*pDb,"drop table if exists ColNames;"
                     "drop view if exists RepeatedNames;",0,0,0);
#endif
#undef SHELL_COLFIX_DB
      rc = sqlite3_exec(*pDb, zTabMake, 0, 0, 0);
      rc_err_oom_die(rc);
    }
    assert(*pDb!=0);
    rc = sqlite3_prepare_v2(*pDb, zTabFill, -1, &pStmt, 0);
    rc_err_oom_die(rc);
    rc = sqlite3_bind_text(pStmt, 1, zColNew, -1, 0);
    rc_err_oom_die(rc);
    rc = sqlite3_step(pStmt);
    rc_err_oom_die(rc);
    sqlite3_finalize(pStmt);
    return 0;
  }else if( *pDb==0 ){
    return 0;
  }else{
    /* Formulate the columns spec, close the DB, zero *pDb. */
    char *zColsSpec = 0;
    int hasDupes = db_int(*pDb, "%s", zHasDupes);
    int nDigits = (hasDupes)? db_int(*pDb, "%s", zColDigits) : 0;
    if( hasDupes ){
#ifdef SHELL_COLUMN_RENAME_CLEAN
      rc = sqlite3_exec(*pDb, zDedoctor, 0, 0, 0);
      rc_err_oom_die(rc);
#endif
      rc = sqlite3_exec(*pDb, zSetReps, 0, 0, 0);
      rc_err_oom_die(rc);
      rc = sqlite3_prepare_v2(*pDb, zRenameRank, -1, &pStmt, 0);
      rc_err_oom_die(rc);
      sqlite3_bind_int(pStmt, 1, nDigits);
      rc = sqlite3_step(pStmt);
      sqlite3_finalize(pStmt);
      if( rc!=SQLITE_DONE ) rc_err_oom_die(SQLITE_NOMEM);
    }
    assert(db_int(*pDb, "%s", zHasDupes)==0); /* Consider: remove this */
    rc = sqlite3_prepare_v2(*pDb, zCollectVar, -1, &pStmt, 0);
    rc_err_oom_die(rc);
    rc = sqlite3_step(pStmt);
    if( rc==SQLITE_ROW ){
      zColsSpec = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0));
    }else{
      zColsSpec = 0;
    }
    if( pzRenamed!=0 ){
      if( !hasDupes ) *pzRenamed = 0;
      else{
        sqlite3_finalize(pStmt);
        if( SQLITE_OK==sqlite3_prepare_v2(*pDb, zRenamesDone, -1, &pStmt, 0)
            && SQLITE_ROW==sqlite3_step(pStmt) ){
          *pzRenamed = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0));
        }else
          *pzRenamed = 0;
      }
    }
    sqlite3_finalize(pStmt);
    sqlite3_close(*pDb);
    *pDb = 0;
    return zColsSpec;

References AUTOCOLUMN_SEP, db_int(), rc_err_oom_die(), sqlite3_bind_int, sqlite3_bind_text, sqlite3_close, sqlite3_column_text, sqlite3_exec, sqlite3_finalize, sqlite3_mprintf, sqlite3_open, sqlite3_prepare_v2, sqlite3_step, SQLITE_DONE, SQLITE_NOMEM, SQLITE_OK, SQLITE_ROW, and zCOL_DB.

Referenced by do_meta_command().

Here is the call graph for this function:

Here is the caller graph for this function:

zSkipValidUtf8()

const char * zSkipValidUtf8	(	const char *	z,
		int	nAccept,
		long	ccm )

        : nAccept>=0 => char count, nAccept<0 => character
 */
const char *zSkipValidUtf8(const char *z, int nAccept, long ccm){
  int ng = (nAccept<0)? -nAccept : 0;
  const char *pcLimit = (nAccept>=0)? z+nAccept : 0;
  assert(z!=0);
  while( (pcLimit)? (z<pcLimit) : (ng-- != 0) ){
    unsigned char c = *(u8*)z;
    if( c<0x7f ){
      if( ccm != 0L && c < 0x20 && ((1L<<c) & ccm) != 0 ) return z;
      ++z; /* ASCII */
    }else if( (c & 0xC0) != 0xC0 ) return z; /* not a lead byte */
    else{
      const char *zt = z+1; /* Got lead byte, look at trail bytes.*/
      do{
        if( pcLimit && zt >= pcLimit ) return z;
        else{
          char ct = *zt++;
          if( ct==0 || (zt-z)>4 || (ct & 0xC0)!=0x80 ){
            /* Trailing bytes are too few, too many, or invalid. */
            return z;
          }
        }
      } while( ((c <<= 1) & 0x40) == 0x40 ); /* Eat lead byte's count. */
      z = zt;
    }
  }

References c.

Referenced by output_c_string(), and output_json_string().

Here is the caller graph for this function:

Variable Documentation

aPercentFunc

const PercentileFunc aPercentFunc[]

static

Initial value:

= {
  { "median",           1,   1, 0 },
  { "percentile",       2, 100, 0 },
  { "percentile_cont",  2,   1, 0 },
  { "percentile_disc",  2,   1, 1 },
}

                                             {
  { "median",           1,   1, 0 },
  { "percentile",       2, 100, 0 },
  { "percentile_cont",  2,   1, 0 },
  { "percentile_disc",  2,   1, 1 },
};

Referenced by sqlite3_percentile_init().

apnd_io_methods

const sqlite3_io_methods apnd_io_methods

static

Initial value:

= {
  3,                              
  apndClose,                      
  apndRead,                       
  apndWrite,                      
  apndTruncate,                   
  apndSync,                       
  apndFileSize,                   
  apndLock,                       
  apndUnlock,                     
  apndCheckReservedLock,          
  apndFileControl,                
  apndSectorSize,                 
  apndDeviceCharacteristics,      
  apndShmMap,                     
  apndShmLock,                    
  apndShmBarrier,                 
  apndShmUnmap,                   
  apndFetch,                      
  apndUnfetch                     
}

                                                  {
  3,                              /* iVersion */
  apndClose,                      /* xClose */
  apndRead,                       /* xRead */
  apndWrite,                      /* xWrite */
  apndTruncate,                   /* xTruncate */
  apndSync,                       /* xSync */
  apndFileSize,                   /* xFileSize */
  apndLock,                       /* xLock */
  apndUnlock,                     /* xUnlock */
  apndCheckReservedLock,          /* xCheckReservedLock */
  apndFileControl,                /* xFileControl */
  apndSectorSize,                 /* xSectorSize */
  apndDeviceCharacteristics,      /* xDeviceCharacteristics */
  apndShmMap,                     /* xShmMap */
  apndShmLock,                    /* xShmLock */
  apndShmBarrier,                 /* xShmBarrier */
  apndShmUnmap,                   /* xShmUnmap */
  apndFetch,                      /* xFetch */
  apndUnfetch                     /* xUnfetch */
};

Referenced by apndOpen().

apnd_vfs

sqlite3_vfs apnd_vfs

static

Initial value:

= {
  3,                            
  0,                            
  1024,                         
  0,                            
  "apndvfs",                    
  0,                             
  apndOpen,                     
  apndDelete,                   
  apndAccess,                   
  apndFullPathname,             
  apndDlOpen,                   
  apndDlError,                  
  apndDlSym,                    
  apndDlClose,                  
  apndRandomness,               
  apndSleep,                    
  apndCurrentTime,              
  apndGetLastError,             
  apndCurrentTimeInt64,         
  apndSetSystemCall,            
  apndGetSystemCall,            
  apndNextSystemCall            
}

                              {
  3,                            /* iVersion (set when registered) */
  0,                            /* szOsFile (set when registered) */
  1024,                         /* mxPathname */
  0,                            /* pNext */
  "apndvfs",                    /* zName */
  0,                            /* pAppData (set when registered) */ 
  apndOpen,                     /* xOpen */
  apndDelete,                   /* xDelete */
  apndAccess,                   /* xAccess */
  apndFullPathname,             /* xFullPathname */
  apndDlOpen,                   /* xDlOpen */
  apndDlError,                  /* xDlError */
  apndDlSym,                    /* xDlSym */
  apndDlClose,                  /* xDlClose */
  apndRandomness,               /* xRandomness */
  apndSleep,                    /* xSleep */
  apndCurrentTime,              /* xCurrentTime */
  apndGetLastError,             /* xGetLastError */
  apndCurrentTimeInt64,         /* xCurrentTimeInt64 */
  apndSetSystemCall,            /* xSetSystemCall */
  apndGetSystemCall,            /* xGetSystemCall */
  apndNextSystemCall            /* xNextSystemCall */
};

Referenced by sqlite3_appendvfs_init().

apndDlSym

void(*)(void) apndDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym) ( sqlite3_vfs * pVfs, void * p, const char * zSym )

static

apvfsSqliteHdr

const char apvfsSqliteHdr[] = "SQLite format 3"

static

Referenced by apndIsAppendvfsDatabase(), and apndIsOrdinaryDatabaseFile().

Argv0

char* Argv0

static

Referenced by main(), and usage().

[struct]

const struct { ... } aUWidth[]

Initial value:

= {
   
  {0, 0x00300},  {1, 0x00370},  {0, 0x00483},  {1, 0x00487},  {0, 0x00488},
  {1, 0x0048a},  {0, 0x00591},  {1, 0x005be},  {0, 0x005bf},  {1, 0x005c0},
  {0, 0x005c1},  {1, 0x005c3},  {0, 0x005c4},  {1, 0x005c6},  {0, 0x005c7},
  {1, 0x005c8},  {0, 0x00600},  {1, 0x00604},  {0, 0x00610},  {1, 0x00616},
  {0, 0x0064b},  {1, 0x0065f},  {0, 0x00670},  {1, 0x00671},  {0, 0x006d6},
  {1, 0x006e5},  {0, 0x006e7},  {1, 0x006e9},  {0, 0x006ea},  {1, 0x006ee},
  {0, 0x0070f},  {1, 0x00710},  {0, 0x00711},  {1, 0x00712},  {0, 0x00730},
  {1, 0x0074b},  {0, 0x007a6},  {1, 0x007b1},  {0, 0x007eb},  {1, 0x007f4},
  {0, 0x00901},  {1, 0x00903},  {0, 0x0093c},  {1, 0x0093d},  {0, 0x00941},
  {1, 0x00949},  {0, 0x0094d},  {1, 0x0094e},  {0, 0x00951},  {1, 0x00955},
  {0, 0x00962},  {1, 0x00964},  {0, 0x00981},  {1, 0x00982},  {0, 0x009bc},
  {1, 0x009bd},  {0, 0x009c1},  {1, 0x009c5},  {0, 0x009cd},  {1, 0x009ce},
  {0, 0x009e2},  {1, 0x009e4},  {0, 0x00a01},  {1, 0x00a03},  {0, 0x00a3c},
  {1, 0x00a3d},  {0, 0x00a41},  {1, 0x00a43},  {0, 0x00a47},  {1, 0x00a49},
  {0, 0x00a4b},  {1, 0x00a4e},  {0, 0x00a70},  {1, 0x00a72},  {0, 0x00a81},
  {1, 0x00a83},  {0, 0x00abc},  {1, 0x00abd},  {0, 0x00ac1},  {1, 0x00ac6},
  {0, 0x00ac7},  {1, 0x00ac9},  {0, 0x00acd},  {1, 0x00ace},  {0, 0x00ae2},
  {1, 0x00ae4},  {0, 0x00b01},  {1, 0x00b02},  {0, 0x00b3c},  {1, 0x00b3d},
  {0, 0x00b3f},  {1, 0x00b40},  {0, 0x00b41},  {1, 0x00b44},  {0, 0x00b4d},
  {1, 0x00b4e},  {0, 0x00b56},  {1, 0x00b57},  {0, 0x00b82},  {1, 0x00b83},
  {0, 0x00bc0},  {1, 0x00bc1},  {0, 0x00bcd},  {1, 0x00bce},  {0, 0x00c3e},
  {1, 0x00c41},  {0, 0x00c46},  {1, 0x00c49},  {0, 0x00c4a},  {1, 0x00c4e},
  {0, 0x00c55},  {1, 0x00c57},  {0, 0x00cbc},  {1, 0x00cbd},  {0, 0x00cbf},
  {1, 0x00cc0},  {0, 0x00cc6},  {1, 0x00cc7},  {0, 0x00ccc},  {1, 0x00cce},
  {0, 0x00ce2},  {1, 0x00ce4},  {0, 0x00d41},  {1, 0x00d44},  {0, 0x00d4d},
  {1, 0x00d4e},  {0, 0x00dca},  {1, 0x00dcb},  {0, 0x00dd2},  {1, 0x00dd5},
  {0, 0x00dd6},  {1, 0x00dd7},  {0, 0x00e31},  {1, 0x00e32},  {0, 0x00e34},
  {1, 0x00e3b},  {0, 0x00e47},  {1, 0x00e4f},  {0, 0x00eb1},  {1, 0x00eb2},
  {0, 0x00eb4},  {1, 0x00eba},  {0, 0x00ebb},  {1, 0x00ebd},  {0, 0x00ec8},
  {1, 0x00ece},  {0, 0x00f18},  {1, 0x00f1a},  {0, 0x00f35},  {1, 0x00f36},
  {0, 0x00f37},  {1, 0x00f38},  {0, 0x00f39},  {1, 0x00f3a},  {0, 0x00f71},
  {1, 0x00f7f},  {0, 0x00f80},  {1, 0x00f85},  {0, 0x00f86},  {1, 0x00f88},
  {0, 0x00f90},  {1, 0x00f98},  {0, 0x00f99},  {1, 0x00fbd},  {0, 0x00fc6},
  {1, 0x00fc7},  {0, 0x0102d},  {1, 0x01031},  {0, 0x01032},  {1, 0x01033},
  {0, 0x01036},  {1, 0x01038},  {0, 0x01039},  {1, 0x0103a},  {0, 0x01058},
  {1, 0x0105a},  {2, 0x01100},  {0, 0x01160},  {1, 0x01200},  {0, 0x0135f},
  {1, 0x01360},  {0, 0x01712},  {1, 0x01715},  {0, 0x01732},  {1, 0x01735},
  {0, 0x01752},  {1, 0x01754},  {0, 0x01772},  {1, 0x01774},  {0, 0x017b4},
  {1, 0x017b6},  {0, 0x017b7},  {1, 0x017be},  {0, 0x017c6},  {1, 0x017c7},
  {0, 0x017c9},  {1, 0x017d4},  {0, 0x017dd},  {1, 0x017de},  {0, 0x0180b},
  {1, 0x0180e},  {0, 0x018a9},  {1, 0x018aa},  {0, 0x01920},  {1, 0x01923},
  {0, 0x01927},  {1, 0x01929},  {0, 0x01932},  {1, 0x01933},  {0, 0x01939},
  {1, 0x0193c},  {0, 0x01a17},  {1, 0x01a19},  {0, 0x01b00},  {1, 0x01b04},
  {0, 0x01b34},  {1, 0x01b35},  {0, 0x01b36},  {1, 0x01b3b},  {0, 0x01b3c},
  {1, 0x01b3d},  {0, 0x01b42},  {1, 0x01b43},  {0, 0x01b6b},  {1, 0x01b74},
  {0, 0x01dc0},  {1, 0x01dcb},  {0, 0x01dfe},  {1, 0x01e00},  {0, 0x0200b},
  {1, 0x02010},  {0, 0x0202a},  {1, 0x0202f},  {0, 0x02060},  {1, 0x02064},
  {0, 0x0206a},  {1, 0x02070},  {0, 0x020d0},  {1, 0x020f0},  {2, 0x02329},
  {1, 0x0232b},  {2, 0x02e80},  {0, 0x0302a},  {2, 0x03030},  {1, 0x0303f},
  {2, 0x03040},  {0, 0x03099},  {2, 0x0309b},  {1, 0x0a4d0},  {0, 0x0a806},
  {1, 0x0a807},  {0, 0x0a80b},  {1, 0x0a80c},  {0, 0x0a825},  {1, 0x0a827},
  {2, 0x0ac00},  {1, 0x0d7a4},  {2, 0x0f900},  {1, 0x0fb00},  {0, 0x0fb1e},
  {1, 0x0fb1f},  {0, 0x0fe00},  {2, 0x0fe10},  {1, 0x0fe1a},  {0, 0x0fe20},
  {1, 0x0fe24},  {2, 0x0fe30},  {1, 0x0fe70},  {0, 0x0feff},  {2, 0x0ff00},
  {1, 0x0ff61},  {2, 0x0ffe0},  {1, 0x0ffe7},  {0, 0x0fff9},  {1, 0x0fffc},
  {0, 0x10a01},  {1, 0x10a04},  {0, 0x10a05},  {1, 0x10a07},  {0, 0x10a0c},
  {1, 0x10a10},  {0, 0x10a38},  {1, 0x10a3b},  {0, 0x10a3f},  {1, 0x10a40},
  {0, 0x1d167},  {1, 0x1d16a},  {0, 0x1d173},  {1, 0x1d183},  {0, 0x1d185},
  {1, 0x1d18c},  {0, 0x1d1aa},  {1, 0x1d1ae},  {0, 0x1d242},  {1, 0x1d245},
  {2, 0x20000},  {1, 0x2fffe},  {2, 0x30000},  {1, 0x3fffe},  {0, 0xe0001},
  {1, 0xe0002},  {0, 0xe0020},  {1, 0xe0080},  {0, 0xe0100},  {1, 0xe01f0}
}

Referenced by cli_wcwidth().

azHelp

const char* azHelp[]

static

                                {
#if defined(SQLITE_HAVE_ZLIB) && !defined(SQLITE_OMIT_VIRTUALTABLE) \
  && !defined(SQLITE_SHELL_FIDDLE)
  ".archive ...             Manage SQL archives",
  "   Each command must have exactly one of the following options:",
  "     -c, --create               Create a new archive",
  "     -u, --update               Add or update files with changed mtime",
  "     -i, --insert               Like -u but always add even if unchanged",
  "     -r, --remove               Remove files from archive",
  "     -t, --list                 List contents of archive",
  "     -x, --extract              Extract files from archive",
  "   Optional arguments:",
  "     -v, --verbose              Print each filename as it is processed",
  "     -f FILE, --file FILE       Use archive FILE (default is current db)",
  "     -a FILE, --append FILE     Open FILE using the apndvfs VFS",
  "     -C DIR, --directory DIR    Read/extract files from directory DIR",
  "     -g, --glob                 Use glob matching for names in archive",
  "     -n, --dryrun               Show the SQL that would have occurred",
  "   Examples:",
  "     .ar -cf ARCHIVE foo bar  # Create ARCHIVE from files foo and bar",
  "     .ar -tf ARCHIVE          # List members of ARCHIVE",
  "     .ar -xvf ARCHIVE         # Verbosely extract files from ARCHIVE",
  "   See also:",
  "      http://sqlite.org/cli.html#sqlite_archive_support",
#endif
#ifndef SQLITE_OMIT_AUTHORIZATION
  ".auth ON|OFF             Show authorizer callbacks",
#endif
#ifndef SQLITE_SHELL_FIDDLE
  ".backup ?DB? FILE        Backup DB (default \"main\") to FILE",
  "   Options:",
  "       --append            Use the appendvfs",
  "       --async             Write to FILE without journal and fsync()",
#endif
  ".bail on|off             Stop after hitting an error.  Default OFF",
#ifndef SQLITE_SHELL_FIDDLE
  ".cd DIRECTORY            Change the working directory to DIRECTORY",
#endif
  ".changes on|off          Show number of rows changed by SQL",
#ifndef SQLITE_SHELL_FIDDLE
  ".check GLOB              Fail if output since .testcase does not match",
  ".clone NEWDB             Clone data into NEWDB from the existing database",
#endif
  ".connection [close] [#]  Open or close an auxiliary database connection",
  ".crlf ?on|off?           Whether or not to use \\r\\n line endings",
  ".databases               List names and files of attached databases",
  ".dbconfig ?op? ?val?     List or change sqlite3_db_config() options",
#if SQLITE_SHELL_HAVE_RECOVER
  ".dbinfo ?DB?             Show status information about the database",
#endif
  ".dbtotxt                 Hex dump of the database file",
  ".dump ?OBJECTS?          Render database content as SQL",
  "   Options:",
  "     --data-only            Output only INSERT statements",
  "     --newlines             Allow unescaped newline characters in output",
  "     --nosys                Omit system tables (ex: \"sqlite_stat1\")",
  "     --preserve-rowids      Include ROWID values in the output",
  "   OBJECTS is a LIKE pattern for tables, indexes, triggers or views to dump",
  "   Additional LIKE patterns can be given in subsequent arguments",
  ".echo on|off             Turn command echo on or off",
  ".eqp on|off|full|...     Enable or disable automatic EXPLAIN QUERY PLAN",
  "   Other Modes:",
#ifdef SQLITE_DEBUG
  "      test                  Show raw EXPLAIN QUERY PLAN output",
  "      trace                 Like \"full\" but enable \"PRAGMA vdbe_trace\"",
#endif
  "      trigger               Like \"full\" but also show trigger bytecode",
#ifndef SQLITE_SHELL_FIDDLE
  ".excel                   Display the output of next command in spreadsheet",
  "   --bom                   Put a UTF8 byte-order mark on intermediate file",
#endif
#ifndef SQLITE_SHELL_FIDDLE
  ".exit ?CODE?             Exit this program with return-code CODE",
#endif
  ".expert                  EXPERIMENTAL. Suggest indexes for queries",
  ".explain ?on|off|auto?   Change the EXPLAIN formatting mode.  Default: auto",
  ".filectrl CMD ...        Run various sqlite3_file_control() operations",
  "   --schema SCHEMA         Use SCHEMA instead of \"main\"",
  "   --help                  Show CMD details",
  ".fullschema ?--indent?   Show schema and the content of sqlite_stat tables",
  ".headers on|off          Turn display of headers on or off",
  ".help ?-all? ?PATTERN?   Show help text for PATTERN",
#ifndef SQLITE_SHELL_FIDDLE
  ".import FILE TABLE       Import data from FILE into TABLE",
  "   Options:",
  "     --ascii               Use \\037 and \\036 as column and row separators",
  "     --csv                 Use , and \\n as column and row separators",
  "     --skip N              Skip the first N rows of input",
  "     --schema S            Target table to be S.TABLE",
  "     -v                    \"Verbose\" - increase auxiliary output",
  "   Notes:",
  "     *  If TABLE does not exist, it is created.  The first row of input",
  "        determines the column names.",
  "     *  If neither --csv or --ascii are used, the input mode is derived",
  "        from the \".mode\" output mode",
  "     *  If FILE begins with \"|\" then it is a command that generates the",
  "        input text.",
#endif
#ifndef SQLITE_OMIT_TEST_CONTROL
  ",imposter INDEX TABLE    Create imposter table TABLE on index INDEX",
#endif
  ".indexes ?TABLE?         Show names of indexes",
  "                           If TABLE is specified, only show indexes for",
  "                           tables matching TABLE using the LIKE operator.",
  ".intck ?STEPS_PER_UNLOCK?  Run an incremental integrity check on the db",
#ifdef SQLITE_ENABLE_IOTRACE
  ",iotrace FILE            Enable I/O diagnostic logging to FILE",
#endif
  ".limit ?LIMIT? ?VAL?     Display or change the value of an SQLITE_LIMIT",
  ".lint OPTIONS            Report potential schema issues.",
  "     Options:",
  "        fkey-indexes     Find missing foreign key indexes",
#if !defined(SQLITE_OMIT_LOAD_EXTENSION) && !defined(SQLITE_SHELL_FIDDLE)
  ".load FILE ?ENTRY?       Load an extension library",
#endif
#if !defined(SQLITE_SHELL_FIDDLE)
  ".log FILE|on|off         Turn logging on or off.  FILE can be stderr/stdout",
#else
  ".log on|off              Turn logging on or off.",
#endif
  ".mode ?MODE? ?OPTIONS?   Set output mode",
  "   MODE is one of:",
  "     ascii       Columns/rows delimited by 0x1F and 0x1E",
  "     box         Tables using unicode box-drawing characters",
  "     csv         Comma-separated values",
  "     column      Output in columns.  (See .width)",
  "     html        HTML <table> code",
  "     insert      SQL insert statements for TABLE",
  "     json        Results in a JSON array",
  "     line        One value per line",
  "     list        Values delimited by \"|\"",
  "     markdown    Markdown table format",
  "     qbox        Shorthand for \"box --wrap 60 --quote\"",
  "     quote       Escape answers as for SQL",
  "     table       ASCII-art table",
  "     tabs        Tab-separated values",
  "     tcl         TCL list elements",
  "   OPTIONS: (for columnar modes or insert mode):",
  "     --escape T     ctrl-char escape; T is one of: symbol, ascii, off",
  "     --wrap N       Wrap output lines to no longer than N characters",
  "     --wordwrap B   Wrap or not at word boundaries per B (on/off)",
  "     --ww           Shorthand for \"--wordwrap 1\"",
  "     --quote        Quote output text as SQL literals",
  "     --noquote      Do not quote output text",
  "     TABLE          The name of SQL table used for \"insert\" mode",
#ifndef SQLITE_SHELL_FIDDLE
  ".nonce STRING            Suspend safe mode for one command if nonce matches",
#endif
  ".nullvalue STRING        Use STRING in place of NULL values",
#ifndef SQLITE_SHELL_FIDDLE
  ".once ?OPTIONS? ?FILE?   Output for the next SQL command only to FILE",
  "     If FILE begins with '|' then open as a pipe",
  "       --bom    Put a UTF8 byte-order mark at the beginning",
  "       -e       Send output to the system text editor",
  "       --plain  Use text/plain output instead of HTML for -w option",
  "       -w       Send output as HTML to a web browser (same as \".www\")",
  "       -x       Send output as CSV to a spreadsheet (same as \".excel\")",
  /* Note that .open is (partially) available in WASM builds but is
  ** currently only intended to be used by the fiddle tool, not
  ** end users, so is "undocumented." */
  ".open ?OPTIONS? ?FILE?   Close existing database and reopen FILE",
  "     Options:",
  "        --append        Use appendvfs to append database to the end of FILE",
#endif
#ifndef SQLITE_OMIT_DESERIALIZE
  "        --deserialize   Load into memory using sqlite3_deserialize()",
  "        --hexdb         Load the output of \"dbtotxt\" as an in-memory db",
  "        --maxsize N     Maximum size for --hexdb or --deserialized database",
#endif
  "        --new           Initialize FILE to an empty database",
  "        --nofollow      Do not follow symbolic links",
  "        --readonly      Open FILE readonly",
  "        --zip           FILE is a ZIP archive",
#ifndef SQLITE_SHELL_FIDDLE
  ".output ?FILE?           Send output to FILE or stdout if FILE is omitted",
  "   If FILE begins with '|' then open it as a pipe.",
  "   If FILE is 'off' then output is disabled.",
  "   Options:",
  "     --bom                 Prefix output with a UTF8 byte-order mark",
  "     -e                    Send output to the system text editor",
  "     --plain               Use text/plain for -w option",
  "     -w                    Send output to a web browser",
  "     -x                    Send output as CSV to a spreadsheet",
#endif
  ".parameter CMD ...       Manage SQL parameter bindings",
  "   clear                   Erase all bindings",
  "   init                    Initialize the TEMP table that holds bindings",
  "   list                    List the current parameter bindings",
  "   set PARAMETER VALUE     Given SQL parameter PARAMETER a value of VALUE",
  "                           PARAMETER should start with one of: $ : @ ?",
  "   unset PARAMETER         Remove PARAMETER from the binding table",
  ".print STRING...         Print literal STRING",
#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
  ".progress N              Invoke progress handler after every N opcodes",
  "   --limit N                 Interrupt after N progress callbacks",
  "   --once                    Do no more than one progress interrupt",
  "   --quiet|-q                No output except at interrupts",
  "   --reset                   Reset the count for each input and interrupt",
#endif
  ".prompt MAIN CONTINUE    Replace the standard prompts",
#ifndef SQLITE_SHELL_FIDDLE
  ".quit                    Stop interpreting input stream, exit if primary.",
  ".read FILE               Read input from FILE or command output",
  "    If FILE begins with \"|\", it is a command that generates the input.",
#endif
#if SQLITE_SHELL_HAVE_RECOVER
  ".recover                 Recover as much data as possible from corrupt db.",
  "   --ignore-freelist        Ignore pages that appear to be on db freelist",
  "   --lost-and-found TABLE   Alternative name for the lost-and-found table",
  "   --no-rowids              Do not attempt to recover rowid values",
  "                            that are not also INTEGER PRIMARY KEYs",
#endif
#ifndef SQLITE_SHELL_FIDDLE
  ".restore ?DB? FILE       Restore content of DB (default \"main\") from FILE",
  ".save ?OPTIONS? FILE     Write database to FILE (an alias for .backup ...)",
#endif
  ".scanstats on|off|est    Turn sqlite3_stmt_scanstatus() metrics on or off",
  ".schema ?PATTERN?        Show the CREATE statements matching PATTERN",
  "   Options:",
  "      --indent             Try to pretty-print the schema",
  "      --nosys              Omit objects whose names start with \"sqlite_\"",
  ",selftest ?OPTIONS?      Run tests defined in the SELFTEST table",
  "    Options:",
  "       --init               Create a new SELFTEST table",
  "       -v                   Verbose output",
  ".separator COL ?ROW?     Change the column and row separators",
#if defined(SQLITE_ENABLE_SESSION)
  ".session ?NAME? CMD ...  Create or control sessions",
  "   Subcommands:",
  "     attach TABLE             Attach TABLE",
  "     changeset FILE           Write a changeset into FILE",
  "     close                    Close one session",
  "     enable ?BOOLEAN?         Set or query the enable bit",
  "     filter GLOB...           Reject tables matching GLOBs",
  "     indirect ?BOOLEAN?       Mark or query the indirect status",
  "     isempty                  Query whether the session is empty",
  "     list                     List currently open session names",
  "     open DB NAME             Open a new session on DB",
  "     patchset FILE            Write a patchset into FILE",
  "   If ?NAME? is omitted, the first defined session is used.",
#endif
  ".sha3sum ...             Compute a SHA3 hash of database content",
  "    Options:",
  "      --schema              Also hash the sqlite_schema table",
  "      --sha3-224            Use the sha3-224 algorithm",
  "      --sha3-256            Use the sha3-256 algorithm (default)",
  "      --sha3-384            Use the sha3-384 algorithm",
  "      --sha3-512            Use the sha3-512 algorithm",
  "    Any other argument is a LIKE pattern for tables to hash",
#if !defined(SQLITE_NOHAVE_SYSTEM) && !defined(SQLITE_SHELL_FIDDLE)
  ".shell CMD ARGS...       Run CMD ARGS... in a system shell",
#endif
  ".show                    Show the current values for various settings",
  ".stats ?ARG?             Show stats or turn stats on or off",
  "   off                      Turn off automatic stat display",
  "   on                       Turn on automatic stat display",
  "   stmt                     Show statement stats",
  "   vmstep                   Show the virtual machine step count only",
#if !defined(SQLITE_NOHAVE_SYSTEM) && !defined(SQLITE_SHELL_FIDDLE)
  ".system CMD ARGS...      Run CMD ARGS... in a system shell",
#endif
  ".tables ?TABLE?          List names of tables matching LIKE pattern TABLE",
#ifndef SQLITE_SHELL_FIDDLE
  ",testcase NAME           Begin redirecting output to 'testcase-out.txt'",
#endif
  ",testctrl CMD ...        Run various sqlite3_test_control() operations",
  "                           Run \".testctrl\" with no arguments for details",
  ".timeout MS              Try opening locked tables for MS milliseconds",
  ".timer on|off            Turn SQL timer on or off",
#ifndef SQLITE_OMIT_TRACE
  ".trace ?OPTIONS?         Output each SQL statement as it is run",
  "    FILE                    Send output to FILE",
  "    stdout                  Send output to stdout",
  "    stderr                  Send output to stderr",
  "    off                     Disable tracing",
  "    --expanded              Expand query parameters",
#ifdef SQLITE_ENABLE_NORMALIZE
  "    --normalized            Normal the SQL statements",
#endif
  "    --plain                 Show SQL as it is input",
  "    --stmt                  Trace statement execution (SQLITE_TRACE_STMT)",
  "    --profile               Profile statements (SQLITE_TRACE_PROFILE)",
  "    --row                   Trace each row (SQLITE_TRACE_ROW)",
  "    --close                 Trace connection close (SQLITE_TRACE_CLOSE)",
#endif /* SQLITE_OMIT_TRACE */
#ifdef SQLITE_DEBUG
  ".unmodule NAME ...       Unregister virtual table modules",
  "    --allexcept             Unregister everything except those named",
#endif
  ".version                 Show source, library and compiler versions",
  ".vfsinfo ?AUX?           Information about the top-level VFS",
  ".vfslist                 List all available VFSes",
  ".vfsname ?AUX?           Print the name of the VFS stack",
  ".width NUM1 NUM2 ...     Set minimum column widths for columnar output",
  "     Negative values right-justify",
#ifndef SQLITE_SHELL_FIDDLE
  ".www                     Display output of the next command in web browser",
  "    --plain                 Show results as text/plain, not as HTML",

Referenced by showHelp().

b64DigitValues

const u8 b64DigitValues[128]

static

Initial value:

= {
  
    0x82  , 0x82  , 0x82  , 0x82  , 0x82  , 0x82  , 0x82  , 0x82  , 0x82  , 0x81  , 0x81  , 0x81  , 0x81  , 0x81  , 0x82  , 0x82  ,
  
    0x82  , 0x82  , 0x82  , 0x82  , 0x82  , 0x82  , 0x82  , 0x82  , 0x82  , 0x82  , 0x82  , 0x82  , 0x82  , 0x82  , 0x82  , 0x82  ,
  
    0x81  , 0x82  , 0x82  , 0x82  , 0x82  , 0x82  , 0x82  , 0x82  , 0x82  , 0x82  , 0x82  ,62, 0x82  , 0x82  , 0x82  ,63,
  
    52,53,54,55, 56,57,58,59, 60,61, 0x82  , 0x82  , 0x82  , 0x80  , 0x82  , 0x82  ,
  
    0x82  , 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,
  
    15,16,17,18, 19,20,21,22, 23,24,25, 0x82  , 0x82  , 0x82  , 0x82  , 0x82  ,
  
    0x82  ,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
  
    41,42,43,44, 45,46,47,48, 49,50,51, 0x82  , 0x82  , 0x82  , 0x82  , 0x82  
}

                                      {
  /*                             HT LF VT  FF CR       */
    ND,ND,ND,ND, ND,ND,ND,ND, ND,WS,WS,WS, WS,WS,ND,ND,
  /*                                                US */
    ND,ND,ND,ND, ND,ND,ND,ND, ND,ND,ND,ND, ND,ND,ND,ND,
  /*sp                                  +            / */
    WS,ND,ND,ND, ND,ND,ND,ND, ND,ND,ND,62, ND,ND,ND,63,
  /* 0  1            5            9            =       */
    52,53,54,55, 56,57,58,59, 60,61,ND,ND, ND,PC,ND,ND,
  /*    A                                            O */
    ND, 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,
  /* P                               Z                 */
    15,16,17,18, 19,20,21,22, 23,24,25,ND, ND,ND,ND,ND,
  /*    a                                            o */
    ND,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
  /* p                               z                 */
    41,42,43,44, 45,46,47,48, 49,50,51,ND, ND,ND,ND,ND
};

b64Numerals

const char b64Numerals[64+1] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

static

Referenced by fromBase64().

b85_cOffset

u8 b85_cOffset[] = { 0, '#', 0, '*'-4, 0 }

static

{ 0, '#', 0, '*'-4, 0 };

bail_on_error

int bail_on_error = 0

static

Referenced by do_meta_command(), main(), process_input(), and process_sqliterc().

completionModule

sqlite3_module completionModule

static

Initial value:

= {
  0,                         
  0,                         
  completionConnect,         
  completionBestIndex,       
  completionDisconnect,      
  0,                         
  completionOpen,            
  completionClose,           
  completionFilter,          
  completionNext,            
  completionEof,             
  completionColumn,          
  completionRowid,           
  0,                         
  0,                         
  0,                         
  0,                         
  0,                         
  0,                         
  0,                         
  0,                         
  0,                         
  0,                         
  0,                         
  0                          
}

                                         {
  0,                         /* iVersion */
  0,                         /* xCreate */
  completionConnect,         /* xConnect */
  completionBestIndex,       /* xBestIndex */
  completionDisconnect,      /* xDisconnect */
  0,                         /* xDestroy */
  completionOpen,            /* xOpen - open a cursor */
  completionClose,           /* xClose - close a cursor */
  completionFilter,          /* xFilter - configure scan constraints */
  completionNext,            /* xNext - advance a cursor */
  completionEof,             /* xEof - check for end of scan */
  completionColumn,          /* xColumn - read data */
  completionRowid,           /* xRowid - read data */
  0,                         /* xUpdate */
  0,                         /* xBegin */
  0,                         /* xSync */
  0,                         /* xCommit */
  0,                         /* xRollback */
  0,                         /* xFindMethod */
  0,                         /* xRename */
  0,                         /* xSavepoint */
  0,                         /* xRelease */
  0,                         /* xRollbackTo */
  0,                         /* xShadowName */
  0                          /* xIntegrity */
};

Referenced by sqlite3CompletionVtabInit().

continuePrompt

char continuePrompt[128]

static

Referenced by do_meta_command(), dynamicContinuePrompt(), and main_init().

dynPrompt

struct DynaPrompt dynPrompt = { {0}, {0}, 0, 0 }

static

Referenced by dynamicContinuePrompt().

enableTimer

int enableTimer = 0

static

Referenced by beginTimer(), do_meta_command(), and endTimer().

ersaztMethods

sqlite3_mem_methods ersaztMethods

static

Initial value:

= {
  memtraceMalloc,
  memtraceFree,
  memtraceRealloc,
  memtraceSize,
  memtraceRoundup,
  memtraceInit,
  memtraceShutdown,
  0
}

                                           {
  memtraceMalloc,
  memtraceFree,
  memtraceRealloc,
  memtraceSize,
  memtraceRoundup,
  memtraceInit,
  memtraceShutdown,
  0
};

Referenced by sqlite3MemTraceActivate().

ersaztPcacheMethods

sqlite3_pcache_methods2 ersaztPcacheMethods

static

Initial value:

= {
  0,
  0,
  pcachetraceInit,
  pcachetraceShutdown,
  pcachetraceCreate,
  pcachetraceCachesize,
  pcachetracePagecount,
  pcachetraceFetch,
  pcachetraceUnpin,
  pcachetraceRekey,
  pcachetraceTruncate,
  pcachetraceDestroy,
  pcachetraceShrink
}

                                                     {
  0,
  0,
  pcachetraceInit,
  pcachetraceShutdown,
  pcachetraceCreate,
  pcachetraceCachesize,
  pcachetracePagecount,
  pcachetraceFetch,
  pcachetraceUnpin,
  pcachetraceRekey,
  pcachetraceTruncate,
  pcachetraceDestroy,
  pcachetraceShrink
};

Referenced by sqlite3PcacheTraceActivate().

[struct]

struct { ... } faultsim_state

Referenced by do_meta_command(), and faultsim_callback().

globalDb

sqlite3* globalDb = 0

static

Referenced by do_meta_command(), interrupt_handler(), main(), and open_db().

iBegin

sqlite3_int64 iBegin

static

Referenced by beginTimer(), and endTimer().

mainPrompt

char mainPrompt[128]

static

Referenced by do_meta_command(), main_init(), and one_input_line().

memtraceBase

sqlite3_mem_methods memtraceBase

static

Referenced by memtraceFree(), memtraceInit(), memtraceMalloc(), memtraceRealloc(), memtraceRoundup(), memtraceShutdown(), memtraceSize(), sqlite3MemTraceActivate(), and sqlite3MemTraceDeactivate().

memtraceOut

FILE* memtraceOut

static

Referenced by memtraceFree(), memtraceMalloc(), memtraceRealloc(), sqlite3MemTraceActivate(), and sqlite3MemTraceDeactivate().

modeDescr

const char* modeDescr[]

static

Initial value:

= {
  "line",
  "column",
  "list",
  "semi",
  "html",
  "insert",
  "quote",
  "tcl",
  "csv",
  "explain",
  "ascii",
  "prettyprint",
  "eqp",
  "json",
  "markdown",
  "table",
  "box",
  "count",
  "off",
  "scanexp",
  "www",
}

                                 {
  "line",
  "column",
  "list",
  "semi",
  "html",
  "insert",
  "quote",
  "tcl",
  "csv",
  "explain",
  "ascii",
  "prettyprint",
  "eqp",
  "json",
  "markdown",
  "table",
  "box",
  "count",
  "off",
  "scanexp",

Referenced by do_meta_command().

needCsvQuote

const char needCsvQuote[]

static

Initial value:

= {
  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,
}

                                   {
  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,

Referenced by output_csv().

pcacheBase

sqlite3_pcache_methods2 pcacheBase

static

Referenced by pcachetraceCachesize(), pcachetraceCreate(), pcachetraceDestroy(), pcachetraceFetch(), pcachetraceInit(), pcachetracePagecount(), pcachetraceRekey(), pcachetraceShrink(), pcachetraceShutdown(), pcachetraceTruncate(), pcachetraceUnpin(), sqlite3PcacheTraceActivate(), and sqlite3PcacheTraceDeactivate().

pcachetraceOut

FILE* pcachetraceOut

static

Referenced by pcachetraceCachesize(), pcachetraceCreate(), pcachetraceDestroy(), pcachetraceFetch(), pcachetraceInit(), pcachetracePagecount(), pcachetraceRekey(), pcachetraceShrink(), pcachetraceShutdown(), pcachetraceTruncate(), pcachetraceUnpin(), sqlite3PcacheTraceActivate(), and sqlite3PcacheTraceDeactivate().

savedSelectTrace

unsigned int savedSelectTrace

static

Referenced by disable_debug_trace_modes().

savedWhereTrace

unsigned int savedWhereTrace

static

Referenced by disable_debug_trace_modes().

sBegin

struct rusage sBegin

static

Referenced by beginTimer(), and endTimer().

seenInterrupt

volatile int seenInterrupt = 0

static

Referenced by ascii_read_one_field(), csv_read_one_field(), do_meta_command(), exec_prepared_stmt_columnar(), interrupt_handler(), one_input_line(), and process_input().

seriesModule

sqlite3_module seriesModule

static

Initial value:

= {
  0,                         
  0,                         
  seriesConnect,             
  seriesBestIndex,           
  seriesDisconnect,          
  0,                         
  seriesOpen,                
  seriesClose,               
  seriesFilter,              
  seriesNext,                
  seriesEof,                 
  seriesColumn,              
  seriesRowid,               
  0,                         
  0,                         
  0,                         
  0,                         
  0,                         
  0,                         
  0,                         
  0,                         
  0,                         
  0,                         
  0,                         
  0                          
}

                                     {
  0,                         /* iVersion */
  0,                         /* xCreate */
  seriesConnect,             /* xConnect */
  seriesBestIndex,           /* xBestIndex */
  seriesDisconnect,          /* xDisconnect */
  0,                         /* xDestroy */
  seriesOpen,                /* xOpen - open a cursor */
  seriesClose,               /* xClose - close a cursor */
  seriesFilter,              /* xFilter - configure scan constraints */
  seriesNext,                /* xNext - advance a cursor */
  seriesEof,                 /* xEof - check for end of scan */
  seriesColumn,              /* xColumn - read data */
  seriesRowid,               /* xRowid - read data */
  0,                         /* xUpdate */
  0,                         /* xBegin */
  0,                         /* xSync */
  0,                         /* xCommit */
  0,                         /* xRollback */
  0,                         /* xFindMethod */
  0,                         /* xRename */
  0,                         /* xSavepoint */
  0,                         /* xRelease */
  0,                         /* xRollbackTo */
  0,                         /* xShadowName */
  0                          /* xIntegrity */
};

Referenced by sqlite3_series_init().

shell_EscModeNames

const char* shell_EscModeNames[] = { "ascii", "symbol", "off" }

static

Referenced by do_meta_command(), and main().

stdin_is_interactive

int stdin_is_interactive = 1

static

Referenced by do_meta_command(), main(), process_input(), process_sqliterc(), and runOneSqlLine().

stdout_is_console

int stdout_is_console = 1

static

Referenced by main().

vfstraceDlSym

void(*)(void) vfstraceDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym) ( sqlite3_vfs * pVfs, void * p, const char * zSymbol )

static

Referenced by vfstrace_register().

zCOL_DB

const char* zCOL_DB = ":memory:"

static

Referenced by zAutoColumn().

zOptions

const char zOptions[]

static

Initial value:

=
  "   --                   treat no subsequent arguments as options\n"
 
 
 
  "   -append              append the database to the end of the file\n"
  "   -ascii               set output mode to 'ascii'\n"
  "   -bail                stop after hitting an error\n"
  "   -batch               force batch I/O\n"
  "   -box                 set output mode to 'box'\n"
  "   -column              set output mode to 'column'\n"
  "   -cmd COMMAND         run \"COMMAND\" before reading stdin\n"
  "   -csv                 set output mode to 'csv'\n"
 
  "   -deserialize         open the database using sqlite3_deserialize()\n"
 
  "   -echo                print inputs before execution\n"
  "   -escape T            ctrl-char escape; T is one of: symbol, ascii, off\n"
  "   -init FILENAME       read/process named file\n"
  "   -[no]header          turn headers on or off\n"
 
 
 
  "   -help                show this message\n"
  "   -html                set output mode to HTML\n"
  "   -interactive         force interactive I/O\n"
  "   -json                set output mode to 'json'\n"
  "   -line                set output mode to 'line'\n"
  "   -list                set output mode to 'list'\n"
  "   -lookaside SIZE N    use N entries of SZ bytes for lookaside memory\n"
  "   -markdown            set output mode to 'markdown'\n"
 
  "   -maxsize N           maximum size for a --deserialize database\n"
 
  "   -memtrace            trace all memory allocations and deallocations\n"
  "   -mmap N              default mmap size set to N\n"
 
 
 
  "   -newline SEP         set output row separator. Default: '\\n'\n"
  "   -nofollow            refuse to open symbolic links to database files\n"
  "   -nonce STRING        set the safe-mode escape nonce\n"
  "   -no-rowid-in-view    Disable rowid-in-view using sqlite3_config()\n"
  "   -nullvalue TEXT      set text string for NULL values. Default ''\n"
  "   -pagecache SIZE N    use N slots of SZ bytes each for page cache memory\n"
  "   -pcachetrace         trace all page cache operations\n"
  "   -quote               set output mode to 'quote'\n"
  "   -readonly            open the database read-only\n"
  "   -safe                enable safe-mode\n"
  "   -separator SEP       set output column separator. Default: '|'\n"
 
 
 
  "   -stats               print memory stats before each finalize\n"
  "   -table               set output mode to 'table'\n"
  "   -tabs                set output mode to 'tabs'\n"
  "   -unsafe-testing      allow unsafe commands and modes for testing\n"
  "   -version             show SQLite version\n"
  "   -vfs NAME            use NAME as the default VFS\n"
  "   -vfstrace            enable tracing of all VFS calls\n"

Referenced by usage().