Fossil SCM

Merge in latest from trunk.

andybradford 2023-11-29 04:32 clone-resume merge

Commit 5d12d42680fef649b289dfe47d67259126a0947fbb027db78bf9800e69d1026e

Parent bc0a4c60c00ddf6…

6 files changed +1862 -1174 +196 -90 +55 -12 +2 -2 +1 -1 +2 -2

~ extsrc/shell.c ~ extsrc/sqlite3.c ~ extsrc/sqlite3.h ~ src/allrepo.c ~ src/hook.c ~ www/unvers.wiki

M extsrc/shell.c

+1862 -1174

		--- extsrc/shell.c
		+++ extsrc/shell.c
		@@ -250,33 +250,1023 @@
250	250	#define WIN32_LEAN_AND_MEAN
251	251	#include <windows.h>
252	252
253	253	/* string conversion routines only needed on Win32 */
254	254	extern char *sqlite3_win32_unicode_to_utf8(LPCWSTR);
255		-extern char sqlite3_win32_mbcs_to_utf8_v2(const char , int);
256		-extern char sqlite3_win32_utf8_to_mbcs_v2(const char , int);
257	255	extern LPWSTR sqlite3_win32_utf8_to_unicode(const char *zText);
258	256	#endif
259	257
260		-/* On Windows, we normally run with output mode of TEXT so that \n characters
261		-** are automatically translated into \r\n. However, this behavior needs
262		-** to be disabled in some cases (ex: when generating CSV output and when
263		-** rendering quoted strings that contain \n characters). The following
264		-** routines take care of that.
265		-*/
266		-#if (defined(_WIN32) \|\| defined(WIN32)) && !SQLITE_OS_WINRT
267		-static void setBinaryMode(FILE *file, int isOutput){
268		- if( isOutput ) fflush(file);
269		- _setmode(_fileno(file), _O_BINARY);
270		-}
271		-static void setTextMode(FILE *file, int isOutput){
272		- if( isOutput ) fflush(file);
273		- _setmode(_fileno(file), _O_TEXT);
274		-}
	258	+/* Use console I/O package as a direct INCLUDE. */
	259	+#define SQLITE_INTERNAL_LINKAGE static
	260	+
	261	+#ifdef SQLITE_SHELL_FIDDLE
	262	+/* Deselect most features from the console I/O package for Fiddle. */
	263	+# define SQLITE_CIO_NO_REDIRECT
	264	+# define SQLITE_CIO_NO_CLASSIFY
	265	+# define SQLITE_CIO_NO_TRANSLATE
	266	+# define SQLITE_CIO_NO_SETMODE
	267	+#endif
	268	+/*********************** Begin ../ext/consio/console_io.h ****************/
	269	+/*
	270	+** 2023 November 1
	271	+**
	272	+** The author disclaims copyright to this source code. In place of
	273	+** a legal notice, here is a blessing:
	274	+**
	275	+** May you do good and not evil.
	276	+** May you find forgiveness for yourself and forgive others.
	277	+** May you share freely, never taking more than you give.
	278	+**
	279	+********************************************************************************
	280	+** This file exposes various interfaces used for console and other I/O
	281	+** by the SQLite project command-line tools. These interfaces are used
	282	+** at either source conglomeration time, compilation time, or run time.
	283	+** This source provides for either inclusion into conglomerated,
	284	+** "single-source" forms or separate compilation then linking.
	285	+**
	286	+** Platform dependencies are "hidden" here by various stratagems so
	287	+** that, provided certain conditions are met, the programs using this
	288	+** source or object code compiled from it need no explicit conditional
	289	+** compilation in their source for their console and stream I/O.
	290	+**
	291	+** The symbols and functionality exposed here are not a public API.
	292	+** This code may change in tandem with other project code as needed.
	293	+**
	294	+** When this .h file and its companion .c are directly incorporated into
	295	+** a source conglomeration (such as shell.c), the preprocessor symbol
	296	+** CIO_WIN_WC_XLATE is defined as 0 or 1, reflecting whether console I/O
	297	+** translation for Windows is effected for the build.
	298	+*/
	299	+
	300	+#ifndef SQLITE_INTERNAL_LINKAGE
	301	+# define SQLITE_INTERNAL_LINKAGE extern /* external to translation unit */
	302	+# include <stdio.h>
	303	+#else
	304	+# define SHELL_NO_SYSINC /* Better yet, modify mkshellc.tcl for this. */
	305	+#endif
	306	+
	307	+#ifndef SQLITE3_H
	308	+/* # include "sqlite3.h" */
	309	+#endif
	310	+
	311	+#ifndef SQLITE_CIO_NO_CLASSIFY
	312	+
	313	+/* Define enum for use with following function. */
	314	+typedef enum StreamsAreConsole {
	315	+ SAC_NoConsole = 0,
	316	+ SAC_InConsole = 1, SAC_OutConsole = 2, SAC_ErrConsole = 4,
	317	+ SAC_AnyConsole = 0x7
	318	+} StreamsAreConsole;
	319	+
	320	+/*
	321	+** Classify the three standard I/O streams according to whether
	322	+** they are connected to a console attached to the process.
	323	+**
	324	+** Returns the bit-wise OR of SAC_{In,Out,Err}Console values,
	325	+** or SAC_NoConsole if none of the streams reaches a console.
	326	+**
	327	+** This function should be called before any I/O is done with
	328	+** the given streams. As a side-effect, the given inputs are
	329	+** recorded so that later I/O operations on them may be done
	330	+** differently than the C library FILE* I/O would be done,
	331	+** iff the stream is used for the I/O functions that follow,
	332	+** and to support the ones that use an implicit stream.
	333	+**
	334	+** On some platforms, stream or console mode alteration (aka
	335	+** "Setup") may be made which is undone by consoleRestore().
	336	+*/
	337	+SQLITE_INTERNAL_LINKAGE StreamsAreConsole
	338	+consoleClassifySetup( FILE pfIn, FILE pfOut, FILE *pfErr );
	339	+/* A usual call for convenience: */
	340	+#define SQLITE_STD_CONSOLE_INIT() consoleClassifySetup(stdin,stdout,stderr)
	341	+
	342	+/*
	343	+** After an initial call to consoleClassifySetup(...), renew
	344	+** the same setup it effected. (A call not after is an error.)
	345	+** This will restore state altered by consoleRestore();
	346	+**
	347	+** Applications which run an inferior (child) process which
	348	+** inherits the same I/O streams may call this function after
	349	+** such a process exits to guard against console mode changes.
	350	+*/
	351	+SQLITE_INTERNAL_LINKAGE void consoleRenewSetup(void);
	352	+
	353	+/*
	354	+** Undo any side-effects left by consoleClassifySetup(...).
	355	+**
	356	+** This should be called after consoleClassifySetup() and
	357	+** before the process terminates normally. It is suitable
	358	+** for use with the atexit() C library procedure. After
	359	+** this call, no console I/O should be done until one of
	360	+** console{Classify or Renew}Setup(...) is called again.
	361	+**
	362	+** Applications which run an inferior (child) process that
	363	+** inherits the same I/O streams might call this procedure
	364	+** before so that said process will have a console setup
	365	+** however users have configured it or come to expect.
	366	+*/
	367	+SQLITE_INTERNAL_LINKAGE void SQLITE_CDECL consoleRestore( void );
	368	+
	369	+#else /* defined(SQLITE_CIO_NO_CLASSIFY) */
	370	+# define consoleClassifySetup(i,o,e)
	371	+# define consoleRenewSetup()
	372	+# define consoleRestore()
	373	+#endif /* defined(SQLITE_CIO_NO_CLASSIFY) */
	374	+
	375	+#ifndef SQLITE_CIO_NO_REDIRECT
	376	+/*
	377	+** Set stream to be used for the functions below which write
	378	+** to "the designated X stream", where X is Output or Error.
	379	+** Returns the previous value.
	380	+**
	381	+** Alternatively, pass the special value, invalidFileStream,
	382	+** to get the designated stream value without setting it.
	383	+**
	384	+** Before the designated streams are set, they default to
	385	+** those passed to consoleClassifySetup(...), and before
	386	+** that is called they default to stdout and stderr.
	387	+**
	388	+** It is error to close a stream so designated, then, without
	389	+** designating another, use the corresponding {o,e}Emit(...).
	390	+*/
	391	+SQLITE_INTERNAL_LINKAGE FILE *invalidFileStream;
	392	+SQLITE_INTERNAL_LINKAGE FILE setOutputStream(FILE pf);
	393	+# ifdef CONSIO_SET_ERROR_STREAM
	394	+SQLITE_INTERNAL_LINKAGE FILE setErrorStream(FILE pf);
	395	+# endif
	396	+#else
	397	+# define setOutputStream(pf)
	398	+# define setErrorStream(pf)
	399	+#endif /* !defined(SQLITE_CIO_NO_REDIRECT) */
	400	+
	401	+#ifndef SQLITE_CIO_NO_TRANSLATE
	402	+/*
	403	+** Emit output like fprintf(). If the output is going to the
	404	+** console and translation from UTF-8 is necessary, perform
	405	+** the needed translation. Otherwise, write formatted output
	406	+** to the provided stream almost as-is, possibly with newline
	407	+** translation as specified by set{Binary,Text}Mode().
	408	+*/
	409	+SQLITE_INTERNAL_LINKAGE int fPrintfUtf8(FILE pfO, const char zFormat, ...);
	410	+/* Like fPrintfUtf8 except stream is always the designated output. */
	411	+SQLITE_INTERNAL_LINKAGE int oPrintfUtf8(const char *zFormat, ...);
	412	+/* Like fPrintfUtf8 except stream is always the designated error. */
	413	+SQLITE_INTERNAL_LINKAGE int ePrintfUtf8(const char *zFormat, ...);
	414	+
	415	+/*
	416	+** Emit output like fputs(). If the output is going to the
	417	+** console and translation from UTF-8 is necessary, perform
	418	+** the needed translation. Otherwise, write given text to the
	419	+** provided stream almost as-is, possibly with newline
	420	+** translation as specified by set{Binary,Text}Mode().
	421	+*/
	422	+SQLITE_INTERNAL_LINKAGE int fPutsUtf8(const char z, FILE pfO);
	423	+/* Like fPutsUtf8 except stream is always the designated output. */
	424	+SQLITE_INTERNAL_LINKAGE int oPutsUtf8(const char *z);
	425	+/* Like fPutsUtf8 except stream is always the designated error. */
	426	+SQLITE_INTERNAL_LINKAGE int ePutsUtf8(const char *z);
	427	+
	428	+/*
	429	+** Emit output like fPutsUtf8(), except that the length of the
	430	+** accepted char or character sequence is limited by nAccept.
	431	+**
	432	+** Returns the number of accepted char values.
	433	+*/
	434	+#ifdef CONSIO_SPUTB
	435	+SQLITE_INTERNAL_LINKAGE int
	436	+fPutbUtf8(FILE pfOut, const char cBuf, int nAccept);
	437	+#endif
	438	+/* Like fPutbUtf8 except stream is always the designated output. */
	439	+SQLITE_INTERNAL_LINKAGE int
	440	+oPutbUtf8(const char *cBuf, int nAccept);
	441	+/* Like fPutbUtf8 except stream is always the designated error. */
	442	+#ifdef CONSIO_EPUTB
	443	+SQLITE_INTERNAL_LINKAGE int
	444	+ePutbUtf8(const char *cBuf, int nAccept);
	445	+#endif
	446	+
	447	+/*
	448	+** Collect input like fgets(...) with special provisions for input
	449	+** from the console on platforms that require same. Defers to the
	450	+** C library fgets() when input is not from the console. Newline
	451	+** translation may be done as set by set{Binary,Text}Mode(). As a
	452	+** convenience, pfIn==NULL is treated as stdin.
	453	+*/
	454	+SQLITE_INTERNAL_LINKAGE char* fGetsUtf8(char cBuf, int ncMax, FILE pfIn);
	455	+/* Like fGetsUtf8 except stream is always the designated input. */
	456	+/* SQLITE_INTERNAL_LINKAGE char* iGetsUtf8(char cBuf, int ncMax); /
	457	+
	458	+#endif /* !defined(SQLITE_CIO_NO_TRANSLATE) */
	459	+
	460	+#ifndef SQLITE_CIO_NO_SETMODE
	461	+/*
	462	+** Set given stream for binary mode, where newline translation is
	463	+** not done, or for text mode where, for some platforms, newlines
	464	+** are translated to the platform's conventional char sequence.
	465	+** If bFlush true, flush the stream.
	466	+**
	467	+** An additional side-effect is that if the stream is one passed
	468	+** to consoleClassifySetup() as an output, it is flushed first.
	469	+**
	470	+** Note that binary/text mode has no effect on console I/O
	471	+** translation. On all platforms, newline to the console starts
	472	+** a new line and CR,LF chars from the console become a newline.
	473	+*/
	474	+SQLITE_INTERNAL_LINKAGE void setBinaryMode(FILE *, short bFlush);
	475	+SQLITE_INTERNAL_LINKAGE void setTextMode(FILE *, short bFlush);
	476	+#endif
	477	+
	478	+#ifdef SQLITE_CIO_PROMPTED_IN
	479	+typedef struct Prompts {
	480	+ int numPrompts;
	481	+ const char **azPrompts;
	482	+} Prompts;
	483	+
	484	+/*
	485	+** Macros for use of a line editor.
	486	+**
	487	+** The following macros define operations involving use of a
	488	+** line-editing library or simple console interaction.
	489	+** A "T" argument is a text (char *) buffer or filename.
	490	+** A "N" argument is an integer.
	491	+**
	492	+** SHELL_ADD_HISTORY(T) // Record text as line(s) of history.
	493	+** SHELL_READ_HISTORY(T) // Read history from file named by T.
	494	+** SHELL_WRITE_HISTORY(T) // Write history to file named by T.
	495	+** SHELL_STIFLE_HISTORY(N) // Limit history to N entries.
	496	+**
	497	+** A console program which does interactive console input is
	498	+** expected to call:
	499	+** SHELL_READ_HISTORY(T) before collecting such input;
	500	+** SHELL_ADD_HISTORY(T) as record-worthy input is taken;
	501	+** SHELL_STIFLE_HISTORY(N) after console input ceases; then
	502	+** SHELL_WRITE_HISTORY(T) before the program exits.
	503	+*/
	504	+
	505	+/*
	506	+** Retrieve a single line of input text from an input stream.
	507	+**
	508	+** If pfIn is the input stream passed to consoleClassifySetup(),
	509	+** and azPrompt is not NULL, then a prompt is issued before the
	510	+** line is collected, as selected by the isContinuation flag.
	511	+** Array azPrompt[{0,1}] holds the {main,continuation} prompt.
	512	+**
	513	+** If zBufPrior is not NULL then it is a buffer from a prior
	514	+** call to this routine that can be reused, or will be freed.
	515	+**
	516	+** The result is stored in space obtained from malloc() and
	517	+** must either be freed by the caller or else passed back to
	518	+** this function as zBufPrior for reuse.
	519	+**
	520	+** This function may call upon services of a line-editing
	521	+** library to interactively collect line edited input.
	522	+*/
	523	+SQLITE_INTERNAL_LINKAGE char *
	524	+shellGetLine(FILE pfIn, char zBufPrior, int nLen,
	525	+ short isContinuation, Prompts azPrompt);
	526	+#endif /* defined(SQLITE_CIO_PROMPTED_IN) */
	527	+/*
	528	+** TBD: Define an interface for application(s) to generate
	529	+** completion candidates for use by the line-editor.
	530	+**
	531	+** This may be premature; the CLI is the only application
	532	+** that does this. Yet, getting line-editing melded into
	533	+** console I/O is desirable because a line-editing library
	534	+** may have to establish console operating mode, possibly
	535	+** in a way that interferes with the above functionality.
	536	+*/
	537	+
	538	+#if !(defined(SQLITE_CIO_NO_UTF8SCAN)&&defined(SQLITE_CIO_NO_TRANSLATE))
	539	+/* Skip over as much z[] input char sequence as is valid UTF-8,
	540	+** limited per nAccept char's or whole characters and containing
	541	+** no char cn such that ((1<<cn) & ccm)!=0. On return, the
	542	+** sequence z:return (inclusive:exclusive) is validated UTF-8.
	543	+** Limit: nAccept>=0 => char count, nAccept<0 => character
	544	+ */
	545	+SQLITE_INTERNAL_LINKAGE const char*
	546	+zSkipValidUtf8(const char *z, int nAccept, long ccm);
	547	+
	548	+#endif
	549	+
	550	+/*********************** End ../ext/consio/console_io.h ******************/
	551	+/*********************** Begin ../ext/consio/console_io.c ****************/
	552	+/*
	553	+** 2023 November 4
	554	+**
	555	+** The author disclaims copyright to this source code. In place of
	556	+** a legal notice, here is a blessing:
	557	+**
	558	+** May you do good and not evil.
	559	+** May you find forgiveness for yourself and forgive others.
	560	+** May you share freely, never taking more than you give.
	561	+**
	562	+********************************************************************************
	563	+** This file implements various interfaces used for console and stream I/O
	564	+** by the SQLite project command-line tools, as explained in console_io.h .
	565	+** Functions prefixed by "SQLITE_INTERNAL_LINKAGE" behave as described there.
	566	+*/
	567	+
	568	+#ifndef SQLITE_CDECL
	569	+# define SQLITE_CDECL
	570	+#endif
	571	+
	572	+#ifndef SHELL_NO_SYSINC
	573	+# include <stdarg.h>
	574	+# include <string.h>
	575	+# include <stdlib.h>
	576	+# include <limits.h>
	577	+# include <assert.h>
	578	+# include "console_io.h"
	579	+/* # include "sqlite3.h" */
	580	+#endif
	581	+
	582	+#ifndef SQLITE_CIO_NO_TRANSLATE
	583	+# if (defined(_WIN32) \|\| defined(WIN32)) && !SQLITE_OS_WINRT
	584	+# ifndef SHELL_NO_SYSINC
	585	+# include <io.h>
	586	+# include <fcntl.h>
	587	+# undef WIN32_LEAN_AND_MEAN
	588	+# define WIN32_LEAN_AND_MEAN
	589	+# include <windows.h>
	590	+# endif
	591	+# define CIO_WIN_WC_XLATE 1 /* Use WCHAR Windows APIs for console I/O */
	592	+# else
	593	+# ifndef SHELL_NO_SYSINC
	594	+# include <unistd.h>
	595	+# endif
	596	+# define CIO_WIN_WC_XLATE 0 /* Use plain C library stream I/O at console */
	597	+# endif
	598	+#else
	599	+# define CIO_WIN_WC_XLATE 0 /* Not exposing translation routines at all */
	600	+#endif
	601	+
	602	+#if CIO_WIN_WC_XLATE
	603	+/* Character used to represent a known-incomplete UTF-8 char group (�) */
	604	+static WCHAR cBadGroup = 0xfffd;
	605	+#endif
	606	+
	607	+#if CIO_WIN_WC_XLATE
	608	+static HANDLE handleOfFile(FILE *pf){
	609	+ int fileDesc = _fileno(pf);
	610	+ union { intptr_t osfh; HANDLE fh; } fid = {
	611	+ (fileDesc>=0)? _get_osfhandle(fileDesc) : (intptr_t)INVALID_HANDLE_VALUE
	612	+ };
	613	+ return fid.fh;
	614	+}
	615	+#endif
	616	+
	617	+#ifndef SQLITE_CIO_NO_TRANSLATE
	618	+typedef struct PerStreamTags {
	619	+# if CIO_WIN_WC_XLATE
	620	+ HANDLE hx;
	621	+ DWORD consMode;
	622	+ char acIncomplete[4];
	623	+# else
	624	+ short reachesConsole;
	625	+# endif
	626	+ FILE *pf;
	627	+} PerStreamTags;
	628	+
	629	+/* Define NULL-like value for things which can validly be 0. */
	630	+# define SHELL_INVALID_FILE_PTR ((FILE *)~0)
	631	+# if CIO_WIN_WC_XLATE
	632	+# define SHELL_INVALID_CONS_MODE 0xFFFF0000
	633	+# endif
	634	+
	635	+# if CIO_WIN_WC_XLATE
	636	+# define PST_INITIALIZER { INVALID_HANDLE_VALUE, SHELL_INVALID_CONS_MODE, \
	637	+ {0,0,0,0}, SHELL_INVALID_FILE_PTR }
	638	+# else
	639	+# define PST_INITIALIZER { 0, SHELL_INVALID_FILE_PTR }
	640	+# endif
	641	+
	642	+/* Quickly say whether a known output is going to the console. */
	643	+# if CIO_WIN_WC_XLATE
	644	+static short pstReachesConsole(PerStreamTags *ppst){
	645	+ return (ppst->hx != INVALID_HANDLE_VALUE);
	646	+}
	647	+# else
	648	+# define pstReachesConsole(ppst) 0
	649	+# endif
	650	+
	651	+# if CIO_WIN_WC_XLATE
	652	+static void restoreConsoleArb(PerStreamTags *ppst){
	653	+ if( pstReachesConsole(ppst) ) SetConsoleMode(ppst->hx, ppst->consMode);
	654	+}
	655	+# else
	656	+# define restoreConsoleArb(ppst)
	657	+# endif
	658	+
	659	+/* Say whether FILE* appears to be a console, collect associated info. */
	660	+static short streamOfConsole(FILE pf, / out / PerStreamTags ppst){
	661	+# if CIO_WIN_WC_XLATE
	662	+ short rv = 0;
	663	+ DWORD dwCM = SHELL_INVALID_CONS_MODE;
	664	+ HANDLE fh = handleOfFile(pf);
	665	+ ppst->pf = pf;
	666	+ if( INVALID_HANDLE_VALUE != fh ){
	667	+ rv = (GetFileType(fh) == FILE_TYPE_CHAR && GetConsoleMode(fh,&dwCM));
	668	+ }
	669	+ ppst->hx = (rv)? fh : INVALID_HANDLE_VALUE;
	670	+ ppst->consMode = dwCM;
	671	+ return rv;
	672	+# else
	673	+ ppst->pf = pf;
	674	+ ppst->reachesConsole = ( (short)isatty(fileno(pf)) );
	675	+ return ppst->reachesConsole;
	676	+# endif
	677	+}
	678	+
	679	+# if CIO_WIN_WC_XLATE
	680	+/* Define console modes for use with the Windows Console API. */
	681	+# define SHELL_CONI_MODE \
	682	+ (ENABLE_ECHO_INPUT \| ENABLE_INSERT_MODE \| ENABLE_LINE_INPUT \| 0x80 \
	683	+ \| ENABLE_QUICK_EDIT_MODE \| ENABLE_EXTENDED_FLAGS \| ENABLE_PROCESSED_INPUT)
	684	+# define SHELL_CONO_MODE (ENABLE_PROCESSED_OUTPUT \| ENABLE_WRAP_AT_EOL_OUTPUT \
	685	+ \| ENABLE_VIRTUAL_TERMINAL_PROCESSING)
	686	+# endif
	687	+
	688	+typedef struct ConsoleInfo {
	689	+ PerStreamTags pstSetup[3];
	690	+ PerStreamTags pstDesignated[3];
	691	+ StreamsAreConsole sacSetup;
	692	+} ConsoleInfo;
	693	+
	694	+static short isValidStreamInfo(PerStreamTags *ppst){
	695	+ return (ppst->pf != SHELL_INVALID_FILE_PTR);
	696	+}
	697	+
	698	+static ConsoleInfo consoleInfo = {
	699	+ { /* pstSetup */ PST_INITIALIZER, PST_INITIALIZER, PST_INITIALIZER },
	700	+ { /* pstDesignated[] */ PST_INITIALIZER, PST_INITIALIZER, PST_INITIALIZER },
	701	+ SAC_NoConsole /* sacSetup */
	702	+};
	703	+
	704	+SQLITE_INTERNAL_LINKAGE FILE* invalidFileStream = (FILE *)~0;
	705	+
	706	+# if CIO_WIN_WC_XLATE
	707	+static void maybeSetupAsConsole(PerStreamTags *ppst, short odir){
	708	+ if( pstReachesConsole(ppst) ){
	709	+ DWORD cm = odir? SHELL_CONO_MODE : SHELL_CONI_MODE;
	710	+ SetConsoleMode(ppst->hx, cm);
	711	+ }
	712	+}
	713	+# else
	714	+# define maybeSetupAsConsole(ppst,odir)
	715	+# endif
	716	+
	717	+SQLITE_INTERNAL_LINKAGE void consoleRenewSetup(void){
	718	+# if CIO_WIN_WC_XLATE
	719	+ int ix = 0;
	720	+ while( ix < 6 ){
	721	+ PerStreamTags *ppst = (ix<3)?
	722	+ &consoleInfo.pstSetup[ix] : &consoleInfo.pstDesignated[ix-3];
	723	+ maybeSetupAsConsole(ppst, (ix % 3)>0);
	724	+ ++ix;
	725	+ }
	726	+# endif
	727	+}
	728	+
	729	+SQLITE_INTERNAL_LINKAGE StreamsAreConsole
	730	+consoleClassifySetup( FILE pfIn, FILE pfOut, FILE *pfErr ){
	731	+ StreamsAreConsole rv = SAC_NoConsole;
	732	+ FILE* apf[3] = { pfIn, pfOut, pfErr };
	733	+ int ix;
	734	+ for( ix = 2; ix >= 0; --ix ){
	735	+ PerStreamTags *ppst = &consoleInfo.pstSetup[ix];
	736	+ if( streamOfConsole(apf[ix], ppst) ){
	737	+ rv \|= (SAC_InConsole<<ix);
	738	+ }
	739	+ consoleInfo.pstDesignated[ix] = *ppst;
	740	+ if( ix > 0 ) fflush(apf[ix]);
	741	+ }
	742	+ consoleInfo.sacSetup = rv;
	743	+ consoleRenewSetup();
	744	+ return rv;
	745	+}
	746	+
	747	+SQLITE_INTERNAL_LINKAGE void SQLITE_CDECL consoleRestore( void ){
	748	+# if CIO_WIN_WC_XLATE
	749	+ static ConsoleInfo *pci = &consoleInfo;
	750	+ if( pci->sacSetup ){
	751	+ int ix;
	752	+ for( ix=0; ix<3; ++ix ){
	753	+ if( pci->sacSetup & (SAC_InConsole<<ix) ){
	754	+ PerStreamTags *ppst = &pci->pstSetup[ix];
	755	+ SetConsoleMode(ppst->hx, ppst->consMode);
	756	+ }
	757	+ }
	758	+ }
	759	+# endif
	760	+}
	761	+#endif /* !defined(SQLITE_CIO_NO_TRANSLATE) */
	762	+
	763	+#ifdef SQLITE_CIO_INPUT_REDIR
	764	+/* Say whether given FILE* is among those known, via either
	765	+** consoleClassifySetup() or set{Output,Error}Stream, as
	766	+** readable, and return an associated PerStreamTags pointer
	767	+** if so. Otherwise, return 0.
	768	+*/
	769	+static PerStreamTags * isKnownReadable(FILE *pf){
	770	+ static PerStreamTags *apst[] = {
	771	+ &consoleInfo.pstDesignated[0], &consoleInfo.pstSetup[0], 0
	772	+ };
	773	+ int ix = 0;
	774	+ do {
	775	+ if( apst[ix]->pf == pf ) break;
	776	+ } while( apst[++ix] != 0 );
	777	+ return apst[ix];
	778	+}
	779	+#endif
	780	+
	781	+#ifndef SQLITE_CIO_NO_TRANSLATE
	782	+/* Say whether given FILE* is among those known, via either
	783	+** consoleClassifySetup() or set{Output,Error}Stream, as
	784	+** writable, and return an associated PerStreamTags pointer
	785	+** if so. Otherwise, return 0.
	786	+*/
	787	+static PerStreamTags * isKnownWritable(FILE *pf){
	788	+ static PerStreamTags *apst[] = {
	789	+ &consoleInfo.pstDesignated[1], &consoleInfo.pstDesignated[2],
	790	+ &consoleInfo.pstSetup[1], &consoleInfo.pstSetup[2], 0
	791	+ };
	792	+ int ix = 0;
	793	+ do {
	794	+ if( apst[ix]->pf == pf ) break;
	795	+ } while( apst[++ix] != 0 );
	796	+ return apst[ix];
	797	+}
	798	+
	799	+static FILE designateEmitStream(FILE pf, unsigned chix){
	800	+ FILE *rv = consoleInfo.pstDesignated[chix].pf;
	801	+ if( pf == invalidFileStream ) return rv;
	802	+ else{
	803	+ /* Setting a possibly new output stream. */
	804	+ PerStreamTags *ppst = isKnownWritable(pf);
	805	+ if( ppst != 0 ){
	806	+ PerStreamTags pst = *ppst;
	807	+ consoleInfo.pstDesignated[chix] = pst;
	808	+ }else streamOfConsole(pf, &consoleInfo.pstDesignated[chix]);
	809	+ }
	810	+ return rv;
	811	+}
	812	+
	813	+SQLITE_INTERNAL_LINKAGE FILE setOutputStream(FILE pf){
	814	+ return designateEmitStream(pf, 1);
	815	+}
	816	+# ifdef CONSIO_SET_ERROR_STREAM
	817	+SQLITE_INTERNAL_LINKAGE FILE setErrorStream(FILE pf){
	818	+ return designateEmitStream(pf, 2);
	819	+}
	820	+# endif
	821	+#endif /* !defined(SQLITE_CIO_NO_TRANSLATE) */
	822	+
	823	+#ifndef SQLITE_CIO_NO_SETMODE
	824	+# if CIO_WIN_WC_XLATE
	825	+static void setModeFlushQ(FILE *pf, short bFlush, int mode){
	826	+ if( bFlush ) fflush(pf);
	827	+ _setmode(_fileno(pf), mode);
	828	+}
	829	+# else
	830	+# define setModeFlushQ(f, b, m) if(b) fflush(f)
	831	+# endif
	832	+
	833	+SQLITE_INTERNAL_LINKAGE void setBinaryMode(FILE *pf, short bFlush){
	834	+ setModeFlushQ(pf, bFlush, _O_BINARY);
	835	+}
	836	+SQLITE_INTERNAL_LINKAGE void setTextMode(FILE *pf, short bFlush){
	837	+ setModeFlushQ(pf, bFlush, _O_TEXT);
	838	+}
	839	+# undef setModeFlushQ
	840	+
	841	+#else /* defined(SQLITE_CIO_NO_SETMODE) */
	842	+# define setBinaryMode(f, bFlush) do{ if((bFlush)) fflush(f); }while(0)
	843	+# define setTextMode(f, bFlush) do{ if((bFlush)) fflush(f); }while(0)
	844	+#endif /* defined(SQLITE_CIO_NO_SETMODE) */
	845	+
	846	+#ifndef SQLITE_CIO_NO_TRANSLATE
	847	+# if CIO_WIN_WC_XLATE
	848	+/* Write buffer cBuf as output to stream known to reach console,
	849	+** limited to ncTake char's. Return ncTake on success, else 0. */
	850	+static int conZstrEmit(PerStreamTags ppst, const char z, int ncTake){
	851	+ int rv = 0;
	852	+ if( z!=NULL ){
	853	+ int nwc = MultiByteToWideChar(CP_UTF8,0, z,ncTake, 0,0);
	854	+ if( nwc > 0 ){
	855	+ WCHAR zw = sqlite3_malloc64(nwcsizeof(WCHAR));
	856	+ if( zw!=NULL ){
	857	+ nwc = MultiByteToWideChar(CP_UTF8,0, z,ncTake, zw,nwc);
	858	+ if( nwc > 0 ){
	859	+ /* Translation from UTF-8 to UTF-16, then WCHARs out. */
	860	+ if( WriteConsoleW(ppst->hx, zw,nwc, 0, NULL) ){
	861	+ rv = ncTake;
	862	+ }
	863	+ }
	864	+ sqlite3_free(zw);
	865	+ }
	866	+ }
	867	+ }
	868	+ return rv;
	869	+}
	870	+
	871	+/* For {f,o,e}PrintfUtf8() when stream is known to reach console. */
	872	+static int conioVmPrintf(PerStreamTags ppst, const char zFormat, va_list ap){
	873	+ char *z = sqlite3_vmprintf(zFormat, ap);
	874	+ if( z ){
	875	+ int rv = conZstrEmit(ppst, z, (int)strlen(z));
	876	+ sqlite3_free(z);
	877	+ return rv;
	878	+ }else return 0;
	879	+}
	880	+# endif /* CIO_WIN_WC_XLATE */
	881	+
	882	+# ifdef CONSIO_GET_EMIT_STREAM
	883	+static PerStreamTags * getDesignatedEmitStream(FILE *pf, unsigned chix,
	884	+ PerStreamTags *ppst){
	885	+ PerStreamTags *rv = isKnownWritable(pf);
	886	+ short isValid = (rv!=0)? isValidStreamInfo(rv) : 0;
	887	+ if( rv != 0 && isValid ) return rv;
	888	+ streamOfConsole(pf, ppst);
	889	+ return ppst;
	890	+}
	891	+# endif
	892	+
	893	+/* Get stream info, either for designated output or error stream when
	894	+** chix equals 1 or 2, or for an arbitrary stream when chix == 0.
	895	+** In either case, ppst references a caller-owned PerStreamTags
	896	+** struct which may be filled in if none of the known writable
	897	+** streams is being held by consoleInfo. The ppf parameter is a
	898	+** byref output when chix!=0 and a byref input when chix==0.
	899	+ */
	900	+static PerStreamTags *
	901	+getEmitStreamInfo(unsigned chix, PerStreamTags *ppst,
	902	+ /* in/out / FILE *ppf){
	903	+ PerStreamTags *ppstTry;
	904	+ FILE *pfEmit;
	905	+ if( chix > 0 ){
	906	+ ppstTry = &consoleInfo.pstDesignated[chix];
	907	+ if( !isValidStreamInfo(ppstTry) ){
	908	+ ppstTry = &consoleInfo.pstSetup[chix];
	909	+ pfEmit = ppst->pf;
	910	+ }else pfEmit = ppstTry->pf;
	911	+ if( !isValidStreamInfo(ppstTry) ){
	912	+ pfEmit = (chix > 1)? stderr : stdout;
	913	+ ppstTry = ppst;
	914	+ streamOfConsole(pfEmit, ppstTry);
	915	+ }
	916	+ *ppf = pfEmit;
	917	+ }else{
	918	+ ppstTry = isKnownWritable(*ppf);
	919	+ if( ppstTry != 0 ) return ppstTry;
	920	+ streamOfConsole(*ppf, ppst);
	921	+ return ppst;
	922	+ }
	923	+ return ppstTry;
	924	+}
	925	+
	926	+SQLITE_INTERNAL_LINKAGE int oPrintfUtf8(const char *zFormat, ...){
	927	+ va_list ap;
	928	+ int rv;
	929	+ FILE *pfOut;
	930	+ PerStreamTags pst = PST_INITIALIZER; /* for unknown streams */
	931	+# if CIO_WIN_WC_XLATE
	932	+ PerStreamTags *ppst = getEmitStreamInfo(1, &pst, &pfOut);
	933	+# else
	934	+ getEmitStreamInfo(1, &pst, &pfOut);
	935	+# endif
	936	+ assert(zFormat!=0);
	937	+ va_start(ap, zFormat);
	938	+# if CIO_WIN_WC_XLATE
	939	+ if( pstReachesConsole(ppst) ){
	940	+ rv = conioVmPrintf(ppst, zFormat, ap);
	941	+ }else{
	942	+# endif
	943	+ rv = vfprintf(pfOut, zFormat, ap);
	944	+# if CIO_WIN_WC_XLATE
	945	+ }
	946	+# endif
	947	+ va_end(ap);
	948	+ return rv;
	949	+}
	950	+
	951	+SQLITE_INTERNAL_LINKAGE int ePrintfUtf8(const char *zFormat, ...){
	952	+ va_list ap;
	953	+ int rv;
	954	+ FILE *pfErr;
	955	+ PerStreamTags pst = PST_INITIALIZER; /* for unknown streams */
	956	+# if CIO_WIN_WC_XLATE
	957	+ PerStreamTags *ppst = getEmitStreamInfo(2, &pst, &pfErr);
	958	+# else
	959	+ getEmitStreamInfo(2, &pst, &pfErr);
	960	+# endif
	961	+ assert(zFormat!=0);
	962	+ va_start(ap, zFormat);
	963	+# if CIO_WIN_WC_XLATE
	964	+ if( pstReachesConsole(ppst) ){
	965	+ rv = conioVmPrintf(ppst, zFormat, ap);
	966	+ }else{
	967	+# endif
	968	+ rv = vfprintf(pfErr, zFormat, ap);
	969	+# if CIO_WIN_WC_XLATE
	970	+ }
	971	+# endif
	972	+ va_end(ap);
	973	+ return rv;
	974	+}
	975	+
	976	+SQLITE_INTERNAL_LINKAGE int fPrintfUtf8(FILE pfO, const char zFormat, ...){
	977	+ va_list ap;
	978	+ int rv;
	979	+ PerStreamTags pst = PST_INITIALIZER; /* for unknown streams */
	980	+# if CIO_WIN_WC_XLATE
	981	+ PerStreamTags *ppst = getEmitStreamInfo(0, &pst, &pfO);
	982	+# else
	983	+ getEmitStreamInfo(0, &pst, &pfO);
	984	+# endif
	985	+ assert(zFormat!=0);
	986	+ va_start(ap, zFormat);
	987	+# if CIO_WIN_WC_XLATE
	988	+ if( pstReachesConsole(ppst) ){
	989	+ maybeSetupAsConsole(ppst, 1);
	990	+ rv = conioVmPrintf(ppst, zFormat, ap);
	991	+ if( 0 == isKnownWritable(ppst->pf) ) restoreConsoleArb(ppst);
	992	+ }else{
	993	+# endif
	994	+ rv = vfprintf(pfO, zFormat, ap);
	995	+# if CIO_WIN_WC_XLATE
	996	+ }
	997	+# endif
	998	+ va_end(ap);
	999	+ return rv;
	1000	+}
	1001	+
	1002	+SQLITE_INTERNAL_LINKAGE int fPutsUtf8(const char z, FILE pfO){
	1003	+ PerStreamTags pst = PST_INITIALIZER; /* for unknown streams */
	1004	+# if CIO_WIN_WC_XLATE
	1005	+ PerStreamTags *ppst = getEmitStreamInfo(0, &pst, &pfO);
	1006	+# else
	1007	+ getEmitStreamInfo(0, &pst, &pfO);
	1008	+# endif
	1009	+ assert(z!=0);
	1010	+# if CIO_WIN_WC_XLATE
	1011	+ if( pstReachesConsole(ppst) ){
	1012	+ int rv;
	1013	+ maybeSetupAsConsole(ppst, 1);
	1014	+ rv = conZstrEmit(ppst, z, (int)strlen(z));
	1015	+ if( 0 == isKnownWritable(ppst->pf) ) restoreConsoleArb(ppst);
	1016	+ return rv;
	1017	+ }else {
	1018	+# endif
	1019	+ return (fputs(z, pfO)<0)? 0 : (int)strlen(z);
	1020	+# if CIO_WIN_WC_XLATE
	1021	+ }
	1022	+# endif
	1023	+}
	1024	+
	1025	+SQLITE_INTERNAL_LINKAGE int ePutsUtf8(const char *z){
	1026	+ FILE *pfErr;
	1027	+ PerStreamTags pst = PST_INITIALIZER; /* for unknown streams */
	1028	+# if CIO_WIN_WC_XLATE
	1029	+ PerStreamTags *ppst = getEmitStreamInfo(2, &pst, &pfErr);
	1030	+# else
	1031	+ getEmitStreamInfo(2, &pst, &pfErr);
	1032	+# endif
	1033	+ assert(z!=0);
	1034	+# if CIO_WIN_WC_XLATE
	1035	+ if( pstReachesConsole(ppst) ) return conZstrEmit(ppst, z, (int)strlen(z));
	1036	+ else {
	1037	+# endif
	1038	+ return (fputs(z, pfErr)<0)? 0 : (int)strlen(z);
	1039	+# if CIO_WIN_WC_XLATE
	1040	+ }
	1041	+# endif
	1042	+}
	1043	+
	1044	+SQLITE_INTERNAL_LINKAGE int oPutsUtf8(const char *z){
	1045	+ FILE *pfOut;
	1046	+ PerStreamTags pst = PST_INITIALIZER; /* for unknown streams */
	1047	+# if CIO_WIN_WC_XLATE
	1048	+ PerStreamTags *ppst = getEmitStreamInfo(1, &pst, &pfOut);
	1049	+# else
	1050	+ getEmitStreamInfo(1, &pst, &pfOut);
	1051	+# endif
	1052	+ assert(z!=0);
	1053	+# if CIO_WIN_WC_XLATE
	1054	+ if( pstReachesConsole(ppst) ) return conZstrEmit(ppst, z, (int)strlen(z));
	1055	+ else {
	1056	+# endif
	1057	+ return (fputs(z, pfOut)<0)? 0 : (int)strlen(z);
	1058	+# if CIO_WIN_WC_XLATE
	1059	+ }
	1060	+# endif
	1061	+}
	1062	+
	1063	+#endif /* !defined(SQLITE_CIO_NO_TRANSLATE) */
	1064	+
	1065	+#if !(defined(SQLITE_CIO_NO_UTF8SCAN) && defined(SQLITE_CIO_NO_TRANSLATE))
	1066	+/* Skip over as much z[] input char sequence as is valid UTF-8,
	1067	+** limited per nAccept char's or whole characters and containing
	1068	+** no char cn such that ((1<<cn) & ccm)!=0. On return, the
	1069	+** sequence z:return (inclusive:exclusive) is validated UTF-8.
	1070	+** Limit: nAccept>=0 => char count, nAccept<0 => character
	1071	+ */
	1072	+SQLITE_INTERNAL_LINKAGE const char*
	1073	+zSkipValidUtf8(const char *z, int nAccept, long ccm){
	1074	+ int ng = (nAccept<0)? -nAccept : 0;
	1075	+ const char *pcLimit = (nAccept>=0)? z+nAccept : 0;
	1076	+ assert(z!=0);
	1077	+ while( (pcLimit)? (z<pcLimit) : (ng-- != 0) ){
	1078	+ char c = *z;
	1079	+ if( (c & 0x80) == 0 ){
	1080	+ if( ccm != 0L && c < 0x20 && ((1L<<c) & ccm) != 0 ) return z;
	1081	+ ++z; /* ASCII */
	1082	+ }else if( (c & 0xC0) != 0xC0 ) return z; /* not a lead byte */
	1083	+ else{
	1084	+ const char zt = z+1; / Got lead byte, look at trail bytes.*/
	1085	+ do{
	1086	+ if( pcLimit && zt >= pcLimit ) return z;
	1087	+ else{
	1088	+ char ct = *zt++;
	1089	+ if( ct==0 \|\| (zt-z)>4 \|\| (ct & 0xC0)!=0x80 ){
	1090	+ /* Trailing bytes are too few, too many, or invalid. */
	1091	+ return z;
	1092	+ }
	1093	+ }
	1094	+ } while( ((c <<= 1) & 0x40) == 0x40 ); /* Eat lead byte's count. */
	1095	+ z = zt;
	1096	+ }
	1097	+ }
	1098	+ return z;
	1099	+}
	1100	+#endif /!(defined(SQLITE_CIO_NO_UTF8SCAN)&&defined(SQLITE_CIO_NO_TRANSLATE))/
	1101	+
	1102	+#ifndef SQLITE_CIO_NO_TRANSLATE
	1103	+
	1104	+#ifdef CONSIO_SPUTB
	1105	+SQLITE_INTERNAL_LINKAGE int
	1106	+fPutbUtf8(FILE pfO, const char cBuf, int nAccept){
	1107	+ assert(pfO!=0);
	1108	+# if CIO_WIN_WC_XLATE
	1109	+ PerStreamTags pst = PST_INITIALIZER; /* for unknown streams */
	1110	+ PerStreamTags *ppst = getEmitStreamInfo(0, &pst, &pfO);
	1111	+ if( pstReachesConsole(ppst) ){
	1112	+ int rv;
	1113	+ maybeSetupAsConsole(ppst, 1);
	1114	+ rv = conZstrEmit(ppst, cBuf, nAccept);
	1115	+ if( 0 == isKnownWritable(ppst->pf) ) restoreConsoleArb(ppst);
	1116	+ return rv;
	1117	+ }else {
	1118	+# endif
	1119	+ return (int)fwrite(cBuf, 1, nAccept, pfO);
	1120	+# if CIO_WIN_WC_XLATE
	1121	+ }
	1122	+# endif
	1123	+}
	1124	+#endif /* defined(CONSIO_SPUTB) */
	1125	+
	1126	+SQLITE_INTERNAL_LINKAGE int
	1127	+oPutbUtf8(const char *cBuf, int nAccept){
	1128	+ FILE *pfOut;
	1129	+ PerStreamTags pst = PST_INITIALIZER; /* for unknown streams */
	1130	+# if CIO_WIN_WC_XLATE
	1131	+ PerStreamTags *ppst = getEmitStreamInfo(1, &pst, &pfOut);
	1132	+# else
	1133	+ getEmitStreamInfo(1, &pst, &pfOut);
	1134	+# endif
	1135	+# if CIO_WIN_WC_XLATE
	1136	+ if( pstReachesConsole(ppst) ){
	1137	+ return conZstrEmit(ppst, cBuf, nAccept);
	1138	+ }else {
	1139	+# endif
	1140	+ return (int)fwrite(cBuf, 1, nAccept, pfOut);
	1141	+# if CIO_WIN_WC_XLATE
	1142	+ }
	1143	+# endif
	1144	+}
	1145	+
	1146	+# ifdef CONSIO_EPUTB
	1147	+SQLITE_INTERNAL_LINKAGE int
	1148	+ePutbUtf8(const char *cBuf, int nAccept){
	1149	+ FILE *pfErr;
	1150	+ PerStreamTags pst = PST_INITIALIZER; /* for unknown streams */
	1151	+ PerStreamTags *ppst = getEmitStreamInfo(2, &pst, &pfErr);
	1152	+# if CIO_WIN_WC_XLATE
	1153	+ if( pstReachesConsole(ppst) ){
	1154	+ return conZstrEmit(ppst, cBuf, nAccept);
	1155	+ }else {
	1156	+# endif
	1157	+ return (int)fwrite(cBuf, 1, nAccept, pfErr);
	1158	+# if CIO_WIN_WC_XLATE
	1159	+ }
	1160	+# endif
	1161	+}
	1162	+# endif /* defined(CONSIO_EPUTB) */
	1163	+
	1164	+SQLITE_INTERNAL_LINKAGE char* fGetsUtf8(char cBuf, int ncMax, FILE pfIn){
	1165	+ if( pfIn==0 ) pfIn = stdin;
	1166	+# if CIO_WIN_WC_XLATE
	1167	+ if( pfIn == consoleInfo.pstSetup[0].pf
	1168	+ && (consoleInfo.sacSetup & SAC_InConsole)!=0 ){
	1169	+# if CIO_WIN_WC_XLATE==1
	1170	+# define SHELL_GULP 150 /* Count of WCHARS to be gulped at a time */
	1171	+ WCHAR wcBuf[SHELL_GULP+1];
	1172	+ int lend = 0, noc = 0;
	1173	+ if( ncMax > 0 ) cBuf[0] = 0;
	1174	+ while( noc < ncMax-8-1 && !lend ){
	1175	+ /* There is room for at least 2 more characters and a 0-terminator. */
	1176	+ int na = (ncMax > SHELL_GULP*4+1 + noc)? SHELL_GULP : (ncMax-1 - noc)/4;
	1177	+# undef SHELL_GULP
	1178	+ DWORD nbr = 0;
	1179	+ BOOL bRC = ReadConsoleW(consoleInfo.pstSetup[0].hx, wcBuf, na, &nbr, 0);
	1180	+ if( bRC && nbr>0 && (wcBuf[nbr-1]&0xF800)==0xD800 ){
	1181	+ /* Last WHAR read is first of a UTF-16 surrogate pair. Grab its mate. */
	1182	+ DWORD nbrx;
	1183	+ bRC &= ReadConsoleW(consoleInfo.pstSetup[0].hx, wcBuf+nbr, 1, &nbrx, 0);
	1184	+ if( bRC ) nbr += nbrx;
	1185	+ }
	1186	+ if( !bRC \|\| (noc==0 && nbr==0) ) return 0;
	1187	+ if( nbr > 0 ){
	1188	+ int nmb = WideCharToMultiByte(CP_UTF8, 0, wcBuf,nbr,0,0,0,0);
	1189	+ if( nmb != 0 && noc+nmb <= ncMax ){
	1190	+ int iseg = noc;
	1191	+ nmb = WideCharToMultiByte(CP_UTF8, 0, wcBuf,nbr,cBuf+noc,nmb,0,0);
	1192	+ noc += nmb;
	1193	+ /* Fixup line-ends as coded by Windows for CR (or "Enter".)
	1194	+ ** This is done without regard for any setMode{Text,Binary}()
	1195	+ ** call that might have been done on the interactive input.
	1196	+ */
	1197	+ if( noc > 0 ){
	1198	+ if( cBuf[noc-1]=='\n' ){
	1199	+ lend = 1;
	1200	+ if( noc > 1 && cBuf[noc-2]=='\r' ) cBuf[--noc-1] = '\n';
	1201	+ }
	1202	+ }
	1203	+ /* Check for ^Z (anywhere in line) too, to act as EOF. */
	1204	+ while( iseg < noc ){
	1205	+ if( cBuf[iseg]=='\x1a' ){
	1206	+ noc = iseg; /* Chop ^Z and anything following. */
	1207	+ lend = 1; /* Counts as end of line too. */
	1208	+ break;
	1209	+ }
	1210	+ ++iseg;
	1211	+ }
	1212	+ }else break; /* Drop apparent garbage in. (Could assert.) */
	1213	+ }else break;
	1214	+ }
	1215	+ /* If got nothing, (after ^Z chop), must be at end-of-file. */
	1216	+ if( noc > 0 ){
	1217	+ cBuf[noc] = 0;
	1218	+ return cBuf;
	1219	+ }else return 0;
	1220	+# endif
	1221	+ }else{
	1222	+# endif
	1223	+ return fgets(cBuf, ncMax, pfIn);
	1224	+# if CIO_WIN_WC_XLATE
	1225	+ }
	1226	+# endif
	1227	+}
	1228	+#endif /* !defined(SQLITE_CIO_NO_TRANSLATE) */
	1229	+
	1230	+#undef SHELL_INVALID_FILE_PTR
	1231	+
	1232	+/*********************** End ../ext/consio/console_io.c ******************/
	1233	+
	1234	+#ifndef SQLITE_SHELL_FIDDLE
	1235	+/* From here onward, fgets() is redirected to the console_io library. */
	1236	+# define fgets(b,n,f) fGetsUtf8(b,n,f)
	1237	+/*
	1238	+ * Define macros for emitting output text in various ways:
	1239	+ * sputz(s, z) => emit 0-terminated string z to given stream s
	1240	+ * sputf(s, f, ...) => emit varargs per format f to given stream s
	1241	+ * oputz(z) => emit 0-terminated string z to default stream
	1242	+ * oputf(f, ...) => emit varargs per format f to default stream
	1243	+ * eputz(z) => emit 0-terminated string z to error stream
	1244	+ * eputf(f, ...) => emit varargs per format f to error stream
	1245	+ * oputb(b, n) => emit char buffer b[0..n-1] to default stream
	1246	+ *
	1247	+ * Note that the default stream is whatever has been last set via:
	1248	+ * setOutputStream(FILE *pf)
	1249	+ * This is normally the stream that CLI normal output goes to.
	1250	+ * For the stand-alone CLI, it is stdout with no .output redirect.
	1251	+ */
	1252	+# define sputz(s,z) fPutsUtf8(z,s)
	1253	+# define sputf fPrintfUtf8
	1254	+# define oputz(z) oPutsUtf8(z)
	1255	+# define oputf oPrintfUtf8
	1256	+# define eputz(z) ePutsUtf8(z)
	1257	+# define eputf ePrintfUtf8
	1258	+# define oputb(buf,na) oPutbUtf8(buf,na)
275	1259	#else
276		-# define setBinaryMode(X,Y)
277		-# define setTextMode(X,Y)
	1260	+/* For Fiddle, all console handling and emit redirection is omitted. */
	1261	+# define sputz(fp,z) fputs(z,fp)
	1262	+# define sputf(fp,fmt, ...) fprintf(fp,fmt,__VA_ARGS__)
	1263	+# define oputz(z) fputs(z,stdout)
	1264	+# define oputf(fmt, ...) printf(fmt,__VA_ARGS__)
	1265	+# define eputz(z) fputs(z,stderr)
	1266	+# define eputf(fmt, ...) fprintf(stderr,fmt,__VA_ARGS__)
	1267	+# define oputb(buf,na) fwrite(buf,1,na,stdout)
278	1268	#endif
279	1269
280	1270	/* True if the timer is enabled */
281	1271	static int enableTimer = 0;
282	1272
		@@ -347,14 +1337,14 @@
347	1337	static void endTimer(void){
348	1338	if( enableTimer ){
349	1339	sqlite3_int64 iEnd = timeOfDay();
350	1340	struct rusage sEnd;
351	1341	getrusage(RUSAGE_SELF, &sEnd);
352		- printf("Run Time: real %.3f user %f sys %f\n",
353		- (iEnd - iBegin)*0.001,
354		- timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
355		- timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
	1342	+ oputf("Run Time: real %.3f user %f sys %f\n",
	1343	+ (iEnd - iBegin)*0.001,
	1344	+ timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
	1345	+ timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
356	1346	}
357	1347	}
358	1348
359	1349	#define BEGIN_TIMER beginTimer()
360	1350	#define END_TIMER endTimer()
		@@ -426,14 +1416,14 @@
426	1416	static void endTimer(void){
427	1417	if( enableTimer && getProcessTimesAddr){
428	1418	FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd;
429	1419	sqlite3_int64 ftWallEnd = timeOfDay();
430	1420	getProcessTimesAddr(hProcess,&ftCreation,&ftExit,&ftKernelEnd,&ftUserEnd);
431		- printf("Run Time: real %.3f user %f sys %f\n",
432		- (ftWallEnd - ftWallBegin)*0.001,
433		- timeDiff(&ftUserBegin, &ftUserEnd),
434		- timeDiff(&ftKernelBegin, &ftKernelEnd));
	1421	+ oputf("Run Time: real %.3f user %f sys %f\n",
	1422	+ (ftWallEnd - ftWallBegin)*0.001,
	1423	+ timeDiff(&ftUserBegin, &ftUserEnd),
	1424	+ timeDiff(&ftKernelBegin, &ftKernelEnd));
435	1425	}
436	1426	}
437	1427
438	1428	#define BEGIN_TIMER beginTimer()
439	1429	#define END_TIMER endTimer()
		@@ -466,32 +1456,13 @@
466	1456	** is true. Otherwise, assume stdin is connected to a file or pipe.
467	1457	*/
468	1458	static int stdin_is_interactive = 1;
469	1459
470	1460	/*
471		-** If build is for non-RT Windows, without 3rd-party line editing,
472		-** console input and output may be done in a UTF-8 compatible way,
473		-** if the OS is capable of it and the --no-utf8 option is not seen.
474		-*/
475		-#if (defined(_WIN32) \|\| defined(WIN32)) && SHELL_USE_LOCAL_GETLINE \
476		- && !defined(SHELL_OMIT_WIN_UTF8) && !SQLITE_OS_WINRT
477		-# define SHELL_WIN_UTF8_OPT 1
478		-/* Record whether to do UTF-8 console I/O translation per stream. */
479		- static int console_utf8_in = 0;
480		- static int console_utf8_out = 0;
481		-/* Record whether can do UTF-8 or --no-utf8 seen in invocation. */
482		- static int mbcs_opted = 1; /* Assume cannot do until shown otherwise. */
483		-#else
484		-# define console_utf8_in 0
485		-# define console_utf8_out 0
486		-# define SHELL_WIN_UTF8_OPT 0
487		-#endif
488		-
489		-/*
490		-** On Windows systems we have to know if standard output is a console
491		-** in order to translate UTF-8 into MBCS. The following variable is
492		-** true if translation is required.
	1461	+** On Windows systems we need to know if standard output is a console
	1462	+** in order to show that UTF-16 translation is done in the sign-on
	1463	+** banner. The following variable is true if it is the console.
493	1464	*/
494	1465	static int stdout_is_console = 1;
495	1466
496	1467	/*
497	1468	** The following is the open SQLite database. We make a pointer
		@@ -609,255 +1580,21 @@
609	1580	shell_strncpy(dynPrompt.dynamicPrompt, ")x!", 4);
610	1581	}else{
611	1582	shell_strncpy(dynPrompt.dynamicPrompt, "(x.", 4);
612	1583	dynPrompt.dynamicPrompt[2] = (char)('0'+dynPrompt.inParenLevel);
613	1584	}
614		- shell_strncpy(dynPrompt.dynamicPrompt+3, continuePrompt+3, PROMPT_LEN_MAX-4);
	1585	+ shell_strncpy(dynPrompt.dynamicPrompt+3, continuePrompt+3,
	1586	+ PROMPT_LEN_MAX-4);
615	1587	}
616	1588	}
617	1589	return dynPrompt.dynamicPrompt;
618	1590	}
619	1591	#endif /* !defined(SQLITE_OMIT_DYNAPROMPT) */
620	1592
621		-#if SHELL_WIN_UTF8_OPT
622		-/* Following struct is used for UTF-8 console I/O. */
623		-static struct ConsoleState {
624		- int stdinEof; /* EOF has been seen on console input */
625		- int infsMode; /* Input file stream mode upon shell start */
626		- UINT inCodePage; /* Input code page upon shell start */
627		- UINT outCodePage; /* Output code page upon shell start */
628		- HANDLE hConsole; /* Console input or output handle */
629		- DWORD consoleMode; /* Console mode upon shell start */
630		-} conState = { 0, 0, 0, 0, INVALID_HANDLE_VALUE, 0 };
631		-
632		-#ifndef _O_U16TEXT /* For build environments lacking this constant: */
633		-# define _O_U16TEXT 0x20000
634		-#endif
635		-
636		-/*
637		-** If given stream number is a console, return 1 and get some attributes,
638		-** else return 0 and set the output attributes to invalid values.
639		-*/
640		-static short console_attrs(unsigned stnum, HANDLE pH, DWORD pConsMode){
641		- static int stid[3] = { STD_INPUT_HANDLE,STD_OUTPUT_HANDLE,STD_ERROR_HANDLE };
642		- HANDLE h;
643		- *pH = INVALID_HANDLE_VALUE;
644		- *pConsMode = 0;
645		- if( stnum > 2 ) return 0;
646		- h = GetStdHandle(stid[stnum]);
647		- if( h!=*pH && GetFileType(h)==FILE_TYPE_CHAR && GetConsoleMode(h,pConsMode) ){
648		- *pH = h;
649		- return 1;
650		- }
651		- return 0;
652		-}
653		-
654		-/*
655		-** Perform a runtime test of Windows console to determine if it can
656		-** do char-stream I/O correctly when the code page is set to CP_UTF8.
657		-** Returns are: 1 => yes it can, 0 => no it cannot
658		-**
659		-** The console's output code page is momentarily set, then restored.
660		-** So this should only be run when the process is given use of the
661		-** console for either input or output.
662		-*/
663		-static short ConsoleDoesUTF8(void){
664		- UINT ocp = GetConsoleOutputCP();
665		- const char TrialUtf8[] = { '\xC8', '\xAB' }; /* "ȫ" or 2 MBCS characters */
666		- WCHAR aReadBack[1] = { 0 }; /* Read back as 0x022B when decoded as UTF-8. */
667		- CONSOLE_SCREEN_BUFFER_INFO csbInfo = {0};
668		- /* Create an inactive screen buffer with which to do the experiment. */
669		- HANDLE hCSB = CreateConsoleScreenBuffer(GENERIC_READ\|GENERIC_WRITE, 0, 0,
670		- CONSOLE_TEXTMODE_BUFFER, NULL);
671		- if( hCSB!=INVALID_HANDLE_VALUE ){
672		- COORD cpos = {0,0};
673		- DWORD rbc;
674		- SetConsoleCursorPosition(hCSB, cpos);
675		- SetConsoleOutputCP(CP_UTF8);
676		- /* Write 2 chars which are a single character in UTF-8 but more in MBCS. */
677		- WriteConsoleA(hCSB, TrialUtf8, sizeof(TrialUtf8), NULL, NULL);
678		- ReadConsoleOutputCharacterW(hCSB, &aReadBack[0], 1, cpos, &rbc);
679		- GetConsoleScreenBufferInfo(hCSB, &csbInfo);
680		- SetConsoleOutputCP(ocp);
681		- CloseHandle(hCSB);
682		- }
683		- /* Return 1 if cursor advanced by 1 position, else 0. */
684		- return (short)(csbInfo.dwCursorPosition.X == 1 && aReadBack[0] == 0x022B);
685		-}
686		-
687		-static short in_console = 0;
688		-static short out_console = 0;
689		-
690		-/*
691		-** Determine whether either normal I/O stream is the console,
692		-** and whether it can do UTF-8 translation, setting globals
693		-** in_console, out_console and mbcs_opted accordingly.
694		-*/
695		-static void probe_console(void){
696		- HANDLE h;
697		- DWORD cMode;
698		- in_console = console_attrs(0, &h, &cMode);
699		- out_console = console_attrs(1, &h, &cMode);
700		- if( in_console \|\| out_console ) mbcs_opted = !ConsoleDoesUTF8();
701		-}
702		-
703		-/*
704		-** If console is used for normal I/O, absent a --no-utf8 option,
705		-** prepare console for UTF-8 input (from either typing or suitable
706		-** paste operations) and/or for UTF-8 output rendering.
707		-**
708		-** The console state upon entry is preserved, in conState, so that
709		-** console_restore() can later restore the same console state.
710		-**
711		-** The globals console_utf8_in and console_utf8_out are set, for
712		-** later use in selecting UTF-8 or MBCS console I/O translations.
713		-** This routine depends upon globals set by probe_console().
714		-*/
715		-static void console_prepare_utf8(void){
716		- struct ConsoleState csWork = { 0, 0, 0, 0, INVALID_HANDLE_VALUE, 0 };
717		-
718		- console_utf8_in = console_utf8_out = 0;
719		- if( (!in_console && !out_console) \|\| mbcs_opted ) return;
720		- console_attrs((in_console)? 0 : 1, &conState.hConsole, &conState.consoleMode);
721		- conState.inCodePage = GetConsoleCP();
722		- conState.outCodePage = GetConsoleOutputCP();
723		- if( in_console ){
724		- SetConsoleCP(CP_UTF8);
725		- DWORD newConsoleMode = conState.consoleMode
726		- \| ENABLE_LINE_INPUT \| ENABLE_PROCESSED_INPUT;
727		- SetConsoleMode(conState.hConsole, newConsoleMode);
728		- conState.infsMode = _setmode(_fileno(stdin), _O_U16TEXT);
729		- console_utf8_in = 1;
730		- }
731		- if( out_console ){
732		- SetConsoleOutputCP(CP_UTF8);
733		- console_utf8_out = 1;
734		- }
735		-}
736		-
737		-/*
738		-** Undo the effects of console_prepare_utf8(), if any.
739		-*/
740		-static void SQLITE_CDECL console_restore(void){
741		- if( (console_utf8_in\|\|console_utf8_out)
742		- && conState.hConsole!=INVALID_HANDLE_VALUE ){
743		- if( console_utf8_in ){
744		- SetConsoleCP(conState.inCodePage);
745		- _setmode(_fileno(stdin), conState.infsMode);
746		- }
747		- if( console_utf8_out ) SetConsoleOutputCP(conState.outCodePage);
748		- SetConsoleMode(conState.hConsole, conState.consoleMode);
749		- /* Avoid multiple calls. */
750		- conState.hConsole = INVALID_HANDLE_VALUE;
751		- conState.consoleMode = 0;
752		- console_utf8_in = 0;
753		- console_utf8_out = 0;
754		- }
755		-}
756		-
757		-/*
758		-** Collect input like fgets(...) with special provisions for input
759		-** from the Windows console to get around its strange coding issues.
760		-** Defers to plain fgets() when input is not interactive or when the
761		-** UTF-8 input is unavailable or opted out.
762		-*/
763		-static char* utf8_fgets(char buf, int ncmax, FILE fin){
764		- if( fin==0 ) fin = stdin;
765		- if( fin==stdin && stdin_is_interactive && console_utf8_in ){
766		-# define SQLITE_IALIM 150
767		- wchar_t wbuf[SQLITE_IALIM];
768		- int lend = 0;
769		- int noc = 0;
770		- if( ncmax==0 \|\| conState.stdinEof ) return 0;
771		- buf[0] = 0;
772		- while( noc<ncmax-7-1 && !lend ){
773		- /* There is room for at least 2 more characters and a 0-terminator. */
774		- int na = (ncmax > SQLITE_IALIM*4+1 + noc)
775		- ? SQLITE_IALIM : (ncmax-1 - noc)/4;
776		-# undef SQLITE_IALIM
777		- DWORD nbr = 0;
778		- BOOL bRC = ReadConsoleW(conState.hConsole, wbuf, na, &nbr, 0);
779		- if( !bRC \|\| (noc==0 && nbr==0) ) return 0;
780		- if( nbr > 0 ){
781		- int nmb = WideCharToMultiByte(CP_UTF8,WC_COMPOSITECHECK\|WC_DEFAULTCHAR,
782		- wbuf,nbr,0,0,0,0);
783		- if( nmb !=0 && noc+nmb <= ncmax ){
784		- int iseg = noc;
785		- nmb = WideCharToMultiByte(CP_UTF8,WC_COMPOSITECHECK\|WC_DEFAULTCHAR,
786		- wbuf,nbr,buf+noc,nmb,0,0);
787		- noc += nmb;
788		- /* Fixup line-ends as coded by Windows for CR (or "Enter".)*/
789		- if( noc > 0 ){
790		- if( buf[noc-1]=='\n' ){
791		- lend = 1;
792		- if( noc > 1 && buf[noc-2]=='\r' ){
793		- buf[noc-2] = '\n';
794		- --noc;
795		- }
796		- }
797		- }
798		- /* Check for ^Z (anywhere in line) too. */
799		- while( iseg < noc ){
800		- if( buf[iseg]==0x1a ){
801		- conState.stdinEof = 1;
802		- noc = iseg; /* Chop ^Z and anything following. */
803		- break;
804		- }
805		- ++iseg;
806		- }
807		- }else break; /* Drop apparent garbage in. (Could assert.) */
808		- }else break;
809		- }
810		- /* If got nothing, (after ^Z chop), must be at end-of-file. */
811		- if( noc == 0 ) return 0;
812		- buf[noc] = 0;
813		- return buf;
814		- }else{
815		- return fgets(buf, ncmax, fin);
816		- }
817		-}
818		-
819		-# define fgets(b,n,f) utf8_fgets(b,n,f)
820		-#endif /* SHELL_WIN_UTF8_OPT */
821		-
822		-/*
823		-** Render output like fprintf(). Except, if the output is going to the
824		-** console and if this is running on a Windows machine, and if UTF-8
825		-** output unavailable (or available but opted out), translate the
826		-** output from UTF-8 into MBCS for output through 8-bit stdout stream.
827		-** (Without -no-utf8, no translation is needed and must not be done.)
828		-*/
829		-#if defined(_WIN32) \|\| defined(WIN32)
830		-void utf8_printf(FILE out, const char zFormat, ...){
831		- va_list ap;
832		- va_start(ap, zFormat);
833		- if( stdout_is_console && (out==stdout \|\| out==stderr) && !console_utf8_out ){
834		- char *z1 = sqlite3_vmprintf(zFormat, ap);
835		- char *z2 = sqlite3_win32_utf8_to_mbcs_v2(z1, 0);
836		- sqlite3_free(z1);
837		- fputs(z2, out);
838		- sqlite3_free(z2);
839		- }else{
840		- vfprintf(out, zFormat, ap);
841		- }
842		- va_end(ap);
843		-}
844		-#elif !defined(utf8_printf)
845		-# define utf8_printf fprintf
846		-#endif
847		-
848		-/*
849		-** Render output like fprintf(). This should not be used on anything that
850		-** includes string formatting (e.g. "%s").
851		-*/
852		-#if !defined(raw_printf)
853		-# define raw_printf fprintf
854		-#endif
855		-
856	1593	/* Indicate out-of-memory and exit. */
857	1594	static void shell_out_of_memory(void){
858		- raw_printf(stderr,"Error: out of memory\n");
	1595	+ eputz("Error: out of memory\n");
859	1596	exit(1);
860	1597	}
861	1598
862	1599	/* Check a pointer to see if it is NULL. If it is NULL, exit with an
863	1600	** out-of-memory error.
		@@ -885,22 +1622,22 @@
885	1622	char *z;
886	1623	if( iotrace==0 ) return;
887	1624	va_start(ap, zFormat);
888	1625	z = sqlite3_vmprintf(zFormat, ap);
889	1626	va_end(ap);
890		- utf8_printf(iotrace, "%s", z);
	1627	+ sputf(iotrace, "%s", z);
891	1628	sqlite3_free(z);
892	1629	}
893	1630	#endif
894	1631
895	1632	/*
896		-** Output string zUtf to stream pOut as w characters. If w is negative,
	1633	+** Output string zUtf to Out stream as w characters. If w is negative,
897	1634	** then right-justify the text. W is the width in UTF-8 characters, not
898	1635	** in bytes. This is different from the %.s specification in printf
899	1636	** since with %.s the width is measured in bytes, not characters.
900	1637	*/
901		-static void utf8_width_print(FILE pOut, int w, const char zUtf){
	1638	+static void utf8_width_print(int w, const char *zUtf){
902	1639	int i;
903	1640	int n;
904	1641	int aw = w<0 ? -w : w;
905	1642	if( zUtf==0 ) zUtf = "";
906	1643	for(i=n=0; zUtf[i]; i++){
		@@ -911,15 +1648,15 @@
911	1648	break;
912	1649	}
913	1650	}
914	1651	}
915	1652	if( n>=aw ){
916		- utf8_printf(pOut, "%.*s", i, zUtf);
	1653	+ oputf("%.*s", i, zUtf);
917	1654	}else if( w<0 ){
918		- utf8_printf(pOut, "%*s%s", aw-n, "", zUtf);
	1655	+ oputf("%*s%s", aw-n, "", zUtf);
919	1656	}else{
920		- utf8_printf(pOut, "%s%*s", zUtf, aw-n, "");
	1657	+ oputf("%s%*s", zUtf, aw-n, "");
921	1658	}
922	1659	}
923	1660
924	1661
925	1662	/*
		@@ -975,11 +1712,11 @@
975	1712	** Return open FILE * if zFile exists, can be opened for read
976	1713	** and is an ordinary file or a character stream source.
977	1714	** Otherwise return 0.
978	1715	*/
979	1716	static FILE * openChrSource(const char *zFile){
980		-#ifdef _WIN32
	1717	+#if defined(_WIN32) \|\| defined(WIN32)
981	1718	struct _stat x = {0};
982	1719	# define STAT_CHR_SRC(mode) ((mode & (_S_IFCHR\|_S_IFIFO\|_S_IFREG))!=0)
983	1720	/* On Windows, open first, then check the stream nature. This order
984	1721	** is necessary because _stat() and sibs, when checking a named pipe,
985	1722	** effectively break the pipe as its supplier sees it. */
		@@ -1038,27 +1775,10 @@
1038	1775	if( n>0 && zLine[n-1]=='\r' ) n--;
1039	1776	zLine[n] = 0;
1040	1777	break;
1041	1778	}
1042	1779	}
1043		-#if defined(_WIN32) \|\| defined(WIN32)
1044		- /* For interactive input on Windows systems, with -no-utf8,
1045		- ** translate the multi-byte characterset characters into UTF-8.
1046		- ** This is the translation that predates console UTF-8 input. */
1047		- if( stdin_is_interactive && in==stdin && !console_utf8_in ){
1048		- char *zTrans = sqlite3_win32_mbcs_to_utf8_v2(zLine, 0);
1049		- if( zTrans ){
1050		- i64 nTrans = strlen(zTrans)+1;
1051		- if( nTrans>nLine ){
1052		- zLine = realloc(zLine, nTrans);
1053		- shell_check_oom(zLine);
1054		- }
1055		- memcpy(zLine, zTrans, nTrans);
1056		- sqlite3_free(zTrans);
1057		- }
1058		- }
1059		-#endif /* defined(_WIN32) \|\| defined(WIN32) */
1060	1780	return zLine;
1061	1781	}
1062	1782
1063	1783	/*
1064	1784	** Retrieve a single line of input text.
		@@ -1081,11 +1801,11 @@
1081	1801	if( in!=0 ){
1082	1802	zResult = local_getline(zPrior, in);
1083	1803	}else{
1084	1804	zPrompt = isContinuation ? CONTINUATION_PROMPT : mainPrompt;
1085	1805	#if SHELL_USE_LOCAL_GETLINE
1086		- printf("%s", zPrompt);
	1806	+ sputz(stdout, zPrompt);
1087	1807	fflush(stdout);
1088	1808	do{
1089	1809	zResult = local_getline(zPrior, stdin);
1090	1810	zPrior = 0;
1091	1811	/* ^C trap creates a false EOF, so let "interrupt" thread catch up. */
		@@ -1328,11 +2048,11 @@
1328	2048	double r = sqlite3_value_double(apVal[0]);
1329	2049	int n = nVal>=2 ? sqlite3_value_int(apVal[1]) : 26;
1330	2050	char z[400];
1331	2051	if( n<1 ) n = 1;
1332	2052	if( n>350 ) n = 350;
1333		- snprintf(z, sizeof(z)-1, "%#+.*e", n, r);
	2053	+ sqlite3_snprintf(sizeof(z), z, "%#+.*e", n, r);
1334	2054	sqlite3_result_text(pCtx, z, -1, SQLITE_TRANSIENT);
1335	2055	}
1336	2056
1337	2057
1338	2058	/*
		@@ -17614,11 +18334,11 @@
17614	18334	** A callback for the sqlite3_log() interface.
17615	18335	*/
17616	18336	static void shellLog(void pArg, int iErrCode, const char zMsg){
17617	18337	ShellState p = (ShellState)pArg;
17618	18338	if( p->pLog==0 ) return;
17619		- utf8_printf(p->pLog, "(%d) %s\n", iErrCode, zMsg);
	18339	+ sputf(p->pLog, "(%d) %s\n", iErrCode, zMsg);
17620	18340	fflush(p->pLog);
17621	18341	}
17622	18342
17623	18343	/*
17624	18344	** SQL function: shell_putsnl(X)
		@@ -17629,13 +18349,13 @@
17629	18349	static void shellPutsFunc(
17630	18350	sqlite3_context *pCtx,
17631	18351	int nVal,
17632	18352	sqlite3_value **apVal
17633	18353	){
17634		- ShellState p = (ShellState)sqlite3_user_data(pCtx);
	18354	+ /* Unused: (ShellState)sqlite3_user_data(pCtx); /
17635	18355	(void)nVal;
17636		- utf8_printf(p->out, "%s\n", sqlite3_value_text(apVal[0]));
	18356	+ oputf("%s\n", sqlite3_value_text(apVal[0]));
17637	18357	sqlite3_result_value(pCtx, apVal[0]);
17638	18358	}
17639	18359
17640	18360	/*
17641	18361	** If in safe mode, print an error message described by the arguments
		@@ -17650,12 +18370,11 @@
17650	18370	va_list ap;
17651	18371	char *zMsg;
17652	18372	va_start(ap, zErrMsg);
17653	18373	zMsg = sqlite3_vmprintf(zErrMsg, ap);
17654	18374	va_end(ap);
17655		- raw_printf(stderr, "line %d: ", p->lineno);
17656		- utf8_printf(stderr, "%s\n", zMsg);
	18375	+ eputf("line %d: %s\n", p->lineno, zMsg);
17657	18376	exit(1);
17658	18377	}
17659	18378	}
17660	18379
17661	18380	/*
		@@ -17819,11 +18538,11 @@
17819	18538	}
17820	18539
17821	18540	/*
17822	18541	** Output the given string as a hex-encoded blob (eg. X'1234' )
17823	18542	*/
17824		-static void output_hex_blob(FILE out, const void pBlob, int nBlob){
	18543	+static void output_hex_blob(const void *pBlob, int nBlob){
17825	18544	int i;
17826	18545	unsigned char aBlob = (unsigned char)pBlob;
17827	18546
17828	18547	char zStr = sqlite3_malloc(nBlob2 + 1);
17829	18548	shell_check_oom(zStr);
		@@ -17836,11 +18555,11 @@
17836	18555	zStr[i*2] = aHex[ (aBlob[i] >> 4) ];
17837	18556	zStr[i*2+1] = aHex[ (aBlob[i] & 0x0F) ];
17838	18557	}
17839	18558	zStr[i*2] = '\0';
17840	18559
17841		- raw_printf(out,"X'%s'", zStr);
	18560	+ oputf("X'%s'", zStr);
17842	18561	sqlite3_free(zStr);
17843	18562	}
17844	18563
17845	18564	/*
17846	18565	** Find a string that is not found anywhere in z[]. Return a pointer
		@@ -17866,39 +18585,46 @@
17866	18585	/*
17867	18586	** Output the given string as a quoted string using SQL quoting conventions.
17868	18587	**
17869	18588	** See also: output_quoted_escaped_string()
17870	18589	*/
17871		-static void output_quoted_string(FILE out, const char z){
	18590	+static void output_quoted_string(const char *z){
17872	18591	int i;
17873	18592	char c;
17874		- setBinaryMode(out, 1);
	18593	+#ifndef SQLITE_SHELL_FIDDLE
	18594	+ FILE *pfO = setOutputStream(invalidFileStream);
	18595	+ setBinaryMode(pfO, 1);
	18596	+#endif
17875	18597	if( z==0 ) return;
17876	18598	for(i=0; (c = z[i])!=0 && c!='\''; i++){}
17877	18599	if( c==0 ){
17878		- utf8_printf(out,"'%s'",z);
	18600	+ oputf("'%s'",z);
17879	18601	}else{
17880		- raw_printf(out, "'");
	18602	+ oputz("'");
17881	18603	while( *z ){
17882	18604	for(i=0; (c = z[i])!=0 && c!='\''; i++){}
17883	18605	if( c=='\'' ) i++;
17884	18606	if( i ){
17885		- utf8_printf(out, "%.*s", i, z);
	18607	+ oputf("%.*s", i, z);
17886	18608	z += i;
17887	18609	}
17888	18610	if( c=='\'' ){
17889		- raw_printf(out, "'");
	18611	+ oputz("'");
17890	18612	continue;
17891	18613	}
17892	18614	if( c==0 ){
17893	18615	break;
17894	18616	}
17895	18617	z++;
17896	18618	}
17897		- raw_printf(out, "'");
	18619	+ oputz("'");
17898	18620	}
17899		- setTextMode(out, 1);
	18621	+#ifndef SQLITE_SHELL_FIDDLE
	18622	+ setTextMode(pfO, 1);
	18623	+#else
	18624	+ setTextMode(stdout, 1);
	18625	+#endif
17900	18626	}
17901	18627
17902	18628	/*
17903	18629	** Output the given string as a quoted string using SQL quoting conventions.
17904	18630	** Additionallly , escape the "\n" and "\r" characters so that they do not
		@@ -17906,17 +18632,20 @@
17906	18632	** systems.
17907	18633	**
17908	18634	** This is like output_quoted_string() but with the addition of the \r\n
17909	18635	** escape mechanism.
17910	18636	*/
17911		-static void output_quoted_escaped_string(FILE out, const char z){
	18637	+static void output_quoted_escaped_string(const char *z){
17912	18638	int i;
17913	18639	char c;
17914		- setBinaryMode(out, 1);
	18640	+#ifndef SQLITE_SHELL_FIDDLE
	18641	+ FILE *pfO = setOutputStream(invalidFileStream);
	18642	+ setBinaryMode(pfO, 1);
	18643	+#endif
17915	18644	for(i=0; (c = z[i])!=0 && c!='\'' && c!='\n' && c!='\r'; i++){}
17916	18645	if( c==0 ){
17917		- utf8_printf(out,"'%s'",z);
	18646	+ oputf("'%s'",z);
17918	18647	}else{
17919	18648	const char *zNL = 0;
17920	18649	const char *zCR = 0;
17921	18650	int nNL = 0;
17922	18651	int nCR = 0;
		@@ -17924,121 +18653,167 @@
17924	18653	for(i=0; z[i]; i++){
17925	18654	if( z[i]=='\n' ) nNL++;
17926	18655	if( z[i]=='\r' ) nCR++;
17927	18656	}
17928	18657	if( nNL ){
17929		- raw_printf(out, "replace(");
	18658	+ oputz("replace(");
17930	18659	zNL = unused_string(z, "\\n", "\\012", zBuf1);
17931	18660	}
17932	18661	if( nCR ){
17933		- raw_printf(out, "replace(");
	18662	+ oputz("replace(");
17934	18663	zCR = unused_string(z, "\\r", "\\015", zBuf2);
17935	18664	}
17936		- raw_printf(out, "'");
	18665	+ oputz("'");
17937	18666	while( *z ){
17938	18667	for(i=0; (c = z[i])!=0 && c!='\n' && c!='\r' && c!='\''; i++){}
17939	18668	if( c=='\'' ) i++;
17940	18669	if( i ){
17941		- utf8_printf(out, "%.*s", i, z);
	18670	+ oputf("%.*s", i, z);
17942	18671	z += i;
17943	18672	}
17944	18673	if( c=='\'' ){
17945		- raw_printf(out, "'");
	18674	+ oputz("'");
17946	18675	continue;
17947	18676	}
17948	18677	if( c==0 ){
17949	18678	break;
17950	18679	}
17951	18680	z++;
17952	18681	if( c=='\n' ){
17953		- raw_printf(out, "%s", zNL);
	18682	+ oputz(zNL);
17954	18683	continue;
17955	18684	}
17956		- raw_printf(out, "%s", zCR);
	18685	+ oputz(zCR);
17957	18686	}
17958		- raw_printf(out, "'");
	18687	+ oputz("'");
17959	18688	if( nCR ){
17960		- raw_printf(out, ",'%s',char(13))", zCR);
	18689	+ oputf(",'%s',char(13))", zCR);
17961	18690	}
17962	18691	if( nNL ){
17963		- raw_printf(out, ",'%s',char(10))", zNL);
	18692	+ oputf(",'%s',char(10))", zNL);
17964	18693	}
17965	18694	}
17966		- setTextMode(out, 1);
	18695	+#ifndef SQLITE_SHELL_FIDDLE
	18696	+ setTextMode(pfO, 1);
	18697	+#else
	18698	+ setTextMode(stdout, 1);
	18699	+#endif
17967	18700	}
17968	18701
	18702	+/*
	18703	+** Find earliest of chars within s specified in zAny.
	18704	+** With ns == ~0, is like strpbrk(s,zAny) and s must be 0-terminated.
	18705	+*/
	18706	+static const char anyOfInStr(const char s, const char *zAny, size_t ns){
	18707	+ const char *pcFirst = 0;
	18708	+ if( ns == ~(size_t)0 ) ns = strlen(s);
	18709	+ while(*zAny){
	18710	+ const char pc = (const char)memchr(s, *zAny&0xff, ns);
	18711	+ if( pc ){
	18712	+ pcFirst = pc;
	18713	+ ns = pcFirst - s;
	18714	+ }
	18715	+ ++zAny;
	18716	+ }
	18717	+ return pcFirst;
	18718	+}
17969	18719	/*
17970	18720	** Output the given string as a quoted according to C or TCL quoting rules.
17971	18721	*/
17972		-static void output_c_string(FILE out, const char z){
17973		- unsigned int c;
17974		- fputc('"', out);
17975		- while( (c = *(z++))!=0 ){
17976		- if( c=='\\' ){
17977		- fputc(c, out);
17978		- fputc(c, out);
17979		- }else if( c=='"' ){
17980		- fputc('\\', out);
17981		- fputc('"', out);
17982		- }else if( c=='\t' ){
17983		- fputc('\\', out);
17984		- fputc('t', out);
17985		- }else if( c=='\n' ){
17986		- fputc('\\', out);
17987		- fputc('n', out);
17988		- }else if( c=='\r' ){
17989		- fputc('\\', out);
17990		- fputc('r', out);
	18722	+static void output_c_string(const char *z){
	18723	+ char c;
	18724	+ static const char *zq = "\"";
	18725	+ static long ctrlMask = ~0L;
	18726	+ static const char zDQBSRO = "\"\\\x7f"; / double-quote, backslash, rubout */
	18727	+ char ace[3] = "\\?";
	18728	+ char cbsSay;
	18729	+ oputz(zq);
	18730	+ while( *z!=0 ){
	18731	+ const char *pcDQBSRO = anyOfInStr(z, zDQBSRO, ~(size_t)0);
	18732	+ const char *pcPast = zSkipValidUtf8(z, INT_MAX, ctrlMask);
	18733	+ const char *pcEnd = (pcDQBSRO && pcDQBSRO < pcPast)? pcDQBSRO : pcPast;
	18734	+ if( pcEnd > z ) oputb(z, (int)(pcEnd-z));
	18735	+ if( (c = *pcEnd)==0 ) break;
	18736	+ ++pcEnd;
	18737	+ switch( c ){
	18738	+ case '\\': case '"':
	18739	+ cbsSay = (char)c;
	18740	+ break;
	18741	+ case '\t': cbsSay = 't'; break;
	18742	+ case '\n': cbsSay = 'n'; break;
	18743	+ case '\r': cbsSay = 'r'; break;
	18744	+ case '\f': cbsSay = 'f'; break;
	18745	+ default: cbsSay = 0; break;
	18746	+ }
	18747	+ if( cbsSay ){
	18748	+ ace[1] = cbsSay;
	18749	+ oputz(ace);
17991	18750	}else if( !isprint(c&0xff) ){
17992		- raw_printf(out, "\\%03o", c&0xff);
	18751	+ oputf("\\%03o", c&0xff);
17993	18752	}else{
17994		- fputc(c, out);
	18753	+ ace[1] = (char)c;
	18754	+ oputz(ace+1);
17995	18755	}
	18756	+ z = pcEnd;
17996	18757	}
17997		- fputc('"', out);
	18758	+ oputz(zq);
17998	18759	}
17999	18760
18000	18761	/*
18001	18762	** Output the given string as a quoted according to JSON quoting rules.
18002	18763	*/
18003		-static void output_json_string(FILE out, const char z, i64 n){
18004		- unsigned int c;
	18764	+static void output_json_string(const char *z, i64 n){
	18765	+ char c;
	18766	+ static const char *zq = "\"";
	18767	+ static long ctrlMask = ~0L;
	18768	+ static const char *zDQBS = "\"\\";
	18769	+ const char *pcLimit;
	18770	+ char ace[3] = "\\?";
	18771	+ char cbsSay;
	18772	+
18005	18773	if( z==0 ) z = "";
18006		- if( n<0 ) n = strlen(z);
18007		- fputc('"', out);
18008		- while( n-- ){
	18774	+ pcLimit = z + ((n<0)? strlen(z) : (size_t)n);
	18775	+ oputz(zq);
	18776	+ while( z < pcLimit ){
	18777	+ const char *pcDQBS = anyOfInStr(z, zDQBS, pcLimit-z);
	18778	+ const char *pcPast = zSkipValidUtf8(z, (int)(pcLimit-z), ctrlMask);
	18779	+ const char *pcEnd = (pcDQBS && pcDQBS < pcPast)? pcDQBS : pcPast;
	18780	+ if( pcEnd > z ){
	18781	+ oputb(z, (int)(pcEnd-z));
	18782	+ z = pcEnd;
	18783	+ }
	18784	+ if( z >= pcLimit ) break;
18009	18785	c = *(z++);
18010		- if( c=='\\' \|\| c=='"' ){
18011		- fputc('\\', out);
18012		- fputc(c, out);
	18786	+ switch( c ){
	18787	+ case '"': case '\\':
	18788	+ cbsSay = (char)c;
	18789	+ break;
	18790	+ case '\b': cbsSay = 'b'; break;
	18791	+ case '\f': cbsSay = 'f'; break;
	18792	+ case '\n': cbsSay = 'n'; break;
	18793	+ case '\r': cbsSay = 'r'; break;
	18794	+ case '\t': cbsSay = 't'; break;
	18795	+ default: cbsSay = 0; break;
	18796	+ }
	18797	+ if( cbsSay ){
	18798	+ ace[1] = cbsSay;
	18799	+ oputz(ace);
18013	18800	}else if( c<=0x1f ){
18014		- fputc('\\', out);
18015		- if( c=='\b' ){
18016		- fputc('b', out);
18017		- }else if( c=='\f' ){
18018		- fputc('f', out);
18019		- }else if( c=='\n' ){
18020		- fputc('n', out);
18021		- }else if( c=='\r' ){
18022		- fputc('r', out);
18023		- }else if( c=='\t' ){
18024		- fputc('t', out);
18025		- }else{
18026		- raw_printf(out, "u%04x",c);
18027		- }
18028		- }else{
18029		- fputc(c, out);
18030		- }
18031		- }
18032		- fputc('"', out);
	18801	+ oputf("u%04x", c);
	18802	+ }else{
	18803	+ ace[1] = (char)c;
	18804	+ oputz(ace+1);
	18805	+ }
	18806	+ }
	18807	+ oputz(zq);
18033	18808	}
18034	18809
18035	18810	/*
18036	18811	** Output the given string with characters that are special to
18037	18812	** HTML escaped.
18038	18813	*/
18039		-static void output_html_string(FILE out, const char z){
	18814	+static void output_html_string(const char *z){
18040	18815	int i;
18041	18816	if( z==0 ) z = "";
18042	18817	while( *z ){
18043	18818	for(i=0; z[i]
18044	18819	&& z[i]!='<'
		@@ -18046,22 +18821,22 @@
18046	18821	&& z[i]!='>'
18047	18822	&& z[i]!='\"'
18048	18823	&& z[i]!='\'';
18049	18824	i++){}
18050	18825	if( i>0 ){
18051		- utf8_printf(out,"%.*s",i,z);
	18826	+ oputf("%.*s",i,z);
18052	18827	}
18053	18828	if( z[i]=='<' ){
18054		- raw_printf(out,"<");
	18829	+ oputz("<");
18055	18830	}else if( z[i]=='&' ){
18056		- raw_printf(out,"&");
	18831	+ oputz("&");
18057	18832	}else if( z[i]=='>' ){
18058		- raw_printf(out,">");
	18833	+ oputz(">");
18059	18834	}else if( z[i]=='\"' ){
18060		- raw_printf(out,""");
	18835	+ oputz(""");
18061	18836	}else if( z[i]=='\'' ){
18062		- raw_printf(out,"'");
	18837	+ oputz("'");
18063	18838	}else{
18064	18839	break;
18065	18840	}
18066	18841	z += i + 1;
18067	18842	}
		@@ -18095,13 +18870,12 @@
18095	18870	** the separator, which may or may not be a comma. p->nullValue is
18096	18871	** the null value. Strings are quoted if necessary. The separator
18097	18872	** is only issued if bSep is true.
18098	18873	*/
18099	18874	static void output_csv(ShellState p, const char z, int bSep){
18100		- FILE *out = p->out;
18101	18875	if( z==0 ){
18102		- utf8_printf(out,"%s",p->nullValue);
	18876	+ oputf("%s",p->nullValue);
18103	18877	}else{
18104	18878	unsigned i;
18105	18879	for(i=0; z[i]; i++){
18106	18880	if( needCsvQuote[((unsigned char*)z)[i]] ){
18107	18881	i = 0;
		@@ -18109,18 +18883,18 @@
18109	18883	}
18110	18884	}
18111	18885	if( i==0 \|\| strstr(z, p->colSeparator)!=0 ){
18112	18886	char *zQuoted = sqlite3_mprintf("\"%w\"", z);
18113	18887	shell_check_oom(zQuoted);
18114		- utf8_printf(out, "%s", zQuoted);
	18888	+ oputz(zQuoted);
18115	18889	sqlite3_free(zQuoted);
18116	18890	}else{
18117		- utf8_printf(out, "%s", z);
	18891	+ oputz(z);
18118	18892	}
18119	18893	}
18120	18894	if( bSep ){
18121		- utf8_printf(p->out, "%s", p->colSeparator);
	18895	+ oputz(p->colSeparator);
18122	18896	}
18123	18897	}
18124	18898
18125	18899	/*
18126	18900	** This routine runs when the user presses Ctrl-C
		@@ -18224,20 +18998,20 @@
18224	18998	const char *az[4];
18225	18999	az[0] = zA1;
18226	19000	az[1] = zA2;
18227	19001	az[2] = zA3;
18228	19002	az[3] = zA4;
18229		- utf8_printf(p->out, "authorizer: %s", azAction[op]);
	19003	+ oputf("authorizer: %s", azAction[op]);
18230	19004	for(i=0; i<4; i++){
18231		- raw_printf(p->out, " ");
	19005	+ oputz(" ");
18232	19006	if( az[i] ){
18233		- output_c_string(p->out, az[i]);
	19007	+ output_c_string(az[i]);
18234	19008	}else{
18235		- raw_printf(p->out, "NULL");
	19009	+ oputz("NULL");
18236	19010	}
18237	19011	}
18238		- raw_printf(p->out, "\n");
	19012	+ oputz("\n");
18239	19013	if( p->bSafeMode ) (void)safeModeAuth(pClientData, op, zA1, zA2, zA3, zA4);
18240	19014	return SQLITE_OK;
18241	19015	}
18242	19016	#endif
18243	19017
		@@ -18249,11 +19023,11 @@
18249	19023	**
18250	19024	** If the schema statement in z[] contains a start-of-comment and if
18251	19025	** sqlite3_complete() returns false, try to terminate the comment before
18252	19026	** printing the result. https://sqlite.org/forum/forumpost/d7be961c5c
18253	19027	*/
18254		-static void printSchemaLine(FILE out, const char z, const char *zTail){
	19028	+static void printSchemaLine(const char z, const char zTail){
18255	19029	char *zToFree = 0;
18256	19030	if( z==0 ) return;
18257	19031	if( zTail==0 ) return;
18258	19032	if( zTail[0]==';' && (strstr(z, "/*")!=0 \|\| strstr(z,"--")!=0) ){
18259	19033	const char *zOrig = z;
		@@ -18271,20 +19045,20 @@
18271	19045	}
18272	19046	sqlite3_free(zNew);
18273	19047	}
18274	19048	}
18275	19049	if( sqlite3_strglob("CREATE TABLE ['\"]*", z)==0 ){
18276		- utf8_printf(out, "CREATE TABLE IF NOT EXISTS %s%s", z+13, zTail);
	19050	+ oputf("CREATE TABLE IF NOT EXISTS %s%s", z+13, zTail);
18277	19051	}else{
18278		- utf8_printf(out, "%s%s", z, zTail);
	19052	+ oputf("%s%s", z, zTail);
18279	19053	}
18280	19054	sqlite3_free(zToFree);
18281	19055	}
18282		-static void printSchemaLineN(FILE out, char z, int n, const char *zTail){
	19056	+static void printSchemaLineN(char z, int n, const char zTail){
18283	19057	char c = z[n];
18284	19058	z[n] = 0;
18285		- printSchemaLine(out, z, zTail);
	19059	+ printSchemaLine(z, zTail);
18286	19060	z[n] = c;
18287	19061	}
18288	19062
18289	19063	/*
18290	19064	** Return true if string z[] has nothing but whitespace and comments to the
		@@ -18308,11 +19082,11 @@
18308	19082	EQPGraphRow *pNew;
18309	19083	i64 nText;
18310	19084	if( zText==0 ) return;
18311	19085	nText = strlen(zText);
18312	19086	if( p->autoEQPtest ){
18313		- utf8_printf(p->out, "%d,%d,%s\n", iEqpId, p2, zText);
	19087	+ oputf("%d,%d,%s\n", iEqpId, p2, zText);
18314	19088	}
18315	19089	pNew = sqlite3_malloc64( sizeof(*pNew) + nText );
18316	19090	shell_check_oom(pNew);
18317	19091	pNew->iEqpId = iEqpId;
18318	19092	pNew->iParentId = p2;
		@@ -18356,12 +19130,11 @@
18356	19130	i64 n = strlen(p->sGraph.zPrefix);
18357	19131	char *z;
18358	19132	for(pRow = eqp_next_row(p, iEqpId, 0); pRow; pRow = pNext){
18359	19133	pNext = eqp_next_row(p, iEqpId, pRow);
18360	19134	z = pRow->zText;
18361		- utf8_printf(p->out, "%s%s%s\n", p->sGraph.zPrefix,
18362		- pNext ? "\|--" : "`--", z);
	19135	+ oputf("%s%s%s\n", p->sGraph.zPrefix, pNext ? "\|--" : "`--", z);
18363	19136	if( n<(i64)sizeof(p->sGraph.zPrefix)-7 ){
18364	19137	memcpy(&p->sGraph.zPrefix[n], pNext ? "\| " : " ", 4);
18365	19138	eqp_render_level(p, pRow->iEqpId);
18366	19139	p->sGraph.zPrefix[n] = 0;
18367	19140	}
		@@ -18377,17 +19150,17 @@
18377	19150	if( pRow->zText[0]=='-' ){
18378	19151	if( pRow->pNext==0 ){
18379	19152	eqp_reset(p);
18380	19153	return;
18381	19154	}
18382		- utf8_printf(p->out, "%s\n", pRow->zText+3);
	19155	+ oputf("%s\n", pRow->zText+3);
18383	19156	p->sGraph.pRow = pRow->pNext;
18384	19157	sqlite3_free(pRow);
18385	19158	}else if( nCycle>0 ){
18386		- utf8_printf(p->out, "QUERY PLAN (cycles=%lld [100%%])\n", nCycle);
	19159	+ oputf("QUERY PLAN (cycles=%lld [100%%])\n", nCycle);
18387	19160	}else{
18388		- utf8_printf(p->out, "QUERY PLAN\n");
	19161	+ oputz("QUERY PLAN\n");
18389	19162	}
18390	19163	p->sGraph.zPrefix[0] = 0;
18391	19164	eqp_render_level(p, 0);
18392	19165	eqp_reset(p);
18393	19166	}
		@@ -18399,33 +19172,33 @@
18399	19172	*/
18400	19173	static int progress_handler(void *pClientData) {
18401	19174	ShellState p = (ShellState)pClientData;
18402	19175	p->nProgress++;
18403	19176	if( p->nProgress>=p->mxProgress && p->mxProgress>0 ){
18404		- raw_printf(p->out, "Progress limit reached (%u)\n", p->nProgress);
	19177	+ oputf("Progress limit reached (%u)\n", p->nProgress);
18405	19178	if( p->flgProgress & SHELL_PROGRESS_RESET ) p->nProgress = 0;
18406	19179	if( p->flgProgress & SHELL_PROGRESS_ONCE ) p->mxProgress = 0;
18407	19180	return 1;
18408	19181	}
18409	19182	if( (p->flgProgress & SHELL_PROGRESS_QUIET)==0 ){
18410		- raw_printf(p->out, "Progress %u\n", p->nProgress);
	19183	+ oputf("Progress %u\n", p->nProgress);
18411	19184	}
18412	19185	return 0;
18413	19186	}
18414	19187	#endif /* SQLITE_OMIT_PROGRESS_CALLBACK */
18415	19188
18416	19189	/*
18417	19190	** Print N dashes
18418	19191	*/
18419		-static void print_dashes(FILE *out, int N){
	19192	+static void print_dashes(int N){
18420	19193	const char zDash[] = "--------------------------------------------------";
18421	19194	const int nDash = sizeof(zDash) - 1;
18422	19195	while( N>nDash ){
18423		- fputs(zDash, out);
	19196	+ oputz(zDash);
18424	19197	N -= nDash;
18425	19198	}
18426		- raw_printf(out, "%.*s", N, zDash);
	19199	+ oputf("%.*s", N, zDash);
18427	19200	}
18428	19201
18429	19202	/*
18430	19203	** Print a markdown or table-style row separator using ascii-art
18431	19204	*/
		@@ -18434,19 +19207,19 @@
18434	19207	int nArg,
18435	19208	const char *zSep
18436	19209	){
18437	19210	int i;
18438	19211	if( nArg>0 ){
18439		- fputs(zSep, p->out);
18440		- print_dashes(p->out, p->actualWidth[0]+2);
	19212	+ oputz(zSep);
	19213	+ print_dashes(p->actualWidth[0]+2);
18441	19214	for(i=1; i<nArg; i++){
18442		- fputs(zSep, p->out);
18443		- print_dashes(p->out, p->actualWidth[i]+2);
	19215	+ oputz(zSep);
	19216	+ print_dashes(p->actualWidth[i]+2);
18444	19217	}
18445		- fputs(zSep, p->out);
	19218	+ oputz(zSep);
18446	19219	}
18447		- fputs("\n", p->out);
	19220	+ oputz("\n");
18448	19221	}
18449	19222
18450	19223	/*
18451	19224	** This is the callback routine that the shell
18452	19225	** invokes for each row of a query result.
		@@ -18472,14 +19245,14 @@
18472	19245	if( azArg==0 ) break;
18473	19246	for(i=0; i<nArg; i++){
18474	19247	int len = strlen30(azCol[i] ? azCol[i] : "");
18475	19248	if( len>w ) w = len;
18476	19249	}
18477		- if( p->cnt++>0 ) utf8_printf(p->out, "%s", p->rowSeparator);
	19250	+ if( p->cnt++>0 ) oputz(p->rowSeparator);
18478	19251	for(i=0; i<nArg; i++){
18479		- utf8_printf(p->out,"%*s = %s%s", w, azCol[i],
18480		- azArg[i] ? azArg[i] : p->nullValue, p->rowSeparator);
	19252	+ oputf("%*s = %s%s", w, azCol[i],
	19253	+ azArg[i] ? azArg[i] : p->nullValue, p->rowSeparator);
18481	19254	}
18482	19255	break;
18483	19256	}
18484	19257	case MODE_ScanExp:
18485	19258	case MODE_Explain: {
		@@ -18502,16 +19275,16 @@
18502	19275	if( nArg>nWidth ) nArg = nWidth;
18503	19276
18504	19277	/* If this is the first row seen, print out the headers */
18505	19278	if( p->cnt++==0 ){
18506	19279	for(i=0; i<nArg; i++){
18507		- utf8_width_print(p->out, aWidth[i], azCol[ aMap[i] ]);
18508		- fputs(i==nArg-1 ? "\n" : " ", p->out);
	19280	+ utf8_width_print(aWidth[i], azCol[ aMap[i] ]);
	19281	+ oputz(i==nArg-1 ? "\n" : " ");
18509	19282	}
18510	19283	for(i=0; i<nArg; i++){
18511		- print_dashes(p->out, aWidth[i]);
18512		- fputs(i==nArg-1 ? "\n" : " ", p->out);
	19284	+ print_dashes(aWidth[i]);
	19285	+ oputz(i==nArg-1 ? "\n" : " ");
18513	19286	}
18514	19287	}
18515	19288
18516	19289	/* If there is no data, exit early. */
18517	19290	if( azArg==0 ) break;
		@@ -18525,21 +19298,21 @@
18525	19298	w = strlenChar(zVal);
18526	19299	zSep = " ";
18527	19300	}
18528	19301	if( i==iIndent && p->aiIndent && p->pStmt ){
18529	19302	if( p->iIndent<p->nIndent ){
18530		- utf8_printf(p->out, "%*.s", p->aiIndent[p->iIndent], "");
	19303	+ oputf("%*.s", p->aiIndent[p->iIndent], "");
18531	19304	}
18532	19305	p->iIndent++;
18533	19306	}
18534		- utf8_width_print(p->out, w, zVal ? zVal : p->nullValue);
18535		- fputs(i==nArg-1 ? "\n" : zSep, p->out);
	19307	+ utf8_width_print(w, zVal ? zVal : p->nullValue);
	19308	+ oputz(i==nArg-1 ? "\n" : zSep);
18536	19309	}
18537	19310	break;
18538	19311	}
18539	19312	case MODE_Semi: { /* .schema and .fullschema output */
18540		- printSchemaLine(p->out, azArg[0], ";\n");
	19313	+ printSchemaLine(azArg[0], ";\n");
18541	19314	break;
18542	19315	}
18543	19316	case MODE_Pretty: { /* .schema and .fullschema with --indent */
18544	19317	char *z;
18545	19318	int j;
		@@ -18550,11 +19323,11 @@
18550	19323	assert( nArg==1 );
18551	19324	if( azArg[0]==0 ) break;
18552	19325	if( sqlite3_strlike("CREATE VIEW%", azArg[0], 0)==0
18553	19326	\|\| sqlite3_strlike("CREATE TRIG%", azArg[0], 0)==0
18554	19327	){
18555		- utf8_printf(p->out, "%s;\n", azArg[0]);
	19328	+ oputf("%s;\n", azArg[0]);
18556	19329	break;
18557	19330	}
18558	19331	z = sqlite3_mprintf("%s", azArg[0]);
18559	19332	shell_check_oom(z);
18560	19333	j = 0;
		@@ -18583,166 +19356,161 @@
18583	19356	}else if( c=='(' ){
18584	19357	nParen++;
18585	19358	}else if( c==')' ){
18586	19359	nParen--;
18587	19360	if( nLine>0 && nParen==0 && j>0 ){
18588		- printSchemaLineN(p->out, z, j, "\n");
	19361	+ printSchemaLineN(z, j, "\n");
18589	19362	j = 0;
18590	19363	}
18591	19364	}
18592	19365	z[j++] = c;
18593	19366	if( nParen==1 && cEnd==0
18594	19367	&& (c=='(' \|\| c=='\n' \|\| (c==',' && !wsToEol(z+i+1)))
18595	19368	){
18596	19369	if( c=='\n' ) j--;
18597		- printSchemaLineN(p->out, z, j, "\n ");
	19370	+ printSchemaLineN(z, j, "\n ");
18598	19371	j = 0;
18599	19372	nLine++;
18600	19373	while( IsSpace(z[i+1]) ){ i++; }
18601	19374	}
18602	19375	}
18603	19376	z[j] = 0;
18604	19377	}
18605		- printSchemaLine(p->out, z, ";\n");
	19378	+ printSchemaLine(z, ";\n");
18606	19379	sqlite3_free(z);
18607	19380	break;
18608	19381	}
18609	19382	case MODE_List: {
18610	19383	if( p->cnt++==0 && p->showHeader ){
18611	19384	for(i=0; i<nArg; i++){
18612		- utf8_printf(p->out,"%s%s",azCol[i],
18613		- i==nArg-1 ? p->rowSeparator : p->colSeparator);
	19385	+ oputf("%s%s",azCol[i], i==nArg-1 ? p->rowSeparator : p->colSeparator);
18614	19386	}
18615	19387	}
18616	19388	if( azArg==0 ) break;
18617	19389	for(i=0; i<nArg; i++){
18618	19390	char *z = azArg[i];
18619	19391	if( z==0 ) z = p->nullValue;
18620		- utf8_printf(p->out, "%s", z);
18621		- if( i<nArg-1 ){
18622		- utf8_printf(p->out, "%s", p->colSeparator);
18623		- }else{
18624		- utf8_printf(p->out, "%s", p->rowSeparator);
18625		- }
	19392	+ oputz(z);
	19393	+ oputz((i<nArg-1)? p->colSeparator : p->rowSeparator);
18626	19394	}
18627	19395	break;
18628	19396	}
18629	19397	case MODE_Html: {
18630	19398	if( p->cnt++==0 && p->showHeader ){
18631		- raw_printf(p->out,"<TR>");
	19399	+ oputz("<TR>");
18632	19400	for(i=0; i<nArg; i++){
18633		- raw_printf(p->out,"<TH>");
18634		- output_html_string(p->out, azCol[i]);
18635		- raw_printf(p->out,"</TH>\n");
	19401	+ oputz("<TH>");
	19402	+ output_html_string(azCol[i]);
	19403	+ oputz("</TH>\n");
18636	19404	}
18637		- raw_printf(p->out,"</TR>\n");
	19405	+ oputz("</TR>\n");
18638	19406	}
18639	19407	if( azArg==0 ) break;
18640		- raw_printf(p->out,"<TR>");
	19408	+ oputz("<TR>");
18641	19409	for(i=0; i<nArg; i++){
18642		- raw_printf(p->out,"<TD>");
18643		- output_html_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
18644		- raw_printf(p->out,"</TD>\n");
	19410	+ oputz("<TD>");
	19411	+ output_html_string(azArg[i] ? azArg[i] : p->nullValue);
	19412	+ oputz("</TD>\n");
18645	19413	}
18646		- raw_printf(p->out,"</TR>\n");
	19414	+ oputz("</TR>\n");
18647	19415	break;
18648	19416	}
18649	19417	case MODE_Tcl: {
18650	19418	if( p->cnt++==0 && p->showHeader ){
18651	19419	for(i=0; i<nArg; i++){
18652		- output_c_string(p->out,azCol[i] ? azCol[i] : "");
18653		- if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator);
	19420	+ output_c_string(azCol[i] ? azCol[i] : "");
	19421	+ if(i<nArg-1) oputz(p->colSeparator);
18654	19422	}
18655		- utf8_printf(p->out, "%s", p->rowSeparator);
	19423	+ oputz(p->rowSeparator);
18656	19424	}
18657	19425	if( azArg==0 ) break;
18658	19426	for(i=0; i<nArg; i++){
18659		- output_c_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
18660		- if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator);
	19427	+ output_c_string(azArg[i] ? azArg[i] : p->nullValue);
	19428	+ if(i<nArg-1) oputz(p->colSeparator);
18661	19429	}
18662		- utf8_printf(p->out, "%s", p->rowSeparator);
	19430	+ oputz(p->rowSeparator);
18663	19431	break;
18664	19432	}
18665	19433	case MODE_Csv: {
18666	19434	setBinaryMode(p->out, 1);
18667	19435	if( p->cnt++==0 && p->showHeader ){
18668	19436	for(i=0; i<nArg; i++){
18669	19437	output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
18670	19438	}
18671		- utf8_printf(p->out, "%s", p->rowSeparator);
	19439	+ oputz(p->rowSeparator);
18672	19440	}
18673	19441	if( nArg>0 ){
18674	19442	for(i=0; i<nArg; i++){
18675	19443	output_csv(p, azArg[i], i<nArg-1);
18676	19444	}
18677		- utf8_printf(p->out, "%s", p->rowSeparator);
	19445	+ oputz(p->rowSeparator);
18678	19446	}
18679	19447	setTextMode(p->out, 1);
18680	19448	break;
18681	19449	}
18682	19450	case MODE_Insert: {
18683	19451	if( azArg==0 ) break;
18684		- utf8_printf(p->out,"INSERT INTO %s",p->zDestTable);
	19452	+ oputf("INSERT INTO %s",p->zDestTable);
18685	19453	if( p->showHeader ){
18686		- raw_printf(p->out,"(");
	19454	+ oputz("(");
18687	19455	for(i=0; i<nArg; i++){
18688		- if( i>0 ) raw_printf(p->out, ",");
	19456	+ if( i>0 ) oputz(",");
18689	19457	if( quoteChar(azCol[i]) ){
18690	19458	char *z = sqlite3_mprintf("\"%w\"", azCol[i]);
18691	19459	shell_check_oom(z);
18692		- utf8_printf(p->out, "%s", z);
	19460	+ oputz(z);
18693	19461	sqlite3_free(z);
18694	19462	}else{
18695		- raw_printf(p->out, "%s", azCol[i]);
	19463	+ oputf("%s", azCol[i]);
18696	19464	}
18697	19465	}
18698		- raw_printf(p->out,")");
	19466	+ oputz(")");
18699	19467	}
18700	19468	p->cnt++;
18701	19469	for(i=0; i<nArg; i++){
18702		- raw_printf(p->out, i>0 ? "," : " VALUES(");
	19470	+ oputz(i>0 ? "," : " VALUES(");
18703	19471	if( (azArg[i]==0) \|\| (aiType && aiType[i]==SQLITE_NULL) ){
18704		- utf8_printf(p->out,"NULL");
	19472	+ oputz("NULL");
18705	19473	}else if( aiType && aiType[i]==SQLITE_TEXT ){
18706	19474	if( ShellHasFlag(p, SHFLG_Newlines) ){
18707		- output_quoted_string(p->out, azArg[i]);
	19475	+ output_quoted_string(azArg[i]);
18708	19476	}else{
18709		- output_quoted_escaped_string(p->out, azArg[i]);
	19477	+ output_quoted_escaped_string(azArg[i]);
18710	19478	}
18711	19479	}else if( aiType && aiType[i]==SQLITE_INTEGER ){
18712		- utf8_printf(p->out,"%s", azArg[i]);
	19480	+ oputz(azArg[i]);
18713	19481	}else if( aiType && aiType[i]==SQLITE_FLOAT ){
18714	19482	char z[50];
18715	19483	double r = sqlite3_column_double(p->pStmt, i);
18716	19484	sqlite3_uint64 ur;
18717	19485	memcpy(&ur,&r,sizeof(r));
18718	19486	if( ur==0x7ff0000000000000LL ){
18719		- raw_printf(p->out, "9.0e+999");
	19487	+ oputz("9.0e+999");
18720	19488	}else if( ur==0xfff0000000000000LL ){
18721		- raw_printf(p->out, "-9.0e+999");
	19489	+ oputz("-9.0e+999");
18722	19490	}else{
18723	19491	sqlite3_int64 ir = (sqlite3_int64)r;
18724	19492	if( r==(double)ir ){
18725	19493	sqlite3_snprintf(50,z,"%lld.0", ir);
18726	19494	}else{
18727	19495	sqlite3_snprintf(50,z,"%!.20g", r);
18728	19496	}
18729		- raw_printf(p->out, "%s", z);
	19497	+ oputz(z);
18730	19498	}
18731	19499	}else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
18732	19500	const void *pBlob = sqlite3_column_blob(p->pStmt, i);
18733	19501	int nBlob = sqlite3_column_bytes(p->pStmt, i);
18734		- output_hex_blob(p->out, pBlob, nBlob);
	19502	+ output_hex_blob(pBlob, nBlob);
18735	19503	}else if( isNumber(azArg[i], 0) ){
18736		- utf8_printf(p->out,"%s", azArg[i]);
	19504	+ oputz(azArg[i]);
18737	19505	}else if( ShellHasFlag(p, SHFLG_Newlines) ){
18738		- output_quoted_string(p->out, azArg[i]);
	19506	+ output_quoted_string(azArg[i]);
18739	19507	}else{
18740		- output_quoted_escaped_string(p->out, azArg[i]);
	19508	+ output_quoted_escaped_string(azArg[i]);
18741	19509	}
18742	19510	}
18743		- raw_printf(p->out,");\n");
	19511	+ oputz(");\n");
18744	19512	break;
18745	19513	}
18746	19514	case MODE_Json: {
18747	19515	if( azArg==0 ) break;
18748	19516	if( p->cnt==0 ){
		@@ -18750,93 +19518,93 @@
18750	19518	}else{
18751	19519	fputs(",\n{", p->out);
18752	19520	}
18753	19521	p->cnt++;
18754	19522	for(i=0; i<nArg; i++){
18755		- output_json_string(p->out, azCol[i], -1);
18756		- putc(':', p->out);
	19523	+ output_json_string(azCol[i], -1);
	19524	+ oputz(":");
18757	19525	if( (azArg[i]==0) \|\| (aiType && aiType[i]==SQLITE_NULL) ){
18758		- fputs("null",p->out);
	19526	+ oputz("null");
18759	19527	}else if( aiType && aiType[i]==SQLITE_FLOAT ){
18760	19528	char z[50];
18761	19529	double r = sqlite3_column_double(p->pStmt, i);
18762	19530	sqlite3_uint64 ur;
18763	19531	memcpy(&ur,&r,sizeof(r));
18764	19532	if( ur==0x7ff0000000000000LL ){
18765		- raw_printf(p->out, "9.0e+999");
	19533	+ oputz("9.0e+999");
18766	19534	}else if( ur==0xfff0000000000000LL ){
18767		- raw_printf(p->out, "-9.0e+999");
	19535	+ oputz("-9.0e+999");
18768	19536	}else{
18769	19537	sqlite3_snprintf(50,z,"%!.20g", r);
18770		- raw_printf(p->out, "%s", z);
	19538	+ oputz(z);
18771	19539	}
18772	19540	}else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
18773	19541	const void *pBlob = sqlite3_column_blob(p->pStmt, i);
18774	19542	int nBlob = sqlite3_column_bytes(p->pStmt, i);
18775		- output_json_string(p->out, pBlob, nBlob);
	19543	+ output_json_string(pBlob, nBlob);
18776	19544	}else if( aiType && aiType[i]==SQLITE_TEXT ){
18777		- output_json_string(p->out, azArg[i], -1);
	19545	+ output_json_string(azArg[i], -1);
18778	19546	}else{
18779		- utf8_printf(p->out,"%s", azArg[i]);
	19547	+ oputz(azArg[i]);
18780	19548	}
18781	19549	if( i<nArg-1 ){
18782		- putc(',', p->out);
	19550	+ oputz(",");
18783	19551	}
18784	19552	}
18785		- putc('}', p->out);
	19553	+ oputz("}");
18786	19554	break;
18787	19555	}
18788	19556	case MODE_Quote: {
18789	19557	if( azArg==0 ) break;
18790	19558	if( p->cnt==0 && p->showHeader ){
18791	19559	for(i=0; i<nArg; i++){
18792	19560	if( i>0 ) fputs(p->colSeparator, p->out);
18793		- output_quoted_string(p->out, azCol[i]);
	19561	+ output_quoted_string(azCol[i]);
18794	19562	}
18795	19563	fputs(p->rowSeparator, p->out);
18796	19564	}
18797	19565	p->cnt++;
18798	19566	for(i=0; i<nArg; i++){
18799	19567	if( i>0 ) fputs(p->colSeparator, p->out);
18800	19568	if( (azArg[i]==0) \|\| (aiType && aiType[i]==SQLITE_NULL) ){
18801		- utf8_printf(p->out,"NULL");
	19569	+ oputz("NULL");
18802	19570	}else if( aiType && aiType[i]==SQLITE_TEXT ){
18803		- output_quoted_string(p->out, azArg[i]);
	19571	+ output_quoted_string(azArg[i]);
18804	19572	}else if( aiType && aiType[i]==SQLITE_INTEGER ){
18805		- utf8_printf(p->out,"%s", azArg[i]);
	19573	+ oputz(azArg[i]);
18806	19574	}else if( aiType && aiType[i]==SQLITE_FLOAT ){
18807	19575	char z[50];
18808	19576	double r = sqlite3_column_double(p->pStmt, i);
18809	19577	sqlite3_snprintf(50,z,"%!.20g", r);
18810		- raw_printf(p->out, "%s", z);
	19578	+ oputz(z);
18811	19579	}else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
18812	19580	const void *pBlob = sqlite3_column_blob(p->pStmt, i);
18813	19581	int nBlob = sqlite3_column_bytes(p->pStmt, i);
18814		- output_hex_blob(p->out, pBlob, nBlob);
	19582	+ output_hex_blob(pBlob, nBlob);
18815	19583	}else if( isNumber(azArg[i], 0) ){
18816		- utf8_printf(p->out,"%s", azArg[i]);
	19584	+ oputz(azArg[i]);
18817	19585	}else{
18818		- output_quoted_string(p->out, azArg[i]);
	19586	+ output_quoted_string(azArg[i]);
18819	19587	}
18820	19588	}
18821	19589	fputs(p->rowSeparator, p->out);
18822	19590	break;
18823	19591	}
18824	19592	case MODE_Ascii: {
18825	19593	if( p->cnt++==0 && p->showHeader ){
18826	19594	for(i=0; i<nArg; i++){
18827		- if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator);
18828		- utf8_printf(p->out,"%s",azCol[i] ? azCol[i] : "");
	19595	+ if( i>0 ) oputz(p->colSeparator);
	19596	+ oputz(azCol[i] ? azCol[i] : "");
18829	19597	}
18830		- utf8_printf(p->out, "%s", p->rowSeparator);
	19598	+ oputz(p->rowSeparator);
18831	19599	}
18832	19600	if( azArg==0 ) break;
18833	19601	for(i=0; i<nArg; i++){
18834		- if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator);
18835		- utf8_printf(p->out,"%s",azArg[i] ? azArg[i] : p->nullValue);
	19602	+ if( i>0 ) oputz(p->colSeparator);
	19603	+ oputz(azArg[i] ? azArg[i] : p->nullValue);
18836	19604	}
18837		- utf8_printf(p->out, "%s", p->rowSeparator);
	19605	+ oputz(p->rowSeparator);
18838	19606	break;
18839	19607	}
18840	19608	case MODE_EQP: {
18841	19609	eqp_append(p, atoi(azArg[0]), atoi(azArg[1]), azArg[3]);
18842	19610	break;
		@@ -18911,11 +19679,11 @@
18911	19679	"INSERT INTO selftest(tno,op,cmd,ans)"
18912	19680	" SELECT rowid*10,op,cmd,ans FROM [_shell$self];\n"
18913	19681	"DROP TABLE [_shell$self];"
18914	19682	,0,0,&zErrMsg);
18915	19683	if( zErrMsg ){
18916		- utf8_printf(stderr, "SELFTEST initialization failure: %s\n", zErrMsg);
	19684	+ eputf("SELFTEST initialization failure: %s\n", zErrMsg);
18917	19685	sqlite3_free(zErrMsg);
18918	19686	}
18919	19687	sqlite3_exec(p->db, "RELEASE selftest_init",0,0,0);
18920	19688	}
18921	19689
		@@ -19014,37 +19782,36 @@
19014	19782	int i;
19015	19783	const char *z;
19016	19784	rc = sqlite3_prepare_v2(p->db, zSelect, -1, &pSelect, 0);
19017	19785	if( rc!=SQLITE_OK \|\| !pSelect ){
19018	19786	char *zContext = shell_error_context(zSelect, p->db);
19019		- utf8_printf(p->out, "/** ERROR: (%d) %s ***/\n%s", rc,
19020		- sqlite3_errmsg(p->db), zContext);
	19787	+ oputf("/** ERROR: (%d) %s ***/\n%s",
	19788	+ rc, sqlite3_errmsg(p->db), zContext);
19021	19789	sqlite3_free(zContext);
19022	19790	if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
19023	19791	return rc;
19024	19792	}
19025	19793	rc = sqlite3_step(pSelect);
19026	19794	nResult = sqlite3_column_count(pSelect);
19027	19795	while( rc==SQLITE_ROW ){
19028	19796	z = (const char*)sqlite3_column_text(pSelect, 0);
19029		- utf8_printf(p->out, "%s", z);
	19797	+ oputf("%s", z);
19030	19798	for(i=1; i<nResult; i++){
19031		- utf8_printf(p->out, ",%s", sqlite3_column_text(pSelect, i));
	19799	+ oputf(",%s", sqlite3_column_text(pSelect, i));
19032	19800	}
19033	19801	if( z==0 ) z = "";
19034	19802	while( z[0] && (z[0]!='-' \|\| z[1]!='-') ) z++;
19035	19803	if( z[0] ){
19036		- raw_printf(p->out, "\n;\n");
	19804	+ oputz("\n;\n");
19037	19805	}else{
19038		- raw_printf(p->out, ";\n");
	19806	+ oputz(";\n");
19039	19807	}
19040	19808	rc = sqlite3_step(pSelect);
19041	19809	}
19042	19810	rc = sqlite3_finalize(pSelect);
19043	19811	if( rc!=SQLITE_OK ){
19044		- utf8_printf(p->out, "/** ERROR: (%d) %s ***/\n", rc,
19045		- sqlite3_errmsg(p->db));
	19812	+ oputf("/** ERROR: (%d) %s ***/\n", rc, sqlite3_errmsg(p->db));
19046	19813	if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
19047	19814	}
19048	19815	return rc;
19049	19816	}
19050	19817
		@@ -19076,11 +19843,11 @@
19076	19843
19077	19844	#ifdef __linux__
19078	19845	/*
19079	19846	** Attempt to display I/O stats on Linux using /proc/PID/io
19080	19847	*/
19081		-static void displayLinuxIoStats(FILE *out){
	19848	+static void displayLinuxIoStats(void){
19082	19849	FILE *in;
19083	19850	char z[200];
19084	19851	sqlite3_snprintf(sizeof(z), z, "/proc/%d/io", getpid());
19085	19852	in = fopen(z, "rb");
19086	19853	if( in==0 ) return;
		@@ -19099,11 +19866,11 @@
19099	19866	};
19100	19867	int i;
19101	19868	for(i=0; i<ArraySize(aTrans); i++){
19102	19869	int n = strlen30(aTrans[i].zPattern);
19103	19870	if( cli_strncmp(aTrans[i].zPattern, z, n)==0 ){
19104		- utf8_printf(out, "%-36s %s", aTrans[i].zDesc, &z[n]);
	19871	+ oputf("%-36s %s", aTrans[i].zDesc, &z[n]);
19105	19872	break;
19106	19873	}
19107	19874	}
19108	19875	}
19109	19876	fclose(in);
		@@ -19112,11 +19879,10 @@
19112	19879
19113	19880	/*
19114	19881	** Display a single line of status using 64-bit values.
19115	19882	*/
19116	19883	static void displayStatLine(
19117		- ShellState p, / The shell context */
19118	19884	char zLabel, / Label for this one line */
19119	19885	char zFormat, / Format for the result */
19120	19886	int iStatusCtrl, /* Which status to display */
19121	19887	int bReset /* True to reset the stats */
19122	19888	){
		@@ -19131,11 +19897,11 @@
19131	19897	if( nPercent>1 ){
19132	19898	sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iCur, iHiwtr);
19133	19899	}else{
19134	19900	sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iHiwtr);
19135	19901	}
19136		- raw_printf(p->out, "%-36s %s\n", zLabel, zLine);
	19902	+ oputf("%-36s %s\n", zLabel, zLine);
19137	19903	}
19138	19904
19139	19905	/*
19140	19906	** Display memory stats.
19141	19907	*/
		@@ -19144,141 +19910,130 @@
19144	19910	ShellState pArg, / Pointer to ShellState */
19145	19911	int bReset /* True to reset the stats */
19146	19912	){
19147	19913	int iCur;
19148	19914	int iHiwtr;
19149		- FILE *out;
19150	19915	if( pArg==0 \|\| pArg->out==0 ) return 0;
19151		- out = pArg->out;
19152	19916
19153	19917	if( pArg->pStmt && pArg->statsOn==2 ){
19154	19918	int nCol, i, x;
19155	19919	sqlite3_stmt *pStmt = pArg->pStmt;
19156	19920	char z[100];
19157	19921	nCol = sqlite3_column_count(pStmt);
19158		- raw_printf(out, "%-36s %d\n", "Number of output columns:", nCol);
	19922	+ oputf("%-36s %d\n", "Number of output columns:", nCol);
19159	19923	for(i=0; i<nCol; i++){
19160	19924	sqlite3_snprintf(sizeof(z),z,"Column %d %nname:", i, &x);
19161		- utf8_printf(out, "%-36s %s\n", z, sqlite3_column_name(pStmt,i));
	19925	+ oputf("%-36s %s\n", z, sqlite3_column_name(pStmt,i));
19162	19926	#ifndef SQLITE_OMIT_DECLTYPE
19163	19927	sqlite3_snprintf(30, z+x, "declared type:");
19164		- utf8_printf(out, "%-36s %s\n", z, sqlite3_column_decltype(pStmt, i));
	19928	+ oputf("%-36s %s\n", z, sqlite3_column_decltype(pStmt, i));
19165	19929	#endif
19166	19930	#ifdef SQLITE_ENABLE_COLUMN_METADATA
19167	19931	sqlite3_snprintf(30, z+x, "database name:");
19168		- utf8_printf(out, "%-36s %s\n", z, sqlite3_column_database_name(pStmt,i));
	19932	+ oputf("%-36s %s\n", z, sqlite3_column_database_name(pStmt,i));
19169	19933	sqlite3_snprintf(30, z+x, "table name:");
19170		- utf8_printf(out, "%-36s %s\n", z, sqlite3_column_table_name(pStmt,i));
	19934	+ oputf("%-36s %s\n", z, sqlite3_column_table_name(pStmt,i));
19171	19935	sqlite3_snprintf(30, z+x, "origin name:");
19172		- utf8_printf(out, "%-36s %s\n", z, sqlite3_column_origin_name(pStmt,i));
	19936	+ oputf("%-36s %s\n", z, sqlite3_column_origin_name(pStmt,i));
19173	19937	#endif
19174	19938	}
19175	19939	}
19176	19940
19177	19941	if( pArg->statsOn==3 ){
19178	19942	if( pArg->pStmt ){
19179	19943	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP,bReset);
19180		- raw_printf(pArg->out, "VM-steps: %d\n", iCur);
	19944	+ oputf("VM-steps: %d\n", iCur);
19181	19945	}
19182	19946	return 0;
19183	19947	}
19184	19948
19185		- displayStatLine(pArg, "Memory Used:",
	19949	+ displayStatLine("Memory Used:",
19186	19950	"%lld (max %lld) bytes", SQLITE_STATUS_MEMORY_USED, bReset);
19187		- displayStatLine(pArg, "Number of Outstanding Allocations:",
	19951	+ displayStatLine("Number of Outstanding Allocations:",
19188	19952	"%lld (max %lld)", SQLITE_STATUS_MALLOC_COUNT, bReset);
19189	19953	if( pArg->shellFlgs & SHFLG_Pagecache ){
19190		- displayStatLine(pArg, "Number of Pcache Pages Used:",
	19954	+ displayStatLine("Number of Pcache Pages Used:",
19191	19955	"%lld (max %lld) pages", SQLITE_STATUS_PAGECACHE_USED, bReset);
19192	19956	}
19193		- displayStatLine(pArg, "Number of Pcache Overflow Bytes:",
	19957	+ displayStatLine("Number of Pcache Overflow Bytes:",
19194	19958	"%lld (max %lld) bytes", SQLITE_STATUS_PAGECACHE_OVERFLOW, bReset);
19195		- displayStatLine(pArg, "Largest Allocation:",
	19959	+ displayStatLine("Largest Allocation:",
19196	19960	"%lld bytes", SQLITE_STATUS_MALLOC_SIZE, bReset);
19197		- displayStatLine(pArg, "Largest Pcache Allocation:",
	19961	+ displayStatLine("Largest Pcache Allocation:",
19198	19962	"%lld bytes", SQLITE_STATUS_PAGECACHE_SIZE, bReset);
19199	19963	#ifdef YYTRACKMAXSTACKDEPTH
19200		- displayStatLine(pArg, "Deepest Parser Stack:",
	19964	+ displayStatLine("Deepest Parser Stack:",
19201	19965	"%lld (max %lld)", SQLITE_STATUS_PARSER_STACK, bReset);
19202	19966	#endif
19203	19967
19204	19968	if( db ){
19205	19969	if( pArg->shellFlgs & SHFLG_Lookaside ){
19206	19970	iHiwtr = iCur = -1;
19207	19971	sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED,
19208	19972	&iCur, &iHiwtr, bReset);
19209		- raw_printf(pArg->out,
19210		- "Lookaside Slots Used: %d (max %d)\n",
19211		- iCur, iHiwtr);
	19973	+ oputf("Lookaside Slots Used: %d (max %d)\n", iCur, iHiwtr);
19212	19974	sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT,
19213	19975	&iCur, &iHiwtr, bReset);
19214		- raw_printf(pArg->out, "Successful lookaside attempts: %d\n",
19215		- iHiwtr);
	19976	+ oputf("Successful lookaside attempts: %d\n", iHiwtr);
19216	19977	sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE,
19217	19978	&iCur, &iHiwtr, bReset);
19218		- raw_printf(pArg->out, "Lookaside failures due to size: %d\n",
19219		- iHiwtr);
	19979	+ oputf("Lookaside failures due to size: %d\n", iHiwtr);
19220	19980	sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL,
19221	19981	&iCur, &iHiwtr, bReset);
19222		- raw_printf(pArg->out, "Lookaside failures due to OOM: %d\n",
19223		- iHiwtr);
	19982	+ oputf("Lookaside failures due to OOM: %d\n", iHiwtr);
19224	19983	}
19225	19984	iHiwtr = iCur = -1;
19226	19985	sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);
19227		- raw_printf(pArg->out, "Pager Heap Usage: %d bytes\n",
19228		- iCur);
	19986	+ oputf("Pager Heap Usage: %d bytes\n", iCur);
19229	19987	iHiwtr = iCur = -1;
19230	19988	sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1);
19231		- raw_printf(pArg->out, "Page cache hits: %d\n", iCur);
	19989	+ oputf("Page cache hits: %d\n", iCur);
19232	19990	iHiwtr = iCur = -1;
19233	19991	sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1);
19234		- raw_printf(pArg->out, "Page cache misses: %d\n", iCur);
	19992	+ oputf("Page cache misses: %d\n", iCur);
19235	19993	iHiwtr = iCur = -1;
19236	19994	sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1);
19237		- raw_printf(pArg->out, "Page cache writes: %d\n", iCur);
	19995	+ oputf("Page cache writes: %d\n", iCur);
19238	19996	iHiwtr = iCur = -1;
19239	19997	sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_SPILL, &iCur, &iHiwtr, 1);
19240		- raw_printf(pArg->out, "Page cache spills: %d\n", iCur);
	19998	+ oputf("Page cache spills: %d\n", iCur);
19241	19999	iHiwtr = iCur = -1;
19242	20000	sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset);
19243		- raw_printf(pArg->out, "Schema Heap Usage: %d bytes\n",
19244		- iCur);
	20001	+ oputf("Schema Heap Usage: %d bytes\n", iCur);
19245	20002	iHiwtr = iCur = -1;
19246	20003	sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset);
19247		- raw_printf(pArg->out, "Statement Heap/Lookaside Usage: %d bytes\n",
19248		- iCur);
	20004	+ oputf("Statement Heap/Lookaside Usage: %d bytes\n", iCur);
19249	20005	}
19250	20006
19251	20007	if( pArg->pStmt ){
19252	20008	int iHit, iMiss;
19253	20009	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP,
19254	20010	bReset);
19255		- raw_printf(pArg->out, "Fullscan Steps: %d\n", iCur);
	20011	+ oputf("Fullscan Steps: %d\n", iCur);
19256	20012	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset);
19257		- raw_printf(pArg->out, "Sort Operations: %d\n", iCur);
	20013	+ oputf("Sort Operations: %d\n", iCur);
19258	20014	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX,bReset);
19259		- raw_printf(pArg->out, "Autoindex Inserts: %d\n", iCur);
	20015	+ oputf("Autoindex Inserts: %d\n", iCur);
19260	20016	iHit = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FILTER_HIT,
19261	20017	bReset);
19262	20018	iMiss = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FILTER_MISS,
19263	20019	bReset);
19264	20020	if( iHit \|\| iMiss ){
19265		- raw_printf(pArg->out, "Bloom filter bypass taken: %d/%d\n",
19266		- iHit, iHit+iMiss);
	20021	+ oputf("Bloom filter bypass taken: %d/%d\n", iHit, iHit+iMiss);
19267	20022	}
19268	20023	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset);
19269		- raw_printf(pArg->out, "Virtual Machine Steps: %d\n", iCur);
	20024	+ oputf("Virtual Machine Steps: %d\n", iCur);
19270	20025	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_REPREPARE,bReset);
19271		- raw_printf(pArg->out, "Reprepare operations: %d\n", iCur);
	20026	+ oputf("Reprepare operations: %d\n", iCur);
19272	20027	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_RUN, bReset);
19273		- raw_printf(pArg->out, "Number of times run: %d\n", iCur);
	20028	+ oputf("Number of times run: %d\n", iCur);
19274	20029	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_MEMUSED, bReset);
19275		- raw_printf(pArg->out, "Memory used by prepared stmt: %d\n", iCur);
	20030	+ oputf("Memory used by prepared stmt: %d\n", iCur);
19276	20031	}
19277	20032
19278	20033	#ifdef __linux__
19279		- displayLinuxIoStats(pArg->out);
	20034	+ displayLinuxIoStats();
19280	20035	#endif
19281	20036
19282	20037	/* Do not remove this machine readable comment: extra-stats-output-here */
19283	20038
19284	20039	return 0;
		@@ -19509,11 +20264,11 @@
19509	20264	#ifndef SQLITE_ENABLE_STMT_SCANSTATUS
19510	20265	UNUSED_PARAMETER(db);
19511	20266	UNUSED_PARAMETER(pArg);
19512	20267	#else
19513	20268	if( pArg->scanstatsOn==3 ){
19514		- const char *zSql =
	20269	+ const char *zSql =
19515	20270	" SELECT addr, opcode, p1, p2, p3, p4, p5, comment, nexec,"
19516	20271	" round(ncycle*100.0 / (sum(ncycle) OVER ()), 2)\|\|'%' AS cycles"
19517	20272	" FROM bytecode(?)";
19518	20273
19519	20274	int rc = SQLITE_OK;
		@@ -19655,21 +20410,21 @@
19655	20410	#define BOX_1234 "\342\224\274" /* U+253c -\|- */
19656	20411
19657	20412	/* Draw horizontal line N characters long using unicode box
19658	20413	** characters
19659	20414	*/
19660		-static void print_box_line(FILE *out, int N){
	20415	+static void print_box_line(int N){
19661	20416	const char zDash[] =
19662	20417	BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24
19663	20418	BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24;
19664	20419	const int nDash = sizeof(zDash) - 1;
19665	20420	N *= 3;
19666	20421	while( N>nDash ){
19667		- utf8_printf(out, zDash);
	20422	+ oputz(zDash);
19668	20423	N -= nDash;
19669	20424	}
19670		- utf8_printf(out, "%.*s", N, zDash);
	20425	+ oputf("%.*s", N, zDash);
19671	20426	}
19672	20427
19673	20428	/*
19674	20429	** Draw a horizontal separator for a MODE_Box table.
19675	20430	*/
		@@ -19680,19 +20435,19 @@
19680	20435	const char *zSep2,
19681	20436	const char *zSep3
19682	20437	){
19683	20438	int i;
19684	20439	if( nArg>0 ){
19685		- utf8_printf(p->out, "%s", zSep1);
19686		- print_box_line(p->out, p->actualWidth[0]+2);
	20440	+ oputz(zSep1);
	20441	+ print_box_line(p->actualWidth[0]+2);
19687	20442	for(i=1; i<nArg; i++){
19688		- utf8_printf(p->out, "%s", zSep2);
19689		- print_box_line(p->out, p->actualWidth[i]+2);
	20443	+ oputz(zSep2);
	20444	+ print_box_line(p->actualWidth[i]+2);
19690	20445	}
19691		- utf8_printf(p->out, "%s", zSep3);
	20446	+ oputz(zSep3);
19692	20447	}
19693		- fputs("\n", p->out);
	20448	+ oputz("\n");
19694	20449	}
19695	20450
19696	20451	/*
19697	20452	** z[] is a line of text that is to be displayed the .mode box or table or
19698	20453	** similar tabular formats. z[] might contain control characters such
		@@ -19951,15 +20706,15 @@
19951	20706	rowSep = "\n";
19952	20707	if( p->showHeader ){
19953	20708	for(i=0; i<nColumn; i++){
19954	20709	w = p->actualWidth[i];
19955	20710	if( p->colWidth[i]<0 ) w = -w;
19956		- utf8_width_print(p->out, w, azData[i]);
	20711	+ utf8_width_print(w, azData[i]);
19957	20712	fputs(i==nColumn-1?"\n":" ", p->out);
19958	20713	}
19959	20714	for(i=0; i<nColumn; i++){
19960		- print_dashes(p->out, p->actualWidth[i]);
	20715	+ print_dashes(p->actualWidth[i]);
19961	20716	fputs(i==nColumn-1?"\n":" ", p->out);
19962	20717	}
19963	20718	}
19964	20719	break;
19965	20720	}
		@@ -19969,12 +20724,12 @@
19969	20724	print_row_separator(p, nColumn, "+");
19970	20725	fputs("\| ", p->out);
19971	20726	for(i=0; i<nColumn; i++){
19972	20727	w = p->actualWidth[i];
19973	20728	n = strlenChar(azData[i]);
19974		- utf8_printf(p->out, "%s%s%s", (w-n)/2, "", azData[i], (w-n+1)/2, "");
19975		- fputs(i==nColumn-1?" \|\n":" \| ", p->out);
	20729	+ oputf("%s%s%s", (w-n)/2, "", azData[i], (w-n+1)/2, "");
	20730	+ oputz(i==nColumn-1?" \|\n":" \| ");
19976	20731	}
19977	20732	print_row_separator(p, nColumn, "+");
19978	20733	break;
19979	20734	}
19980	20735	case MODE_Markdown: {
		@@ -19982,66 +20737,66 @@
19982	20737	rowSep = " \|\n";
19983	20738	fputs("\| ", p->out);
19984	20739	for(i=0; i<nColumn; i++){
19985	20740	w = p->actualWidth[i];
19986	20741	n = strlenChar(azData[i]);
19987		- utf8_printf(p->out, "%s%s%s", (w-n)/2, "", azData[i], (w-n+1)/2, "");
19988		- fputs(i==nColumn-1?" \|\n":" \| ", p->out);
	20742	+ oputf("%s%s%s", (w-n)/2, "", azData[i], (w-n+1)/2, "");
	20743	+ oputz(i==nColumn-1?" \|\n":" \| ");
19989	20744	}
19990	20745	print_row_separator(p, nColumn, "\|");
19991	20746	break;
19992	20747	}
19993	20748	case MODE_Box: {
19994	20749	colSep = " " BOX_13 " ";
19995	20750	rowSep = " " BOX_13 "\n";
19996	20751	print_box_row_separator(p, nColumn, BOX_23, BOX_234, BOX_34);
19997		- utf8_printf(p->out, BOX_13 " ");
	20752	+ oputz(BOX_13 " ");
19998	20753	for(i=0; i<nColumn; i++){
19999	20754	w = p->actualWidth[i];
20000	20755	n = strlenChar(azData[i]);
20001		- utf8_printf(p->out, "%s%s%s%s",
20002		- (w-n)/2, "", azData[i], (w-n+1)/2, "",
20003		- i==nColumn-1?" "BOX_13"\n":" "BOX_13" ");
	20756	+ oputf("%s%s%s%s",
	20757	+ (w-n)/2, "", azData[i], (w-n+1)/2, "",
	20758	+ i==nColumn-1?" "BOX_13"\n":" "BOX_13" ");
20004	20759	}
20005	20760	print_box_row_separator(p, nColumn, BOX_123, BOX_1234, BOX_134);
20006	20761	break;
20007	20762	}
20008	20763	}
20009	20764	for(i=nColumn, j=0; i<nTotal; i++, j++){
20010	20765	if( j==0 && p->cMode!=MODE_Column ){
20011		- utf8_printf(p->out, "%s", p->cMode==MODE_Box?BOX_13" ":"\| ");
	20766	+ oputz(p->cMode==MODE_Box?BOX_13" ":"\| ");
20012	20767	}
20013	20768	z = azData[i];
20014	20769	if( z==0 ) z = p->nullValue;
20015	20770	w = p->actualWidth[j];
20016	20771	if( p->colWidth[j]<0 ) w = -w;
20017		- utf8_width_print(p->out, w, z);
	20772	+ utf8_width_print(w, z);
20018	20773	if( j==nColumn-1 ){
20019		- utf8_printf(p->out, "%s", rowSep);
	20774	+ oputz(rowSep);
20020	20775	if( bMultiLineRowExists && abRowDiv[i/nColumn-1] && i+1<nTotal ){
20021	20776	if( p->cMode==MODE_Table ){
20022	20777	print_row_separator(p, nColumn, "+");
20023	20778	}else if( p->cMode==MODE_Box ){
20024	20779	print_box_row_separator(p, nColumn, BOX_123, BOX_1234, BOX_134);
20025	20780	}else if( p->cMode==MODE_Column ){
20026		- raw_printf(p->out, "\n");
	20781	+ oputz("\n");
20027	20782	}
20028	20783	}
20029	20784	j = -1;
20030	20785	if( seenInterrupt ) goto columnar_end;
20031	20786	}else{
20032		- utf8_printf(p->out, "%s", colSep);
	20787	+ oputz(colSep);
20033	20788	}
20034	20789	}
20035	20790	if( p->cMode==MODE_Table ){
20036	20791	print_row_separator(p, nColumn, "+");
20037	20792	}else if( p->cMode==MODE_Box ){
20038	20793	print_box_row_separator(p, nColumn, BOX_12, BOX_124, BOX_14);
20039	20794	}
20040	20795	columnar_end:
20041	20796	if( seenInterrupt ){
20042		- utf8_printf(p->out, "Interrupt\n");
	20797	+ oputz("Interrupt\n");
20043	20798	}
20044	20799	nData = (nRow+1)*nColumn;
20045	20800	for(i=0; i<nData; i++){
20046	20801	z = azData[i];
20047	20802	if( z!=zEmpty && z!=zShowNull ) free(azData[i]);
		@@ -20176,34 +20931,33 @@
20176	20931	int rc = SQLITE_OK;
20177	20932	sqlite3expert *p = pState->expert.pExpert;
20178	20933	assert( p );
20179	20934	assert( bCancel \|\| pzErr==0 \|\| *pzErr==0 );
20180	20935	if( bCancel==0 ){
20181		- FILE *out = pState->out;
20182	20936	int bVerbose = pState->expert.bVerbose;
20183	20937
20184	20938	rc = sqlite3_expert_analyze(p, pzErr);
20185	20939	if( rc==SQLITE_OK ){
20186	20940	int nQuery = sqlite3_expert_count(p);
20187	20941	int i;
20188	20942
20189	20943	if( bVerbose ){
20190	20944	const char *zCand = sqlite3_expert_report(p,0,EXPERT_REPORT_CANDIDATES);
20191		- raw_printf(out, "-- Candidates -----------------------------\n");
20192		- raw_printf(out, "%s\n", zCand);
	20945	+ oputz("-- Candidates -----------------------------\n");
	20946	+ oputf("%s\n", zCand);
20193	20947	}
20194	20948	for(i=0; i<nQuery; i++){
20195	20949	const char *zSql = sqlite3_expert_report(p, i, EXPERT_REPORT_SQL);
20196	20950	const char *zIdx = sqlite3_expert_report(p, i, EXPERT_REPORT_INDEXES);
20197	20951	const char *zEQP = sqlite3_expert_report(p, i, EXPERT_REPORT_PLAN);
20198	20952	if( zIdx==0 ) zIdx = "(no new indexes)\n";
20199	20953	if( bVerbose ){
20200		- raw_printf(out, "-- Query %d --------------------------------\n",i+1);
20201		- raw_printf(out, "%s\n\n", zSql);
	20954	+ oputf("-- Query %d --------------------------------\n",i+1);
	20955	+ oputf("%s\n\n", zSql);
20202	20956	}
20203		- raw_printf(out, "%s\n", zIdx);
20204		- raw_printf(out, "%s\n", zEQP);
	20957	+ oputf("%s\n", zIdx);
	20958	+ oputf("%s\n", zEQP);
20205	20959	}
20206	20960	}
20207	20961	}
20208	20962	sqlite3_expert_destroy(p);
20209	20963	pState->expert.pExpert = 0;
		@@ -20234,31 +20988,30 @@
20234	20988	if( n>=2 && 0==cli_strncmp(z, "-verbose", n) ){
20235	20989	pState->expert.bVerbose = 1;
20236	20990	}
20237	20991	else if( n>=2 && 0==cli_strncmp(z, "-sample", n) ){
20238	20992	if( i==(nArg-1) ){
20239		- raw_printf(stderr, "option requires an argument: %s\n", z);
	20993	+ eputf("option requires an argument: %s\n", z);
20240	20994	rc = SQLITE_ERROR;
20241	20995	}else{
20242	20996	iSample = (int)integerValue(azArg[++i]);
20243	20997	if( iSample<0 \|\| iSample>100 ){
20244		- raw_printf(stderr, "value out of range: %s\n", azArg[i]);
	20998	+ eputf("value out of range: %s\n", azArg[i]);
20245	20999	rc = SQLITE_ERROR;
20246	21000	}
20247	21001	}
20248	21002	}
20249	21003	else{
20250		- raw_printf(stderr, "unknown option: %s\n", z);
	21004	+ eputf("unknown option: %s\n", z);
20251	21005	rc = SQLITE_ERROR;
20252	21006	}
20253	21007	}
20254	21008
20255	21009	if( rc==SQLITE_OK ){
20256	21010	pState->expert.pExpert = sqlite3_expert_new(pState->db, &zErr);
20257	21011	if( pState->expert.pExpert==0 ){
20258		- raw_printf(stderr, "sqlite3_expert_new: %s\n",
20259		- zErr ? zErr : "out of memory");
	21012	+ eputf("sqlite3_expert_new: %s\n", zErr ? zErr : "out of memory");
20260	21013	rc = SQLITE_ERROR;
20261	21014	}else{
20262	21015	sqlite3_expert_config(
20263	21016	pState->expert.pExpert, EXPERT_CONFIG_SAMPLE, iSample
20264	21017	);
		@@ -20581,33 +21334,33 @@
20581	21334	if( zType==0 ) return 0;
20582	21335	dataOnly = (p->shellFlgs & SHFLG_DumpDataOnly)!=0;
20583	21336	noSys = (p->shellFlgs & SHFLG_DumpNoSys)!=0;
20584	21337
20585	21338	if( cli_strcmp(zTable, "sqlite_sequence")==0 && !noSys ){
20586		- if( !dataOnly ) raw_printf(p->out, "DELETE FROM sqlite_sequence;\n");
	21339	+ if( !dataOnly ) oputz("DELETE FROM sqlite_sequence;\n");
20587	21340	}else if( sqlite3_strglob("sqlite_stat?", zTable)==0 && !noSys ){
20588		- if( !dataOnly ) raw_printf(p->out, "ANALYZE sqlite_schema;\n");
	21341	+ if( !dataOnly ) oputz("ANALYZE sqlite_schema;\n");
20589	21342	}else if( cli_strncmp(zTable, "sqlite_", 7)==0 ){
20590	21343	return 0;
20591	21344	}else if( dataOnly ){
20592	21345	/* no-op */
20593	21346	}else if( cli_strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
20594	21347	char *zIns;
20595	21348	if( !p->writableSchema ){
20596		- raw_printf(p->out, "PRAGMA writable_schema=ON;\n");
	21349	+ oputz("PRAGMA writable_schema=ON;\n");
20597	21350	p->writableSchema = 1;
20598	21351	}
20599	21352	zIns = sqlite3_mprintf(
20600	21353	"INSERT INTO sqlite_schema(type,name,tbl_name,rootpage,sql)"
20601	21354	"VALUES('table','%q','%q',0,'%q');",
20602	21355	zTable, zTable, zSql);
20603	21356	shell_check_oom(zIns);
20604		- utf8_printf(p->out, "%s\n", zIns);
	21357	+ oputf("%s\n", zIns);
20605	21358	sqlite3_free(zIns);
20606	21359	return 0;
20607	21360	}else{
20608		- printSchemaLine(p->out, zSql, ";\n");
	21361	+ printSchemaLine(zSql, ";\n");
20609	21362	}
20610	21363
20611	21364	if( cli_strcmp(zType, "table")==0 ){
20612	21365	ShellText sSelect;
20613	21366	ShellText sTable;
		@@ -20661,11 +21414,11 @@
20661	21414	savedMode = p->mode;
20662	21415	p->zDestTable = sTable.z;
20663	21416	p->mode = p->cMode = MODE_Insert;
20664	21417	rc = shell_exec(p, sSelect.z, 0);
20665	21418	if( (rc&0xff)==SQLITE_CORRUPT ){
20666		- raw_printf(p->out, "/**** CORRUPTION ERROR *****/\n");
	21419	+ oputz("/**** CORRUPTION ERROR *****/\n");
20667	21420	toggleSelectOrder(p->db);
20668	21421	shell_exec(p, sSelect.z, 0);
20669	21422	toggleSelectOrder(p->db);
20670	21423	}
20671	21424	p->zDestTable = savedDestTable;
		@@ -20692,22 +21445,22 @@
20692	21445	char *zErr = 0;
20693	21446	rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr);
20694	21447	if( rc==SQLITE_CORRUPT ){
20695	21448	char *zQ2;
20696	21449	int len = strlen30(zQuery);
20697		- raw_printf(p->out, "/**** CORRUPTION ERROR *****/\n");
	21450	+ oputz("/**** CORRUPTION ERROR *****/\n");
20698	21451	if( zErr ){
20699		- utf8_printf(p->out, "/**** %s ****/\n", zErr);
	21452	+ oputf("/**** %s ****/\n", zErr);
20700	21453	sqlite3_free(zErr);
20701	21454	zErr = 0;
20702	21455	}
20703	21456	zQ2 = malloc( len+100 );
20704	21457	if( zQ2==0 ) return rc;
20705	21458	sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery);
20706	21459	rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr);
20707	21460	if( rc ){
20708		- utf8_printf(p->out, "/**** ERROR: %s ****/\n", zErr);
	21461	+ oputf("/**** ERROR: %s ****/\n", zErr);
20709	21462	}else{
20710	21463	rc = SQLITE_CORRUPT;
20711	21464	}
20712	21465	sqlite3_free(zErr);
20713	21466	free(zQ2);
		@@ -21059,24 +21812,24 @@
21059	21812	hh &= ~HH_Summary;
21060	21813	break;
21061	21814	}
21062	21815	if( ((hw^hh)&HH_Undoc)==0 ){
21063	21816	if( (hh&HH_Summary)!=0 ){
21064		- utf8_printf(out, ".%s\n", azHelp[i]+1);
	21817	+ sputf(out, ".%s\n", azHelp[i]+1);
21065	21818	++n;
21066	21819	}else if( (hw&HW_SummaryOnly)==0 ){
21067		- utf8_printf(out, "%s\n", azHelp[i]);
	21820	+ sputf(out, "%s\n", azHelp[i]);
21068	21821	}
21069	21822	}
21070	21823	}
21071	21824	}else{
21072	21825	/* Seek documented commands for which zPattern is an exact prefix */
21073	21826	zPat = sqlite3_mprintf(".%s*", zPattern);
21074	21827	shell_check_oom(zPat);
21075	21828	for(i=0; i<ArraySize(azHelp); i++){
21076	21829	if( sqlite3_strglob(zPat, azHelp[i])==0 ){
21077		- utf8_printf(out, "%s\n", azHelp[i]);
	21830	+ sputf(out, "%s\n", azHelp[i]);
21078	21831	j = i+1;
21079	21832	n++;
21080	21833	}
21081	21834	}
21082	21835	sqlite3_free(zPat);
		@@ -21083,11 +21836,11 @@
21083	21836	if( n ){
21084	21837	if( n==1 ){
21085	21838	/* when zPattern is a prefix of exactly one command, then include
21086	21839	** the details of that command, which should begin at offset j */
21087	21840	while( j<ArraySize(azHelp)-1 && azHelp[j][0]==' ' ){
21088		- utf8_printf(out, "%s\n", azHelp[j]);
	21841	+ sputf(out, "%s\n", azHelp[j]);
21089	21842	j++;
21090	21843	}
21091	21844	}
21092	21845	return n;
21093	21846	}
		@@ -21100,14 +21853,14 @@
21100	21853	while( i<ArraySize(azHelp)-1 && azHelp[i+1][0]==' ' ) ++i;
21101	21854	continue;
21102	21855	}
21103	21856	if( azHelp[i][0]=='.' ) j = i;
21104	21857	if( sqlite3_strlike(zPat, azHelp[i], 0)==0 ){
21105		- utf8_printf(out, "%s\n", azHelp[j]);
	21858	+ sputf(out, "%s\n", azHelp[j]);
21106	21859	while( j<ArraySize(azHelp)-1 && azHelp[j+1][0]==' ' ){
21107	21860	j++;
21108		- utf8_printf(out, "%s\n", azHelp[j]);
	21861	+ sputf(out, "%s\n", azHelp[j]);
21109	21862	}
21110	21863	i = j;
21111	21864	n++;
21112	21865	}
21113	21866	}
		@@ -21141,27 +21894,27 @@
21141	21894	char *pBuf;
21142	21895	int rc;
21143	21896	if( in==0 ) return 0;
21144	21897	rc = fseek(in, 0, SEEK_END);
21145	21898	if( rc!=0 ){
21146		- raw_printf(stderr, "Error: '%s' not seekable\n", zName);
	21899	+ eputf("Error: '%s' not seekable\n", zName);
21147	21900	fclose(in);
21148	21901	return 0;
21149	21902	}
21150	21903	nIn = ftell(in);
21151	21904	rewind(in);
21152	21905	pBuf = sqlite3_malloc64( nIn+1 );
21153	21906	if( pBuf==0 ){
21154		- raw_printf(stderr, "Error: out of memory\n");
	21907	+ eputz("Error: out of memory\n");
21155	21908	fclose(in);
21156	21909	return 0;
21157	21910	}
21158	21911	nRead = fread(pBuf, nIn, 1, in);
21159	21912	fclose(in);
21160	21913	if( nRead!=1 ){
21161	21914	sqlite3_free(pBuf);
21162		- raw_printf(stderr, "Error: cannot read '%s'\n", zName);
	21915	+ eputf("Error: cannot read '%s'\n", zName);
21163	21916	return 0;
21164	21917	}
21165	21918	pBuf[nIn] = 0;
21166	21919	if( pnByte ) *pnByte = nIn;
21167	21920	return pBuf;
		@@ -21278,11 +22031,11 @@
21278	22031	unsigned int x[16];
21279	22032	char zLine[1000];
21280	22033	if( zDbFilename ){
21281	22034	in = fopen(zDbFilename, "r");
21282	22035	if( in==0 ){
21283		- utf8_printf(stderr, "cannot open \"%s\" for reading\n", zDbFilename);
	22036	+ eputf("cannot open \"%s\" for reading\n", zDbFilename);
21284	22037	return 0;
21285	22038	}
21286	22039	nLine = 0;
21287	22040	}else{
21288	22041	in = p->in;
		@@ -21299,11 +22052,11 @@
21299	22052	n = (n+pgsz-1)&~(pgsz-1); /* Round n up to the next multiple of pgsz */
21300	22053	a = sqlite3_malloc( n ? n : 1 );
21301	22054	shell_check_oom(a);
21302	22055	memset(a, 0, n);
21303	22056	if( pgsz<512 \|\| pgsz>65536 \|\| (pgsz & (pgsz-1))!=0 ){
21304		- utf8_printf(stderr, "invalid pagesize\n");
	22057	+ eputz("invalid pagesize\n");
21305	22058	goto readHexDb_error;
21306	22059	}
21307	22060	for(nLine++; fgets(zLine, sizeof(zLine), in)!=0; nLine++){
21308	22061	rc = sscanf(zLine, "\| page %d offset %d", &j, &k);
21309	22062	if( rc==2 ){
		@@ -21341,11 +22094,11 @@
21341	22094	if(cli_strncmp(zLine, "\| end ", 6)==0 ) break;
21342	22095	}
21343	22096	p->lineno = nLine;
21344	22097	}
21345	22098	sqlite3_free(a);
21346		- utf8_printf(stderr,"Error on line %d of --hexdb input\n", nLine);
	22099	+ eputf("Error on line %d of --hexdb input\n", nLine);
21347	22100	return 0;
21348	22101	}
21349	22102	#endif /* SQLITE_OMIT_DESERIALIZE */
21350	22103
21351	22104	/*
		@@ -21417,26 +22170,23 @@
21417	22170	break;
21418	22171	}
21419	22172	}
21420	22173	globalDb = p->db;
21421	22174	if( p->db==0 \|\| SQLITE_OK!=sqlite3_errcode(p->db) ){
21422		- utf8_printf(stderr,"Error: unable to open database \"%s\": %s\n",
21423		- zDbFilename, sqlite3_errmsg(p->db));
	22175	+ eputf("Error: unable to open database \"%s\": %s\n",
	22176	+ zDbFilename, sqlite3_errmsg(p->db));
21424	22177	if( (openFlags & OPEN_DB_KEEPALIVE)==0 ){
21425	22178	exit(1);
21426	22179	}
21427	22180	sqlite3_close(p->db);
21428	22181	sqlite3_open(":memory:", &p->db);
21429	22182	if( p->db==0 \|\| SQLITE_OK!=sqlite3_errcode(p->db) ){
21430		- utf8_printf(stderr,
21431		- "Also: unable to open substitute in-memory database.\n"
21432		- );
	22183	+ eputz("Also: unable to open substitute in-memory database.\n");
21433	22184	exit(1);
21434	22185	}else{
21435		- utf8_printf(stderr,
21436		- "Notice: using substitute in-memory database instead of \"%s\"\n",
21437		- zDbFilename);
	22186	+ eputf("Notice: using substitute in-memory database instead of \"%s\"\n",
	22187	+ zDbFilename);
21438	22188	}
21439	22189	}
21440	22190	sqlite3_db_config(p->db, SQLITE_DBCONFIG_STMT_SCANSTATUS, (int)0, (int*)0);
21441	22191
21442	22192	/* Reflect the use or absence of --unsafe-testing invocation. */
		@@ -21539,11 +22289,11 @@
21539	22289	}
21540	22290	rc = sqlite3_deserialize(p->db, "main", aData, nData, nData,
21541	22291	SQLITE_DESERIALIZE_RESIZEABLE \|
21542	22292	SQLITE_DESERIALIZE_FREEONCLOSE);
21543	22293	if( rc ){
21544		- utf8_printf(stderr, "Error: sqlite3_deserialize() returns %d\n", rc);
	22294	+ eputf("Error: sqlite3_deserialize() returns %d\n", rc);
21545	22295	}
21546	22296	if( p->szMax>0 ){
21547	22297	sqlite3_file_control(p->db, "main", SQLITE_FCNTL_SIZE_LIMIT, &p->szMax);
21548	22298	}
21549	22299	}
		@@ -21563,12 +22313,11 @@
21563	22313	** Attempt to close the database connection. Report errors.
21564	22314	*/
21565	22315	void close_db(sqlite3 *db){
21566	22316	int rc = sqlite3_close(db);
21567	22317	if( rc ){
21568		- utf8_printf(stderr, "Error: sqlite3_close() returns %d: %s\n",
21569		- rc, sqlite3_errmsg(db));
	22318	+ eputf("Error: sqlite3_close() returns %d: %s\n", rc, sqlite3_errmsg(db));
21570	22319	}
21571	22320	}
21572	22321
21573	22322	#if HAVE_READLINE \|\| HAVE_EDITLINE
21574	22323	/*
		@@ -21725,12 +22474,11 @@
21725	22474	return 1;
21726	22475	}
21727	22476	if( sqlite3_stricmp(zArg, "off")==0 \|\| sqlite3_stricmp(zArg,"no")==0 ){
21728	22477	return 0;
21729	22478	}
21730		- utf8_printf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
21731		- zArg);
	22479	+ eputf("ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n", zArg);
21732	22480	return 0;
21733	22481	}
21734	22482
21735	22483	/*
21736	22484	** Set or clear a shell flag according to a boolean value.
		@@ -21764,11 +22512,11 @@
21764	22512	}else if( cli_strcmp(zFile, "off")==0 ){
21765	22513	f = 0;
21766	22514	}else{
21767	22515	f = fopen(zFile, bTextMode ? "w" : "wb");
21768	22516	if( f==0 ){
21769		- utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile);
	22517	+ eputf("Error: cannot open \"%s\"\n", zFile);
21770	22518	}
21771	22519	}
21772	22520	return f;
21773	22521	}
21774	22522
		@@ -21786,11 +22534,11 @@
21786	22534	sqlite3_stmt *pStmt;
21787	22535	const char *zSql;
21788	22536	i64 nSql;
21789	22537	if( p->traceOut==0 ) return 0;
21790	22538	if( mType==SQLITE_TRACE_CLOSE ){
21791		- utf8_printf(p->traceOut, "-- closing database connection\n");
	22539	+ sputz(p->traceOut, "-- closing database connection\n");
21792	22540	return 0;
21793	22541	}
21794	22542	if( mType!=SQLITE_TRACE_ROW && pX!=0 && ((const char*)pX)[0]=='-' ){
21795	22543	zSql = (const char*)pX;
21796	22544	}else{
		@@ -21817,16 +22565,16 @@
21817	22565	if( nSql>1000000000 ) nSql = 1000000000;
21818	22566	while( nSql>0 && zSql[nSql-1]==';' ){ nSql--; }
21819	22567	switch( mType ){
21820	22568	case SQLITE_TRACE_ROW:
21821	22569	case SQLITE_TRACE_STMT: {
21822		- utf8_printf(p->traceOut, "%.*s;\n", (int)nSql, zSql);
	22570	+ sputf(p->traceOut, "%.*s;\n", (int)nSql, zSql);
21823	22571	break;
21824	22572	}
21825	22573	case SQLITE_TRACE_PROFILE: {
21826	22574	sqlite3_int64 nNanosec = pX ? (sqlite3_int64)pX : 0;
21827		- utf8_printf(p->traceOut, "%.*s; -- %lld ns\n", (int)nSql, zSql, nNanosec);
	22575	+ sputf(p->traceOut, "%.*s; -- %lld ns\n", (int)nSql, zSql, nNanosec);
21828	22576	break;
21829	22577	}
21830	22578	}
21831	22579	return 0;
21832	22580	}
		@@ -21929,16 +22677,15 @@
21929	22677	do{ p->n--; }while( p->z[p->n]!=cQuote );
21930	22678	p->cTerm = c;
21931	22679	break;
21932	22680	}
21933	22681	if( pc==cQuote && c!='\r' ){
21934		- utf8_printf(stderr, "%s:%d: unescaped %c character\n",
21935		- p->zFile, p->nLine, cQuote);
	22682	+ eputf("%s:%d: unescaped %c character\n", p->zFile, p->nLine, cQuote);
21936	22683	}
21937	22684	if( c==EOF ){
21938		- utf8_printf(stderr, "%s:%d: unterminated %c-quoted field\n",
21939		- p->zFile, startLine, cQuote);
	22685	+ eputf("%s:%d: unterminated %c-quoted field\n",
	22686	+ p->zFile, startLine, cQuote);
21940	22687	p->cTerm = c;
21941	22688	break;
21942	22689	}
21943	22690	import_append_char(p, c);
21944	22691	ppc = pc;
		@@ -22032,13 +22779,12 @@
22032	22779
22033	22780	zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable);
22034	22781	shell_check_oom(zQuery);
22035	22782	rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
22036	22783	if( rc ){
22037		- utf8_printf(stderr, "Error %d: %s on [%s]\n",
22038		- sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
22039		- zQuery);
	22784	+ eputf("Error %d: %s on [%s]\n",
	22785	+ sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), zQuery);
22040	22786	goto end_data_xfer;
22041	22787	}
22042	22788	n = sqlite3_column_count(pQuery);
22043	22789	zInsert = sqlite3_malloc64(200 + nTable + n*3);
22044	22790	shell_check_oom(zInsert);
		@@ -22050,13 +22796,12 @@
22050	22796	i += 2;
22051	22797	}
22052	22798	memcpy(zInsert+i, ");", 3);
22053	22799	rc = sqlite3_prepare_v2(newDb, zInsert, -1, &pInsert, 0);
22054	22800	if( rc ){
22055		- utf8_printf(stderr, "Error %d: %s on [%s]\n",
22056		- sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb),
22057		- zInsert);
	22801	+ eputf("Error %d: %s on [%s]\n",
	22802	+ sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb), zInsert);
22058	22803	goto end_data_xfer;
22059	22804	}
22060	22805	for(k=0; k<2; k++){
22061	22806	while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
22062	22807	for(i=0; i<n; i++){
		@@ -22087,12 +22832,12 @@
22087	22832	}
22088	22833	}
22089	22834	} /* End for */
22090	22835	rc = sqlite3_step(pInsert);
22091	22836	if( rc!=SQLITE_OK && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
22092		- utf8_printf(stderr, "Error %d: %s\n", sqlite3_extended_errcode(newDb),
22093		- sqlite3_errmsg(newDb));
	22837	+ eputf("Error %d: %s\n",
	22838	+ sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb));
22094	22839	}
22095	22840	sqlite3_reset(pInsert);
22096	22841	cnt++;
22097	22842	if( (cnt%spinRate)==0 ){
22098	22843	printf("%c\b", "\|/-\\"[(cnt/spinRate)%4]);
		@@ -22105,11 +22850,11 @@
22105	22850	zQuery = sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;",
22106	22851	zTable);
22107	22852	shell_check_oom(zQuery);
22108	22853	rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
22109	22854	if( rc ){
22110		- utf8_printf(stderr, "Warning: cannot step \"%s\" backwards", zTable);
	22855	+ eputf("Warning: cannot step \"%s\" backwards", zTable);
22111	22856	break;
22112	22857	}
22113	22858	} /* End for(k=0...) */
22114	22859
22115	22860	end_data_xfer:
		@@ -22142,62 +22887,60 @@
22142	22887	zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_schema"
22143	22888	" WHERE %s ORDER BY rowid ASC", zWhere);
22144	22889	shell_check_oom(zQuery);
22145	22890	rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
22146	22891	if( rc ){
22147		- utf8_printf(stderr, "Error: (%d) %s on [%s]\n",
22148		- sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
22149		- zQuery);
	22892	+ eputf("Error: (%d) %s on [%s]\n", sqlite3_extended_errcode(p->db),
	22893	+ sqlite3_errmsg(p->db), zQuery);
22150	22894	goto end_schema_xfer;
22151	22895	}
22152	22896	while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
22153	22897	zName = sqlite3_column_text(pQuery, 0);
22154	22898	zSql = sqlite3_column_text(pQuery, 1);
22155	22899	if( zName==0 \|\| zSql==0 ) continue;
22156	22900	if( sqlite3_stricmp((char*)zName, "sqlite_sequence")!=0 ){
22157		- printf("%s... ", zName); fflush(stdout);
	22901	+ sputf(stdout, "%s... ", zName); fflush(stdout);
22158	22902	sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
22159	22903	if( zErrMsg ){
22160		- utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
	22904	+ eputf("Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
22161	22905	sqlite3_free(zErrMsg);
22162	22906	zErrMsg = 0;
22163	22907	}
22164	22908	}
22165	22909	if( xForEach ){
22166	22910	xForEach(p, newDb, (const char*)zName);
22167	22911	}
22168		- printf("done\n");
	22912	+ sputz(stdout, "done\n");
22169	22913	}
22170	22914	if( rc!=SQLITE_DONE ){
22171	22915	sqlite3_finalize(pQuery);
22172	22916	sqlite3_free(zQuery);
22173	22917	zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_schema"
22174	22918	" WHERE %s ORDER BY rowid DESC", zWhere);
22175	22919	shell_check_oom(zQuery);
22176	22920	rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
22177	22921	if( rc ){
22178		- utf8_printf(stderr, "Error: (%d) %s on [%s]\n",
22179		- sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
22180		- zQuery);
	22922	+ eputf("Error: (%d) %s on [%s]\n",
	22923	+ sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), zQuery);
22181	22924	goto end_schema_xfer;
22182	22925	}
22183	22926	while( sqlite3_step(pQuery)==SQLITE_ROW ){
22184	22927	zName = sqlite3_column_text(pQuery, 0);
22185	22928	zSql = sqlite3_column_text(pQuery, 1);
22186	22929	if( zName==0 \|\| zSql==0 ) continue;
22187	22930	if( sqlite3_stricmp((char*)zName, "sqlite_sequence")==0 ) continue;
22188		- printf("%s... ", zName); fflush(stdout);
	22931	+ sputf(stdout, "%s... ", zName); fflush(stdout);
22189	22932	sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
22190	22933	if( zErrMsg ){
22191		- utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
	22934	+ eputf("Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
22192	22935	sqlite3_free(zErrMsg);
22193	22936	zErrMsg = 0;
22194	22937	}
22195	22938	if( xForEach ){
22196	22939	xForEach(p, newDb, (const char*)zName);
22197	22940	}
22198		- printf("done\n");
	22941	+ sputz(stdout, "done\n");
22199	22942	}
22200	22943	}
22201	22944	end_schema_xfer:
22202	22945	sqlite3_finalize(pQuery);
22203	22946	sqlite3_free(zQuery);
		@@ -22210,17 +22953,16 @@
22210	22953	*/
22211	22954	static void tryToClone(ShellState p, const char zNewDb){
22212	22955	int rc;
22213	22956	sqlite3 *newDb = 0;
22214	22957	if( access(zNewDb,0)==0 ){
22215		- utf8_printf(stderr, "File \"%s\" already exists.\n", zNewDb);
	22958	+ eputf("File \"%s\" already exists.\n", zNewDb);
22216	22959	return;
22217	22960	}
22218	22961	rc = sqlite3_open(zNewDb, &newDb);
22219	22962	if( rc ){
22220		- utf8_printf(stderr, "Cannot create output database: %s\n",
22221		- sqlite3_errmsg(newDb));
	22963	+ eputf("Cannot create output database: %s\n", sqlite3_errmsg(newDb));
22222	22964	}else{
22223	22965	sqlite3_exec(p->db, "PRAGMA writable_schema=ON;", 0, 0, 0);
22224	22966	sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0);
22225	22967	tryToCloneSchema(p, newDb, "type='table'", tryToCloneData);
22226	22968	tryToCloneSchema(p, newDb, "type!='table'", 0);
		@@ -22227,10 +22969,22 @@
22227	22969	sqlite3_exec(newDb, "COMMIT;", 0, 0, 0);
22228	22970	sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
22229	22971	}
22230	22972	close_db(newDb);
22231	22973	}
	22974	+
	22975	+#ifndef SQLITE_SHELL_FIDDLE
	22976	+/*
	22977	+** Change the output stream (file or pipe or console) to something else.
	22978	+*/
	22979	+static void output_redir(ShellState p, FILE pfNew){
	22980	+ if( p->out != stdout ) eputz("Output already redirected.\n");
	22981	+ else{
	22982	+ p->out = pfNew;
	22983	+ setOutputStream(pfNew);
	22984	+ }
	22985	+}
22232	22986
22233	22987	/*
22234	22988	** Change the output file back to stdout.
22235	22989	**
22236	22990	** If the p->doXdgOpen flag is set, that means the output was being
		@@ -22255,11 +23009,11 @@
22255	23009	"xdg-open";
22256	23010	#endif
22257	23011	char *zCmd;
22258	23012	zCmd = sqlite3_mprintf("%s %s", zXdgOpenCmd, p->zTempFile);
22259	23013	if( system(zCmd) ){
22260		- utf8_printf(stderr, "Failed: [%s]\n", zCmd);
	23014	+ eputf("Failed: [%s]\n", zCmd);
22261	23015	}else{
22262	23016	/* Give the start/open/xdg-open command some time to get
22263	23017	** going before we continue, and potential delete the
22264	23018	** p->zTempFile data file out from under it */
22265	23019	sqlite3_sleep(2000);
		@@ -22270,11 +23024,16 @@
22270	23024	}
22271	23025	#endif /* !defined(SQLITE_NOHAVE_SYSTEM) */
22272	23026	}
22273	23027	p->outfile[0] = 0;
22274	23028	p->out = stdout;
	23029	+ setOutputStream(stdout);
22275	23030	}
	23031	+#else
	23032	+# define output_redir(SS,pfO)
	23033	+# define output_reset(SS)
	23034	+#endif
22276	23035
22277	23036	/*
22278	23037	** Run an SQL command and return the single integer result.
22279	23038	*/
22280	23039	static int db_int(sqlite3 db, const char zSql){
		@@ -22341,11 +23100,11 @@
22341	23100	if( p->db==0 ) return 1;
22342	23101	rc = sqlite3_prepare_v2(p->db,
22343	23102	"SELECT data FROM sqlite_dbpage(?1) WHERE pgno=1",
22344	23103	-1, &pStmt, 0);
22345	23104	if( rc ){
22346		- utf8_printf(stderr, "error: %s\n", sqlite3_errmsg(p->db));
	23105	+ eputf("error: %s\n", sqlite3_errmsg(p->db));
22347	23106	sqlite3_finalize(pStmt);
22348	23107	return 1;
22349	23108	}
22350	23109	sqlite3_bind_text(pStmt, 1, zDb, -1, SQLITE_STATIC);
22351	23110	if( sqlite3_step(pStmt)==SQLITE_ROW
		@@ -22354,32 +23113,32 @@
22354	23113	const u8 *pb = sqlite3_column_blob(pStmt,0);
22355	23114	shell_check_oom(pb);
22356	23115	memcpy(aHdr, pb, 100);
22357	23116	sqlite3_finalize(pStmt);
22358	23117	}else{
22359		- raw_printf(stderr, "unable to read database header\n");
	23118	+ eputz("unable to read database header\n");
22360	23119	sqlite3_finalize(pStmt);
22361	23120	return 1;
22362	23121	}
22363	23122	i = get2byteInt(aHdr+16);
22364	23123	if( i==1 ) i = 65536;
22365		- utf8_printf(p->out, "%-20s %d\n", "database page size:", i);
22366		- utf8_printf(p->out, "%-20s %d\n", "write format:", aHdr[18]);
22367		- utf8_printf(p->out, "%-20s %d\n", "read format:", aHdr[19]);
22368		- utf8_printf(p->out, "%-20s %d\n", "reserved bytes:", aHdr[20]);
	23124	+ oputf("%-20s %d\n", "database page size:", i);
	23125	+ oputf("%-20s %d\n", "write format:", aHdr[18]);
	23126	+ oputf("%-20s %d\n", "read format:", aHdr[19]);
	23127	+ oputf("%-20s %d\n", "reserved bytes:", aHdr[20]);
22369	23128	for(i=0; i<ArraySize(aField); i++){
22370	23129	int ofst = aField[i].ofst;
22371	23130	unsigned int val = get4byteInt(aHdr + ofst);
22372		- utf8_printf(p->out, "%-20s %u", aField[i].zName, val);
	23131	+ oputf("%-20s %u", aField[i].zName, val);
22373	23132	switch( ofst ){
22374	23133	case 56: {
22375		- if( val==1 ) raw_printf(p->out, " (utf8)");
22376		- if( val==2 ) raw_printf(p->out, " (utf16le)");
22377		- if( val==3 ) raw_printf(p->out, " (utf16be)");
	23134	+ if( val==1 ) oputz(" (utf8)");
	23135	+ if( val==2 ) oputz(" (utf16le)");
	23136	+ if( val==3 ) oputz(" (utf16be)");
22378	23137	}
22379	23138	}
22380		- raw_printf(p->out, "\n");
	23139	+ oputz("\n");
22381	23140	}
22382	23141	if( zDb==0 ){
22383	23142	zSchemaTab = sqlite3_mprintf("main.sqlite_schema");
22384	23143	}else if( cli_strcmp(zDb,"temp")==0 ){
22385	23144	zSchemaTab = sqlite3_mprintf("%s", "sqlite_temp_schema");
		@@ -22388,25 +23147,25 @@
22388	23147	}
22389	23148	for(i=0; i<ArraySize(aQuery); i++){
22390	23149	char *zSql = sqlite3_mprintf(aQuery[i].zSql, zSchemaTab);
22391	23150	int val = db_int(p->db, zSql);
22392	23151	sqlite3_free(zSql);
22393		- utf8_printf(p->out, "%-20s %d\n", aQuery[i].zName, val);
	23152	+ oputf("%-20s %d\n", aQuery[i].zName, val);
22394	23153	}
22395	23154	sqlite3_free(zSchemaTab);
22396	23155	sqlite3_file_control(p->db, zDb, SQLITE_FCNTL_DATA_VERSION, &iDataVersion);
22397		- utf8_printf(p->out, "%-20s %u\n", "data version", iDataVersion);
	23156	+ oputf("%-20s %u\n", "data version", iDataVersion);
22398	23157	return 0;
22399	23158	}
22400	23159	#endif /* SQLITE_SHELL_HAVE_RECOVER */
22401	23160
22402	23161	/*
22403	23162	** Print the current sqlite3_errmsg() value to stderr and return 1.
22404	23163	*/
22405	23164	static int shellDatabaseError(sqlite3 *db){
22406	23165	const char *zErr = sqlite3_errmsg(db);
22407		- utf8_printf(stderr, "Error: %s\n", zErr);
	23166	+ eputf("Error: %s\n", zErr);
22408	23167	return 1;
22409	23168	}
22410	23169
22411	23170	/*
22412	23171	** Compare the pattern in zGlob[] against the text in z[]. Return TRUE
		@@ -22637,11 +23396,10 @@
22637	23396	ShellState pState, / Current shell tool state */
22638	23397	char *azArg, / Array of arguments passed to dot command */
22639	23398	int nArg /* Number of entries in azArg[] */
22640	23399	){
22641	23400	sqlite3 db = pState->db; / Database handle to query "main" db of */
22642		- FILE out = pState->out; / Stream to write non-error output to */
22643	23401	int bVerbose = 0; /* If -verbose is present */
22644	23402	int bGroupByParent = 0; /* If -groupbyparent is present */
22645	23403	int i; /* To iterate through azArg[] */
22646	23404	const char zIndent = ""; / How much to indent CREATE INDEX by */
22647	23405	int rc; /* Return code */
		@@ -22719,13 +23477,11 @@
22719	23477	else if( n>1 && sqlite3_strnicmp("-groupbyparent", azArg[i], n)==0 ){
22720	23478	bGroupByParent = 1;
22721	23479	zIndent = " ";
22722	23480	}
22723	23481	else{
22724		- raw_printf(stderr, "Usage: %s %s ?-verbose? ?-groupbyparent?\n",
22725		- azArg[0], azArg[1]
22726		- );
	23482	+ eputf("Usage: %s %s ?-verbose? ?-groupbyparent?\n", azArg[0], azArg[1]);
22727	23483	return SQLITE_ERROR;
22728	23484	}
22729	23485	}
22730	23486
22731	23487	/* Register the fkey_collate_clause() SQL function */
		@@ -22765,44 +23521,44 @@
22765	23521	}
22766	23522	rc = sqlite3_finalize(pExplain);
22767	23523	if( rc!=SQLITE_OK ) break;
22768	23524
22769	23525	if( res<0 ){
22770		- raw_printf(stderr, "Error: internal error");
	23526	+ eputz("Error: internal error");
22771	23527	break;
22772	23528	}else{
22773	23529	if( bGroupByParent
22774	23530	&& (bVerbose \|\| res==0)
22775	23531	&& (zPrev==0 \|\| sqlite3_stricmp(zParent, zPrev))
22776	23532	){
22777		- raw_printf(out, "-- Parent table %s\n", zParent);
	23533	+ oputf("-- Parent table %s\n", zParent);
22778	23534	sqlite3_free(zPrev);
22779	23535	zPrev = sqlite3_mprintf("%s", zParent);
22780	23536	}
22781	23537
22782	23538	if( res==0 ){
22783		- raw_printf(out, "%s%s --> %s\n", zIndent, zCI, zTarget);
	23539	+ oputf("%s%s --> %s\n", zIndent, zCI, zTarget);
22784	23540	}else if( bVerbose ){
22785		- raw_printf(out, "%s/* no extra indexes required for %s -> %s */\n",
22786		- zIndent, zFrom, zTarget
	23541	+ oputf("%s/* no extra indexes required for %s -> %s */\n",
	23542	+ zIndent, zFrom, zTarget
22787	23543	);
22788	23544	}
22789	23545	}
22790	23546	}
22791	23547	sqlite3_free(zPrev);
22792	23548
22793	23549	if( rc!=SQLITE_OK ){
22794		- raw_printf(stderr, "%s\n", sqlite3_errmsg(db));
	23550	+ eputf("%s\n", sqlite3_errmsg(db));
22795	23551	}
22796	23552
22797	23553	rc2 = sqlite3_finalize(pSql);
22798	23554	if( rc==SQLITE_OK && rc2!=SQLITE_OK ){
22799	23555	rc = rc2;
22800		- raw_printf(stderr, "%s\n", sqlite3_errmsg(db));
	23556	+ eputf("%s\n", sqlite3_errmsg(db));
22801	23557	}
22802	23558	}else{
22803		- raw_printf(stderr, "%s\n", sqlite3_errmsg(db));
	23559	+ eputf("%s\n", sqlite3_errmsg(db));
22804	23560	}
22805	23561
22806	23562	return rc;
22807	23563	}
22808	23564
		@@ -22818,13 +23574,13 @@
22818	23574	n = (nArg>=2 ? strlen30(azArg[1]) : 0);
22819	23575	if( n<1 \|\| sqlite3_strnicmp(azArg[1], "fkey-indexes", n) ) goto usage;
22820	23576	return lintFkeyIndexes(pState, azArg, nArg);
22821	23577
22822	23578	usage:
22823		- raw_printf(stderr, "Usage %s sub-command ?switches...?\n", azArg[0]);
22824		- raw_printf(stderr, "Where sub-commands are:\n");
22825		- raw_printf(stderr, " fkey-indexes\n");
	23579	+ eputf("Usage %s sub-command ?switches...?\n", azArg[0]);
	23580	+ eputz("Where sub-commands are:\n");
	23581	+ eputz(" fkey-indexes\n");
22826	23582	return SQLITE_ERROR;
22827	23583	}
22828	23584
22829	23585	#if !defined SQLITE_OMIT_VIRTUALTABLE
22830	23586	static void shellPrepare(
		@@ -22835,13 +23591,11 @@
22835	23591	){
22836	23592	*ppStmt = 0;
22837	23593	if( *pRc==SQLITE_OK ){
22838	23594	int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0);
22839	23595	if( rc!=SQLITE_OK ){
22840		- raw_printf(stderr, "sql error: %s (%d)\n",
22841		- sqlite3_errmsg(db), sqlite3_errcode(db)
22842		- );
	23596	+ eputf("sql error: %s (%d)\n", sqlite3_errmsg(db), sqlite3_errcode(db));
22843	23597	*pRc = rc;
22844	23598	}
22845	23599	}
22846	23600	}
22847	23601
		@@ -22888,11 +23642,11 @@
22888	23642	if( pStmt ){
22889	23643	sqlite3 *db = sqlite3_db_handle(pStmt);
22890	23644	int rc = sqlite3_finalize(pStmt);
22891	23645	if( *pRc==SQLITE_OK ){
22892	23646	if( rc!=SQLITE_OK ){
22893		- raw_printf(stderr, "SQL error: %s\n", sqlite3_errmsg(db));
	23647	+ eputf("SQL error: %s\n", sqlite3_errmsg(db));
22894	23648	}
22895	23649	*pRc = rc;
22896	23650	}
22897	23651	}
22898	23652	}
		@@ -22909,11 +23663,11 @@
22909	23663	){
22910	23664	int rc = sqlite3_reset(pStmt);
22911	23665	if( *pRc==SQLITE_OK ){
22912	23666	if( rc!=SQLITE_OK ){
22913	23667	sqlite3 *db = sqlite3_db_handle(pStmt);
22914		- raw_printf(stderr, "SQL error: %s\n", sqlite3_errmsg(db));
	23668	+ eputf("SQL error: %s\n", sqlite3_errmsg(db));
22915	23669	}
22916	23670	*pRc = rc;
22917	23671	}
22918	23672	}
22919	23673	#endif /* !defined SQLITE_OMIT_VIRTUALTABLE */
		@@ -22959,15 +23713,15 @@
22959	23713	va_list ap;
22960	23714	char *z;
22961	23715	va_start(ap, zFmt);
22962	23716	z = sqlite3_vmprintf(zFmt, ap);
22963	23717	va_end(ap);
22964		- utf8_printf(stderr, "Error: %s\n", z);
	23718	+ eputf("Error: %s\n", z);
22965	23719	if( pAr->fromCmdLine ){
22966		- utf8_printf(stderr, "Use \"-A\" for more help\n");
	23720	+ eputz("Use \"-A\" for more help\n");
22967	23721	}else{
22968		- utf8_printf(stderr, "Use \".archive --help\" for more help\n");
	23722	+ eputz("Use \".archive --help\" for more help\n");
22969	23723	}
22970	23724	sqlite3_free(z);
22971	23725	return SQLITE_ERROR;
22972	23726	}
22973	23727
		@@ -23063,11 +23817,11 @@
23063	23817	};
23064	23818	int nSwitch = sizeof(aSwitch) / sizeof(struct ArSwitch);
23065	23819	struct ArSwitch *pEnd = &aSwitch[nSwitch];
23066	23820
23067	23821	if( nArg<=1 ){
23068		- utf8_printf(stderr, "Wrong number of arguments. Usage:\n");
	23822	+ eputz("Wrong number of arguments. Usage:\n");
23069	23823	return arUsage(stderr);
23070	23824	}else{
23071	23825	char *z = azArg[1];
23072	23826	if( z[0]!='-' ){
23073	23827	/* Traditional style [tar] invocation */
		@@ -23169,11 +23923,11 @@
23169	23923	}
23170	23924	}
23171	23925	}
23172	23926	}
23173	23927	if( pAr->eCmd==0 ){
23174		- utf8_printf(stderr, "Required argument missing. Usage:\n");
	23928	+ eputz("Required argument missing. Usage:\n");
23175	23929	return arUsage(stderr);
23176	23930	}
23177	23931	return SQLITE_OK;
23178	23932	}
23179	23933
		@@ -23212,11 +23966,11 @@
23212	23966	if( SQLITE_ROW==sqlite3_step(pTest) ){
23213	23967	bOk = 1;
23214	23968	}
23215	23969	shellReset(&rc, pTest);
23216	23970	if( rc==SQLITE_OK && bOk==0 ){
23217		- utf8_printf(stderr, "not found in archive: %s\n", z);
	23971	+ eputf("not found in archive: %s\n", z);
23218	23972	rc = SQLITE_ERROR;
23219	23973	}
23220	23974	}
23221	23975	shellFinalize(&rc, pTest);
23222	23976	}
		@@ -23279,30 +24033,26 @@
23279	24033	arWhereClause(&rc, pAr, &zWhere);
23280	24034
23281	24035	shellPreparePrintf(pAr->db, &rc, &pSql, zSql, azCols[pAr->bVerbose],
23282	24036	pAr->zSrcTable, zWhere);
23283	24037	if( pAr->bDryRun ){
23284		- utf8_printf(pAr->p->out, "%s\n", sqlite3_sql(pSql));
	24038	+ oputf("%s\n", sqlite3_sql(pSql));
23285	24039	}else{
23286	24040	while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){
23287	24041	if( pAr->bVerbose ){
23288		- utf8_printf(pAr->p->out, "%s % 10d %s %s\n",
23289		- sqlite3_column_text(pSql, 0),
23290		- sqlite3_column_int(pSql, 1),
23291		- sqlite3_column_text(pSql, 2),
23292		- sqlite3_column_text(pSql, 3)
23293		- );
	24042	+ oputf("%s % 10d %s %s\n",
	24043	+ sqlite3_column_text(pSql, 0), sqlite3_column_int(pSql, 1),
	24044	+ sqlite3_column_text(pSql, 2),sqlite3_column_text(pSql, 3));
23294	24045	}else{
23295		- utf8_printf(pAr->p->out, "%s\n", sqlite3_column_text(pSql, 0));
	24046	+ oputf("%s\n", sqlite3_column_text(pSql, 0));
23296	24047	}
23297	24048	}
23298	24049	}
23299	24050	shellFinalize(&rc, pSql);
23300	24051	sqlite3_free(zWhere);
23301	24052	return rc;
23302	24053	}
23303		-
23304	24054
23305	24055	/*
23306	24056	** Implementation of .ar "Remove" command.
23307	24057	*/
23308	24058	static int arRemoveCommand(ArCommand *pAr){
		@@ -23318,11 +24068,11 @@
23318	24068	}
23319	24069	if( rc==SQLITE_OK ){
23320	24070	zSql = sqlite3_mprintf("DELETE FROM %s WHERE %s;",
23321	24071	pAr->zSrcTable, zWhere);
23322	24072	if( pAr->bDryRun ){
23323		- utf8_printf(pAr->p->out, "%s\n", zSql);
	24073	+ oputf("%s\n", zSql);
23324	24074	}else{
23325	24075	char *zErr = 0;
23326	24076	rc = sqlite3_exec(pAr->db, "SAVEPOINT ar;", 0, 0, 0);
23327	24077	if( rc==SQLITE_OK ){
23328	24078	rc = sqlite3_exec(pAr->db, zSql, 0, 0, &zErr);
		@@ -23331,11 +24081,11 @@
23331	24081	}else{
23332	24082	rc = sqlite3_exec(pAr->db, "RELEASE ar;", 0, 0, 0);
23333	24083	}
23334	24084	}
23335	24085	if( zErr ){
23336		- utf8_printf(stdout, "ERROR: %s\n", zErr);
	24086	+ sputf(stdout, "ERROR: %s\n", zErr); /* stdout? */
23337	24087	sqlite3_free(zErr);
23338	24088	}
23339	24089	}
23340	24090	}
23341	24091	sqlite3_free(zWhere);
		@@ -23395,15 +24145,15 @@
23395	24145	** populating them changes the timestamp). */
23396	24146	for(i=0; i<2; i++){
23397	24147	j = sqlite3_bind_parameter_index(pSql, "$dirOnly");
23398	24148	sqlite3_bind_int(pSql, j, i);
23399	24149	if( pAr->bDryRun ){
23400		- utf8_printf(pAr->p->out, "%s\n", sqlite3_sql(pSql));
	24150	+ oputf("%s\n", sqlite3_sql(pSql));
23401	24151	}else{
23402	24152	while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){
23403	24153	if( i==0 && pAr->bVerbose ){
23404		- utf8_printf(pAr->p->out, "%s\n", sqlite3_column_text(pSql, 0));
	24154	+ oputf("%s\n", sqlite3_column_text(pSql, 0));
23405	24155	}
23406	24156	}
23407	24157	}
23408	24158	shellReset(&rc, pSql);
23409	24159	}
		@@ -23419,17 +24169,17 @@
23419	24169	** Run the SQL statement in zSql. Or if doing a --dryrun, merely print it out.
23420	24170	*/
23421	24171	static int arExecSql(ArCommand pAr, const char zSql){
23422	24172	int rc;
23423	24173	if( pAr->bDryRun ){
23424		- utf8_printf(pAr->p->out, "%s\n", zSql);
	24174	+ oputf("%s\n", zSql);
23425	24175	rc = SQLITE_OK;
23426	24176	}else{
23427	24177	char *zErr = 0;
23428	24178	rc = sqlite3_exec(pAr->db, zSql, 0, 0, &zErr);
23429	24179	if( zErr ){
23430		- utf8_printf(stdout, "ERROR: %s\n", zErr);
	24180	+ sputf(stdout, "ERROR: %s\n", zErr);
23431	24181	sqlite3_free(zErr);
23432	24182	}
23433	24183	}
23434	24184	return rc;
23435	24185	}
		@@ -23600,19 +24350,17 @@
23600	24350	}else{
23601	24351	flags = SQLITE_OPEN_READONLY;
23602	24352	}
23603	24353	cmd.db = 0;
23604	24354	if( cmd.bDryRun ){
23605		- utf8_printf(pState->out, "-- open database '%s'%s\n", cmd.zFile,
23606		- eDbType==SHELL_OPEN_APPENDVFS ? " using 'apndvfs'" : "");
	24355	+ oputf("-- open database '%s'%s\n", cmd.zFile,
	24356	+ eDbType==SHELL_OPEN_APPENDVFS ? " using 'apndvfs'" : "");
23607	24357	}
23608	24358	rc = sqlite3_open_v2(cmd.zFile, &cmd.db, flags,
23609	24359	eDbType==SHELL_OPEN_APPENDVFS ? "apndvfs" : 0);
23610	24360	if( rc!=SQLITE_OK ){
23611		- utf8_printf(stderr, "cannot open file: %s (%s)\n",
23612		- cmd.zFile, sqlite3_errmsg(cmd.db)
23613		- );
	24361	+ eputf("cannot open file: %s (%s)\n", cmd.zFile, sqlite3_errmsg(cmd.db));
23614	24362	goto end_ar_command;
23615	24363	}
23616	24364	sqlite3_fileio_init(cmd.db, 0, 0);
23617	24365	sqlite3_sqlar_init(cmd.db, 0, 0);
23618	24366	sqlite3_create_function(cmd.db, "shell_putsnl", 1, SQLITE_UTF8, cmd.p,
		@@ -23621,11 +24369,11 @@
23621	24369	}
23622	24370	if( cmd.zSrcTable==0 && cmd.bZip==0 && cmd.eCmd!=AR_CMD_HELP ){
23623	24371	if( cmd.eCmd!=AR_CMD_CREATE
23624	24372	&& sqlite3_table_column_metadata(cmd.db,0,"sqlar","name",0,0,0,0,0)
23625	24373	){
23626		- utf8_printf(stderr, "database does not contain an 'sqlar' table\n");
	24374	+ eputz("database does not contain an 'sqlar' table\n");
23627	24375	rc = SQLITE_ERROR;
23628	24376	goto end_ar_command;
23629	24377	}
23630	24378	cmd.zSrcTable = sqlite3_mprintf("sqlar");
23631	24379	}
		@@ -23679,11 +24427,11 @@
23679	24427	** This function is used as a callback by the recover extension. Simply
23680	24428	** print the supplied SQL statement to stdout.
23681	24429	*/
23682	24430	static int recoverSqlCb(void pCtx, const char zSql){
23683	24431	ShellState pState = (ShellState)pCtx;
23684		- utf8_printf(pState->out, "%s;\n", zSql);
	24432	+ sputf(pState->out, "%s;\n", zSql);
23685	24433	return SQLITE_OK;
23686	24434	}
23687	24435
23688	24436	/*
23689	24437	** This function is called to recover data from the database. A script
		@@ -23722,11 +24470,11 @@
23722	24470	}else
23723	24471	if( n<=10 && memcmp("-no-rowids", z, n)==0 ){
23724	24472	bRowids = 0;
23725	24473	}
23726	24474	else{
23727		- utf8_printf(stderr, "unexpected option: %s\n", azArg[i]);
	24475	+ eputf("unexpected option: %s\n", azArg[i]);
23728	24476	showHelp(pState->out, azArg[0]);
23729	24477	return 1;
23730	24478	}
23731	24479	}
23732	24480
		@@ -23741,11 +24489,11 @@
23741	24489
23742	24490	sqlite3_recover_run(p);
23743	24491	if( sqlite3_recover_errcode(p)!=SQLITE_OK ){
23744	24492	const char *zErr = sqlite3_recover_errmsg(p);
23745	24493	int errCode = sqlite3_recover_errcode(p);
23746		- raw_printf(stderr, "sql error: %s (%d)\n", zErr, errCode);
	24494	+ eputf("sql error: %s (%d)\n", zErr, errCode);
23747	24495	}
23748	24496	rc = sqlite3_recover_finish(p);
23749	24497	return rc;
23750	24498	}
23751	24499	#endif /* SQLITE_SHELL_HAVE_RECOVER */
		@@ -23766,11 +24514,11 @@
23766	24514	*/
23767	24515	#ifdef SHELL_DEBUG
23768	24516	#define rc_err_oom_die(rc) \
23769	24517	if( rc==SQLITE_NOMEM ) shell_check_oom(0); \
23770	24518	else if(!(rc==SQLITE_OK\|\|rc==SQLITE_DONE)) \
23771		- fprintf(stderr,"E:%d\n",rc), assert(0)
	24519	+ eputf("E:%d\n",rc), assert(0)
23772	24520	#else
23773	24521	static void rc_err_oom_die(int rc){
23774	24522	if( rc==SQLITE_NOMEM ) shell_check_oom(0);
23775	24523	assert(rc==SQLITE_OK\|\|rc==SQLITE_DONE);
23776	24524	}
		@@ -23906,10 +24654,11 @@
23906	24654	#ifdef SHELL_COLFIX_DB
23907	24655	if(*zCOL_DB!=':')
23908	24656	sqlite3_exec(*pDb,"drop table if exists ColNames;"
23909	24657	"drop view if exists RepeatedNames;",0,0,0);
23910	24658	#endif
	24659	+#undef SHELL_COLFIX_DB
23911	24660	rc = sqlite3_exec(*pDb, zTabMake, 0, 0, 0);
23912	24661	rc_err_oom_die(rc);
23913	24662	}
23914	24663	assert(*pDb!=0);
23915	24664	rc = sqlite3_prepare_v2(*pDb, zTabFill, -1, &pStmt, 0);
		@@ -24019,11 +24768,11 @@
24019	24768	clearTempFile(p);
24020	24769
24021	24770	#ifndef SQLITE_OMIT_AUTHORIZATION
24022	24771	if( c=='a' && cli_strncmp(azArg[0], "auth", n)==0 ){
24023	24772	if( nArg!=2 ){
24024		- raw_printf(stderr, "Usage: .auth ON\|OFF\n");
	24773	+ eputz("Usage: .auth ON\|OFF\n");
24025	24774	rc = 1;
24026	24775	goto meta_command_exit;
24027	24776	}
24028	24777	open_db(p, 0);
24029	24778	if( booleanValue(azArg[1]) ){
		@@ -24066,32 +24815,32 @@
24066	24815	}else
24067	24816	if( cli_strcmp(z, "-async")==0 ){
24068	24817	bAsync = 1;
24069	24818	}else
24070	24819	{
24071		- utf8_printf(stderr, "unknown option: %s\n", azArg[j]);
	24820	+ eputf("unknown option: %s\n", azArg[j]);
24072	24821	return 1;
24073	24822	}
24074	24823	}else if( zDestFile==0 ){
24075	24824	zDestFile = azArg[j];
24076	24825	}else if( zDb==0 ){
24077	24826	zDb = zDestFile;
24078	24827	zDestFile = azArg[j];
24079	24828	}else{
24080		- raw_printf(stderr, "Usage: .backup ?DB? ?OPTIONS? FILENAME\n");
	24829	+ eputz("Usage: .backup ?DB? ?OPTIONS? FILENAME\n");
24081	24830	return 1;
24082	24831	}
24083	24832	}
24084	24833	if( zDestFile==0 ){
24085		- raw_printf(stderr, "missing FILENAME argument on .backup\n");
	24834	+ eputz("missing FILENAME argument on .backup\n");
24086	24835	return 1;
24087	24836	}
24088	24837	if( zDb==0 ) zDb = "main";
24089	24838	rc = sqlite3_open_v2(zDestFile, &pDest,
24090	24839	SQLITE_OPEN_READWRITE\|SQLITE_OPEN_CREATE, zVfs);
24091	24840	if( rc!=SQLITE_OK ){
24092		- utf8_printf(stderr, "Error: cannot open \"%s\"\n", zDestFile);
	24841	+ eputf("Error: cannot open \"%s\"\n", zDestFile);
24093	24842	close_db(pDest);
24094	24843	return 1;
24095	24844	}
24096	24845	if( bAsync ){
24097	24846	sqlite3_exec(pDest, "PRAGMA synchronous=OFF; PRAGMA journal_mode=OFF;",
		@@ -24098,20 +24847,20 @@
24098	24847	0, 0, 0);
24099	24848	}
24100	24849	open_db(p, 0);
24101	24850	pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
24102	24851	if( pBackup==0 ){
24103		- utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
	24852	+ eputf("Error: %s\n", sqlite3_errmsg(pDest));
24104	24853	close_db(pDest);
24105	24854	return 1;
24106	24855	}
24107	24856	while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
24108	24857	sqlite3_backup_finish(pBackup);
24109	24858	if( rc==SQLITE_DONE ){
24110	24859	rc = 0;
24111	24860	}else{
24112		- utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
	24861	+ eputf("Error: %s\n", sqlite3_errmsg(pDest));
24113	24862	rc = 1;
24114	24863	}
24115	24864	close_db(pDest);
24116	24865	}else
24117	24866	#endif /* !defined(SQLITE_SHELL_FIDDLE) */
		@@ -24118,11 +24867,11 @@
24118	24867
24119	24868	if( c=='b' && n>=3 && cli_strncmp(azArg[0], "bail", n)==0 ){
24120	24869	if( nArg==2 ){
24121	24870	bail_on_error = booleanValue(azArg[1]);
24122	24871	}else{
24123		- raw_printf(stderr, "Usage: .bail on\|off\n");
	24872	+ eputz("Usage: .bail on\|off\n");
24124	24873	rc = 1;
24125	24874	}
24126	24875	}else
24127	24876
24128	24877	/* Undocumented. Legacy only. See "crnl" below */
		@@ -24132,13 +24881,12 @@
24132	24881	setBinaryMode(p->out, 1);
24133	24882	}else{
24134	24883	setTextMode(p->out, 1);
24135	24884	}
24136	24885	}else{
24137		- raw_printf(stderr, "The \".binary\" command is deprecated."
24138		- " Use \".crnl\" instead.\n");
24139		- raw_printf(stderr, "Usage: .binary on\|off\n");
	24886	+ eputz("The \".binary\" command is deprecated. Use \".crnl\" instead.\n"
	24887	+ "Usage: .binary on\|off\n");
24140	24888	rc = 1;
24141	24889	}
24142	24890	}else
24143	24891
24144	24892	/* The undocumented ".breakpoint" command causes a call to the no-op
		@@ -24158,25 +24906,25 @@
24158	24906	sqlite3_free(z);
24159	24907	#else
24160	24908	rc = chdir(azArg[1]);
24161	24909	#endif
24162	24910	if( rc ){
24163		- utf8_printf(stderr, "Cannot change to directory \"%s\"\n", azArg[1]);
	24911	+ eputf("Cannot change to directory \"%s\"\n", azArg[1]);
24164	24912	rc = 1;
24165	24913	}
24166	24914	}else{
24167		- raw_printf(stderr, "Usage: .cd DIRECTORY\n");
	24915	+ eputz("Usage: .cd DIRECTORY\n");
24168	24916	rc = 1;
24169	24917	}
24170	24918	}else
24171	24919	#endif /* !defined(SQLITE_SHELL_FIDDLE) */
24172	24920
24173	24921	if( c=='c' && n>=3 && cli_strncmp(azArg[0], "changes", n)==0 ){
24174	24922	if( nArg==2 ){
24175	24923	setOrClearFlag(p, SHFLG_CountChanges, azArg[1]);
24176	24924	}else{
24177		- raw_printf(stderr, "Usage: .changes on\|off\n");
	24925	+ eputz("Usage: .changes on\|off\n");
24178	24926	rc = 1;
24179	24927	}
24180	24928	}else
24181	24929
24182	24930	#ifndef SQLITE_SHELL_FIDDLE
		@@ -24186,21 +24934,20 @@
24186	24934	*/
24187	24935	if( c=='c' && n>=3 && cli_strncmp(azArg[0], "check", n)==0 ){
24188	24936	char *zRes = 0;
24189	24937	output_reset(p);
24190	24938	if( nArg!=2 ){
24191		- raw_printf(stderr, "Usage: .check GLOB-PATTERN\n");
	24939	+ eputz("Usage: .check GLOB-PATTERN\n");
24192	24940	rc = 2;
24193	24941	}else if( (zRes = readFile("testcase-out.txt", 0))==0 ){
24194	24942	rc = 2;
24195	24943	}else if( testcase_glob(azArg[1],zRes)==0 ){
24196		- utf8_printf(stderr,
24197		- "testcase-%s FAILED\n Expected: [%s]\n Got: [%s]\n",
24198		- p->zTestcase, azArg[1], zRes);
	24944	+ eputf("testcase-%s FAILED\n Expected: [%s]\n Got: [%s]\n",
	24945	+ p->zTestcase, azArg[1], zRes);
24199	24946	rc = 1;
24200	24947	}else{
24201		- utf8_printf(stdout, "testcase-%s ok\n", p->zTestcase);
	24948	+ oputf("testcase-%s ok\n", p->zTestcase);
24202	24949	p->nCheck++;
24203	24950	}
24204	24951	sqlite3_free(zRes);
24205	24952	}else
24206	24953	#endif /* !defined(SQLITE_SHELL_FIDDLE) */
		@@ -24209,11 +24956,11 @@
24209	24956	if( c=='c' && cli_strncmp(azArg[0], "clone", n)==0 ){
24210	24957	failIfSafeMode(p, "cannot run .clone in safe mode");
24211	24958	if( nArg==2 ){
24212	24959	tryToClone(p, azArg[1]);
24213	24960	}else{
24214		- raw_printf(stderr, "Usage: .clone FILENAME\n");
	24961	+ eputz("Usage: .clone FILENAME\n");
24215	24962	rc = 1;
24216	24963	}
24217	24964	}else
24218	24965	#endif /* !defined(SQLITE_SHELL_FIDDLE) */
24219	24966
		@@ -24229,13 +24976,13 @@
24229	24976	zFile = "(memory)";
24230	24977	}else if( zFile[0]==0 ){
24231	24978	zFile = "(temporary-file)";
24232	24979	}
24233	24980	if( p->pAuxDb == &p->aAuxDb[i] ){
24234		- utf8_printf(stdout, "ACTIVE %d: %s\n", i, zFile);
	24981	+ sputf(stdout, "ACTIVE %d: %s\n", i, zFile);
24235	24982	}else if( p->aAuxDb[i].db!=0 ){
24236		- utf8_printf(stdout, " %d: %s\n", i, zFile);
	24983	+ sputf(stdout, " %d: %s\n", i, zFile);
24237	24984	}
24238	24985	}
24239	24986	}else if( nArg==2 && IsDigit(azArg[1][0]) && azArg[1][1]==0 ){
24240	24987	int i = azArg[1][0] - '0';
24241	24988	if( p->pAuxDb != &p->aAuxDb[i] && i>=0 && i<ArraySize(p->aAuxDb) ){
		@@ -24248,19 +24995,19 @@
24248	24995	&& IsDigit(azArg[2][0]) && azArg[2][1]==0 ){
24249	24996	int i = azArg[2][0] - '0';
24250	24997	if( i<0 \|\| i>=ArraySize(p->aAuxDb) ){
24251	24998	/* No-op */
24252	24999	}else if( p->pAuxDb == &p->aAuxDb[i] ){
24253		- raw_printf(stderr, "cannot close the active database connection\n");
	25000	+ eputz("cannot close the active database connection\n");
24254	25001	rc = 1;
24255	25002	}else if( p->aAuxDb[i].db ){
24256	25003	session_close_all(p, i);
24257	25004	close_db(p->aAuxDb[i].db);
24258	25005	p->aAuxDb[i].db = 0;
24259	25006	}
24260	25007	}else{
24261		- raw_printf(stderr, "Usage: .connection [close] [CONNECTION-NUMBER]\n");
	25008	+ eputz("Usage: .connection [close] [CONNECTION-NUMBER]\n");
24262	25009	rc = 1;
24263	25010	}
24264	25011	}else
24265	25012
24266	25013	if( c=='c' && n==4 && cli_strncmp(azArg[0], "crnl", n)==0 ){
		@@ -24270,13 +25017,13 @@
24270	25017	}else{
24271	25018	setBinaryMode(p->out, 1);
24272	25019	}
24273	25020	}else{
24274	25021	#if !defined(_WIN32) && !defined(WIN32)
24275		- raw_printf(stderr, "The \".crnl\" is a no-op on non-Windows machines.\n");
	25022	+ eputz("The \".crnl\" is a no-op on non-Windows machines.\n");
24276	25023	#endif
24277		- raw_printf(stderr, "Usage: .crnl on\|off\n");
	25024	+ eputz("Usage: .crnl on\|off\n");
24278	25025	rc = 1;
24279	25026	}
24280	25027	}else
24281	25028
24282	25029	if( c=='d' && n>1 && cli_strncmp(azArg[0], "databases", n)==0 ){
		@@ -24285,11 +25032,11 @@
24285	25032	sqlite3_stmt *pStmt;
24286	25033	int i;
24287	25034	open_db(p, 0);
24288	25035	rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
24289	25036	if( rc ){
24290		- utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
	25037	+ eputf("Error: %s\n", sqlite3_errmsg(p->db));
24291	25038	rc = 1;
24292	25039	}else{
24293	25040	while( sqlite3_step(pStmt)==SQLITE_ROW ){
24294	25041	const char zSchema = (const char )sqlite3_column_text(pStmt,1);
24295	25042	const char zFile = (const char)sqlite3_column_text(pStmt,2);
		@@ -24304,15 +25051,13 @@
24304	25051	sqlite3_finalize(pStmt);
24305	25052	for(i=0; i<nName; i++){
24306	25053	int eTxn = sqlite3_txn_state(p->db, azName[i*2]);
24307	25054	int bRdonly = sqlite3_db_readonly(p->db, azName[i*2]);
24308	25055	const char z = azName[i2+1];
24309		- utf8_printf(p->out, "%s: %s %s%s\n",
24310		- azName[i*2],
24311		- z && z[0] ? z : "\"\"",
24312		- bRdonly ? "r/o" : "r/w",
24313		- eTxn==SQLITE_TXN_NONE ? "" :
	25056	+ oputf("%s: %s %s%s\n",
	25057	+ azName[i*2], z && z[0] ? z : "\"\"", bRdonly ? "r/o" : "r/w",
	25058	+ eTxn==SQLITE_TXN_NONE ? "" :
24314	25059	eTxn==SQLITE_TXN_READ ? " read-txn" : " write-txn");
24315	25060	free(azName[i*2]);
24316	25061	free(azName[i*2+1]);
24317	25062	}
24318	25063	sqlite3_free(azName);
		@@ -24348,16 +25093,16 @@
24348	25093	if( nArg>1 && cli_strcmp(azArg[1], aDbConfig[ii].zName)!=0 ) continue;
24349	25094	if( nArg>=3 ){
24350	25095	sqlite3_db_config(p->db, aDbConfig[ii].op, booleanValue(azArg[2]), 0);
24351	25096	}
24352	25097	sqlite3_db_config(p->db, aDbConfig[ii].op, -1, &v);
24353		- utf8_printf(p->out, "%19s %s\n", aDbConfig[ii].zName, v ? "on" : "off");
	25098	+ oputf("%19s %s\n", aDbConfig[ii].zName, v ? "on" : "off");
24354	25099	if( nArg>1 ) break;
24355	25100	}
24356	25101	if( nArg>1 && ii==ArraySize(aDbConfig) ){
24357		- utf8_printf(stderr, "Error: unknown dbconfig \"%s\"\n", azArg[1]);
24358		- utf8_printf(stderr, "Enter \".dbconfig\" with no arguments for a list\n");
	25102	+ eputf("Error: unknown dbconfig \"%s\"\n", azArg[1]);
	25103	+ eputz("Enter \".dbconfig\" with no arguments for a list\n");
24359	25104	}
24360	25105	}else
24361	25106
24362	25107	#if SQLITE_SHELL_HAVE_RECOVER
24363	25108	if( c=='d' && n>=3 && cli_strncmp(azArg[0], "dbinfo", n)==0 ){
		@@ -24383,12 +25128,12 @@
24383	25128	if( azArg[i][0]=='-' ){
24384	25129	const char *z = azArg[i]+1;
24385	25130	if( z[0]=='-' ) z++;
24386	25131	if( cli_strcmp(z,"preserve-rowids")==0 ){
24387	25132	#ifdef SQLITE_OMIT_VIRTUALTABLE
24388		- raw_printf(stderr, "The --preserve-rowids option is not compatible"
24389		- " with SQLITE_OMIT_VIRTUALTABLE\n");
	25133	+ eputz("The --preserve-rowids option is not compatible"
	25134	+ " with SQLITE_OMIT_VIRTUALTABLE\n");
24390	25135	rc = 1;
24391	25136	sqlite3_free(zLike);
24392	25137	goto meta_command_exit;
24393	25138	#else
24394	25139	ShellSetFlag(p, SHFLG_PreserveRowid);
		@@ -24402,11 +25147,11 @@
24402	25147	}else
24403	25148	if( cli_strcmp(z,"nosys")==0 ){
24404	25149	ShellSetFlag(p, SHFLG_DumpNoSys);
24405	25150	}else
24406	25151	{
24407		- raw_printf(stderr, "Unknown option \"%s\" on \".dump\"\n", azArg[i]);
	25152	+ eputf("Unknown option \"%s\" on \".dump\"\n", azArg[i]);
24408	25153	rc = 1;
24409	25154	sqlite3_free(zLike);
24410	25155	goto meta_command_exit;
24411	25156	}
24412	25157	}else{
		@@ -24436,12 +25181,12 @@
24436	25181
24437	25182	if( (p->shellFlgs & SHFLG_DumpDataOnly)==0 ){
24438	25183	/* When playing back a "dump", the content might appear in an order
24439	25184	** which causes immediate foreign key constraints to be violated.
24440	25185	** So disable foreign-key constraint enforcement to prevent problems. */
24441		- raw_printf(p->out, "PRAGMA foreign_keys=OFF;\n");
24442		- raw_printf(p->out, "BEGIN TRANSACTION;\n");
	25186	+ oputz("PRAGMA foreign_keys=OFF;\n");
	25187	+ oputz("BEGIN TRANSACTION;\n");
24443	25188	}
24444	25189	p->writableSchema = 0;
24445	25190	p->showHeader = 0;
24446	25191	/* Set writable_schema=ON since doing so forces SQLite to initialize
24447	25192	** as much of the schema as it can even if the sqlite_schema table is
		@@ -24468,27 +25213,27 @@
24468	25213	run_table_dump_query(p, zSql);
24469	25214	sqlite3_free(zSql);
24470	25215	}
24471	25216	sqlite3_free(zLike);
24472	25217	if( p->writableSchema ){
24473		- raw_printf(p->out, "PRAGMA writable_schema=OFF;\n");
	25218	+ oputz("PRAGMA writable_schema=OFF;\n");
24474	25219	p->writableSchema = 0;
24475	25220	}
24476	25221	sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
24477	25222	sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0);
24478	25223	if( (p->shellFlgs & SHFLG_DumpDataOnly)==0 ){
24479		- raw_printf(p->out, p->nErr?"ROLLBACK; -- due to errors\n":"COMMIT;\n");
	25224	+ oputz(p->nErr?"ROLLBACK; -- due to errors\n":"COMMIT;\n");
24480	25225	}
24481	25226	p->showHeader = savedShowHeader;
24482	25227	p->shellFlgs = savedShellFlags;
24483	25228	}else
24484	25229
24485	25230	if( c=='e' && cli_strncmp(azArg[0], "echo", n)==0 ){
24486	25231	if( nArg==2 ){
24487	25232	setOrClearFlag(p, SHFLG_Echo, azArg[1]);
24488	25233	}else{
24489		- raw_printf(stderr, "Usage: .echo on\|off\n");
	25234	+ eputz("Usage: .echo on\|off\n");
24490	25235	rc = 1;
24491	25236	}
24492	25237	}else
24493	25238
24494	25239	if( c=='e' && cli_strncmp(azArg[0], "eqp", n)==0 ){
		@@ -24515,11 +25260,11 @@
24515	25260	#endif
24516	25261	}else{
24517	25262	p->autoEQP = (u8)booleanValue(azArg[1]);
24518	25263	}
24519	25264	}else{
24520		- raw_printf(stderr, "Usage: .eqp off\|on\|trace\|trigger\|full\n");
	25265	+ eputz("Usage: .eqp off\|on\|trace\|trigger\|full\n");
24521	25266	rc = 1;
24522	25267	}
24523	25268	}else
24524	25269
24525	25270	#ifndef SQLITE_SHELL_FIDDLE
		@@ -24554,13 +25299,12 @@
24554	25299	}else
24555	25300
24556	25301	#ifndef SQLITE_OMIT_VIRTUALTABLE
24557	25302	if( c=='e' && cli_strncmp(azArg[0], "expert", n)==0 ){
24558	25303	if( p->bSafeMode ){
24559		- raw_printf(stderr,
24560		- "Cannot run experimental commands such as \"%s\" in safe mode\n",
24561		- azArg[0]);
	25304	+ eputf("Cannot run experimental commands such as \"%s\" in safe mode\n",
	25305	+ azArg[0]);
24562	25306	rc = 1;
24563	25307	}else{
24564	25308	open_db(p, 0);
24565	25309	expertDotCommand(p, azArg, nArg);
24566	25310	}
		@@ -24612,14 +25356,13 @@
24612	25356	if( zCmd[0]=='-' && zCmd[1] ) zCmd++;
24613	25357	}
24614	25358
24615	25359	/* --help lists all file-controls */
24616	25360	if( cli_strcmp(zCmd,"help")==0 ){
24617		- utf8_printf(p->out, "Available file-controls:\n");
	25361	+ oputz("Available file-controls:\n");
24618	25362	for(i=0; i<ArraySize(aCtrl); i++){
24619		- utf8_printf(p->out, " .filectrl %s %s\n",
24620		- aCtrl[i].zCtrlName, aCtrl[i].zUsage);
	25363	+ oputf(" .filectrl %s %s\n", aCtrl[i].zCtrlName, aCtrl[i].zUsage);
24621	25364	}
24622	25365	rc = 1;
24623	25366	goto meta_command_exit;
24624	25367	}
24625	25368
		@@ -24630,20 +25373,20 @@
24630	25373	if( cli_strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){
24631	25374	if( filectrl<0 ){
24632	25375	filectrl = aCtrl[i].ctrlCode;
24633	25376	iCtrl = i;
24634	25377	}else{
24635		- utf8_printf(stderr, "Error: ambiguous file-control: \"%s\"\n"
24636		- "Use \".filectrl --help\" for help\n", zCmd);
	25378	+ eputf("Error: ambiguous file-control: \"%s\"\n"
	25379	+ "Use \".filectrl --help\" for help\n", zCmd);
24637	25380	rc = 1;
24638	25381	goto meta_command_exit;
24639	25382	}
24640	25383	}
24641	25384	}
24642	25385	if( filectrl<0 ){
24643		- utf8_printf(stderr,"Error: unknown file-control: %s\n"
24644		- "Use \".filectrl --help\" for help\n", zCmd);
	25386	+ eputf("Error: unknown file-control: %s\n"
	25387	+ "Use \".filectrl --help\" for help\n", zCmd);
24645	25388	}else{
24646	25389	switch(filectrl){
24647	25390	case SQLITE_FCNTL_SIZE_LIMIT: {
24648	25391	if( nArg!=2 && nArg!=3 ) break;
24649	25392	iRes = nArg==3 ? integerValue(azArg[2]) : -1;
		@@ -24682,11 +25425,11 @@
24682	25425	case SQLITE_FCNTL_TEMPFILENAME: {
24683	25426	char *z = 0;
24684	25427	if( nArg!=2 ) break;
24685	25428	sqlite3_file_control(p->db, zSchema, filectrl, &z);
24686	25429	if( z ){
24687		- utf8_printf(p->out, "%s\n", z);
	25430	+ oputf("%s\n", z);
24688	25431	sqlite3_free(z);
24689	25432	}
24690	25433	isOk = 2;
24691	25434	break;
24692	25435	}
		@@ -24696,23 +25439,23 @@
24696	25439	x = atoi(azArg[2]);
24697	25440	sqlite3_file_control(p->db, zSchema, filectrl, &x);
24698	25441	}
24699	25442	x = -1;
24700	25443	sqlite3_file_control(p->db, zSchema, filectrl, &x);
24701		- utf8_printf(p->out,"%d\n", x);
	25444	+ oputf("%d\n", x);
24702	25445	isOk = 2;
24703	25446	break;
24704	25447	}
24705	25448	}
24706	25449	}
24707	25450	if( isOk==0 && iCtrl>=0 ){
24708		- utf8_printf(p->out, "Usage: .filectrl %s %s\n", zCmd,aCtrl[iCtrl].zUsage);
	25451	+ oputf("Usage: .filectrl %s %s\n", zCmd,aCtrl[iCtrl].zUsage);
24709	25452	rc = 1;
24710	25453	}else if( isOk==1 ){
24711	25454	char zBuf[100];
24712	25455	sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", iRes);
24713		- raw_printf(p->out, "%s\n", zBuf);
	25456	+ oputf("%s\n", zBuf);
24714	25457	}
24715	25458	}else
24716	25459
24717	25460	if( c=='f' && cli_strncmp(azArg[0], "fullschema", n)==0 ){
24718	25461	ShellState data;
		@@ -24723,11 +25466,11 @@
24723	25466	if( nArg==2 && optionMatch(azArg[1], "indent") ){
24724	25467	data.cMode = data.mode = MODE_Pretty;
24725	25468	nArg = 1;
24726	25469	}
24727	25470	if( nArg!=1 ){
24728		- raw_printf(stderr, "Usage: .fullschema ?--indent?\n");
	25471	+ eputz("Usage: .fullschema ?--indent?\n");
24729	25472	rc = 1;
24730	25473	goto meta_command_exit;
24731	25474	}
24732	25475	open_db(p, 0);
24733	25476	rc = sqlite3_exec(p->db,
		@@ -24749,37 +25492,37 @@
24749	25492	doStats = sqlite3_step(pStmt)==SQLITE_ROW;
24750	25493	sqlite3_finalize(pStmt);
24751	25494	}
24752	25495	}
24753	25496	if( doStats==0 ){
24754		- raw_printf(p->out, "/* No STAT tables available */\n");
	25497	+ oputz("/* No STAT tables available */\n");
24755	25498	}else{
24756		- raw_printf(p->out, "ANALYZE sqlite_schema;\n");
	25499	+ oputz("ANALYZE sqlite_schema;\n");
24757	25500	data.cMode = data.mode = MODE_Insert;
24758	25501	data.zDestTable = "sqlite_stat1";
24759	25502	shell_exec(&data, "SELECT * FROM sqlite_stat1", 0);
24760	25503	data.zDestTable = "sqlite_stat4";
24761	25504	shell_exec(&data, "SELECT * FROM sqlite_stat4", 0);
24762		- raw_printf(p->out, "ANALYZE sqlite_schema;\n");
	25505	+ oputz("ANALYZE sqlite_schema;\n");
24763	25506	}
24764	25507	}else
24765	25508
24766	25509	if( c=='h' && cli_strncmp(azArg[0], "headers", n)==0 ){
24767	25510	if( nArg==2 ){
24768	25511	p->showHeader = booleanValue(azArg[1]);
24769	25512	p->shellFlgs \|= SHFLG_HeaderSet;
24770	25513	}else{
24771		- raw_printf(stderr, "Usage: .headers on\|off\n");
	25514	+ eputz("Usage: .headers on\|off\n");
24772	25515	rc = 1;
24773	25516	}
24774	25517	}else
24775	25518
24776	25519	if( c=='h' && cli_strncmp(azArg[0], "help", n)==0 ){
24777	25520	if( nArg>=2 ){
24778	25521	n = showHelp(p->out, azArg[1]);
24779	25522	if( n==0 ){
24780		- utf8_printf(p->out, "Nothing matches '%s'\n", azArg[1]);
	25523	+ oputf("Nothing matches '%s'\n", azArg[1]);
24781	25524	}
24782	25525	}else{
24783	25526	showHelp(p->out, 0);
24784	25527	}
24785	25528	}else
		@@ -24819,11 +25562,11 @@
24819	25562	if( zFile==0 ){
24820	25563	zFile = z;
24821	25564	}else if( zTable==0 ){
24822	25565	zTable = z;
24823	25566	}else{
24824		- utf8_printf(p->out, "ERROR: extra argument: \"%s\". Usage:\n", z);
	25567	+ oputf("ERROR: extra argument: \"%s\". Usage:\n", z);
24825	25568	showHelp(p->out, "import");
24826	25569	goto meta_command_exit;
24827	25570	}
24828	25571	}else if( cli_strcmp(z,"-v")==0 ){
24829	25572	eVerbose++;
		@@ -24840,18 +25583,18 @@
24840	25583	sCtx.cColSep = ',';
24841	25584	sCtx.cRowSep = '\n';
24842	25585	xRead = csv_read_one_field;
24843	25586	useOutputMode = 0;
24844	25587	}else{
24845		- utf8_printf(p->out, "ERROR: unknown option: \"%s\". Usage:\n", z);
	25588	+ oputf("ERROR: unknown option: \"%s\". Usage:\n", z);
24846	25589	showHelp(p->out, "import");
24847	25590	goto meta_command_exit;
24848	25591	}
24849	25592	}
24850	25593	if( zTable==0 ){
24851		- utf8_printf(p->out, "ERROR: missing %s argument. Usage:\n",
24852		- zFile==0 ? "FILE" : "TABLE");
	25594	+ oputf("ERROR: missing %s argument. Usage:\n",
	25595	+ zFile==0 ? "FILE" : "TABLE");
24853	25596	showHelp(p->out, "import");
24854	25597	goto meta_command_exit;
24855	25598	}
24856	25599	seenInterrupt = 0;
24857	25600	open_db(p, 0);
		@@ -24858,24 +25601,21 @@
24858	25601	if( useOutputMode ){
24859	25602	/* If neither the --csv or --ascii options are specified, then set
24860	25603	** the column and row separator characters from the output mode. */
24861	25604	nSep = strlen30(p->colSeparator);
24862	25605	if( nSep==0 ){
24863		- raw_printf(stderr,
24864		- "Error: non-null column separator required for import\n");
	25606	+ eputz("Error: non-null column separator required for import\n");
24865	25607	goto meta_command_exit;
24866	25608	}
24867	25609	if( nSep>1 ){
24868		- raw_printf(stderr,
24869		- "Error: multi-character column separators not allowed"
	25610	+ eputz("Error: multi-character column separators not allowed"
24870	25611	" for import\n");
24871	25612	goto meta_command_exit;
24872	25613	}
24873	25614	nSep = strlen30(p->rowSeparator);
24874	25615	if( nSep==0 ){
24875		- raw_printf(stderr,
24876		- "Error: non-null row separator required for import\n");
	25616	+ eputz("Error: non-null row separator required for import\n");
24877	25617	goto meta_command_exit;
24878	25618	}
24879	25619	if( nSep==2 && p->mode==MODE_Csv
24880	25620	&& cli_strcmp(p->rowSeparator,SEP_CrLf)==0
24881	25621	){
		@@ -24885,22 +25625,22 @@
24885	25625	** and output row separators. */
24886	25626	sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
24887	25627	nSep = strlen30(p->rowSeparator);
24888	25628	}
24889	25629	if( nSep>1 ){
24890		- raw_printf(stderr, "Error: multi-character row separators not allowed"
24891		- " for import\n");
	25630	+ eputz("Error: multi-character row separators not allowed"
	25631	+ " for import\n");
24892	25632	goto meta_command_exit;
24893	25633	}
24894	25634	sCtx.cColSep = (u8)p->colSeparator[0];
24895	25635	sCtx.cRowSep = (u8)p->rowSeparator[0];
24896	25636	}
24897	25637	sCtx.zFile = zFile;
24898	25638	sCtx.nLine = 1;
24899	25639	if( sCtx.zFile[0]=='\|' ){
24900	25640	#ifdef SQLITE_OMIT_POPEN
24901		- raw_printf(stderr, "Error: pipes are not supported in this OS\n");
	25641	+ eputz("Error: pipes are not supported in this OS\n");
24902	25642	goto meta_command_exit;
24903	25643	#else
24904	25644	sCtx.in = popen(sCtx.zFile+1, "r");
24905	25645	sCtx.zFile = "<pipe>";
24906	25646	sCtx.xCloser = pclose;
		@@ -24908,23 +25648,23 @@
24908	25648	}else{
24909	25649	sCtx.in = fopen(sCtx.zFile, "rb");
24910	25650	sCtx.xCloser = fclose;
24911	25651	}
24912	25652	if( sCtx.in==0 ){
24913		- utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile);
	25653	+ eputf("Error: cannot open \"%s\"\n", zFile);
24914	25654	goto meta_command_exit;
24915	25655	}
24916	25656	if( eVerbose>=2 \|\| (eVerbose>=1 && useOutputMode) ){
24917	25657	char zSep[2];
24918	25658	zSep[1] = 0;
24919	25659	zSep[0] = sCtx.cColSep;
24920		- utf8_printf(p->out, "Column separator ");
24921		- output_c_string(p->out, zSep);
24922		- utf8_printf(p->out, ", row separator ");
	25660	+ oputz("Column separator ");
	25661	+ output_c_string(zSep);
	25662	+ oputz(", row separator ");
24923	25663	zSep[0] = sCtx.cRowSep;
24924		- output_c_string(p->out, zSep);
24925		- utf8_printf(p->out, "\n");
	25664	+ output_c_string(zSep);
	25665	+ oputz("\n");
24926	25666	}
24927	25667	sCtx.z = sqlite3_malloc64(120);
24928	25668	if( sCtx.z==0 ){
24929	25669	import_cleanup(&sCtx);
24930	25670	shell_out_of_memory();
		@@ -24955,18 +25695,18 @@
24955	25695	zAutoColumn(sCtx.z, &dbCols, 0);
24956	25696	if( sCtx.cTerm!=sCtx.cColSep ) break;
24957	25697	}
24958	25698	zColDefs = zAutoColumn(0, &dbCols, &zRenames);
24959	25699	if( zRenames!=0 ){
24960		- utf8_printf((stdin_is_interactive && p->in==stdin)? p->out : stderr,
24961		- "Columns renamed during .import %s due to duplicates:\n"
24962		- "%s\n", sCtx.zFile, zRenames);
	25700	+ sputf((stdin_is_interactive && p->in==stdin)? p->out : stderr,
	25701	+ "Columns renamed during .import %s due to duplicates:\n"
	25702	+ "%s\n", sCtx.zFile, zRenames);
24963	25703	sqlite3_free(zRenames);
24964	25704	}
24965	25705	assert(dbCols==0);
24966	25706	if( zColDefs==0 ){
24967		- utf8_printf(stderr,"%s: empty file\n", sCtx.zFile);
	25707	+ eputf("%s: empty file\n", sCtx.zFile);
24968	25708	import_fail:
24969	25709	sqlite3_free(zCreate);
24970	25710	sqlite3_free(zSql);
24971	25711	sqlite3_free(zFullTabName);
24972	25712	import_cleanup(&sCtx);
		@@ -24973,24 +25713,24 @@
24973	25713	rc = 1;
24974	25714	goto meta_command_exit;
24975	25715	}
24976	25716	zCreate = sqlite3_mprintf("%z%z\n", zCreate, zColDefs);
24977	25717	if( eVerbose>=1 ){
24978		- utf8_printf(p->out, "%s\n", zCreate);
	25718	+ oputf("%s\n", zCreate);
24979	25719	}
24980	25720	rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
24981	25721	if( rc ){
24982		- utf8_printf(stderr, "%s failed:\n%s\n", zCreate, sqlite3_errmsg(p->db));
	25722	+ eputf("%s failed:\n%s\n", zCreate, sqlite3_errmsg(p->db));
24983	25723	goto import_fail;
24984	25724	}
24985	25725	sqlite3_free(zCreate);
24986	25726	zCreate = 0;
24987	25727	rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
24988	25728	}
24989	25729	if( rc ){
24990	25730	if (pStmt) sqlite3_finalize(pStmt);
24991		- utf8_printf(stderr,"Error: %s\n", sqlite3_errmsg(p->db));
	25731	+ eputf("Error: %s\n", sqlite3_errmsg(p->db));
24992	25732	goto import_fail;
24993	25733	}
24994	25734	sqlite3_free(zSql);
24995	25735	nCol = sqlite3_column_count(pStmt);
24996	25736	sqlite3_finalize(pStmt);
		@@ -25008,15 +25748,15 @@
25008	25748	zSql[j++] = '?';
25009	25749	}
25010	25750	zSql[j++] = ')';
25011	25751	zSql[j] = 0;
25012	25752	if( eVerbose>=2 ){
25013		- utf8_printf(p->out, "Insert using: %s\n", zSql);
	25753	+ oputf("Insert using: %s\n", zSql);
25014	25754	}
25015	25755	rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
25016	25756	if( rc ){
25017		- utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
	25757	+ eputf("Error: %s\n", sqlite3_errmsg(p->db));
25018	25758	if (pStmt) sqlite3_finalize(pStmt);
25019	25759	goto import_fail;
25020	25760	}
25021	25761	sqlite3_free(zSql);
25022	25762	sqlite3_free(zFullTabName);
		@@ -25045,32 +25785,31 @@
25045	25785	if( z==0 && (xRead==csv_read_one_field) && i==nCol-1 && i>0 ){
25046	25786	z = "";
25047	25787	}
25048	25788	sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT);
25049	25789	if( i<nCol-1 && sCtx.cTerm!=sCtx.cColSep ){
25050		- utf8_printf(stderr, "%s:%d: expected %d columns but found %d - "
25051		- "filling the rest with NULL\n",
25052		- sCtx.zFile, startLine, nCol, i+1);
	25790	+ eputf("%s:%d: expected %d columns but found %d"
	25791	+ " - filling the rest with NULL\n",
	25792	+ sCtx.zFile, startLine, nCol, i+1);
25053	25793	i += 2;
25054	25794	while( i<=nCol ){ sqlite3_bind_null(pStmt, i); i++; }
25055	25795	}
25056	25796	}
25057	25797	if( sCtx.cTerm==sCtx.cColSep ){
25058	25798	do{
25059	25799	xRead(&sCtx);
25060	25800	i++;
25061	25801	}while( sCtx.cTerm==sCtx.cColSep );
25062		- utf8_printf(stderr, "%s:%d: expected %d columns but found %d - "
25063		- "extras ignored\n",
25064		- sCtx.zFile, startLine, nCol, i);
	25802	+ eputf("%s:%d: expected %d columns but found %d - extras ignored\n",
	25803	+ sCtx.zFile, startLine, nCol, i);
25065	25804	}
25066	25805	if( i>=nCol ){
25067	25806	sqlite3_step(pStmt);
25068	25807	rc = sqlite3_reset(pStmt);
25069	25808	if( rc!=SQLITE_OK ){
25070		- utf8_printf(stderr, "%s:%d: INSERT failed: %s\n", sCtx.zFile,
25071		- startLine, sqlite3_errmsg(p->db));
	25809	+ eputf("%s:%d: INSERT failed: %s\n",
	25810	+ sCtx.zFile, startLine, sqlite3_errmsg(p->db));
25072	25811	sCtx.nErr++;
25073	25812	}else{
25074	25813	sCtx.nRow++;
25075	25814	}
25076	25815	}
		@@ -25078,13 +25817,12 @@
25078	25817
25079	25818	import_cleanup(&sCtx);
25080	25819	sqlite3_finalize(pStmt);
25081	25820	if( needCommit ) sqlite3_exec(p->db, "COMMIT", 0, 0, 0);
25082	25821	if( eVerbose>0 ){
25083		- utf8_printf(p->out,
25084		- "Added %d rows with %d errors using %d lines of input\n",
25085		- sCtx.nRow, sCtx.nErr, sCtx.nLine-1);
	25822	+ oputf("Added %d rows with %d errors using %d lines of input\n",
	25823	+ sCtx.nRow, sCtx.nErr, sCtx.nLine-1);
25086	25824	}
25087	25825	}else
25088	25826	#endif /* !defined(SQLITE_SHELL_FIDDLE) */
25089	25827
25090	25828	#ifndef SQLITE_UNTESTABLE
		@@ -25095,18 +25833,18 @@
25095	25833	int tnum = 0;
25096	25834	int isWO = 0; /* True if making an imposter of a WITHOUT ROWID table */
25097	25835	int lenPK = 0; /* Length of the PRIMARY KEY string for isWO tables */
25098	25836	int i;
25099	25837	if( !ShellHasFlag(p,SHFLG_TestingMode) ){
25100		- utf8_printf(stderr, ".%s unavailable without --unsafe-testing\n",
25101		- "imposter");
	25838	+ eputf(".%s unavailable without --unsafe-testing\n",
	25839	+ "imposter");
25102	25840	rc = 1;
25103	25841	goto meta_command_exit;
25104	25842	}
25105	25843	if( !(nArg==3 \|\| (nArg==2 && sqlite3_stricmp(azArg[1],"off")==0)) ){
25106		- utf8_printf(stderr, "Usage: .imposter INDEX IMPOSTER\n"
25107		- " .imposter off\n");
	25844	+ eputz("Usage: .imposter INDEX IMPOSTER\n"
	25845	+ " .imposter off\n");
25108	25846	/* Also allowed, but not documented:
25109	25847	**
25110	25848	** .imposter TABLE IMPOSTER
25111	25849	**
25112	25850	** where TABLE is a WITHOUT ROWID table. In that case, the
		@@ -25161,11 +25899,11 @@
25161	25899	zCollist = sqlite3_mprintf("%z,\"%w\"", zCollist, zCol);
25162	25900	}
25163	25901	}
25164	25902	sqlite3_finalize(pStmt);
25165	25903	if( i==0 \|\| tnum==0 ){
25166		- utf8_printf(stderr, "no such index: \"%s\"\n", azArg[1]);
	25904	+ eputf("no such index: \"%s\"\n", azArg[1]);
25167	25905	rc = 1;
25168	25906	sqlite3_free(zCollist);
25169	25907	goto meta_command_exit;
25170	25908	}
25171	25909	if( lenPK==0 ) lenPK = 100000;
		@@ -25176,20 +25914,18 @@
25176	25914	rc = sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 1, tnum);
25177	25915	if( rc==SQLITE_OK ){
25178	25916	rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
25179	25917	sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 0);
25180	25918	if( rc ){
25181		- utf8_printf(stderr, "Error in [%s]: %s\n", zSql, sqlite3_errmsg(p->db));
	25919	+ eputf("Error in [%s]: %s\n", zSql, sqlite3_errmsg(p->db));
25182	25920	}else{
25183		- utf8_printf(stdout, "%s;\n", zSql);
25184		- raw_printf(stdout,
25185		- "WARNING: writing to an imposter table will corrupt the \"%s\" %s!\n",
25186		- azArg[1], isWO ? "table" : "index"
25187		- );
	25921	+ sputf(stdout, "%s;\n", zSql);
	25922	+ sputf(stdout, "WARNING: writing to an imposter table will corrupt"
	25923	+ " the \"%s\" %s!\n", azArg[1], isWO ? "table" : "index");
25188	25924	}
25189	25925	}else{
25190		- raw_printf(stderr, "SQLITE_TESTCTRL_IMPOSTER returns %d\n", rc);
	25926	+ eputf("SQLITE_TESTCTRL_IMPOSTER returns %d\n", rc);
25191	25927	rc = 1;
25192	25928	}
25193	25929	sqlite3_free(zSql);
25194	25930	}else
25195	25931	#endif /* !defined(SQLITE_OMIT_TEST_CONTROL) */
		@@ -25205,11 +25941,11 @@
25205	25941	sqlite3IoTrace = iotracePrintf;
25206	25942	iotrace = stdout;
25207	25943	}else{
25208	25944	iotrace = fopen(azArg[1], "w");
25209	25945	if( iotrace==0 ){
25210		- utf8_printf(stderr, "Error: cannot open \"%s\"\n", azArg[1]);
	25946	+ eputf("Error: cannot open \"%s\"\n", azArg[1]);
25211	25947	sqlite3IoTrace = 0;
25212	25948	rc = 1;
25213	25949	}else{
25214	25950	sqlite3IoTrace = iotracePrintf;
25215	25951	}
		@@ -25237,15 +25973,15 @@
25237	25973	};
25238	25974	int i, n2;
25239	25975	open_db(p, 0);
25240	25976	if( nArg==1 ){
25241	25977	for(i=0; i<ArraySize(aLimit); i++){
25242		- printf("%20s %d\n", aLimit[i].zLimitName,
25243		- sqlite3_limit(p->db, aLimit[i].limitCode, -1));
	25978	+ sputf(stdout, "%20s %d\n", aLimit[i].zLimitName,
	25979	+ sqlite3_limit(p->db, aLimit[i].limitCode, -1));
25244	25980	}
25245	25981	}else if( nArg>3 ){
25246		- raw_printf(stderr, "Usage: .limit NAME ?NEW-VALUE?\n");
	25982	+ eputz("Usage: .limit NAME ?NEW-VALUE?\n");
25247	25983	rc = 1;
25248	25984	goto meta_command_exit;
25249	25985	}else{
25250	25986	int iLimit = -1;
25251	25987	n2 = strlen30(azArg[1]);
		@@ -25252,29 +25988,29 @@
25252	25988	for(i=0; i<ArraySize(aLimit); i++){
25253	25989	if( sqlite3_strnicmp(aLimit[i].zLimitName, azArg[1], n2)==0 ){
25254	25990	if( iLimit<0 ){
25255	25991	iLimit = i;
25256	25992	}else{
25257		- utf8_printf(stderr, "ambiguous limit: \"%s\"\n", azArg[1]);
	25993	+ eputf("ambiguous limit: \"%s\"\n", azArg[1]);
25258	25994	rc = 1;
25259	25995	goto meta_command_exit;
25260	25996	}
25261	25997	}
25262	25998	}
25263	25999	if( iLimit<0 ){
25264		- utf8_printf(stderr, "unknown limit: \"%s\"\n"
25265		- "enter \".limits\" with no arguments for a list.\n",
25266		- azArg[1]);
	26000	+ eputf("unknown limit: \"%s\"\n"
	26001	+ "enter \".limits\" with no arguments for a list.\n",
	26002	+ azArg[1]);
25267	26003	rc = 1;
25268	26004	goto meta_command_exit;
25269	26005	}
25270	26006	if( nArg==3 ){
25271	26007	sqlite3_limit(p->db, aLimit[iLimit].limitCode,
25272	26008	(int)integerValue(azArg[2]));
25273	26009	}
25274		- printf("%20s %d\n", aLimit[iLimit].zLimitName,
25275		- sqlite3_limit(p->db, aLimit[iLimit].limitCode, -1));
	26010	+ sputf(stdout, "%20s %d\n", aLimit[iLimit].zLimitName,
	26011	+ sqlite3_limit(p->db, aLimit[iLimit].limitCode, -1));
25276	26012	}
25277	26013	}else
25278	26014
25279	26015	if( c=='l' && n>2 && cli_strncmp(azArg[0], "lint", n)==0 ){
25280	26016	open_db(p, 0);
		@@ -25286,38 +26022,38 @@
25286	26022	const char zFile, zProc;
25287	26023	char *zErrMsg = 0;
25288	26024	failIfSafeMode(p, "cannot run .load in safe mode");
25289	26025	if( nArg<2 \|\| azArg[1][0]==0 ){
25290	26026	/* Must have a non-empty FILE. (Will not load self.) */
25291		- raw_printf(stderr, "Usage: .load FILE ?ENTRYPOINT?\n");
	26027	+ eputz("Usage: .load FILE ?ENTRYPOINT?\n");
25292	26028	rc = 1;
25293	26029	goto meta_command_exit;
25294	26030	}
25295	26031	zFile = azArg[1];
25296	26032	zProc = nArg>=3 ? azArg[2] : 0;
25297	26033	open_db(p, 0);
25298	26034	rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
25299	26035	if( rc!=SQLITE_OK ){
25300		- utf8_printf(stderr, "Error: %s\n", zErrMsg);
	26036	+ eputf("Error: %s\n", zErrMsg);
25301	26037	sqlite3_free(zErrMsg);
25302	26038	rc = 1;
25303	26039	}
25304	26040	}else
25305	26041	#endif
25306	26042
25307	26043	if( c=='l' && cli_strncmp(azArg[0], "log", n)==0 ){
25308	26044	if( nArg!=2 ){
25309		- raw_printf(stderr, "Usage: .log FILENAME\n");
	26045	+ eputz("Usage: .log FILENAME\n");
25310	26046	rc = 1;
25311	26047	}else{
25312	26048	const char *zFile = azArg[1];
25313	26049	if( p->bSafeMode
25314	26050	&& cli_strcmp(zFile,"on")!=0
25315	26051	&& cli_strcmp(zFile,"off")!=0
25316	26052	){
25317		- raw_printf(stdout, "cannot set .log to anything other "
25318		- "than \"on\" or \"off\"\n");
	26053	+ sputz(stdout, "cannot set .log to anything other"
	26054	+ " than \"on\" or \"off\"\n");
25319	26055	zFile = "off";
25320	26056	}
25321	26057	output_file_close(p->pLog);
25322	26058	if( cli_strcmp(zFile,"on")==0 ) zFile = "stdout";
25323	26059	p->pLog = output_file_open(zFile, 0);
		@@ -25352,37 +26088,35 @@
25352	26088	cmOpts = cmo;
25353	26089	}
25354	26090	}else if( zTabname==0 ){
25355	26091	zTabname = z;
25356	26092	}else if( z[0]=='-' ){
25357		- utf8_printf(stderr, "unknown option: %s\n", z);
25358		- utf8_printf(stderr, "options:\n"
25359		- " --noquote\n"
25360		- " --quote\n"
25361		- " --wordwrap on/off\n"
25362		- " --wrap N\n"
25363		- " --ww\n");
	26093	+ eputf("unknown option: %s\n", z);
	26094	+ eputz("options:\n"
	26095	+ " --noquote\n"
	26096	+ " --quote\n"
	26097	+ " --wordwrap on/off\n"
	26098	+ " --wrap N\n"
	26099	+ " --ww\n");
25364	26100	rc = 1;
25365	26101	goto meta_command_exit;
25366	26102	}else{
25367		- utf8_printf(stderr, "extra argument: \"%s\"\n", z);
	26103	+ eputf("extra argument: \"%s\"\n", z);
25368	26104	rc = 1;
25369	26105	goto meta_command_exit;
25370	26106	}
25371	26107	}
25372	26108	if( zMode==0 ){
25373	26109	if( p->mode==MODE_Column
25374	26110	\|\| (p->mode>=MODE_Markdown && p->mode<=MODE_Box)
25375	26111	){
25376		- raw_printf
25377		- (p->out,
25378		- "current output mode: %s --wrap %d --wordwrap %s --%squote\n",
25379		- modeDescr[p->mode], p->cmOpts.iWrap,
25380		- p->cmOpts.bWordWrap ? "on" : "off",
25381		- p->cmOpts.bQuote ? "" : "no");
	26112	+ oputf("current output mode: %s --wrap %d --wordwrap %s --%squote\n",
	26113	+ modeDescr[p->mode], p->cmOpts.iWrap,
	26114	+ p->cmOpts.bWordWrap ? "on" : "off",
	26115	+ p->cmOpts.bQuote ? "" : "no");
25382	26116	}else{
25383		- raw_printf(p->out, "current output mode: %s\n", modeDescr[p->mode]);
	26117	+ oputf("current output mode: %s\n", modeDescr[p->mode]);
25384	26118	}
25385	26119	zMode = modeDescr[p->mode];
25386	26120	}
25387	26121	n2 = strlen30(zMode);
25388	26122	if( cli_strncmp(zMode,"lines",n2)==0 ){
		@@ -25437,26 +26171,26 @@
25437	26171	}else if( cli_strncmp(zMode,"off",n2)==0 ){
25438	26172	p->mode = MODE_Off;
25439	26173	}else if( cli_strncmp(zMode,"json",n2)==0 ){
25440	26174	p->mode = MODE_Json;
25441	26175	}else{
25442		- raw_printf(stderr, "Error: mode should be one of: "
25443		- "ascii box column csv html insert json line list markdown "
25444		- "qbox quote table tabs tcl\n");
	26176	+ eputz("Error: mode should be one of: "
	26177	+ "ascii box column csv html insert json line list markdown "
	26178	+ "qbox quote table tabs tcl\n");
25445	26179	rc = 1;
25446	26180	}
25447	26181	p->cMode = p->mode;
25448	26182	}else
25449	26183
25450	26184	#ifndef SQLITE_SHELL_FIDDLE
25451	26185	if( c=='n' && cli_strcmp(azArg[0], "nonce")==0 ){
25452	26186	if( nArg!=2 ){
25453		- raw_printf(stderr, "Usage: .nonce NONCE\n");
	26187	+ eputz("Usage: .nonce NONCE\n");
25454	26188	rc = 1;
25455	26189	}else if( p->zNonce==0 \|\| cli_strcmp(azArg[1],p->zNonce)!=0 ){
25456		- raw_printf(stderr, "line %d: incorrect nonce: \"%s\"\n",
25457		- p->lineno, azArg[1]);
	26190	+ eputf("line %d: incorrect nonce: \"%s\"\n",
	26191	+ p->lineno, azArg[1]);
25458	26192	exit(1);
25459	26193	}else{
25460	26194	p->bSafeMode = 0;
25461	26195	return 0; /* Return immediately to bypass the safe mode reset
25462	26196	** at the end of this procedure */
		@@ -25467,11 +26201,11 @@
25467	26201	if( c=='n' && cli_strncmp(azArg[0], "nullvalue", n)==0 ){
25468	26202	if( nArg==2 ){
25469	26203	sqlite3_snprintf(sizeof(p->nullValue), p->nullValue,
25470	26204	"%.*s", (int)ArraySize(p->nullValue)-1, azArg[1]);
25471	26205	}else{
25472		- raw_printf(stderr, "Usage: .nullvalue STRING\n");
	26206	+ eputz("Usage: .nullvalue STRING\n");
25473	26207	rc = 1;
25474	26208	}
25475	26209	}else
25476	26210
25477	26211	if( c=='o' && cli_strncmp(azArg[0], "open", n)==0 && n>=2 ){
		@@ -25506,15 +26240,15 @@
25506	26240	p->szMax = integerValue(azArg[++iName]);
25507	26241	#endif /* SQLITE_OMIT_DESERIALIZE */
25508	26242	}else
25509	26243	#endif /* !SQLITE_SHELL_FIDDLE */
25510	26244	if( z[0]=='-' ){
25511		- utf8_printf(stderr, "unknown option: %s\n", z);
	26245	+ eputf("unknown option: %s\n", z);
25512	26246	rc = 1;
25513	26247	goto meta_command_exit;
25514	26248	}else if( zFN ){
25515		- utf8_printf(stderr, "extra argument: \"%s\"\n", z);
	26249	+ eputf("extra argument: \"%s\"\n", z);
25516	26250	rc = 1;
25517	26251	goto meta_command_exit;
25518	26252	}else{
25519	26253	zFN = z;
25520	26254	}
		@@ -25552,11 +26286,11 @@
25552	26286	zNewFilename = 0;
25553	26287	}
25554	26288	p->pAuxDb->zDbFilename = zNewFilename;
25555	26289	open_db(p, OPEN_DB_KEEPALIVE);
25556	26290	if( p->db==0 ){
25557		- utf8_printf(stderr, "Error: cannot open '%s'\n", zNewFilename);
	26291	+ eputf("Error: cannot open '%s'\n", zNewFilename);
25558	26292	sqlite3_free(zNewFilename);
25559	26293	}else{
25560	26294	p->pAuxDb->zFreeOnClose = zNewFilename;
25561	26295	}
25562	26296	}
		@@ -25576,13 +26310,13 @@
25576	26310	char *zFile = 0;
25577	26311	int bTxtMode = 0;
25578	26312	int i;
25579	26313	int eMode = 0;
25580	26314	int bOnce = 0; /* 0: .output, 1: .once, 2: .excel */
25581		- unsigned char zBOM[4]; /* Byte-order mark to using if --bom is present */
	26315	+ static const char *zBomUtf8 = "\xef\xbb\xbf";
	26316	+ const char *zBom = 0;
25582	26317
25583		- zBOM[0] = 0;
25584	26318	failIfSafeMode(p, "cannot run .%s in safe mode", azArg[0]);
25585	26319	if( c=='e' ){
25586	26320	eMode = 'x';
25587	26321	bOnce = 2;
25588	26322	}else if( cli_strncmp(azArg[0],"once",n)==0 ){
		@@ -25591,21 +26325,17 @@
25591	26325	for(i=1; i<nArg; i++){
25592	26326	char *z = azArg[i];
25593	26327	if( z[0]=='-' ){
25594	26328	if( z[1]=='-' ) z++;
25595	26329	if( cli_strcmp(z,"-bom")==0 ){
25596		- zBOM[0] = 0xef;
25597		- zBOM[1] = 0xbb;
25598		- zBOM[2] = 0xbf;
25599		- zBOM[3] = 0;
	26330	+ zBom = zBomUtf8;
25600	26331	}else if( c!='e' && cli_strcmp(z,"-x")==0 ){
25601	26332	eMode = 'x'; /* spreadsheet */
25602	26333	}else if( c!='e' && cli_strcmp(z,"-e")==0 ){
25603	26334	eMode = 'e'; /* text editor */
25604	26335	}else{
25605		- utf8_printf(p->out, "ERROR: unknown option: \"%s\". Usage:\n",
25606		- azArg[i]);
	26336	+ oputf("ERROR: unknown option: \"%s\". Usage:\n", azArg[i]);
25607	26337	showHelp(p->out, azArg[0]);
25608	26338	rc = 1;
25609	26339	goto meta_command_exit;
25610	26340	}
25611	26341	}else if( zFile==0 && eMode!='e' && eMode!='x' ){
		@@ -25613,12 +26343,11 @@
25613	26343	if( zFile && zFile[0]=='\|' ){
25614	26344	while( i+1<nArg ) zFile = sqlite3_mprintf("%z %s", zFile, azArg[++i]);
25615	26345	break;
25616	26346	}
25617	26347	}else{
25618		- utf8_printf(p->out,"ERROR: extra parameter: \"%s\". Usage:\n",
25619		- azArg[i]);
	26348	+ oputf("ERROR: extra parameter: \"%s\". Usage:\n", azArg[i]);
25620	26349	showHelp(p->out, azArg[0]);
25621	26350	rc = 1;
25622	26351	sqlite3_free(zFile);
25623	26352	goto meta_command_exit;
25624	26353	}
		@@ -25653,34 +26382,34 @@
25653	26382	}
25654	26383	#endif /* SQLITE_NOHAVE_SYSTEM */
25655	26384	shell_check_oom(zFile);
25656	26385	if( zFile[0]=='\|' ){
25657	26386	#ifdef SQLITE_OMIT_POPEN
25658		- raw_printf(stderr, "Error: pipes are not supported in this OS\n");
	26387	+ eputz("Error: pipes are not supported in this OS\n");
25659	26388	rc = 1;
25660		- p->out = stdout;
	26389	+ output_redir(p, stdout);
25661	26390	#else
25662		- p->out = popen(zFile + 1, "w");
25663		- if( p->out==0 ){
25664		- utf8_printf(stderr,"Error: cannot open pipe \"%s\"\n", zFile + 1);
25665		- p->out = stdout;
	26391	+ FILE *pfPipe = popen(zFile + 1, "w");
	26392	+ if( pfPipe==0 ){
	26393	+ eputf("Error: cannot open pipe \"%s\"\n", zFile + 1);
25666	26394	rc = 1;
25667	26395	}else{
25668		- if( zBOM[0] ) fwrite(zBOM, 1, 3, p->out);
	26396	+ output_redir(p, pfPipe);
	26397	+ if( zBom ) oputz(zBom);
25669	26398	sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
25670	26399	}
25671	26400	#endif
25672	26401	}else{
25673		- p->out = output_file_open(zFile, bTxtMode);
25674		- if( p->out==0 ){
	26402	+ FILE *pfFile = output_file_open(zFile, bTxtMode);
	26403	+ if( pfFile==0 ){
25675	26404	if( cli_strcmp(zFile,"off")!=0 ){
25676		- utf8_printf(stderr,"Error: cannot write to \"%s\"\n", zFile);
	26405	+ eputf("Error: cannot write to \"%s\"\n", zFile);
25677	26406	}
25678		- p->out = stdout;
25679	26407	rc = 1;
25680	26408	} else {
25681		- if( zBOM[0] ) fwrite(zBOM, 1, 3, p->out);
	26409	+ output_redir(p, pfFile);
	26410	+ if( zBom ) oputz(zBom);
25682	26411	sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
25683	26412	}
25684	26413	}
25685	26414	sqlite3_free(zFile);
25686	26415	}else
		@@ -25717,12 +26446,12 @@
25717	26446	if( len ){
25718	26447	rx = sqlite3_prepare_v2(p->db,
25719	26448	"SELECT key, quote(value) "
25720	26449	"FROM temp.sqlite_parameters;", -1, &pStmt, 0);
25721	26450	while( rx==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){
25722		- utf8_printf(p->out, "%-*s %s\n", len, sqlite3_column_text(pStmt,0),
25723		- sqlite3_column_text(pStmt,1));
	26451	+ oputf("%-*s %s\n", len, sqlite3_column_text(pStmt,0),
	26452	+ sqlite3_column_text(pStmt,1));
25724	26453	}
25725	26454	sqlite3_finalize(pStmt);
25726	26455	}
25727	26456	}else
25728	26457
		@@ -25762,11 +26491,11 @@
25762	26491	"VALUES(%Q,%Q);", zKey, zValue);
25763	26492	shell_check_oom(zSql);
25764	26493	rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
25765	26494	sqlite3_free(zSql);
25766	26495	if( rx!=SQLITE_OK ){
25767		- utf8_printf(p->out, "Error: %s\n", sqlite3_errmsg(p->db));
	26496	+ oputf("Error: %s\n", sqlite3_errmsg(p->db));
25768	26497	sqlite3_finalize(pStmt);
25769	26498	pStmt = 0;
25770	26499	rc = 1;
25771	26500	}
25772	26501	}
		@@ -25791,14 +26520,14 @@
25791	26520	}else
25792	26521
25793	26522	if( c=='p' && n>=3 && cli_strncmp(azArg[0], "print", n)==0 ){
25794	26523	int i;
25795	26524	for(i=1; i<nArg; i++){
25796		- if( i>1 ) raw_printf(p->out, " ");
25797		- utf8_printf(p->out, "%s", azArg[i]);
	26525	+ if( i>1 ) oputz(" ");
	26526	+ oputz(azArg[i]);
25798	26527	}
25799		- raw_printf(p->out, "\n");
	26528	+ oputz("\n");
25800	26529	}else
25801	26530
25802	26531	#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
25803	26532	if( c=='p' && n>=3 && cli_strncmp(azArg[0], "progress", n)==0 ){
25804	26533	int i;
		@@ -25823,19 +26552,19 @@
25823	26552	p->flgProgress \|= SHELL_PROGRESS_ONCE;
25824	26553	continue;
25825	26554	}
25826	26555	if( cli_strcmp(z,"limit")==0 ){
25827	26556	if( i+1>=nArg ){
25828		- utf8_printf(stderr, "Error: missing argument on --limit\n");
	26557	+ eputz("Error: missing argument on --limit\n");
25829	26558	rc = 1;
25830	26559	goto meta_command_exit;
25831	26560	}else{
25832	26561	p->mxProgress = (int)integerValue(azArg[++i]);
25833	26562	}
25834	26563	continue;
25835	26564	}
25836		- utf8_printf(stderr, "Error: unknown option: \"%s\"\n", azArg[i]);
	26565	+ eputf("Error: unknown option: \"%s\"\n", azArg[i]);
25837	26566	rc = 1;
25838	26567	goto meta_command_exit;
25839	26568	}else{
25840	26569	nn = (int)integerValue(z);
25841	26570	}
		@@ -25864,31 +26593,31 @@
25864	26593	if( c=='r' && n>=3 && cli_strncmp(azArg[0], "read", n)==0 ){
25865	26594	FILE *inSaved = p->in;
25866	26595	int savedLineno = p->lineno;
25867	26596	failIfSafeMode(p, "cannot run .read in safe mode");
25868	26597	if( nArg!=2 ){
25869		- raw_printf(stderr, "Usage: .read FILE\n");
	26598	+ eputz("Usage: .read FILE\n");
25870	26599	rc = 1;
25871	26600	goto meta_command_exit;
25872	26601	}
25873	26602	if( azArg[1][0]=='\|' ){
25874	26603	#ifdef SQLITE_OMIT_POPEN
25875		- raw_printf(stderr, "Error: pipes are not supported in this OS\n");
	26604	+ eputz("Error: pipes are not supported in this OS\n");
25876	26605	rc = 1;
25877	26606	p->out = stdout;
25878	26607	#else
25879	26608	p->in = popen(azArg[1]+1, "r");
25880	26609	if( p->in==0 ){
25881		- utf8_printf(stderr, "Error: cannot open \"%s\"\n", azArg[1]);
	26610	+ eputf("Error: cannot open \"%s\"\n", azArg[1]);
25882	26611	rc = 1;
25883	26612	}else{
25884	26613	rc = process_input(p);
25885	26614	pclose(p->in);
25886	26615	}
25887	26616	#endif
25888	26617	}else if( (p->in = openChrSource(azArg[1]))==0 ){
25889		- utf8_printf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
	26618	+ eputf("Error: cannot open \"%s\"\n", azArg[1]);
25890	26619	rc = 1;
25891	26620	}else{
25892	26621	rc = process_input(p);
25893	26622	fclose(p->in);
25894	26623	}
		@@ -25911,24 +26640,24 @@
25911	26640	zDb = "main";
25912	26641	}else if( nArg==3 ){
25913	26642	zSrcFile = azArg[2];
25914	26643	zDb = azArg[1];
25915	26644	}else{
25916		- raw_printf(stderr, "Usage: .restore ?DB? FILE\n");
	26645	+ eputz("Usage: .restore ?DB? FILE\n");
25917	26646	rc = 1;
25918	26647	goto meta_command_exit;
25919	26648	}
25920	26649	rc = sqlite3_open(zSrcFile, &pSrc);
25921	26650	if( rc!=SQLITE_OK ){
25922		- utf8_printf(stderr, "Error: cannot open \"%s\"\n", zSrcFile);
	26651	+ eputf("Error: cannot open \"%s\"\n", zSrcFile);
25923	26652	close_db(pSrc);
25924	26653	return 1;
25925	26654	}
25926	26655	open_db(p, 0);
25927	26656	pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
25928	26657	if( pBackup==0 ){
25929		- utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
	26658	+ eputf("Error: %s\n", sqlite3_errmsg(p->db));
25930	26659	close_db(pSrc);
25931	26660	return 1;
25932	26661	}
25933	26662	while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
25934	26663	\|\| rc==SQLITE_BUSY ){
		@@ -25939,14 +26668,14 @@
25939	26668	}
25940	26669	sqlite3_backup_finish(pBackup);
25941	26670	if( rc==SQLITE_DONE ){
25942	26671	rc = 0;
25943	26672	}else if( rc==SQLITE_BUSY \|\| rc==SQLITE_LOCKED ){
25944		- raw_printf(stderr, "Error: source database is busy\n");
	26673	+ eputz("Error: source database is busy\n");
25945	26674	rc = 1;
25946	26675	}else{
25947		- utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
	26676	+ eputf("Error: %s\n", sqlite3_errmsg(p->db));
25948	26677	rc = 1;
25949	26678	}
25950	26679	close_db(pSrc);
25951	26680	}else
25952	26681	#endif /* !defined(SQLITE_SHELL_FIDDLE) */
		@@ -25963,15 +26692,19 @@
25963	26692	}
25964	26693	open_db(p, 0);
25965	26694	sqlite3_db_config(
25966	26695	p->db, SQLITE_DBCONFIG_STMT_SCANSTATUS, p->scanstatsOn, (int*)0
25967	26696	);
25968		-#ifndef SQLITE_ENABLE_STMT_SCANSTATUS
25969		- raw_printf(stderr, "Warning: .scanstats not available in this build.\n");
	26697	+#if !defined(SQLITE_ENABLE_STMT_SCANSTATUS)
	26698	+ eputz("Warning: .scanstats not available in this build.\n");
	26699	+#elif !defined(SQLITE_ENABLE_BYTECODE_VTAB)
	26700	+ if( p->scanstatsOn==3 ){
	26701	+ eputz("Warning: \".scanstats vm\" not available in this build.\n");
	26702	+ }
25970	26703	#endif
25971	26704	}else{
25972		- raw_printf(stderr, "Usage: .scanstats on\|off\|est\n");
	26705	+ eputz("Usage: .scanstats on\|off\|est\n");
25973	26706	rc = 1;
25974	26707	}
25975	26708	}else
25976	26709
25977	26710	if( c=='s' && cli_strncmp(azArg[0], "schema", n)==0 ){
		@@ -25996,18 +26729,17 @@
25996	26729	}else if( optionMatch(azArg[ii],"debug") ){
25997	26730	bDebug = 1;
25998	26731	}else if( optionMatch(azArg[ii],"nosys") ){
25999	26732	bNoSystemTabs = 1;
26000	26733	}else if( azArg[ii][0]=='-' ){
26001		- utf8_printf(stderr, "Unknown option: \"%s\"\n", azArg[ii]);
	26734	+ eputf("Unknown option: \"%s\"\n", azArg[ii]);
26002	26735	rc = 1;
26003	26736	goto meta_command_exit;
26004	26737	}else if( zName==0 ){
26005	26738	zName = azArg[ii];
26006	26739	}else{
26007		- raw_printf(stderr,
26008		- "Usage: .schema ?--indent? ?--nosys? ?LIKE-PATTERN?\n");
	26740	+ eputz("Usage: .schema ?--indent? ?--nosys? ?LIKE-PATTERN?\n");
26009	26741	rc = 1;
26010	26742	goto meta_command_exit;
26011	26743	}
26012	26744	}
26013	26745	if( zName!=0 ){
		@@ -26036,11 +26768,11 @@
26036	26768	if( zDiv ){
26037	26769	sqlite3_stmt *pStmt = 0;
26038	26770	rc = sqlite3_prepare_v2(p->db, "SELECT name FROM pragma_database_list",
26039	26771	-1, &pStmt, 0);
26040	26772	if( rc ){
26041		- utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
	26773	+ eputf("Error: %s\n", sqlite3_errmsg(p->db));
26042	26774	sqlite3_finalize(pStmt);
26043	26775	rc = 1;
26044	26776	goto meta_command_exit;
26045	26777	}
26046	26778	appendText(&sSelect, "SELECT sql FROM", 0);
		@@ -26098,22 +26830,22 @@
26098	26830	appendText(&sSelect, "name NOT LIKE 'sqlite_%%' AND ", 0);
26099	26831	}
26100	26832	appendText(&sSelect, "sql IS NOT NULL"
26101	26833	" ORDER BY snum, rowid", 0);
26102	26834	if( bDebug ){
26103		- utf8_printf(p->out, "SQL: %s;\n", sSelect.z);
	26835	+ oputf("SQL: %s;\n", sSelect.z);
26104	26836	}else{
26105	26837	rc = sqlite3_exec(p->db, sSelect.z, callback, &data, &zErrMsg);
26106	26838	}
26107	26839	freeText(&sSelect);
26108	26840	}
26109	26841	if( zErrMsg ){
26110		- utf8_printf(stderr,"Error: %s\n", zErrMsg);
	26842	+ eputf("Error: %s\n", zErrMsg);
26111	26843	sqlite3_free(zErrMsg);
26112	26844	rc = 1;
26113	26845	}else if( rc != SQLITE_OK ){
26114		- raw_printf(stderr,"Error: querying schema information\n");
	26846	+ eputz("Error: querying schema information\n");
26115	26847	rc = 1;
26116	26848	}else{
26117	26849	rc = 0;
26118	26850	}
26119	26851	}else
		@@ -26155,15 +26887,15 @@
26155	26887	*/
26156	26888	if( cli_strcmp(azCmd[0],"attach")==0 ){
26157	26889	if( nCmd!=2 ) goto session_syntax_error;
26158	26890	if( pSession->p==0 ){
26159	26891	session_not_open:
26160		- raw_printf(stderr, "ERROR: No sessions are open\n");
	26892	+ eputz("ERROR: No sessions are open\n");
26161	26893	}else{
26162	26894	rc = sqlite3session_attach(pSession->p, azCmd[1]);
26163	26895	if( rc ){
26164		- raw_printf(stderr, "ERROR: sqlite3session_attach() returns %d\n", rc);
	26896	+ eputf("ERROR: sqlite3session_attach() returns %d\n",rc);
26165	26897	rc = 0;
26166	26898	}
26167	26899	}
26168	26900	}else
26169	26901
		@@ -26178,28 +26910,27 @@
26178	26910	failIfSafeMode(p, "cannot run \".session %s\" in safe mode", azCmd[0]);
26179	26911	if( nCmd!=2 ) goto session_syntax_error;
26180	26912	if( pSession->p==0 ) goto session_not_open;
26181	26913	out = fopen(azCmd[1], "wb");
26182	26914	if( out==0 ){
26183		- utf8_printf(stderr, "ERROR: cannot open \"%s\" for writing\n",
26184		- azCmd[1]);
	26915	+ eputf("ERROR: cannot open \"%s\" for writing\n",
	26916	+ azCmd[1]);
26185	26917	}else{
26186	26918	int szChng;
26187	26919	void *pChng;
26188	26920	if( azCmd[0][0]=='c' ){
26189	26921	rc = sqlite3session_changeset(pSession->p, &szChng, &pChng);
26190	26922	}else{
26191	26923	rc = sqlite3session_patchset(pSession->p, &szChng, &pChng);
26192	26924	}
26193	26925	if( rc ){
26194		- printf("Error: error code %d\n", rc);
	26926	+ sputf(stdout, "Error: error code %d\n", rc);
26195	26927	rc = 0;
26196	26928	}
26197	26929	if( pChng
26198	26930	&& fwrite(pChng, szChng, 1, out)!=1 ){
26199		- raw_printf(stderr, "ERROR: Failed to write entire %d-byte output\n",
26200		- szChng);
	26931	+ eputf("ERROR: Failed to write entire %d-byte output\n", szChng);
26201	26932	}
26202	26933	sqlite3_free(pChng);
26203	26934	fclose(out);
26204	26935	}
26205	26936	}else
		@@ -26222,12 +26953,11 @@
26222	26953	int ii;
26223	26954	if( nCmd>2 ) goto session_syntax_error;
26224	26955	ii = nCmd==1 ? -1 : booleanValue(azCmd[1]);
26225	26956	if( pAuxDb->nSession ){
26226	26957	ii = sqlite3session_enable(pSession->p, ii);
26227		- utf8_printf(p->out, "session %s enable flag = %d\n",
26228		- pSession->zName, ii);
	26958	+ oputf("session %s enable flag = %d\n", pSession->zName, ii);
26229	26959	}
26230	26960	}else
26231	26961
26232	26962	/* .session filter GLOB ....
26233	26963	** Set a list of GLOB patterns of table names to be excluded.
		@@ -26240,14 +26970,11 @@
26240	26970	sqlite3_free(pSession->azFilter[ii]);
26241	26971	}
26242	26972	sqlite3_free(pSession->azFilter);
26243	26973	nByte = sizeof(pSession->azFilter[0])*(nCmd-1);
26244	26974	pSession->azFilter = sqlite3_malloc( nByte );
26245		- if( pSession->azFilter==0 ){
26246		- raw_printf(stderr, "Error: out or memory\n");
26247		- exit(1);
26248		- }
	26975	+ shell_check_oom( pSession->azFilter );
26249	26976	for(ii=1; ii<nCmd; ii++){
26250	26977	char *x = pSession->azFilter[ii-1] = sqlite3_mprintf("%s", azCmd[ii]);
26251	26978	shell_check_oom(x);
26252	26979	}
26253	26980	pSession->nFilter = ii-1;
		@@ -26261,12 +26988,11 @@
26261	26988	int ii;
26262	26989	if( nCmd>2 ) goto session_syntax_error;
26263	26990	ii = nCmd==1 ? -1 : booleanValue(azCmd[1]);
26264	26991	if( pAuxDb->nSession ){
26265	26992	ii = sqlite3session_indirect(pSession->p, ii);
26266		- utf8_printf(p->out, "session %s indirect flag = %d\n",
26267		- pSession->zName, ii);
	26993	+ oputf("session %s indirect flag = %d\n", pSession->zName, ii);
26268	26994	}
26269	26995	}else
26270	26996
26271	26997	/* .session isempty
26272	26998	** Determine if the session is empty
		@@ -26274,21 +27000,20 @@
26274	27000	if( cli_strcmp(azCmd[0], "isempty")==0 ){
26275	27001	int ii;
26276	27002	if( nCmd!=1 ) goto session_syntax_error;
26277	27003	if( pAuxDb->nSession ){
26278	27004	ii = sqlite3session_isempty(pSession->p);
26279		- utf8_printf(p->out, "session %s isempty flag = %d\n",
26280		- pSession->zName, ii);
	27005	+ oputf("session %s isempty flag = %d\n", pSession->zName, ii);
26281	27006	}
26282	27007	}else
26283	27008
26284	27009	/* .session list
26285	27010	** List all currently open sessions
26286	27011	*/
26287	27012	if( cli_strcmp(azCmd[0],"list")==0 ){
26288	27013	for(i=0; i<pAuxDb->nSession; i++){
26289		- utf8_printf(p->out, "%d %s\n", i, pAuxDb->aSession[i].zName);
	27014	+ oputf("%d %s\n", i, pAuxDb->aSession[i].zName);
26290	27015	}
26291	27016	}else
26292	27017
26293	27018	/* .session open DB NAME
26294	27019	** Open a new session called NAME on the attached database DB.
		@@ -26299,23 +27024,22 @@
26299	27024	if( nCmd!=3 ) goto session_syntax_error;
26300	27025	zName = azCmd[2];
26301	27026	if( zName[0]==0 ) goto session_syntax_error;
26302	27027	for(i=0; i<pAuxDb->nSession; i++){
26303	27028	if( cli_strcmp(pAuxDb->aSession[i].zName,zName)==0 ){
26304		- utf8_printf(stderr, "Session \"%s\" already exists\n", zName);
	27029	+ eputf("Session \"%s\" already exists\n", zName);
26305	27030	goto meta_command_exit;
26306	27031	}
26307	27032	}
26308	27033	if( pAuxDb->nSession>=ArraySize(pAuxDb->aSession) ){
26309		- raw_printf(stderr,
26310		- "Maximum of %d sessions\n", ArraySize(pAuxDb->aSession));
	27034	+ eputf("Maximum of %d sessions\n", ArraySize(pAuxDb->aSession));
26311	27035	goto meta_command_exit;
26312	27036	}
26313	27037	pSession = &pAuxDb->aSession[pAuxDb->nSession];
26314	27038	rc = sqlite3session_create(p->db, azCmd[1], &pSession->p);
26315	27039	if( rc ){
26316		- raw_printf(stderr, "Cannot open session: error code=%d\n", rc);
	27040	+ eputf("Cannot open session: error code=%d\n", rc);
26317	27041	rc = 0;
26318	27042	goto meta_command_exit;
26319	27043	}
26320	27044	pSession->nFilter = 0;
26321	27045	sqlite3session_table_filter(pSession->p, session_filter, pSession);
		@@ -26335,20 +27059,20 @@
26335	27059	if( c=='s' && n>=10 && cli_strncmp(azArg[0], "selftest-", 9)==0 ){
26336	27060	if( cli_strncmp(azArg[0]+9, "boolean", n-9)==0 ){
26337	27061	int i, v;
26338	27062	for(i=1; i<nArg; i++){
26339	27063	v = booleanValue(azArg[i]);
26340		- utf8_printf(p->out, "%s: %d 0x%x\n", azArg[i], v, v);
	27064	+ oputf("%s: %d 0x%x\n", azArg[i], v, v);
26341	27065	}
26342	27066	}
26343	27067	if( cli_strncmp(azArg[0]+9, "integer", n-9)==0 ){
26344	27068	int i; sqlite3_int64 v;
26345	27069	for(i=1; i<nArg; i++){
26346	27070	char zBuf[200];
26347	27071	v = integerValue(azArg[i]);
26348	27072	sqlite3_snprintf(sizeof(zBuf),zBuf,"%s: %lld 0x%llx\n", azArg[i],v,v);
26349		- utf8_printf(p->out, "%s", zBuf);
	27073	+ oputz(zBuf);
26350	27074	}
26351	27075	}
26352	27076	}else
26353	27077	#endif
26354	27078
		@@ -26371,13 +27095,12 @@
26371	27095	}else
26372	27096	if( cli_strcmp(z,"-v")==0 ){
26373	27097	bVerbose++;
26374	27098	}else
26375	27099	{
26376		- utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
26377		- azArg[i], azArg[0]);
26378		- raw_printf(stderr, "Should be one of: --init -v\n");
	27100	+ eputf("Unknown option \"%s\" on \"%s\"\n", azArg[i], azArg[0]);
	27101	+ eputz("Should be one of: --init -v\n");
26379	27102	rc = 1;
26380	27103	goto meta_command_exit;
26381	27104	}
26382	27105	}
26383	27106	if( sqlite3_table_column_metadata(p->db,"main","selftest",0,0,0,0,0,0)
		@@ -26402,11 +27125,11 @@
26402	27125	"VALUES(0,'memo','Missing SELFTEST table - default checks only',''),"
26403	27126	" (1,'run','PRAGMA integrity_check','ok')",
26404	27127	-1, &pStmt, 0);
26405	27128	}
26406	27129	if( rc ){
26407		- raw_printf(stderr, "Error querying the selftest table\n");
	27130	+ eputz("Error querying the selftest table\n");
26408	27131	rc = 1;
26409	27132	sqlite3_finalize(pStmt);
26410	27133	goto meta_command_exit;
26411	27134	}
26412	27135	for(i=1; sqlite3_step(pStmt)==SQLITE_ROW; i++){
		@@ -26418,52 +27141,51 @@
26418	27141	if( zOp==0 ) continue;
26419	27142	if( zSql==0 ) continue;
26420	27143	if( zAns==0 ) continue;
26421	27144	k = 0;
26422	27145	if( bVerbose>0 ){
26423		- printf("%d: %s %s\n", tno, zOp, zSql);
	27146	+ sputf(stdout, "%d: %s %s\n", tno, zOp, zSql);
26424	27147	}
26425	27148	if( cli_strcmp(zOp,"memo")==0 ){
26426		- utf8_printf(p->out, "%s\n", zSql);
	27149	+ oputf("%s\n", zSql);
26427	27150	}else
26428	27151	if( cli_strcmp(zOp,"run")==0 ){
26429	27152	char *zErrMsg = 0;
26430	27153	str.n = 0;
26431	27154	str.z[0] = 0;
26432	27155	rc = sqlite3_exec(p->db, zSql, captureOutputCallback, &str, &zErrMsg);
26433	27156	nTest++;
26434	27157	if( bVerbose ){
26435		- utf8_printf(p->out, "Result: %s\n", str.z);
	27158	+ oputf("Result: %s\n", str.z);
26436	27159	}
26437	27160	if( rc \|\| zErrMsg ){
26438	27161	nErr++;
26439	27162	rc = 1;
26440		- utf8_printf(p->out, "%d: error-code-%d: %s\n", tno, rc, zErrMsg);
	27163	+ oputf("%d: error-code-%d: %s\n", tno, rc, zErrMsg);
26441	27164	sqlite3_free(zErrMsg);
26442	27165	}else if( cli_strcmp(zAns,str.z)!=0 ){
26443	27166	nErr++;
26444	27167	rc = 1;
26445		- utf8_printf(p->out, "%d: Expected: [%s]\n", tno, zAns);
26446		- utf8_printf(p->out, "%d: Got: [%s]\n", tno, str.z);
	27168	+ oputf("%d: Expected: [%s]\n", tno, zAns);
	27169	+ oputf("%d: Got: [%s]\n", tno, str.z);
26447	27170	}
26448		- }else
26449		- {
26450		- utf8_printf(stderr,
26451		- "Unknown operation \"%s\" on selftest line %d\n", zOp, tno);
	27171	+ }
	27172	+ else{
	27173	+ eputf("Unknown operation \"%s\" on selftest line %d\n", zOp, tno);
26452	27174	rc = 1;
26453	27175	break;
26454	27176	}
26455	27177	} /* End loop over rows of content from SELFTEST */
26456	27178	sqlite3_finalize(pStmt);
26457	27179	} /* End loop over k */
26458	27180	freeText(&str);
26459		- utf8_printf(p->out, "%d errors out of %d tests\n", nErr, nTest);
	27181	+ oputf("%d errors out of %d tests\n", nErr, nTest);
26460	27182	}else
26461	27183
26462	27184	if( c=='s' && cli_strncmp(azArg[0], "separator", n)==0 ){
26463	27185	if( nArg<2 \|\| nArg>3 ){
26464		- raw_printf(stderr, "Usage: .separator COL ?ROW?\n");
	27186	+ eputz("Usage: .separator COL ?ROW?\n");
26465	27187	rc = 1;
26466	27188	}
26467	27189	if( nArg>=2 ){
26468	27190	sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator,
26469	27191	"%.*s", (int)ArraySize(p->colSeparator)-1, azArg[1]);
		@@ -26502,18 +27224,17 @@
26502	27224	}else
26503	27225	if( cli_strcmp(z,"debug")==0 ){
26504	27226	bDebug = 1;
26505	27227	}else
26506	27228	{
26507		- utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
26508		- azArg[i], azArg[0]);
	27229	+ eputf("Unknown option \"%s\" on \"%s\"\n", azArg[i], azArg[0]);
26509	27230	showHelp(p->out, azArg[0]);
26510	27231	rc = 1;
26511	27232	goto meta_command_exit;
26512	27233	}
26513	27234	}else if( zLike ){
26514		- raw_printf(stderr, "Usage: .sha3sum ?OPTIONS? ?LIKE-PATTERN?\n");
	27235	+ eputz("Usage: .sha3sum ?OPTIONS? ?LIKE-PATTERN?\n");
26515	27236	rc = 1;
26516	27237	goto meta_command_exit;
26517	27238	}else{
26518	27239	zLike = z;
26519	27240	bSeparate = 1;
		@@ -26581,11 +27302,11 @@
26581	27302	}
26582	27303	shell_check_oom(zSql);
26583	27304	freeText(&sQuery);
26584	27305	freeText(&sSql);
26585	27306	if( bDebug ){
26586		- utf8_printf(p->out, "%s\n", zSql);
	27307	+ oputf("%s\n", zSql);
26587	27308	}else{
26588	27309	shell_exec(p, zSql, 0);
26589	27310	}
26590	27311	#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) && !defined(SQLITE_OMIT_VIRTUALTABLE)
26591	27312	{
		@@ -26611,11 +27332,11 @@
26611	27332	"\|\|group_concat('CAST(CAST('\|\|cname\|\|' AS BLOB) AS TEXT)<>'\|\|cname\n"
26612	27333	"\|\| ' AND typeof('\|\|cname\|\|')=''text'' ',\n"
26613	27334	"' OR ') as query, tname from tabcols group by tname)"
26614	27335	, zRevText);
26615	27336	shell_check_oom(zRevText);
26616		- if( bDebug ) utf8_printf(p->out, "%s\n", zRevText);
	27337	+ if( bDebug ) oputf("%s\n", zRevText);
26617	27338	lrc = sqlite3_prepare_v2(p->db, zRevText, -1, &pStmt, 0);
26618	27339	if( lrc!=SQLITE_OK ){
26619	27340	/* assert(lrc==SQLITE_NOMEM); // might also be SQLITE_ERROR if the
26620	27341	** user does cruel and unnatural things like ".limit expr_depth 0". */
26621	27342	rc = 1;
		@@ -26624,29 +27345,28 @@
26624	27345	lrc = SQLITE_ROW==sqlite3_step(pStmt);
26625	27346	if( lrc ){
26626	27347	const char zGenQuery = (char)sqlite3_column_text(pStmt,0);
26627	27348	sqlite3_stmt *pCheckStmt;
26628	27349	lrc = sqlite3_prepare_v2(p->db, zGenQuery, -1, &pCheckStmt, 0);
26629		- if( bDebug ) utf8_printf(p->out, "%s\n", zGenQuery);
	27350	+ if( bDebug ) oputf("%s\n", zGenQuery);
26630	27351	if( lrc!=SQLITE_OK ){
26631	27352	rc = 1;
26632	27353	}else{
26633	27354	if( SQLITE_ROW==sqlite3_step(pCheckStmt) ){
26634	27355	double countIrreversible = sqlite3_column_double(pCheckStmt, 0);
26635	27356	if( countIrreversible>0 ){
26636	27357	int sz = (int)(countIrreversible + 0.5);
26637		- utf8_printf(stderr,
26638		- "Digest includes %d invalidly encoded text field%s.\n",
26639		- sz, (sz>1)? "s": "");
	27358	+ eputf("Digest includes %d invalidly encoded text field%s.\n",
	27359	+ sz, (sz>1)? "s": "");
26640	27360	}
26641	27361	}
26642	27362	sqlite3_finalize(pCheckStmt);
26643	27363	}
26644	27364	sqlite3_finalize(pStmt);
26645	27365	}
26646	27366	}
26647		- if( rc ) utf8_printf(stderr, ".sha3sum failed.\n");
	27367	+ if( rc ) eputz(".sha3sum failed.\n");
26648	27368	sqlite3_free(zRevText);
26649	27369	}
26650	27370	#endif /* !defined(_OMIT_SCHEMA_PRAGMAS) && !defined(_OMIT_VIRTUALTABLE) */
26651	27371	sqlite3_free(zSql);
26652	27372	}else
		@@ -26658,76 +27378,77 @@
26658	27378	){
26659	27379	char *zCmd;
26660	27380	int i, x;
26661	27381	failIfSafeMode(p, "cannot run .%s in safe mode", azArg[0]);
26662	27382	if( nArg<2 ){
26663		- raw_printf(stderr, "Usage: .system COMMAND\n");
	27383	+ eputz("Usage: .system COMMAND\n");
26664	27384	rc = 1;
26665	27385	goto meta_command_exit;
26666	27386	}
26667	27387	zCmd = sqlite3_mprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]);
26668	27388	for(i=2; i<nArg && zCmd!=0; i++){
26669	27389	zCmd = sqlite3_mprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"",
26670	27390	zCmd, azArg[i]);
26671	27391	}
	27392	+ consoleRestore();
26672	27393	x = zCmd!=0 ? system(zCmd) : 1;
	27394	+ consoleRenewSetup();
26673	27395	sqlite3_free(zCmd);
26674		- if( x ) raw_printf(stderr, "System command returns %d\n", x);
	27396	+ if( x ) eputf("System command returns %d\n", x);
26675	27397	}else
26676	27398	#endif /* !defined(SQLITE_NOHAVE_SYSTEM) && !defined(SQLITE_SHELL_FIDDLE) */
26677	27399
26678	27400	if( c=='s' && cli_strncmp(azArg[0], "show", n)==0 ){
26679	27401	static const char *azBool[] = { "off", "on", "trigger", "full"};
26680	27402	const char *zOut;
26681	27403	int i;
26682	27404	if( nArg!=1 ){
26683		- raw_printf(stderr, "Usage: .show\n");
	27405	+ eputz("Usage: .show\n");
26684	27406	rc = 1;
26685	27407	goto meta_command_exit;
26686	27408	}
26687		- utf8_printf(p->out, "%12.12s: %s\n","echo",
26688		- azBool[ShellHasFlag(p, SHFLG_Echo)]);
26689		- utf8_printf(p->out, "%12.12s: %s\n","eqp", azBool[p->autoEQP&3]);
26690		- utf8_printf(p->out, "%12.12s: %s\n","explain",
26691		- p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off");
26692		- utf8_printf(p->out,"%12.12s: %s\n","headers", azBool[p->showHeader!=0]);
	27409	+ oputf("%12.12s: %s\n","echo",
	27410	+ azBool[ShellHasFlag(p, SHFLG_Echo)]);
	27411	+ oputf("%12.12s: %s\n","eqp", azBool[p->autoEQP&3]);
	27412	+ oputf("%12.12s: %s\n","explain",
	27413	+ p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off");
	27414	+ oputf("%12.12s: %s\n","headers", azBool[p->showHeader!=0]);
26693	27415	if( p->mode==MODE_Column
26694	27416	\|\| (p->mode>=MODE_Markdown && p->mode<=MODE_Box)
26695	27417	){
26696		- utf8_printf
26697		- (p->out, "%12.12s: %s --wrap %d --wordwrap %s --%squote\n", "mode",
26698		- modeDescr[p->mode], p->cmOpts.iWrap,
26699		- p->cmOpts.bWordWrap ? "on" : "off",
26700		- p->cmOpts.bQuote ? "" : "no");
	27418	+ oputf("%12.12s: %s --wrap %d --wordwrap %s --%squote\n", "mode",
	27419	+ modeDescr[p->mode], p->cmOpts.iWrap,
	27420	+ p->cmOpts.bWordWrap ? "on" : "off",
	27421	+ p->cmOpts.bQuote ? "" : "no");
26701	27422	}else{
26702		- utf8_printf(p->out, "%12.12s: %s\n","mode", modeDescr[p->mode]);
26703		- }
26704		- utf8_printf(p->out, "%12.12s: ", "nullvalue");
26705		- output_c_string(p->out, p->nullValue);
26706		- raw_printf(p->out, "\n");
26707		- utf8_printf(p->out,"%12.12s: %s\n","output",
26708		- strlen30(p->outfile) ? p->outfile : "stdout");
26709		- utf8_printf(p->out,"%12.12s: ", "colseparator");
26710		- output_c_string(p->out, p->colSeparator);
26711		- raw_printf(p->out, "\n");
26712		- utf8_printf(p->out,"%12.12s: ", "rowseparator");
26713		- output_c_string(p->out, p->rowSeparator);
26714		- raw_printf(p->out, "\n");
	27423	+ oputf("%12.12s: %s\n","mode", modeDescr[p->mode]);
	27424	+ }
	27425	+ oputf("%12.12s: ", "nullvalue");
	27426	+ output_c_string(p->nullValue);
	27427	+ oputz("\n");
	27428	+ oputf("%12.12s: %s\n","output",
	27429	+ strlen30(p->outfile) ? p->outfile : "stdout");
	27430	+ oputf("%12.12s: ", "colseparator");
	27431	+ output_c_string(p->colSeparator);
	27432	+ oputz("\n");
	27433	+ oputf("%12.12s: ", "rowseparator");
	27434	+ output_c_string(p->rowSeparator);
	27435	+ oputz("\n");
26715	27436	switch( p->statsOn ){
26716	27437	case 0: zOut = "off"; break;
26717	27438	default: zOut = "on"; break;
26718	27439	case 2: zOut = "stmt"; break;
26719	27440	case 3: zOut = "vmstep"; break;
26720	27441	}
26721		- utf8_printf(p->out, "%12.12s: %s\n","stats", zOut);
26722		- utf8_printf(p->out, "%12.12s: ", "width");
	27442	+ oputf("%12.12s: %s\n","stats", zOut);
	27443	+ oputf("%12.12s: ", "width");
26723	27444	for (i=0;i<p->nWidth;i++) {
26724		- raw_printf(p->out, "%d ", p->colWidth[i]);
	27445	+ oputf("%d ", p->colWidth[i]);
26725	27446	}
26726		- raw_printf(p->out, "\n");
26727		- utf8_printf(p->out, "%12.12s: %s\n", "filename",
26728		- p->pAuxDb->zDbFilename ? p->pAuxDb->zDbFilename : "");
	27447	+ oputz("\n");
	27448	+ oputf("%12.12s: %s\n", "filename",
	27449	+ p->pAuxDb->zDbFilename ? p->pAuxDb->zDbFilename : "");
26729	27450	}else
26730	27451
26731	27452	if( c=='s' && cli_strncmp(azArg[0], "stats", n)==0 ){
26732	27453	if( nArg==2 ){
26733	27454	if( cli_strcmp(azArg[1],"stmt")==0 ){
		@@ -26738,11 +27459,11 @@
26738	27459	p->statsOn = (u8)booleanValue(azArg[1]);
26739	27460	}
26740	27461	}else if( nArg==1 ){
26741	27462	display_stats(p->db, p, 0);
26742	27463	}else{
26743		- raw_printf(stderr, "Usage: .stats ?on\|off\|stmt\|vmstep?\n");
	27464	+ eputz("Usage: .stats ?on\|off\|stmt\|vmstep?\n");
26744	27465	rc = 1;
26745	27466	}
26746	27467	}else
26747	27468
26748	27469	if( (c=='t' && n>1 && cli_strncmp(azArg[0], "tables", n)==0)
		@@ -26764,11 +27485,11 @@
26764	27485
26765	27486	if( nArg>2 && c=='i' ){
26766	27487	/* It is an historical accident that the .indexes command shows an error
26767	27488	** when called with the wrong number of arguments whereas the .tables
26768	27489	** command does not. */
26769		- raw_printf(stderr, "Usage: .indexes ?LIKE-PATTERN?\n");
	27490	+ eputz("Usage: .indexes ?LIKE-PATTERN?\n");
26770	27491	rc = 1;
26771	27492	sqlite3_finalize(pStmt);
26772	27493	goto meta_command_exit;
26773	27494	}
26774	27495	for(ii=0; sqlite3_step(pStmt)==SQLITE_ROW; ii++){
		@@ -26840,14 +27561,13 @@
26840	27561	if( nPrintCol<1 ) nPrintCol = 1;
26841	27562	nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
26842	27563	for(i=0; i<nPrintRow; i++){
26843	27564	for(j=i; j<nRow; j+=nPrintRow){
26844	27565	char *zSp = j<nPrintRow ? "" : " ";
26845		- utf8_printf(p->out, "%s%-*s", zSp, maxlen,
26846		- azResult[j] ? azResult[j]:"");
	27566	+ oputf("%s%-*s", zSp, maxlen, azResult[j] ? azResult[j]:"");
26847	27567	}
26848		- raw_printf(p->out, "\n");
	27568	+ oputz("\n");
26849	27569	}
26850	27570	}
26851	27571
26852	27572	for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]);
26853	27573	sqlite3_free(azResult);
		@@ -26857,11 +27577,11 @@
26857	27577	/* Begin redirecting output to the file "testcase-out.txt" */
26858	27578	if( c=='t' && cli_strcmp(azArg[0],"testcase")==0 ){
26859	27579	output_reset(p);
26860	27580	p->out = output_file_open("testcase-out.txt", 0);
26861	27581	if( p->out==0 ){
26862		- raw_printf(stderr, "Error: cannot open 'testcase-out.txt'\n");
	27582	+ eputz("Error: cannot open 'testcase-out.txt'\n");
26863	27583	}
26864	27584	if( nArg>=2 ){
26865	27585	sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "%s", azArg[1]);
26866	27586	}else{
26867	27587	sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "?");
		@@ -26898,11 +27618,11 @@
26898	27618	{"prng_save", SQLITE_TESTCTRL_PRNG_SAVE, 0, "" },
26899	27619	{"prng_seed", SQLITE_TESTCTRL_PRNG_SEED, 0, "SEED ?db?" },
26900	27620	{"seek_count", SQLITE_TESTCTRL_SEEK_COUNT, 0, "" },
26901	27621	{"sorter_mmap", SQLITE_TESTCTRL_SORTER_MMAP, 0, "NMAX" },
26902	27622	{"tune", SQLITE_TESTCTRL_TUNE, 1, "ID VALUE" },
26903		- {"uselongdouble", SQLITE_TESTCTRL_USELONGDOUBLE,0,"?BOOLEAN\|\"default\"?"},
	27623	+ {"uselongdouble", SQLITE_TESTCTRL_USELONGDOUBLE,0,"?BOOLEAN\|\"default\"?"},
26904	27624	};
26905	27625	int testctrl = -1;
26906	27626	int iCtrl = -1;
26907	27627	int rc2 = 0; /* 0: usage. 1: %d 2: %x 3: no-output */
26908	27628	int isOk = 0;
		@@ -26918,15 +27638,15 @@
26918	27638	if( zCmd[0]=='-' && zCmd[1] ) zCmd++;
26919	27639	}
26920	27640
26921	27641	/* --help lists all test-controls */
26922	27642	if( cli_strcmp(zCmd,"help")==0 ){
26923		- utf8_printf(p->out, "Available test-controls:\n");
	27643	+ oputz("Available test-controls:\n");
26924	27644	for(i=0; i<ArraySize(aCtrl); i++){
26925	27645	if( aCtrl[i].unSafe && !ShellHasFlag(p,SHFLG_TestingMode) ) continue;
26926		- utf8_printf(p->out, " .testctrl %s %s\n",
26927		- aCtrl[i].zCtrlName, aCtrl[i].zUsage);
	27646	+ oputf(" .testctrl %s %s\n",
	27647	+ aCtrl[i].zCtrlName, aCtrl[i].zUsage);
26928	27648	}
26929	27649	rc = 1;
26930	27650	goto meta_command_exit;
26931	27651	}
26932	27652
		@@ -26938,20 +27658,20 @@
26938	27658	if( cli_strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){
26939	27659	if( testctrl<0 ){
26940	27660	testctrl = aCtrl[i].ctrlCode;
26941	27661	iCtrl = i;
26942	27662	}else{
26943		- utf8_printf(stderr, "Error: ambiguous test-control: \"%s\"\n"
26944		- "Use \".testctrl --help\" for help\n", zCmd);
	27663	+ eputf("Error: ambiguous test-control: \"%s\"\n"
	27664	+ "Use \".testctrl --help\" for help\n", zCmd);
26945	27665	rc = 1;
26946	27666	goto meta_command_exit;
26947	27667	}
26948	27668	}
26949	27669	}
26950	27670	if( testctrl<0 ){
26951		- utf8_printf(stderr,"Error: unknown test-control: %s\n"
26952		- "Use \".testctrl --help\" for help\n", zCmd);
	27671	+ eputf("Error: unknown test-control: %s\n"
	27672	+ "Use \".testctrl --help\" for help\n", zCmd);
26953	27673	}else{
26954	27674	switch(testctrl){
26955	27675
26956	27676	/* sqlite3_test_control(int, db, int) */
26957	27677	case SQLITE_TESTCTRL_OPTIMIZATIONS:
		@@ -26987,11 +27707,11 @@
26987	27707	if( nArg==3 \|\| nArg==4 ){
26988	27708	int ii = (int)integerValue(azArg[2]);
26989	27709	sqlite3 *db;
26990	27710	if( ii==0 && cli_strcmp(azArg[2],"random")==0 ){
26991	27711	sqlite3_randomness(sizeof(ii),&ii);
26992		- printf("-- random seed: %d\n", ii);
	27712	+ sputf(stdout, "-- random seed: %d\n", ii);
26993	27713	}
26994	27714	if( nArg==3 ){
26995	27715	db = 0;
26996	27716	}else{
26997	27717	db = p->db;
		@@ -27055,11 +27775,11 @@
27055	27775	break;
27056	27776
27057	27777	case SQLITE_TESTCTRL_SEEK_COUNT: {
27058	27778	u64 x = 0;
27059	27779	rc2 = sqlite3_test_control(testctrl, p->db, &x);
27060		- utf8_printf(p->out, "%llu\n", x);
	27780	+ oputf("%llu\n", x);
27061	27781	isOk = 3;
27062	27782	break;
27063	27783	}
27064	27784
27065	27785	#ifdef YYCOVERAGE
		@@ -27086,15 +27806,15 @@
27086	27806	int id = 1;
27087	27807	while(1){
27088	27808	int val = 0;
27089	27809	rc2 = sqlite3_test_control(testctrl, -id, &val);
27090	27810	if( rc2!=SQLITE_OK ) break;
27091		- if( id>1 ) utf8_printf(p->out, " ");
27092		- utf8_printf(p->out, "%d: %d", id, val);
	27811	+ if( id>1 ) oputz(" ");
	27812	+ oputf("%d: %d", id, val);
27093	27813	id++;
27094	27814	}
27095		- if( id>1 ) utf8_printf(p->out, "\n");
	27815	+ if( id>1 ) oputz("\n");
27096	27816	isOk = 3;
27097	27817	}
27098	27818	break;
27099	27819	}
27100	27820	#endif
		@@ -27106,16 +27826,16 @@
27106	27826	}
27107	27827	break;
27108	27828	}
27109	27829	}
27110	27830	if( isOk==0 && iCtrl>=0 ){
27111		- utf8_printf(p->out, "Usage: .testctrl %s %s\n", zCmd,aCtrl[iCtrl].zUsage);
	27831	+ oputf("Usage: .testctrl %s %s\n", zCmd,aCtrl[iCtrl].zUsage);
27112	27832	rc = 1;
27113	27833	}else if( isOk==1 ){
27114		- raw_printf(p->out, "%d\n", rc2);
	27834	+ oputf("%d\n", rc2);
27115	27835	}else if( isOk==2 ){
27116		- raw_printf(p->out, "0x%08x\n", rc2);
	27836	+ oputf("0x%08x\n", rc2);
27117	27837	}
27118	27838	}else
27119	27839	#endif /* !defined(SQLITE_UNTESTABLE) */
27120	27840
27121	27841	if( c=='t' && n>4 && cli_strncmp(azArg[0], "timeout", n)==0 ){
		@@ -27125,15 +27845,15 @@
27125	27845
27126	27846	if( c=='t' && n>=5 && cli_strncmp(azArg[0], "timer", n)==0 ){
27127	27847	if( nArg==2 ){
27128	27848	enableTimer = booleanValue(azArg[1]);
27129	27849	if( enableTimer && !HAS_TIMER ){
27130		- raw_printf(stderr, "Error: timer not available on this system.\n");
	27850	+ eputz("Error: timer not available on this system.\n");
27131	27851	enableTimer = 0;
27132	27852	}
27133	27853	}else{
27134		- raw_printf(stderr, "Usage: .timer on\|off\n");
	27854	+ eputz("Usage: .timer on\|off\n");
27135	27855	rc = 1;
27136	27856	}
27137	27857	}else
27138	27858
27139	27859	#ifndef SQLITE_OMIT_TRACE
		@@ -27166,11 +27886,11 @@
27166	27886	}
27167	27887	else if( optionMatch(z, "close") ){
27168	27888	mType \|= SQLITE_TRACE_CLOSE;
27169	27889	}
27170	27890	else {
27171		- raw_printf(stderr, "Unknown option \"%s\" on \".trace\"\n", z);
	27891	+ eputf("Unknown option \"%s\" on \".trace\"\n", z);
27172	27892	rc = 1;
27173	27893	goto meta_command_exit;
27174	27894	}
27175	27895	}else{
27176	27896	output_file_close(p->traceOut);
		@@ -27190,11 +27910,11 @@
27190	27910	if( c=='u' && cli_strncmp(azArg[0], "unmodule", n)==0 ){
27191	27911	int ii;
27192	27912	int lenOpt;
27193	27913	char *zOpt;
27194	27914	if( nArg<2 ){
27195		- raw_printf(stderr, "Usage: .unmodule [--allexcept] NAME ...\n");
	27915	+ eputz("Usage: .unmodule [--allexcept] NAME ...\n");
27196	27916	rc = 1;
27197	27917	goto meta_command_exit;
27198	27918	}
27199	27919	open_db(p, 0);
27200	27920	zOpt = azArg[1];
		@@ -27212,100 +27932,100 @@
27212	27932	#endif
27213	27933
27214	27934	#if SQLITE_USER_AUTHENTICATION
27215	27935	if( c=='u' && cli_strncmp(azArg[0], "user", n)==0 ){
27216	27936	if( nArg<2 ){
27217		- raw_printf(stderr, "Usage: .user SUBCOMMAND ...\n");
	27937	+ eputz("Usage: .user SUBCOMMAND ...\n");
27218	27938	rc = 1;
27219	27939	goto meta_command_exit;
27220	27940	}
27221	27941	open_db(p, 0);
27222	27942	if( cli_strcmp(azArg[1],"login")==0 ){
27223	27943	if( nArg!=4 ){
27224		- raw_printf(stderr, "Usage: .user login USER PASSWORD\n");
	27944	+ eputz("Usage: .user login USER PASSWORD\n");
27225	27945	rc = 1;
27226	27946	goto meta_command_exit;
27227	27947	}
27228	27948	rc = sqlite3_user_authenticate(p->db, azArg[2], azArg[3],
27229	27949	strlen30(azArg[3]));
27230	27950	if( rc ){
27231		- utf8_printf(stderr, "Authentication failed for user %s\n", azArg[2]);
	27951	+ eputf("Authentication failed for user %s\n", azArg[2]);
27232	27952	rc = 1;
27233	27953	}
27234	27954	}else if( cli_strcmp(azArg[1],"add")==0 ){
27235	27955	if( nArg!=5 ){
27236		- raw_printf(stderr, "Usage: .user add USER PASSWORD ISADMIN\n");
	27956	+ eputz("Usage: .user add USER PASSWORD ISADMIN\n");
27237	27957	rc = 1;
27238	27958	goto meta_command_exit;
27239	27959	}
27240	27960	rc = sqlite3_user_add(p->db, azArg[2], azArg[3], strlen30(azArg[3]),
27241	27961	booleanValue(azArg[4]));
27242	27962	if( rc ){
27243		- raw_printf(stderr, "User-Add failed: %d\n", rc);
	27963	+ eputf("User-Add failed: %d\n", rc);
27244	27964	rc = 1;
27245	27965	}
27246	27966	}else if( cli_strcmp(azArg[1],"edit")==0 ){
27247	27967	if( nArg!=5 ){
27248		- raw_printf(stderr, "Usage: .user edit USER PASSWORD ISADMIN\n");
	27968	+ eputz("Usage: .user edit USER PASSWORD ISADMIN\n");
27249	27969	rc = 1;
27250	27970	goto meta_command_exit;
27251	27971	}
27252	27972	rc = sqlite3_user_change(p->db, azArg[2], azArg[3], strlen30(azArg[3]),
27253	27973	booleanValue(azArg[4]));
27254	27974	if( rc ){
27255		- raw_printf(stderr, "User-Edit failed: %d\n", rc);
	27975	+ eputf("User-Edit failed: %d\n", rc);
27256	27976	rc = 1;
27257	27977	}
27258	27978	}else if( cli_strcmp(azArg[1],"delete")==0 ){
27259	27979	if( nArg!=3 ){
27260		- raw_printf(stderr, "Usage: .user delete USER\n");
	27980	+ eputz("Usage: .user delete USER\n");
27261	27981	rc = 1;
27262	27982	goto meta_command_exit;
27263	27983	}
27264	27984	rc = sqlite3_user_delete(p->db, azArg[2]);
27265	27985	if( rc ){
27266		- raw_printf(stderr, "User-Delete failed: %d\n", rc);
	27986	+ eputf("User-Delete failed: %d\n", rc);
27267	27987	rc = 1;
27268	27988	}
27269	27989	}else{
27270		- raw_printf(stderr, "Usage: .user login\|add\|edit\|delete ...\n");
	27990	+ eputz("Usage: .user login\|add\|edit\|delete ...\n");
27271	27991	rc = 1;
27272	27992	goto meta_command_exit;
27273	27993	}
27274	27994	}else
27275	27995	#endif /* SQLITE_USER_AUTHENTICATION */
27276	27996
27277	27997	if( c=='v' && cli_strncmp(azArg[0], "version", n)==0 ){
27278	27998	char zPtrSz = sizeof(void)==8 ? "64-bit" : "32-bit";
27279		- utf8_printf(p->out, "SQLite %s %s\n" /extra-version-info/,
27280		- sqlite3_libversion(), sqlite3_sourceid());
	27999	+ oputf("SQLite %s %s\n" /extra-version-info/,
	28000	+ sqlite3_libversion(), sqlite3_sourceid());
27281	28001	#if SQLITE_HAVE_ZLIB
27282		- utf8_printf(p->out, "zlib version %s\n", zlibVersion());
	28002	+ oputf("zlib version %s\n", zlibVersion());
27283	28003	#endif
27284	28004	#define CTIMEOPT_VAL_(opt) #opt
27285	28005	#define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt)
27286	28006	#if defined(__clang__) && defined(__clang_major__)
27287		- utf8_printf(p->out, "clang-" CTIMEOPT_VAL(__clang_major__) "."
27288		- CTIMEOPT_VAL(__clang_minor__) "."
27289		- CTIMEOPT_VAL(__clang_patchlevel__) " (%s)\n", zPtrSz);
	28007	+ oputf("clang-" CTIMEOPT_VAL(__clang_major__) "."
	28008	+ CTIMEOPT_VAL(__clang_minor__) "."
	28009	+ CTIMEOPT_VAL(__clang_patchlevel__) " (%s)\n", zPtrSz);
27290	28010	#elif defined(_MSC_VER)
27291		- utf8_printf(p->out, "msvc-" CTIMEOPT_VAL(_MSC_VER) " (%s)\n", zPtrSz);
	28011	+ oputf("msvc-" CTIMEOPT_VAL(_MSC_VER) " (%s)\n", zPtrSz);
27292	28012	#elif defined(__GNUC__) && defined(__VERSION__)
27293		- utf8_printf(p->out, "gcc-" __VERSION__ " (%s)\n", zPtrSz);
	28013	+ oputf("gcc-" __VERSION__ " (%s)\n", zPtrSz);
27294	28014	#endif
27295	28015	}else
27296	28016
27297	28017	if( c=='v' && cli_strncmp(azArg[0], "vfsinfo", n)==0 ){
27298	28018	const char *zDbName = nArg==2 ? azArg[1] : "main";
27299	28019	sqlite3_vfs *pVfs = 0;
27300	28020	if( p->db ){
27301	28021	sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFS_POINTER, &pVfs);
27302	28022	if( pVfs ){
27303		- utf8_printf(p->out, "vfs.zName = \"%s\"\n", pVfs->zName);
27304		- raw_printf(p->out, "vfs.iVersion = %d\n", pVfs->iVersion);
27305		- raw_printf(p->out, "vfs.szOsFile = %d\n", pVfs->szOsFile);
27306		- raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname);
	28023	+ oputf("vfs.zName = \"%s\"\n", pVfs->zName);
	28024	+ oputf("vfs.iVersion = %d\n", pVfs->iVersion);
	28025	+ oputf("vfs.szOsFile = %d\n", pVfs->szOsFile);
	28026	+ oputf("vfs.mxPathname = %d\n", pVfs->mxPathname);
27307	28027	}
27308	28028	}
27309	28029	}else
27310	28030
27311	28031	if( c=='v' && cli_strncmp(azArg[0], "vfslist", n)==0 ){
		@@ -27313,17 +28033,17 @@
27313	28033	sqlite3_vfs *pCurrent = 0;
27314	28034	if( p->db ){
27315	28035	sqlite3_file_control(p->db, "main", SQLITE_FCNTL_VFS_POINTER, &pCurrent);
27316	28036	}
27317	28037	for(pVfs=sqlite3_vfs_find(0); pVfs; pVfs=pVfs->pNext){
27318		- utf8_printf(p->out, "vfs.zName = \"%s\"%s\n", pVfs->zName,
27319		- pVfs==pCurrent ? " <--- CURRENT" : "");
27320		- raw_printf(p->out, "vfs.iVersion = %d\n", pVfs->iVersion);
27321		- raw_printf(p->out, "vfs.szOsFile = %d\n", pVfs->szOsFile);
27322		- raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname);
	28038	+ oputf("vfs.zName = \"%s\"%s\n", pVfs->zName,
	28039	+ pVfs==pCurrent ? " <--- CURRENT" : "");
	28040	+ oputf("vfs.iVersion = %d\n", pVfs->iVersion);
	28041	+ oputf("vfs.szOsFile = %d\n", pVfs->szOsFile);
	28042	+ oputf("vfs.mxPathname = %d\n", pVfs->mxPathname);
27323	28043	if( pVfs->pNext ){
27324		- raw_printf(p->out, "-----------------------------------\n");
	28044	+ oputz("-----------------------------------\n");
27325	28045	}
27326	28046	}
27327	28047	}else
27328	28048
27329	28049	if( c=='v' && cli_strncmp(azArg[0], "vfsname", n)==0 ){
		@@ -27330,11 +28050,11 @@
27330	28050	const char *zDbName = nArg==2 ? azArg[1] : "main";
27331	28051	char *zVfsName = 0;
27332	28052	if( p->db ){
27333	28053	sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName);
27334	28054	if( zVfsName ){
27335		- utf8_printf(p->out, "%s\n", zVfsName);
	28055	+ oputf("%s\n", zVfsName);
27336	28056	sqlite3_free(zVfsName);
27337	28057	}
27338	28058	}
27339	28059	}else
27340	28060
		@@ -27354,12 +28074,12 @@
27354	28074	p->colWidth[j-1] = (int)integerValue(azArg[j]);
27355	28075	}
27356	28076	}else
27357	28077
27358	28078	{
27359		- utf8_printf(stderr, "Error: unknown command or invalid arguments: "
27360		- " \"%s\". Enter \".help\" for help\n", azArg[0]);
	28079	+ eputf("Error: unknown command or invalid arguments: "
	28080	+ " \"%s\". Enter \".help\" for help\n", azArg[0]);
27361	28081	rc = 1;
27362	28082	}
27363	28083
27364	28084	meta_command_exit:
27365	28085	if( p->outCount ){
		@@ -27545,26 +28265,26 @@
27545	28265	sqlite3_snprintf(sizeof(zPrefix), zPrefix,
27546	28266	"%s near line %d:", zErrorType, startline);
27547	28267	}else{
27548	28268	sqlite3_snprintf(sizeof(zPrefix), zPrefix, "%s:", zErrorType);
27549	28269	}
27550		- utf8_printf(stderr, "%s %s\n", zPrefix, zErrorTail);
	28270	+ eputf("%s %s\n", zPrefix, zErrorTail);
27551	28271	sqlite3_free(zErrMsg);
27552	28272	zErrMsg = 0;
27553	28273	return 1;
27554	28274	}else if( ShellHasFlag(p, SHFLG_CountChanges) ){
27555	28275	char zLineBuf[2000];
27556	28276	sqlite3_snprintf(sizeof(zLineBuf), zLineBuf,
27557	28277	"changes: %lld total_changes: %lld",
27558	28278	sqlite3_changes64(p->db), sqlite3_total_changes64(p->db));
27559		- raw_printf(p->out, "%s\n", zLineBuf);
	28279	+ oputf("%s\n", zLineBuf);
27560	28280	}
27561	28281	return 0;
27562	28282	}
27563	28283
27564	28284	static void echo_group_input(ShellState p, const char zDo){
27565		- if( ShellHasFlag(p, SHFLG_Echo) ) utf8_printf(p->out, "%s\n", zDo);
	28285	+ if( ShellHasFlag(p, SHFLG_Echo) ) oputf("%s\n", zDo);
27566	28286	}
27567	28287
27568	28288	#ifdef SQLITE_SHELL_FIDDLE
27569	28289	/*
27570	28290	** Alternate one_input_line() impl for wasm mode. This is not in the primary
		@@ -27618,12 +28338,12 @@
27618	28338	i64 startline = 0; /* Line number for start of current input */
27619	28339	QuickScanState qss = QSS_Start; /* Accumulated line status (so far) */
27620	28340
27621	28341	if( p->inputNesting==MAX_INPUT_NESTING ){
27622	28342	/* This will be more informative in a later version. */
27623		- utf8_printf(stderr,"Input nesting limit (%d) reached at line %d."
27624		- " Check recursion.\n", MAX_INPUT_NESTING, p->lineno);
	28343	+ eputf("Input nesting limit (%d) reached at line %d."
	28344	+ " Check recursion.\n", MAX_INPUT_NESTING, p->lineno);
27625	28345	return 1;
27626	28346	}
27627	28347	++p->inputNesting;
27628	28348	p->lineno = 0;
27629	28349	CONTINUE_PROMPT_RESET;
		@@ -27630,11 +28350,11 @@
27630	28350	while( errCnt==0 \|\| !bail_on_error \|\| (p->in==0 && stdin_is_interactive) ){
27631	28351	fflush(p->out);
27632	28352	zLine = one_input_line(p->in, zLine, nSql>0);
27633	28353	if( zLine==0 ){
27634	28354	/* End of input */
27635		- if( p->in==0 && stdin_is_interactive ) printf("\n");
	28355	+ if( p->in==0 && stdin_is_interactive ) oputz("\n");
27636	28356	break;
27637	28357	}
27638	28358	if( seenInterrupt ){
27639	28359	if( p->in!=0 ) break;
27640	28360	seenInterrupt = 0;
		@@ -27840,27 +28560,27 @@
27840	28560	sqliterc = find_xdg_config();
27841	28561	}
27842	28562	if( sqliterc == NULL ){
27843	28563	home_dir = find_home_dir(0);
27844	28564	if( home_dir==0 ){
27845		- raw_printf(stderr, "-- warning: cannot find home directory;"
27846		- " cannot read ~/.sqliterc\n");
	28565	+ eputz("-- warning: cannot find home directory;"
	28566	+ " cannot read ~/.sqliterc\n");
27847	28567	return;
27848	28568	}
27849	28569	zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir);
27850	28570	shell_check_oom(zBuf);
27851	28571	sqliterc = zBuf;
27852	28572	}
27853	28573	p->in = fopen(sqliterc,"rb");
27854	28574	if( p->in ){
27855	28575	if( stdin_is_interactive ){
27856		- utf8_printf(stderr,"-- Loading resources from %s\n",sqliterc);
	28576	+ eputf("-- Loading resources from %s\n", sqliterc);
27857	28577	}
27858	28578	if( process_input(p) && bail_on_error ) exit(1);
27859	28579	fclose(p->in);
27860	28580	}else if( sqliterc_override!=0 ){
27861		- utf8_printf(stderr,"cannot open: \"%s\"\n", sqliterc);
	28581	+ eputf("cannot open: \"%s\"\n", sqliterc);
27862	28582	if( bail_on_error ) exit(1);
27863	28583	}
27864	28584	p->in = inSaved;
27865	28585	p->lineno = savedLineno;
27866	28586	sqlite3_free(zBuf);
		@@ -27906,13 +28626,10 @@
27906	28626	" -mmap N default mmap size set to N\n"
27907	28627	#ifdef SQLITE_ENABLE_MULTIPLEX
27908	28628	" -multiplex enable the multiplexor VFS\n"
27909	28629	#endif
27910	28630	" -newline SEP set output row separator. Default: '\\n'\n"
27911		-#if SHELL_WIN_UTF8_OPT
27912		- " -no-utf8 do not try to set up UTF-8 output (for legacy)\n"
27913		-#endif
27914	28631	" -nofollow refuse to open symbolic links to database files\n"
27915	28632	" -nonce STRING set the safe-mode escape nonce\n"
27916	28633	" -nullvalue TEXT set text string for NULL values. Default ''\n"
27917	28634	" -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n"
27918	28635	" -pcachetrace trace all page cache operations\n"
		@@ -27925,13 +28642,10 @@
27925	28642	#endif
27926	28643	" -stats print memory stats before each finalize\n"
27927	28644	" -table set output mode to 'table'\n"
27928	28645	" -tabs set output mode to 'tabs'\n"
27929	28646	" -unsafe-testing allow unsafe commands and modes for testing\n"
27930		-#if SHELL_WIN_UTF8_OPT && 0 /* Option is accepted, but is now the default. */
27931		- " -utf8 setup interactive console code page for UTF-8\n"
27932		-#endif
27933	28647	" -version show SQLite version\n"
27934	28648	" -vfs NAME use NAME as the default VFS\n"
27935	28649	#ifdef SQLITE_ENABLE_VFSTRACE
27936	28650	" -vfstrace enable tracing of all VFS calls\n"
27937	28651	#endif
		@@ -27938,18 +28652,17 @@
27938	28652	#ifdef SQLITE_HAVE_ZLIB
27939	28653	" -zip open the file as a ZIP Archive\n"
27940	28654	#endif
27941	28655	;
27942	28656	static void usage(int showDetail){
27943		- utf8_printf(stderr,
27944		- "Usage: %s [OPTIONS] [FILENAME [SQL]]\n"
27945		- "FILENAME is the name of an SQLite database. A new database is created\n"
27946		- "if the file does not previously exist. Defaults to :memory:.\n", Argv0);
	28657	+ eputf("Usage: %s [OPTIONS] [FILENAME [SQL]]\n"
	28658	+ "FILENAME is the name of an SQLite database. A new database is created\n"
	28659	+ "if the file does not previously exist. Defaults to :memory:.\n", Argv0);
27947	28660	if( showDetail ){
27948		- utf8_printf(stderr, "OPTIONS include:\n%s", zOptions);
	28661	+ eputf("OPTIONS include:\n%s", zOptions);
27949	28662	}else{
27950		- raw_printf(stderr, "Use the -help option for additional information\n");
	28663	+ eputz("Use the -help option for additional information\n");
27951	28664	}
27952	28665	exit(1);
27953	28666	}
27954	28667
27955	28668	/*
		@@ -27956,12 +28669,12 @@
27956	28669	** Internal check: Verify that the SQLite is uninitialized. Print a
27957	28670	** error message if it is initialized.
27958	28671	*/
27959	28672	static void verify_uninitialized(void){
27960	28673	if( sqlite3_config(-1)==SQLITE_MISUSE ){
27961		- utf8_printf(stdout, "WARNING: attempt to configure SQLite after"
27962		- " initialization.\n");
	28674	+ sputz(stdout, "WARNING: attempt to configure SQLite after"
	28675	+ " initialization.\n");
27963	28676	}
27964	28677	}
27965	28678
27966	28679	/*
27967	28680	** Initialize the state information in data
		@@ -27986,46 +28699,45 @@
27986	28699	}
27987	28700
27988	28701	/*
27989	28702	** Output text to the console in a font that attracts extra attention.
27990	28703	*/
27991		-#ifdef _WIN32
	28704	+#if defined(_WIN32) \|\| defined(WIN32)
27992	28705	static void printBold(const char *zText){
27993	28706	#if !SQLITE_OS_WINRT
27994	28707	HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
27995	28708	CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo;
27996	28709	GetConsoleScreenBufferInfo(out, &defaultScreenInfo);
27997	28710	SetConsoleTextAttribute(out,
27998	28711	FOREGROUND_RED\|FOREGROUND_INTENSITY
27999	28712	);
28000	28713	#endif
28001		- printf("%s", zText);
	28714	+ oputz(zText);
28002	28715	#if !SQLITE_OS_WINRT
28003	28716	SetConsoleTextAttribute(out, defaultScreenInfo.wAttributes);
28004	28717	#endif
28005	28718	}
28006	28719	#else
28007	28720	static void printBold(const char *zText){
28008		- printf("\033[1m%s\033[0m", zText);
	28721	+ oputf("\033[1m%s\033[0m", zText);
28009	28722	}
28010	28723	#endif
28011	28724
28012	28725	/*
28013	28726	** Get the argument to an --option. Throw an error and die if no argument
28014	28727	** is available.
28015	28728	*/
28016	28729	static char cmdline_option_value(int argc, char *argv, int i){
28017	28730	if( i==argc ){
28018		- utf8_printf(stderr, "%s: Error: missing argument to %s\n",
28019		- argv[0], argv[argc-1]);
	28731	+ eputf("%s: Error: missing argument to %s\n", argv[0], argv[argc-1]);
28020	28732	exit(1);
28021	28733	}
28022	28734	return argv[i];
28023	28735	}
28024	28736
28025	28737	static void sayAbnormalExit(void){
28026		- if( seenInterrupt ) fprintf(stderr, "Program interrupted.\n");
	28738	+ if( seenInterrupt ) eputz("Program interrupted.\n");
28027	28739	}
28028	28740
28029	28741	#ifndef SQLITE_SHELL_IS_UTF8
28030	28742	# if (defined(_WIN32) \|\| defined(WIN32)) \
28031	28743	&& (defined(_MSC_VER) \|\| (defined(UNICODE) && defined(__GNUC__)))
		@@ -28051,10 +28763,11 @@
28051	28763	char *zErrMsg = 0;
28052	28764	#ifdef SQLITE_SHELL_FIDDLE
28053	28765	# define data shellState
28054	28766	#else
28055	28767	ShellState data;
	28768	+ StreamsAreConsole consStreams = SAC_NoConsole;
28056	28769	#endif
28057	28770	const char *zInitFile = 0;
28058	28771	int i;
28059	28772	int rc = 0;
28060	28773	int warnInmemoryDb = 0;
		@@ -28072,27 +28785,24 @@
28072	28785	#ifdef SQLITE_SHELL_FIDDLE
28073	28786	stdin_is_interactive = 0;
28074	28787	stdout_is_console = 1;
28075	28788	data.wasm.zDefaultDbName = "/fiddle.sqlite3";
28076	28789	#else
28077		- stdin_is_interactive = isatty(0);
28078		- stdout_is_console = isatty(1);
28079		-#endif
28080		-#if SHELL_WIN_UTF8_OPT
28081		- probe_console(); /* Check for console I/O and UTF-8 capability. */
28082		- if( !mbcs_opted ) atexit(console_restore);
	28790	+ consStreams = consoleClassifySetup(stdin, stdout, stderr);
	28791	+ stdin_is_interactive = (consStreams & SAC_InConsole)!=0;
	28792	+ stdout_is_console = (consStreams & SAC_OutConsole)!=0;
	28793	+ atexit(consoleRestore);
28083	28794	#endif
28084	28795	atexit(sayAbnormalExit);
28085	28796	#ifdef SQLITE_DEBUG
28086	28797	mem_main_enter = sqlite3_memory_used();
28087	28798	#endif
28088	28799	#if !defined(_WIN32_WCE)
28089	28800	if( getenv("SQLITE_DEBUG_BREAK") ){
28090	28801	if( isatty(0) && isatty(2) ){
28091		- fprintf(stderr,
28092		- "attach debugger to process %d and press any key to continue.\n",
28093		- GETPID());
	28802	+ eputf("attach debugger to process %d and press any key to continue.\n",
	28803	+ GETPID());
28094	28804	fgetc(stdin);
28095	28805	}else{
28096	28806	#if defined(_WIN32) \|\| defined(WIN32)
28097	28807	#if SQLITE_OS_WINRT
28098	28808	__debugbreak();
		@@ -28108,18 +28818,18 @@
28108	28818	/* Register a valid signal handler early, before much else is done. */
28109	28819	#ifdef SIGINT
28110	28820	signal(SIGINT, interrupt_handler);
28111	28821	#elif (defined(_WIN32) \|\| defined(WIN32)) && !defined(_WIN32_WCE)
28112	28822	if( !SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE) ){
28113		- fprintf(stderr, "No ^C handler.\n");
	28823	+ eputz("No ^C handler.\n");
28114	28824	}
28115	28825	#endif
28116	28826
28117	28827	#if USE_SYSTEM_SQLITE+0!=1
28118	28828	if( cli_strncmp(sqlite3_sourceid(),SQLITE_SOURCE_ID,60)!=0 ){
28119		- utf8_printf(stderr, "SQLite header and source version mismatch\n%s\n%s\n",
28120		- sqlite3_sourceid(), SQLITE_SOURCE_ID);
	28829	+ eputf("SQLite header and source version mismatch\n%s\n%s\n",
	28830	+ sqlite3_sourceid(), SQLITE_SOURCE_ID);
28121	28831	exit(1);
28122	28832	}
28123	28833	#endif
28124	28834	main_init(&data);
28125	28835
		@@ -28211,18 +28921,11 @@
28211	28921	** informational messages (like from process_sqliterc) before
28212	28922	** we do the actual processing of arguments later in a second pass.
28213	28923	*/
28214	28924	stdin_is_interactive = 0;
28215	28925	}else if( cli_strcmp(z,"-utf8")==0 ){
28216		-#if SHELL_WIN_UTF8_OPT
28217		- /* Option accepted, but is ignored except for this diagnostic. */
28218		- if( mbcs_opted ) fprintf(stderr, "Cannot do UTF-8 at this console.\n");
28219		-#endif /* SHELL_WIN_UTF8_OPT */
28220	28926	}else if( cli_strcmp(z,"-no-utf8")==0 ){
28221		-#if SHELL_WIN_UTF8_OPT
28222		- mbcs_opted = 1;
28223		-#endif /* SHELL_WIN_UTF8_OPT */
28224	28927	}else if( cli_strcmp(z,"-heap")==0 ){
28225	28928	#if defined(SQLITE_ENABLE_MEMSYS3) \|\| defined(SQLITE_ENABLE_MEMSYS5)
28226	28929	const char *zSize;
28227	28930	sqlite3_int64 szHeap;
28228	28931
		@@ -28353,30 +29056,21 @@
28353	29056	if( zVfs ){
28354	29057	sqlite3_vfs *pVfs = sqlite3_vfs_find(zVfs);
28355	29058	if( pVfs ){
28356	29059	sqlite3_vfs_register(pVfs, 1);
28357	29060	}else{
28358		- utf8_printf(stderr, "no such VFS: \"%s\"\n", zVfs);
	29061	+ eputf("no such VFS: \"%s\"\n", zVfs);
28359	29062	exit(1);
28360	29063	}
28361	29064	}
28362		-#if SHELL_WIN_UTF8_OPT
28363		- /* Get indicated Windows console setup done before running invocation commands. */
28364		- if( in_console \|\| out_console ){
28365		- console_prepare_utf8();
28366		- }
28367		- if( !in_console ){
28368		- setBinaryMode(stdin, 0);
28369		- }
28370		-#endif
28371	29065
28372	29066	if( data.pAuxDb->zDbFilename==0 ){
28373	29067	#ifndef SQLITE_OMIT_MEMORYDB
28374	29068	data.pAuxDb->zDbFilename = ":memory:";
28375	29069	warnInmemoryDb = argc==1;
28376	29070	#else
28377		- utf8_printf(stderr,"%s: Error: no database filename specified\n", Argv0);
	29071	+ eputf("%s: Error: no database filename specified\n", Argv0);
28378	29072	return 1;
28379	29073	#endif
28380	29074	}
28381	29075	data.out = stdout;
28382	29076	#ifndef SQLITE_SHELL_FIDDLE
		@@ -28489,12 +29183,12 @@
28489	29183	*/
28490	29184	ShellSetFlag(&data, SHFLG_Backslash);
28491	29185	}else if( cli_strcmp(z,"-bail")==0 ){
28492	29186	/* No-op. The bail_on_error flag should already be set. */
28493	29187	}else if( cli_strcmp(z,"-version")==0 ){
28494		- printf("%s %s (%d-bit)\n", sqlite3_libversion(), sqlite3_sourceid(),
28495		- 8(int)sizeof(char));
	29188	+ oputf("%s %s (%d-bit)\n", sqlite3_libversion(), sqlite3_sourceid(),
	29189	+ 8(int)sizeof(char));
28496	29190	return 0;
28497	29191	}else if( cli_strcmp(z,"-interactive")==0 ){
28498	29192	/* already handled */
28499	29193	}else if( cli_strcmp(z,"-batch")==0 ){
28500	29194	/* already handled */
		@@ -28546,22 +29240,22 @@
28546	29240	if( rc && bail_on_error ) return rc==2 ? 0 : rc;
28547	29241	}else{
28548	29242	open_db(&data, 0);
28549	29243	rc = shell_exec(&data, z, &zErrMsg);
28550	29244	if( zErrMsg!=0 ){
28551		- utf8_printf(stderr,"Error: %s\n", zErrMsg);
	29245	+ eputf("Error: %s\n", zErrMsg);
28552	29246	if( bail_on_error ) return rc!=0 ? rc : 1;
28553	29247	}else if( rc!=0 ){
28554		- utf8_printf(stderr,"Error: unable to process SQL \"%s\"\n", z);
	29248	+ eputf("Error: unable to process SQL \"%s\"\n", z);
28555	29249	if( bail_on_error ) return rc;
28556	29250	}
28557	29251	}
28558	29252	#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB)
28559	29253	}else if( cli_strncmp(z, "-A", 2)==0 ){
28560	29254	if( nCmd>0 ){
28561		- utf8_printf(stderr, "Error: cannot mix regular SQL or dot-commands"
28562		- " with \"%s\"\n", z);
	29255	+ eputf("Error: cannot mix regular SQL or dot-commands"
	29256	+ " with \"%s\"\n", z);
28563	29257	return 1;
28564	29258	}
28565	29259	open_db(&data, OPEN_DB_ZIPFILE);
28566	29260	if( z[2] ){
28567	29261	argv[i] = &z[2];
		@@ -28575,12 +29269,12 @@
28575	29269	}else if( cli_strcmp(z,"-safe")==0 ){
28576	29270	data.bSafeMode = data.bSafeModePersist = 1;
28577	29271	}else if( cli_strcmp(z,"-unsafe-testing")==0 ){
28578	29272	/* Acted upon in first pass. */
28579	29273	}else{
28580		- utf8_printf(stderr,"%s: Error: unknown option: %s\n", Argv0, z);
28581		- raw_printf(stderr,"Use -help for a list of options.\n");
	29274	+ eputf("%s: Error: unknown option: %s\n", Argv0, z);
	29275	+ eputz("Use -help for a list of options.\n");
28582	29276	return 1;
28583	29277	}
28584	29278	data.cMode = data.mode;
28585	29279	}
28586	29280
		@@ -28600,13 +29294,13 @@
28600	29294	open_db(&data, 0);
28601	29295	echo_group_input(&data, azCmd[i]);
28602	29296	rc = shell_exec(&data, azCmd[i], &zErrMsg);
28603	29297	if( zErrMsg \|\| rc ){
28604	29298	if( zErrMsg!=0 ){
28605		- utf8_printf(stderr,"Error: %s\n", zErrMsg);
	29299	+ eputf("Error: %s\n", zErrMsg);
28606	29300	}else{
28607		- utf8_printf(stderr,"Error: unable to process SQL: %s\n", azCmd[i]);
	29301	+ eputf("Error: unable to process SQL: %s\n", azCmd[i]);
28608	29302	}
28609	29303	sqlite3_free(zErrMsg);
28610	29304	free(azCmd);
28611	29305	return rc!=0 ? rc : 1;
28612	29306	}
		@@ -28616,30 +29310,24 @@
28616	29310	/* Run commands received from standard input
28617	29311	*/
28618	29312	if( stdin_is_interactive ){
28619	29313	char *zHome;
28620	29314	char *zHistory;
28621		- const char *zCharset = "";
28622	29315	int nHistory;
28623		-#if SHELL_WIN_UTF8_OPT
28624		- switch( console_utf8_in+2*console_utf8_out ){
28625		- default: case 0: break;
28626		- case 1: zCharset = " (utf8 in)"; break;
28627		- case 2: zCharset = " (utf8 out)"; break;
28628		- case 3: zCharset = " (utf8 I/O)"; break;
28629		- }
	29316	+#if CIO_WIN_WC_XLATE
	29317	+# define SHELL_CIO_CHAR_SET (stdout_is_console? " (UTF-16 console I/O)" : "")
	29318	+#else
	29319	+# define SHELL_CIO_CHAR_SET ""
28630	29320	#endif
28631		- printf(
28632		- "SQLite version %s %.19s%s\n" /extra-version-info/
28633		- "Enter \".help\" for usage hints.\n",
28634		- sqlite3_libversion(), sqlite3_sourceid(), zCharset
28635		- );
	29321	+ oputf("SQLite version %s %.19s%s\n" /extra-version-info/
	29322	+ "Enter \".help\" for usage hints.\n",
	29323	+ sqlite3_libversion(), sqlite3_sourceid(), SHELL_CIO_CHAR_SET);
28636	29324	if( warnInmemoryDb ){
28637		- printf("Connected to a ");
	29325	+ oputz("Connected to a ");
28638	29326	printBold("transient in-memory database");
28639		- printf(".\nUse \".open FILENAME\" to reopen on a "
28640		- "persistent database.\n");
	29327	+ oputz(".\nUse \".open FILENAME\" to reopen on a"
	29328	+ " persistent database.\n");
28641	29329	}
28642	29330	zHistory = getenv("SQLITE_HISTORY");
28643	29331	if( zHistory ){
28644	29332	zHistory = strdup(zHistory);
28645	29333	}else if( (zHome = find_home_dir(0))!=0 ){
		@@ -28695,12 +29383,12 @@
28695	29383	/* Clear the global data structure so that valgrind will detect memory
28696	29384	** leaks */
28697	29385	memset(&data, 0, sizeof(data));
28698	29386	#ifdef SQLITE_DEBUG
28699	29387	if( sqlite3_memory_used()>mem_main_enter ){
28700		- utf8_printf(stderr, "Memory leaked: %u bytes\n",
28701		- (unsigned int)(sqlite3_memory_used()-mem_main_enter));
	29388	+ eputf("Memory leaked: %u bytes\n",
	29389	+ (unsigned int)(sqlite3_memory_used()-mem_main_enter));
28702	29390	}
28703	29391	#endif
28704	29392	#endif /* !SQLITE_SHELL_FIDDLE */
28705	29393	return rc;
28706	29394	}
28707	29395

	--- extsrc/shell.c
	+++ extsrc/shell.c
	@@ -250,33 +250,1023 @@
250	#define WIN32_LEAN_AND_MEAN
251	#include <windows.h>
252
253	/* string conversion routines only needed on Win32 */
254	extern char *sqlite3_win32_unicode_to_utf8(LPCWSTR);
255	extern char sqlite3_win32_mbcs_to_utf8_v2(const char , int);
256	extern char sqlite3_win32_utf8_to_mbcs_v2(const char , int);
257	extern LPWSTR sqlite3_win32_utf8_to_unicode(const char *zText);
258	#endif
259
260	/* On Windows, we normally run with output mode of TEXT so that \n characters
261	** are automatically translated into \r\n. However, this behavior needs
262	** to be disabled in some cases (ex: when generating CSV output and when
263	** rendering quoted strings that contain \n characters). The following
264	** routines take care of that.
265	*/
266	#if (defined(_WIN32) \|\| defined(WIN32)) && !SQLITE_OS_WINRT
267	static void setBinaryMode(FILE *file, int isOutput){
268	if( isOutput ) fflush(file);
269	_setmode(_fileno(file), _O_BINARY);
270	}
271	static void setTextMode(FILE *file, int isOutput){
272	if( isOutput ) fflush(file);
273	_setmode(_fileno(file), _O_TEXT);
274	}


























































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































275	#else
276	# define setBinaryMode(X,Y)
277	# define setTextMode(X,Y)






278	#endif
279
280	/* True if the timer is enabled */
281	static int enableTimer = 0;
282
	@@ -347,14 +1337,14 @@
347	static void endTimer(void){
348	if( enableTimer ){
349	sqlite3_int64 iEnd = timeOfDay();
350	struct rusage sEnd;
351	getrusage(RUSAGE_SELF, &sEnd);
352	printf("Run Time: real %.3f user %f sys %f\n",
353	(iEnd - iBegin)*0.001,
354	timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
355	timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
356	}
357	}
358
359	#define BEGIN_TIMER beginTimer()
360	#define END_TIMER endTimer()
	@@ -426,14 +1416,14 @@
426	static void endTimer(void){
427	if( enableTimer && getProcessTimesAddr){
428	FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd;
429	sqlite3_int64 ftWallEnd = timeOfDay();
430	getProcessTimesAddr(hProcess,&ftCreation,&ftExit,&ftKernelEnd,&ftUserEnd);
431	printf("Run Time: real %.3f user %f sys %f\n",
432	(ftWallEnd - ftWallBegin)*0.001,
433	timeDiff(&ftUserBegin, &ftUserEnd),
434	timeDiff(&ftKernelBegin, &ftKernelEnd));
435	}
436	}
437
438	#define BEGIN_TIMER beginTimer()
439	#define END_TIMER endTimer()
	@@ -466,32 +1456,13 @@
466	** is true. Otherwise, assume stdin is connected to a file or pipe.
467	*/
468	static int stdin_is_interactive = 1;
469
470	/*
471	** If build is for non-RT Windows, without 3rd-party line editing,
472	** console input and output may be done in a UTF-8 compatible way,
473	** if the OS is capable of it and the --no-utf8 option is not seen.
474	*/
475	#if (defined(_WIN32) \|\| defined(WIN32)) && SHELL_USE_LOCAL_GETLINE \
476	&& !defined(SHELL_OMIT_WIN_UTF8) && !SQLITE_OS_WINRT
477	# define SHELL_WIN_UTF8_OPT 1
478	/* Record whether to do UTF-8 console I/O translation per stream. */
479	static int console_utf8_in = 0;
480	static int console_utf8_out = 0;
481	/* Record whether can do UTF-8 or --no-utf8 seen in invocation. */
482	static int mbcs_opted = 1; /* Assume cannot do until shown otherwise. */
483	#else
484	# define console_utf8_in 0
485	# define console_utf8_out 0
486	# define SHELL_WIN_UTF8_OPT 0
487	#endif
488
489	/*
490	** On Windows systems we have to know if standard output is a console
491	** in order to translate UTF-8 into MBCS. The following variable is
492	** true if translation is required.
493	*/
494	static int stdout_is_console = 1;
495
496	/*
497	** The following is the open SQLite database. We make a pointer
	@@ -609,255 +1580,21 @@
609	shell_strncpy(dynPrompt.dynamicPrompt, ")x!", 4);
610	}else{
611	shell_strncpy(dynPrompt.dynamicPrompt, "(x.", 4);
612	dynPrompt.dynamicPrompt[2] = (char)('0'+dynPrompt.inParenLevel);
613	}
614	shell_strncpy(dynPrompt.dynamicPrompt+3, continuePrompt+3, PROMPT_LEN_MAX-4);

615	}
616	}
617	return dynPrompt.dynamicPrompt;
618	}
619	#endif /* !defined(SQLITE_OMIT_DYNAPROMPT) */
620
621	#if SHELL_WIN_UTF8_OPT
622	/* Following struct is used for UTF-8 console I/O. */
623	static struct ConsoleState {
624	int stdinEof; /* EOF has been seen on console input */
625	int infsMode; /* Input file stream mode upon shell start */
626	UINT inCodePage; /* Input code page upon shell start */
627	UINT outCodePage; /* Output code page upon shell start */
628	HANDLE hConsole; /* Console input or output handle */
629	DWORD consoleMode; /* Console mode upon shell start */
630	} conState = { 0, 0, 0, 0, INVALID_HANDLE_VALUE, 0 };
631
632	#ifndef _O_U16TEXT /* For build environments lacking this constant: */
633	# define _O_U16TEXT 0x20000
634	#endif
635
636	/*
637	** If given stream number is a console, return 1 and get some attributes,
638	** else return 0 and set the output attributes to invalid values.
639	*/
640	static short console_attrs(unsigned stnum, HANDLE pH, DWORD pConsMode){
641	static int stid[3] = { STD_INPUT_HANDLE,STD_OUTPUT_HANDLE,STD_ERROR_HANDLE };
642	HANDLE h;
643	*pH = INVALID_HANDLE_VALUE;
644	*pConsMode = 0;
645	if( stnum > 2 ) return 0;
646	h = GetStdHandle(stid[stnum]);
647	if( h!=*pH && GetFileType(h)==FILE_TYPE_CHAR && GetConsoleMode(h,pConsMode) ){
648	*pH = h;
649	return 1;
650	}
651	return 0;
652	}
653
654	/*
655	** Perform a runtime test of Windows console to determine if it can
656	** do char-stream I/O correctly when the code page is set to CP_UTF8.
657	** Returns are: 1 => yes it can, 0 => no it cannot
658	**
659	** The console's output code page is momentarily set, then restored.
660	** So this should only be run when the process is given use of the
661	** console for either input or output.
662	*/
663	static short ConsoleDoesUTF8(void){
664	UINT ocp = GetConsoleOutputCP();
665	const char TrialUtf8[] = { '\xC8', '\xAB' }; /* "ȫ" or 2 MBCS characters */
666	WCHAR aReadBack[1] = { 0 }; /* Read back as 0x022B when decoded as UTF-8. */
667	CONSOLE_SCREEN_BUFFER_INFO csbInfo = {0};
668	/* Create an inactive screen buffer with which to do the experiment. */
669	HANDLE hCSB = CreateConsoleScreenBuffer(GENERIC_READ\|GENERIC_WRITE, 0, 0,
670	CONSOLE_TEXTMODE_BUFFER, NULL);
671	if( hCSB!=INVALID_HANDLE_VALUE ){
672	COORD cpos = {0,0};
673	DWORD rbc;
674	SetConsoleCursorPosition(hCSB, cpos);
675	SetConsoleOutputCP(CP_UTF8);
676	/* Write 2 chars which are a single character in UTF-8 but more in MBCS. */
677	WriteConsoleA(hCSB, TrialUtf8, sizeof(TrialUtf8), NULL, NULL);
678	ReadConsoleOutputCharacterW(hCSB, &aReadBack[0], 1, cpos, &rbc);
679	GetConsoleScreenBufferInfo(hCSB, &csbInfo);
680	SetConsoleOutputCP(ocp);
681	CloseHandle(hCSB);
682	}
683	/* Return 1 if cursor advanced by 1 position, else 0. */
684	return (short)(csbInfo.dwCursorPosition.X == 1 && aReadBack[0] == 0x022B);
685	}
686
687	static short in_console = 0;
688	static short out_console = 0;
689
690	/*
691	** Determine whether either normal I/O stream is the console,
692	** and whether it can do UTF-8 translation, setting globals
693	** in_console, out_console and mbcs_opted accordingly.
694	*/
695	static void probe_console(void){
696	HANDLE h;
697	DWORD cMode;
698	in_console = console_attrs(0, &h, &cMode);
699	out_console = console_attrs(1, &h, &cMode);
700	if( in_console \|\| out_console ) mbcs_opted = !ConsoleDoesUTF8();
701	}
702
703	/*
704	** If console is used for normal I/O, absent a --no-utf8 option,
705	** prepare console for UTF-8 input (from either typing or suitable
706	** paste operations) and/or for UTF-8 output rendering.
707	**
708	** The console state upon entry is preserved, in conState, so that
709	** console_restore() can later restore the same console state.
710	**
711	** The globals console_utf8_in and console_utf8_out are set, for
712	** later use in selecting UTF-8 or MBCS console I/O translations.
713	** This routine depends upon globals set by probe_console().
714	*/
715	static void console_prepare_utf8(void){
716	struct ConsoleState csWork = { 0, 0, 0, 0, INVALID_HANDLE_VALUE, 0 };
717
718	console_utf8_in = console_utf8_out = 0;
719	if( (!in_console && !out_console) \|\| mbcs_opted ) return;
720	console_attrs((in_console)? 0 : 1, &conState.hConsole, &conState.consoleMode);
721	conState.inCodePage = GetConsoleCP();
722	conState.outCodePage = GetConsoleOutputCP();
723	if( in_console ){
724	SetConsoleCP(CP_UTF8);
725	DWORD newConsoleMode = conState.consoleMode
726	\| ENABLE_LINE_INPUT \| ENABLE_PROCESSED_INPUT;
727	SetConsoleMode(conState.hConsole, newConsoleMode);
728	conState.infsMode = _setmode(_fileno(stdin), _O_U16TEXT);
729	console_utf8_in = 1;
730	}
731	if( out_console ){
732	SetConsoleOutputCP(CP_UTF8);
733	console_utf8_out = 1;
734	}
735	}
736
737	/*
738	** Undo the effects of console_prepare_utf8(), if any.
739	*/
740	static void SQLITE_CDECL console_restore(void){
741	if( (console_utf8_in\|\|console_utf8_out)
742	&& conState.hConsole!=INVALID_HANDLE_VALUE ){
743	if( console_utf8_in ){
744	SetConsoleCP(conState.inCodePage);
745	_setmode(_fileno(stdin), conState.infsMode);
746	}
747	if( console_utf8_out ) SetConsoleOutputCP(conState.outCodePage);
748	SetConsoleMode(conState.hConsole, conState.consoleMode);
749	/* Avoid multiple calls. */
750	conState.hConsole = INVALID_HANDLE_VALUE;
751	conState.consoleMode = 0;
752	console_utf8_in = 0;
753	console_utf8_out = 0;
754	}
755	}
756
757	/*
758	** Collect input like fgets(...) with special provisions for input
759	** from the Windows console to get around its strange coding issues.
760	** Defers to plain fgets() when input is not interactive or when the
761	** UTF-8 input is unavailable or opted out.
762	*/
763	static char* utf8_fgets(char buf, int ncmax, FILE fin){
764	if( fin==0 ) fin = stdin;
765	if( fin==stdin && stdin_is_interactive && console_utf8_in ){
766	# define SQLITE_IALIM 150
767	wchar_t wbuf[SQLITE_IALIM];
768	int lend = 0;
769	int noc = 0;
770	if( ncmax==0 \|\| conState.stdinEof ) return 0;
771	buf[0] = 0;
772	while( noc<ncmax-7-1 && !lend ){
773	/* There is room for at least 2 more characters and a 0-terminator. */
774	int na = (ncmax > SQLITE_IALIM*4+1 + noc)
775	? SQLITE_IALIM : (ncmax-1 - noc)/4;
776	# undef SQLITE_IALIM
777	DWORD nbr = 0;
778	BOOL bRC = ReadConsoleW(conState.hConsole, wbuf, na, &nbr, 0);
779	if( !bRC \|\| (noc==0 && nbr==0) ) return 0;
780	if( nbr > 0 ){
781	int nmb = WideCharToMultiByte(CP_UTF8,WC_COMPOSITECHECK\|WC_DEFAULTCHAR,
782	wbuf,nbr,0,0,0,0);
783	if( nmb !=0 && noc+nmb <= ncmax ){
784	int iseg = noc;
785	nmb = WideCharToMultiByte(CP_UTF8,WC_COMPOSITECHECK\|WC_DEFAULTCHAR,
786	wbuf,nbr,buf+noc,nmb,0,0);
787	noc += nmb;
788	/* Fixup line-ends as coded by Windows for CR (or "Enter".)*/
789	if( noc > 0 ){
790	if( buf[noc-1]=='\n' ){
791	lend = 1;
792	if( noc > 1 && buf[noc-2]=='\r' ){
793	buf[noc-2] = '\n';
794	--noc;
795	}
796	}
797	}
798	/* Check for ^Z (anywhere in line) too. */
799	while( iseg < noc ){
800	if( buf[iseg]==0x1a ){
801	conState.stdinEof = 1;
802	noc = iseg; /* Chop ^Z and anything following. */
803	break;
804	}
805	++iseg;
806	}
807	}else break; /* Drop apparent garbage in. (Could assert.) */
808	}else break;
809	}
810	/* If got nothing, (after ^Z chop), must be at end-of-file. */
811	if( noc == 0 ) return 0;
812	buf[noc] = 0;
813	return buf;
814	}else{
815	return fgets(buf, ncmax, fin);
816	}
817	}
818
819	# define fgets(b,n,f) utf8_fgets(b,n,f)
820	#endif /* SHELL_WIN_UTF8_OPT */
821
822	/*
823	** Render output like fprintf(). Except, if the output is going to the
824	** console and if this is running on a Windows machine, and if UTF-8
825	** output unavailable (or available but opted out), translate the
826	** output from UTF-8 into MBCS for output through 8-bit stdout stream.
827	** (Without -no-utf8, no translation is needed and must not be done.)
828	*/
829	#if defined(_WIN32) \|\| defined(WIN32)
830	void utf8_printf(FILE out, const char zFormat, ...){
831	va_list ap;
832	va_start(ap, zFormat);
833	if( stdout_is_console && (out==stdout \|\| out==stderr) && !console_utf8_out ){
834	char *z1 = sqlite3_vmprintf(zFormat, ap);
835	char *z2 = sqlite3_win32_utf8_to_mbcs_v2(z1, 0);
836	sqlite3_free(z1);
837	fputs(z2, out);
838	sqlite3_free(z2);
839	}else{
840	vfprintf(out, zFormat, ap);
841	}
842	va_end(ap);
843	}
844	#elif !defined(utf8_printf)
845	# define utf8_printf fprintf
846	#endif
847
848	/*
849	** Render output like fprintf(). This should not be used on anything that
850	** includes string formatting (e.g. "%s").
851	*/
852	#if !defined(raw_printf)
853	# define raw_printf fprintf
854	#endif
855
856	/* Indicate out-of-memory and exit. */
857	static void shell_out_of_memory(void){
858	raw_printf(stderr,"Error: out of memory\n");
859	exit(1);
860	}
861
862	/* Check a pointer to see if it is NULL. If it is NULL, exit with an
863	** out-of-memory error.
	@@ -885,22 +1622,22 @@
885	char *z;
886	if( iotrace==0 ) return;
887	va_start(ap, zFormat);
888	z = sqlite3_vmprintf(zFormat, ap);
889	va_end(ap);
890	utf8_printf(iotrace, "%s", z);
891	sqlite3_free(z);
892	}
893	#endif
894
895	/*
896	** Output string zUtf to stream pOut as w characters. If w is negative,
897	** then right-justify the text. W is the width in UTF-8 characters, not
898	** in bytes. This is different from the %.s specification in printf
899	** since with %.s the width is measured in bytes, not characters.
900	*/
901	static void utf8_width_print(FILE pOut, int w, const char zUtf){
902	int i;
903	int n;
904	int aw = w<0 ? -w : w;
905	if( zUtf==0 ) zUtf = "";
906	for(i=n=0; zUtf[i]; i++){
	@@ -911,15 +1648,15 @@
911	break;
912	}
913	}
914	}
915	if( n>=aw ){
916	utf8_printf(pOut, "%.*s", i, zUtf);
917	}else if( w<0 ){
918	utf8_printf(pOut, "%*s%s", aw-n, "", zUtf);
919	}else{
920	utf8_printf(pOut, "%s%*s", zUtf, aw-n, "");
921	}
922	}
923
924
925	/*
	@@ -975,11 +1712,11 @@
975	** Return open FILE * if zFile exists, can be opened for read
976	** and is an ordinary file or a character stream source.
977	** Otherwise return 0.
978	*/
979	static FILE * openChrSource(const char *zFile){
980	#ifdef _WIN32
981	struct _stat x = {0};
982	# define STAT_CHR_SRC(mode) ((mode & (_S_IFCHR\|_S_IFIFO\|_S_IFREG))!=0)
983	/* On Windows, open first, then check the stream nature. This order
984	** is necessary because _stat() and sibs, when checking a named pipe,
985	** effectively break the pipe as its supplier sees it. */
	@@ -1038,27 +1775,10 @@
1038	if( n>0 && zLine[n-1]=='\r' ) n--;
1039	zLine[n] = 0;
1040	break;
1041	}
1042	}
1043	#if defined(_WIN32) \|\| defined(WIN32)
1044	/* For interactive input on Windows systems, with -no-utf8,
1045	** translate the multi-byte characterset characters into UTF-8.
1046	** This is the translation that predates console UTF-8 input. */
1047	if( stdin_is_interactive && in==stdin && !console_utf8_in ){
1048	char *zTrans = sqlite3_win32_mbcs_to_utf8_v2(zLine, 0);
1049	if( zTrans ){
1050	i64 nTrans = strlen(zTrans)+1;
1051	if( nTrans>nLine ){
1052	zLine = realloc(zLine, nTrans);
1053	shell_check_oom(zLine);
1054	}
1055	memcpy(zLine, zTrans, nTrans);
1056	sqlite3_free(zTrans);
1057	}
1058	}
1059	#endif /* defined(_WIN32) \|\| defined(WIN32) */
1060	return zLine;
1061	}
1062
1063	/*
1064	** Retrieve a single line of input text.
	@@ -1081,11 +1801,11 @@
1081	if( in!=0 ){
1082	zResult = local_getline(zPrior, in);
1083	}else{
1084	zPrompt = isContinuation ? CONTINUATION_PROMPT : mainPrompt;
1085	#if SHELL_USE_LOCAL_GETLINE
1086	printf("%s", zPrompt);
1087	fflush(stdout);
1088	do{
1089	zResult = local_getline(zPrior, stdin);
1090	zPrior = 0;
1091	/* ^C trap creates a false EOF, so let "interrupt" thread catch up. */
	@@ -1328,11 +2048,11 @@
1328	double r = sqlite3_value_double(apVal[0]);
1329	int n = nVal>=2 ? sqlite3_value_int(apVal[1]) : 26;
1330	char z[400];
1331	if( n<1 ) n = 1;
1332	if( n>350 ) n = 350;
1333	snprintf(z, sizeof(z)-1, "%#+.*e", n, r);
1334	sqlite3_result_text(pCtx, z, -1, SQLITE_TRANSIENT);
1335	}
1336
1337
1338	/*
	@@ -17614,11 +18334,11 @@
17614	** A callback for the sqlite3_log() interface.
17615	*/
17616	static void shellLog(void pArg, int iErrCode, const char zMsg){
17617	ShellState p = (ShellState)pArg;
17618	if( p->pLog==0 ) return;
17619	utf8_printf(p->pLog, "(%d) %s\n", iErrCode, zMsg);
17620	fflush(p->pLog);
17621	}
17622
17623	/*
17624	** SQL function: shell_putsnl(X)
	@@ -17629,13 +18349,13 @@
17629	static void shellPutsFunc(
17630	sqlite3_context *pCtx,
17631	int nVal,
17632	sqlite3_value **apVal
17633	){
17634	ShellState p = (ShellState)sqlite3_user_data(pCtx);
17635	(void)nVal;
17636	utf8_printf(p->out, "%s\n", sqlite3_value_text(apVal[0]));
17637	sqlite3_result_value(pCtx, apVal[0]);
17638	}
17639
17640	/*
17641	** If in safe mode, print an error message described by the arguments
	@@ -17650,12 +18370,11 @@
17650	va_list ap;
17651	char *zMsg;
17652	va_start(ap, zErrMsg);
17653	zMsg = sqlite3_vmprintf(zErrMsg, ap);
17654	va_end(ap);
17655	raw_printf(stderr, "line %d: ", p->lineno);
17656	utf8_printf(stderr, "%s\n", zMsg);
17657	exit(1);
17658	}
17659	}
17660
17661	/*
	@@ -17819,11 +18538,11 @@
17819	}
17820
17821	/*
17822	** Output the given string as a hex-encoded blob (eg. X'1234' )
17823	*/
17824	static void output_hex_blob(FILE out, const void pBlob, int nBlob){
17825	int i;
17826	unsigned char aBlob = (unsigned char)pBlob;
17827
17828	char zStr = sqlite3_malloc(nBlob2 + 1);
17829	shell_check_oom(zStr);
	@@ -17836,11 +18555,11 @@
17836	zStr[i*2] = aHex[ (aBlob[i] >> 4) ];
17837	zStr[i*2+1] = aHex[ (aBlob[i] & 0x0F) ];
17838	}
17839	zStr[i*2] = '\0';
17840
17841	raw_printf(out,"X'%s'", zStr);
17842	sqlite3_free(zStr);
17843	}
17844
17845	/*
17846	** Find a string that is not found anywhere in z[]. Return a pointer
	@@ -17866,39 +18585,46 @@
17866	/*
17867	** Output the given string as a quoted string using SQL quoting conventions.
17868	**
17869	** See also: output_quoted_escaped_string()
17870	*/
17871	static void output_quoted_string(FILE out, const char z){
17872	int i;
17873	char c;
17874	setBinaryMode(out, 1);



17875	if( z==0 ) return;
17876	for(i=0; (c = z[i])!=0 && c!='\''; i++){}
17877	if( c==0 ){
17878	utf8_printf(out,"'%s'",z);
17879	}else{
17880	raw_printf(out, "'");
17881	while( *z ){
17882	for(i=0; (c = z[i])!=0 && c!='\''; i++){}
17883	if( c=='\'' ) i++;
17884	if( i ){
17885	utf8_printf(out, "%.*s", i, z);
17886	z += i;
17887	}
17888	if( c=='\'' ){
17889	raw_printf(out, "'");
17890	continue;
17891	}
17892	if( c==0 ){
17893	break;
17894	}
17895	z++;
17896	}
17897	raw_printf(out, "'");
17898	}
17899	setTextMode(out, 1);




17900	}
17901
17902	/*
17903	** Output the given string as a quoted string using SQL quoting conventions.
17904	** Additionallly , escape the "\n" and "\r" characters so that they do not
	@@ -17906,17 +18632,20 @@
17906	** systems.
17907	**
17908	** This is like output_quoted_string() but with the addition of the \r\n
17909	** escape mechanism.
17910	*/
17911	static void output_quoted_escaped_string(FILE out, const char z){
17912	int i;
17913	char c;
17914	setBinaryMode(out, 1);



17915	for(i=0; (c = z[i])!=0 && c!='\'' && c!='\n' && c!='\r'; i++){}
17916	if( c==0 ){
17917	utf8_printf(out,"'%s'",z);
17918	}else{
17919	const char *zNL = 0;
17920	const char *zCR = 0;
17921	int nNL = 0;
17922	int nCR = 0;
	@@ -17924,121 +18653,167 @@
17924	for(i=0; z[i]; i++){
17925	if( z[i]=='\n' ) nNL++;
17926	if( z[i]=='\r' ) nCR++;
17927	}
17928	if( nNL ){
17929	raw_printf(out, "replace(");
17930	zNL = unused_string(z, "\\n", "\\012", zBuf1);
17931	}
17932	if( nCR ){
17933	raw_printf(out, "replace(");
17934	zCR = unused_string(z, "\\r", "\\015", zBuf2);
17935	}
17936	raw_printf(out, "'");
17937	while( *z ){
17938	for(i=0; (c = z[i])!=0 && c!='\n' && c!='\r' && c!='\''; i++){}
17939	if( c=='\'' ) i++;
17940	if( i ){
17941	utf8_printf(out, "%.*s", i, z);
17942	z += i;
17943	}
17944	if( c=='\'' ){
17945	raw_printf(out, "'");
17946	continue;
17947	}
17948	if( c==0 ){
17949	break;
17950	}
17951	z++;
17952	if( c=='\n' ){
17953	raw_printf(out, "%s", zNL);
17954	continue;
17955	}
17956	raw_printf(out, "%s", zCR);
17957	}
17958	raw_printf(out, "'");
17959	if( nCR ){
17960	raw_printf(out, ",'%s',char(13))", zCR);
17961	}
17962	if( nNL ){
17963	raw_printf(out, ",'%s',char(10))", zNL);
17964	}
17965	}
17966	setTextMode(out, 1);




17967	}
17968

















17969	/*
17970	** Output the given string as a quoted according to C or TCL quoting rules.
17971	*/
17972	static void output_c_string(FILE out, const char z){
17973	unsigned int c;
17974	fputc('"', out);
17975	while( (c = *(z++))!=0 ){
17976	if( c=='\\' ){
17977	fputc(c, out);
17978	fputc(c, out);
17979	}else if( c=='"' ){
17980	fputc('\\', out);
17981	fputc('"', out);
17982	}else if( c=='\t' ){
17983	fputc('\\', out);
17984	fputc('t', out);
17985	}else if( c=='\n' ){
17986	fputc('\\', out);
17987	fputc('n', out);
17988	}else if( c=='\r' ){
17989	fputc('\\', out);
17990	fputc('r', out);









17991	}else if( !isprint(c&0xff) ){
17992	raw_printf(out, "\\%03o", c&0xff);
17993	}else{
17994	fputc(c, out);

17995	}

17996	}
17997	fputc('"', out);
17998	}
17999
18000	/*
18001	** Output the given string as a quoted according to JSON quoting rules.
18002	*/
18003	static void output_json_string(FILE out, const char z, i64 n){
18004	unsigned int c;







18005	if( z==0 ) z = "";
18006	if( n<0 ) n = strlen(z);
18007	fputc('"', out);
18008	while( n-- ){








18009	c = *(z++);
18010	if( c=='\\' \|\| c=='"' ){
18011	fputc('\\', out);
18012	fputc(c, out);











18013	}else if( c<=0x1f ){
18014	fputc('\\', out);
18015	if( c=='\b' ){
18016	fputc('b', out);
18017	}else if( c=='\f' ){
18018	fputc('f', out);
18019	}else if( c=='\n' ){
18020	fputc('n', out);
18021	}else if( c=='\r' ){
18022	fputc('r', out);
18023	}else if( c=='\t' ){
18024	fputc('t', out);
18025	}else{
18026	raw_printf(out, "u%04x",c);
18027	}
18028	}else{
18029	fputc(c, out);
18030	}
18031	}
18032	fputc('"', out);
18033	}
18034
18035	/*
18036	** Output the given string with characters that are special to
18037	** HTML escaped.
18038	*/
18039	static void output_html_string(FILE out, const char z){
18040	int i;
18041	if( z==0 ) z = "";
18042	while( *z ){
18043	for(i=0; z[i]
18044	&& z[i]!='<'
	@@ -18046,22 +18821,22 @@
18046	&& z[i]!='>'
18047	&& z[i]!='\"'
18048	&& z[i]!='\'';
18049	i++){}
18050	if( i>0 ){
18051	utf8_printf(out,"%.*s",i,z);
18052	}
18053	if( z[i]=='<' ){
18054	raw_printf(out,"<");
18055	}else if( z[i]=='&' ){
18056	raw_printf(out,"&");
18057	}else if( z[i]=='>' ){
18058	raw_printf(out,">");
18059	}else if( z[i]=='\"' ){
18060	raw_printf(out,""");
18061	}else if( z[i]=='\'' ){
18062	raw_printf(out,"'");
18063	}else{
18064	break;
18065	}
18066	z += i + 1;
18067	}
	@@ -18095,13 +18870,12 @@
18095	** the separator, which may or may not be a comma. p->nullValue is
18096	** the null value. Strings are quoted if necessary. The separator
18097	** is only issued if bSep is true.
18098	*/
18099	static void output_csv(ShellState p, const char z, int bSep){
18100	FILE *out = p->out;
18101	if( z==0 ){
18102	utf8_printf(out,"%s",p->nullValue);
18103	}else{
18104	unsigned i;
18105	for(i=0; z[i]; i++){
18106	if( needCsvQuote[((unsigned char*)z)[i]] ){
18107	i = 0;
	@@ -18109,18 +18883,18 @@
18109	}
18110	}
18111	if( i==0 \|\| strstr(z, p->colSeparator)!=0 ){
18112	char *zQuoted = sqlite3_mprintf("\"%w\"", z);
18113	shell_check_oom(zQuoted);
18114	utf8_printf(out, "%s", zQuoted);
18115	sqlite3_free(zQuoted);
18116	}else{
18117	utf8_printf(out, "%s", z);
18118	}
18119	}
18120	if( bSep ){
18121	utf8_printf(p->out, "%s", p->colSeparator);
18122	}
18123	}
18124
18125	/*
18126	** This routine runs when the user presses Ctrl-C
	@@ -18224,20 +18998,20 @@
18224	const char *az[4];
18225	az[0] = zA1;
18226	az[1] = zA2;
18227	az[2] = zA3;
18228	az[3] = zA4;
18229	utf8_printf(p->out, "authorizer: %s", azAction[op]);
18230	for(i=0; i<4; i++){
18231	raw_printf(p->out, " ");
18232	if( az[i] ){
18233	output_c_string(p->out, az[i]);
18234	}else{
18235	raw_printf(p->out, "NULL");
18236	}
18237	}
18238	raw_printf(p->out, "\n");
18239	if( p->bSafeMode ) (void)safeModeAuth(pClientData, op, zA1, zA2, zA3, zA4);
18240	return SQLITE_OK;
18241	}
18242	#endif
18243
	@@ -18249,11 +19023,11 @@
18249	**
18250	** If the schema statement in z[] contains a start-of-comment and if
18251	** sqlite3_complete() returns false, try to terminate the comment before
18252	** printing the result. https://sqlite.org/forum/forumpost/d7be961c5c
18253	*/
18254	static void printSchemaLine(FILE out, const char z, const char *zTail){
18255	char *zToFree = 0;
18256	if( z==0 ) return;
18257	if( zTail==0 ) return;
18258	if( zTail[0]==';' && (strstr(z, "/*")!=0 \|\| strstr(z,"--")!=0) ){
18259	const char *zOrig = z;
	@@ -18271,20 +19045,20 @@
18271	}
18272	sqlite3_free(zNew);
18273	}
18274	}
18275	if( sqlite3_strglob("CREATE TABLE ['\"]*", z)==0 ){
18276	utf8_printf(out, "CREATE TABLE IF NOT EXISTS %s%s", z+13, zTail);
18277	}else{
18278	utf8_printf(out, "%s%s", z, zTail);
18279	}
18280	sqlite3_free(zToFree);
18281	}
18282	static void printSchemaLineN(FILE out, char z, int n, const char *zTail){
18283	char c = z[n];
18284	z[n] = 0;
18285	printSchemaLine(out, z, zTail);
18286	z[n] = c;
18287	}
18288
18289	/*
18290	** Return true if string z[] has nothing but whitespace and comments to the
	@@ -18308,11 +19082,11 @@
18308	EQPGraphRow *pNew;
18309	i64 nText;
18310	if( zText==0 ) return;
18311	nText = strlen(zText);
18312	if( p->autoEQPtest ){
18313	utf8_printf(p->out, "%d,%d,%s\n", iEqpId, p2, zText);
18314	}
18315	pNew = sqlite3_malloc64( sizeof(*pNew) + nText );
18316	shell_check_oom(pNew);
18317	pNew->iEqpId = iEqpId;
18318	pNew->iParentId = p2;
	@@ -18356,12 +19130,11 @@
18356	i64 n = strlen(p->sGraph.zPrefix);
18357	char *z;
18358	for(pRow = eqp_next_row(p, iEqpId, 0); pRow; pRow = pNext){
18359	pNext = eqp_next_row(p, iEqpId, pRow);
18360	z = pRow->zText;
18361	utf8_printf(p->out, "%s%s%s\n", p->sGraph.zPrefix,
18362	pNext ? "\|--" : "`--", z);
18363	if( n<(i64)sizeof(p->sGraph.zPrefix)-7 ){
18364	memcpy(&p->sGraph.zPrefix[n], pNext ? "\| " : " ", 4);
18365	eqp_render_level(p, pRow->iEqpId);
18366	p->sGraph.zPrefix[n] = 0;
18367	}
	@@ -18377,17 +19150,17 @@
18377	if( pRow->zText[0]=='-' ){
18378	if( pRow->pNext==0 ){
18379	eqp_reset(p);
18380	return;
18381	}
18382	utf8_printf(p->out, "%s\n", pRow->zText+3);
18383	p->sGraph.pRow = pRow->pNext;
18384	sqlite3_free(pRow);
18385	}else if( nCycle>0 ){
18386	utf8_printf(p->out, "QUERY PLAN (cycles=%lld [100%%])\n", nCycle);
18387	}else{
18388	utf8_printf(p->out, "QUERY PLAN\n");
18389	}
18390	p->sGraph.zPrefix[0] = 0;
18391	eqp_render_level(p, 0);
18392	eqp_reset(p);
18393	}
	@@ -18399,33 +19172,33 @@
18399	*/
18400	static int progress_handler(void *pClientData) {
18401	ShellState p = (ShellState)pClientData;
18402	p->nProgress++;
18403	if( p->nProgress>=p->mxProgress && p->mxProgress>0 ){
18404	raw_printf(p->out, "Progress limit reached (%u)\n", p->nProgress);
18405	if( p->flgProgress & SHELL_PROGRESS_RESET ) p->nProgress = 0;
18406	if( p->flgProgress & SHELL_PROGRESS_ONCE ) p->mxProgress = 0;
18407	return 1;
18408	}
18409	if( (p->flgProgress & SHELL_PROGRESS_QUIET)==0 ){
18410	raw_printf(p->out, "Progress %u\n", p->nProgress);
18411	}
18412	return 0;
18413	}
18414	#endif /* SQLITE_OMIT_PROGRESS_CALLBACK */
18415
18416	/*
18417	** Print N dashes
18418	*/
18419	static void print_dashes(FILE *out, int N){
18420	const char zDash[] = "--------------------------------------------------";
18421	const int nDash = sizeof(zDash) - 1;
18422	while( N>nDash ){
18423	fputs(zDash, out);
18424	N -= nDash;
18425	}
18426	raw_printf(out, "%.*s", N, zDash);
18427	}
18428
18429	/*
18430	** Print a markdown or table-style row separator using ascii-art
18431	*/
	@@ -18434,19 +19207,19 @@
18434	int nArg,
18435	const char *zSep
18436	){
18437	int i;
18438	if( nArg>0 ){
18439	fputs(zSep, p->out);
18440	print_dashes(p->out, p->actualWidth[0]+2);
18441	for(i=1; i<nArg; i++){
18442	fputs(zSep, p->out);
18443	print_dashes(p->out, p->actualWidth[i]+2);
18444	}
18445	fputs(zSep, p->out);
18446	}
18447	fputs("\n", p->out);
18448	}
18449
18450	/*
18451	** This is the callback routine that the shell
18452	** invokes for each row of a query result.
	@@ -18472,14 +19245,14 @@
18472	if( azArg==0 ) break;
18473	for(i=0; i<nArg; i++){
18474	int len = strlen30(azCol[i] ? azCol[i] : "");
18475	if( len>w ) w = len;
18476	}
18477	if( p->cnt++>0 ) utf8_printf(p->out, "%s", p->rowSeparator);
18478	for(i=0; i<nArg; i++){
18479	utf8_printf(p->out,"%*s = %s%s", w, azCol[i],
18480	azArg[i] ? azArg[i] : p->nullValue, p->rowSeparator);
18481	}
18482	break;
18483	}
18484	case MODE_ScanExp:
18485	case MODE_Explain: {
	@@ -18502,16 +19275,16 @@
18502	if( nArg>nWidth ) nArg = nWidth;
18503
18504	/* If this is the first row seen, print out the headers */
18505	if( p->cnt++==0 ){
18506	for(i=0; i<nArg; i++){
18507	utf8_width_print(p->out, aWidth[i], azCol[ aMap[i] ]);
18508	fputs(i==nArg-1 ? "\n" : " ", p->out);
18509	}
18510	for(i=0; i<nArg; i++){
18511	print_dashes(p->out, aWidth[i]);
18512	fputs(i==nArg-1 ? "\n" : " ", p->out);
18513	}
18514	}
18515
18516	/* If there is no data, exit early. */
18517	if( azArg==0 ) break;
	@@ -18525,21 +19298,21 @@
18525	w = strlenChar(zVal);
18526	zSep = " ";
18527	}
18528	if( i==iIndent && p->aiIndent && p->pStmt ){
18529	if( p->iIndent<p->nIndent ){
18530	utf8_printf(p->out, "%*.s", p->aiIndent[p->iIndent], "");
18531	}
18532	p->iIndent++;
18533	}
18534	utf8_width_print(p->out, w, zVal ? zVal : p->nullValue);
18535	fputs(i==nArg-1 ? "\n" : zSep, p->out);
18536	}
18537	break;
18538	}
18539	case MODE_Semi: { /* .schema and .fullschema output */
18540	printSchemaLine(p->out, azArg[0], ";\n");
18541	break;
18542	}
18543	case MODE_Pretty: { /* .schema and .fullschema with --indent */
18544	char *z;
18545	int j;
	@@ -18550,11 +19323,11 @@
18550	assert( nArg==1 );
18551	if( azArg[0]==0 ) break;
18552	if( sqlite3_strlike("CREATE VIEW%", azArg[0], 0)==0
18553	\|\| sqlite3_strlike("CREATE TRIG%", azArg[0], 0)==0
18554	){
18555	utf8_printf(p->out, "%s;\n", azArg[0]);
18556	break;
18557	}
18558	z = sqlite3_mprintf("%s", azArg[0]);
18559	shell_check_oom(z);
18560	j = 0;
	@@ -18583,166 +19356,161 @@
18583	}else if( c=='(' ){
18584	nParen++;
18585	}else if( c==')' ){
18586	nParen--;
18587	if( nLine>0 && nParen==0 && j>0 ){
18588	printSchemaLineN(p->out, z, j, "\n");
18589	j = 0;
18590	}
18591	}
18592	z[j++] = c;
18593	if( nParen==1 && cEnd==0
18594	&& (c=='(' \|\| c=='\n' \|\| (c==',' && !wsToEol(z+i+1)))
18595	){
18596	if( c=='\n' ) j--;
18597	printSchemaLineN(p->out, z, j, "\n ");
18598	j = 0;
18599	nLine++;
18600	while( IsSpace(z[i+1]) ){ i++; }
18601	}
18602	}
18603	z[j] = 0;
18604	}
18605	printSchemaLine(p->out, z, ";\n");
18606	sqlite3_free(z);
18607	break;
18608	}
18609	case MODE_List: {
18610	if( p->cnt++==0 && p->showHeader ){
18611	for(i=0; i<nArg; i++){
18612	utf8_printf(p->out,"%s%s",azCol[i],
18613	i==nArg-1 ? p->rowSeparator : p->colSeparator);
18614	}
18615	}
18616	if( azArg==0 ) break;
18617	for(i=0; i<nArg; i++){
18618	char *z = azArg[i];
18619	if( z==0 ) z = p->nullValue;
18620	utf8_printf(p->out, "%s", z);
18621	if( i<nArg-1 ){
18622	utf8_printf(p->out, "%s", p->colSeparator);
18623	}else{
18624	utf8_printf(p->out, "%s", p->rowSeparator);
18625	}
18626	}
18627	break;
18628	}
18629	case MODE_Html: {
18630	if( p->cnt++==0 && p->showHeader ){
18631	raw_printf(p->out,"<TR>");
18632	for(i=0; i<nArg; i++){
18633	raw_printf(p->out,"<TH>");
18634	output_html_string(p->out, azCol[i]);
18635	raw_printf(p->out,"</TH>\n");
18636	}
18637	raw_printf(p->out,"</TR>\n");
18638	}
18639	if( azArg==0 ) break;
18640	raw_printf(p->out,"<TR>");
18641	for(i=0; i<nArg; i++){
18642	raw_printf(p->out,"<TD>");
18643	output_html_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
18644	raw_printf(p->out,"</TD>\n");
18645	}
18646	raw_printf(p->out,"</TR>\n");
18647	break;
18648	}
18649	case MODE_Tcl: {
18650	if( p->cnt++==0 && p->showHeader ){
18651	for(i=0; i<nArg; i++){
18652	output_c_string(p->out,azCol[i] ? azCol[i] : "");
18653	if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator);
18654	}
18655	utf8_printf(p->out, "%s", p->rowSeparator);
18656	}
18657	if( azArg==0 ) break;
18658	for(i=0; i<nArg; i++){
18659	output_c_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
18660	if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator);
18661	}
18662	utf8_printf(p->out, "%s", p->rowSeparator);
18663	break;
18664	}
18665	case MODE_Csv: {
18666	setBinaryMode(p->out, 1);
18667	if( p->cnt++==0 && p->showHeader ){
18668	for(i=0; i<nArg; i++){
18669	output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
18670	}
18671	utf8_printf(p->out, "%s", p->rowSeparator);
18672	}
18673	if( nArg>0 ){
18674	for(i=0; i<nArg; i++){
18675	output_csv(p, azArg[i], i<nArg-1);
18676	}
18677	utf8_printf(p->out, "%s", p->rowSeparator);
18678	}
18679	setTextMode(p->out, 1);
18680	break;
18681	}
18682	case MODE_Insert: {
18683	if( azArg==0 ) break;
18684	utf8_printf(p->out,"INSERT INTO %s",p->zDestTable);
18685	if( p->showHeader ){
18686	raw_printf(p->out,"(");
18687	for(i=0; i<nArg; i++){
18688	if( i>0 ) raw_printf(p->out, ",");
18689	if( quoteChar(azCol[i]) ){
18690	char *z = sqlite3_mprintf("\"%w\"", azCol[i]);
18691	shell_check_oom(z);
18692	utf8_printf(p->out, "%s", z);
18693	sqlite3_free(z);
18694	}else{
18695	raw_printf(p->out, "%s", azCol[i]);
18696	}
18697	}
18698	raw_printf(p->out,")");
18699	}
18700	p->cnt++;
18701	for(i=0; i<nArg; i++){
18702	raw_printf(p->out, i>0 ? "," : " VALUES(");
18703	if( (azArg[i]==0) \|\| (aiType && aiType[i]==SQLITE_NULL) ){
18704	utf8_printf(p->out,"NULL");
18705	}else if( aiType && aiType[i]==SQLITE_TEXT ){
18706	if( ShellHasFlag(p, SHFLG_Newlines) ){
18707	output_quoted_string(p->out, azArg[i]);
18708	}else{
18709	output_quoted_escaped_string(p->out, azArg[i]);
18710	}
18711	}else if( aiType && aiType[i]==SQLITE_INTEGER ){
18712	utf8_printf(p->out,"%s", azArg[i]);
18713	}else if( aiType && aiType[i]==SQLITE_FLOAT ){
18714	char z[50];
18715	double r = sqlite3_column_double(p->pStmt, i);
18716	sqlite3_uint64 ur;
18717	memcpy(&ur,&r,sizeof(r));
18718	if( ur==0x7ff0000000000000LL ){
18719	raw_printf(p->out, "9.0e+999");
18720	}else if( ur==0xfff0000000000000LL ){
18721	raw_printf(p->out, "-9.0e+999");
18722	}else{
18723	sqlite3_int64 ir = (sqlite3_int64)r;
18724	if( r==(double)ir ){
18725	sqlite3_snprintf(50,z,"%lld.0", ir);
18726	}else{
18727	sqlite3_snprintf(50,z,"%!.20g", r);
18728	}
18729	raw_printf(p->out, "%s", z);
18730	}
18731	}else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
18732	const void *pBlob = sqlite3_column_blob(p->pStmt, i);
18733	int nBlob = sqlite3_column_bytes(p->pStmt, i);
18734	output_hex_blob(p->out, pBlob, nBlob);
18735	}else if( isNumber(azArg[i], 0) ){
18736	utf8_printf(p->out,"%s", azArg[i]);
18737	}else if( ShellHasFlag(p, SHFLG_Newlines) ){
18738	output_quoted_string(p->out, azArg[i]);
18739	}else{
18740	output_quoted_escaped_string(p->out, azArg[i]);
18741	}
18742	}
18743	raw_printf(p->out,");\n");
18744	break;
18745	}
18746	case MODE_Json: {
18747	if( azArg==0 ) break;
18748	if( p->cnt==0 ){
	@@ -18750,93 +19518,93 @@
18750	}else{
18751	fputs(",\n{", p->out);
18752	}
18753	p->cnt++;
18754	for(i=0; i<nArg; i++){
18755	output_json_string(p->out, azCol[i], -1);
18756	putc(':', p->out);
18757	if( (azArg[i]==0) \|\| (aiType && aiType[i]==SQLITE_NULL) ){
18758	fputs("null",p->out);
18759	}else if( aiType && aiType[i]==SQLITE_FLOAT ){
18760	char z[50];
18761	double r = sqlite3_column_double(p->pStmt, i);
18762	sqlite3_uint64 ur;
18763	memcpy(&ur,&r,sizeof(r));
18764	if( ur==0x7ff0000000000000LL ){
18765	raw_printf(p->out, "9.0e+999");
18766	}else if( ur==0xfff0000000000000LL ){
18767	raw_printf(p->out, "-9.0e+999");
18768	}else{
18769	sqlite3_snprintf(50,z,"%!.20g", r);
18770	raw_printf(p->out, "%s", z);
18771	}
18772	}else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
18773	const void *pBlob = sqlite3_column_blob(p->pStmt, i);
18774	int nBlob = sqlite3_column_bytes(p->pStmt, i);
18775	output_json_string(p->out, pBlob, nBlob);
18776	}else if( aiType && aiType[i]==SQLITE_TEXT ){
18777	output_json_string(p->out, azArg[i], -1);
18778	}else{
18779	utf8_printf(p->out,"%s", azArg[i]);
18780	}
18781	if( i<nArg-1 ){
18782	putc(',', p->out);
18783	}
18784	}
18785	putc('}', p->out);
18786	break;
18787	}
18788	case MODE_Quote: {
18789	if( azArg==0 ) break;
18790	if( p->cnt==0 && p->showHeader ){
18791	for(i=0; i<nArg; i++){
18792	if( i>0 ) fputs(p->colSeparator, p->out);
18793	output_quoted_string(p->out, azCol[i]);
18794	}
18795	fputs(p->rowSeparator, p->out);
18796	}
18797	p->cnt++;
18798	for(i=0; i<nArg; i++){
18799	if( i>0 ) fputs(p->colSeparator, p->out);
18800	if( (azArg[i]==0) \|\| (aiType && aiType[i]==SQLITE_NULL) ){
18801	utf8_printf(p->out,"NULL");
18802	}else if( aiType && aiType[i]==SQLITE_TEXT ){
18803	output_quoted_string(p->out, azArg[i]);
18804	}else if( aiType && aiType[i]==SQLITE_INTEGER ){
18805	utf8_printf(p->out,"%s", azArg[i]);
18806	}else if( aiType && aiType[i]==SQLITE_FLOAT ){
18807	char z[50];
18808	double r = sqlite3_column_double(p->pStmt, i);
18809	sqlite3_snprintf(50,z,"%!.20g", r);
18810	raw_printf(p->out, "%s", z);
18811	}else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
18812	const void *pBlob = sqlite3_column_blob(p->pStmt, i);
18813	int nBlob = sqlite3_column_bytes(p->pStmt, i);
18814	output_hex_blob(p->out, pBlob, nBlob);
18815	}else if( isNumber(azArg[i], 0) ){
18816	utf8_printf(p->out,"%s", azArg[i]);
18817	}else{
18818	output_quoted_string(p->out, azArg[i]);
18819	}
18820	}
18821	fputs(p->rowSeparator, p->out);
18822	break;
18823	}
18824	case MODE_Ascii: {
18825	if( p->cnt++==0 && p->showHeader ){
18826	for(i=0; i<nArg; i++){
18827	if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator);
18828	utf8_printf(p->out,"%s",azCol[i] ? azCol[i] : "");
18829	}
18830	utf8_printf(p->out, "%s", p->rowSeparator);
18831	}
18832	if( azArg==0 ) break;
18833	for(i=0; i<nArg; i++){
18834	if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator);
18835	utf8_printf(p->out,"%s",azArg[i] ? azArg[i] : p->nullValue);
18836	}
18837	utf8_printf(p->out, "%s", p->rowSeparator);
18838	break;
18839	}
18840	case MODE_EQP: {
18841	eqp_append(p, atoi(azArg[0]), atoi(azArg[1]), azArg[3]);
18842	break;
	@@ -18911,11 +19679,11 @@
18911	"INSERT INTO selftest(tno,op,cmd,ans)"
18912	" SELECT rowid*10,op,cmd,ans FROM [_shell$self];\n"
18913	"DROP TABLE [_shell$self];"
18914	,0,0,&zErrMsg);
18915	if( zErrMsg ){
18916	utf8_printf(stderr, "SELFTEST initialization failure: %s\n", zErrMsg);
18917	sqlite3_free(zErrMsg);
18918	}
18919	sqlite3_exec(p->db, "RELEASE selftest_init",0,0,0);
18920	}
18921
	@@ -19014,37 +19782,36 @@
19014	int i;
19015	const char *z;
19016	rc = sqlite3_prepare_v2(p->db, zSelect, -1, &pSelect, 0);
19017	if( rc!=SQLITE_OK \|\| !pSelect ){
19018	char *zContext = shell_error_context(zSelect, p->db);
19019	utf8_printf(p->out, "/** ERROR: (%d) %s ***/\n%s", rc,
19020	sqlite3_errmsg(p->db), zContext);
19021	sqlite3_free(zContext);
19022	if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
19023	return rc;
19024	}
19025	rc = sqlite3_step(pSelect);
19026	nResult = sqlite3_column_count(pSelect);
19027	while( rc==SQLITE_ROW ){
19028	z = (const char*)sqlite3_column_text(pSelect, 0);
19029	utf8_printf(p->out, "%s", z);
19030	for(i=1; i<nResult; i++){
19031	utf8_printf(p->out, ",%s", sqlite3_column_text(pSelect, i));
19032	}
19033	if( z==0 ) z = "";
19034	while( z[0] && (z[0]!='-' \|\| z[1]!='-') ) z++;
19035	if( z[0] ){
19036	raw_printf(p->out, "\n;\n");
19037	}else{
19038	raw_printf(p->out, ";\n");
19039	}
19040	rc = sqlite3_step(pSelect);
19041	}
19042	rc = sqlite3_finalize(pSelect);
19043	if( rc!=SQLITE_OK ){
19044	utf8_printf(p->out, "/** ERROR: (%d) %s ***/\n", rc,
19045	sqlite3_errmsg(p->db));
19046	if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
19047	}
19048	return rc;
19049	}
19050
	@@ -19076,11 +19843,11 @@
19076
19077	#ifdef __linux__
19078	/*
19079	** Attempt to display I/O stats on Linux using /proc/PID/io
19080	*/
19081	static void displayLinuxIoStats(FILE *out){
19082	FILE *in;
19083	char z[200];
19084	sqlite3_snprintf(sizeof(z), z, "/proc/%d/io", getpid());
19085	in = fopen(z, "rb");
19086	if( in==0 ) return;
	@@ -19099,11 +19866,11 @@
19099	};
19100	int i;
19101	for(i=0; i<ArraySize(aTrans); i++){
19102	int n = strlen30(aTrans[i].zPattern);
19103	if( cli_strncmp(aTrans[i].zPattern, z, n)==0 ){
19104	utf8_printf(out, "%-36s %s", aTrans[i].zDesc, &z[n]);
19105	break;
19106	}
19107	}
19108	}
19109	fclose(in);
	@@ -19112,11 +19879,10 @@
19112
19113	/*
19114	** Display a single line of status using 64-bit values.
19115	*/
19116	static void displayStatLine(
19117	ShellState p, / The shell context */
19118	char zLabel, / Label for this one line */
19119	char zFormat, / Format for the result */
19120	int iStatusCtrl, /* Which status to display */
19121	int bReset /* True to reset the stats */
19122	){
	@@ -19131,11 +19897,11 @@
19131	if( nPercent>1 ){
19132	sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iCur, iHiwtr);
19133	}else{
19134	sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iHiwtr);
19135	}
19136	raw_printf(p->out, "%-36s %s\n", zLabel, zLine);
19137	}
19138
19139	/*
19140	** Display memory stats.
19141	*/
	@@ -19144,141 +19910,130 @@
19144	ShellState pArg, / Pointer to ShellState */
19145	int bReset /* True to reset the stats */
19146	){
19147	int iCur;
19148	int iHiwtr;
19149	FILE *out;
19150	if( pArg==0 \|\| pArg->out==0 ) return 0;
19151	out = pArg->out;
19152
19153	if( pArg->pStmt && pArg->statsOn==2 ){
19154	int nCol, i, x;
19155	sqlite3_stmt *pStmt = pArg->pStmt;
19156	char z[100];
19157	nCol = sqlite3_column_count(pStmt);
19158	raw_printf(out, "%-36s %d\n", "Number of output columns:", nCol);
19159	for(i=0; i<nCol; i++){
19160	sqlite3_snprintf(sizeof(z),z,"Column %d %nname:", i, &x);
19161	utf8_printf(out, "%-36s %s\n", z, sqlite3_column_name(pStmt,i));
19162	#ifndef SQLITE_OMIT_DECLTYPE
19163	sqlite3_snprintf(30, z+x, "declared type:");
19164	utf8_printf(out, "%-36s %s\n", z, sqlite3_column_decltype(pStmt, i));
19165	#endif
19166	#ifdef SQLITE_ENABLE_COLUMN_METADATA
19167	sqlite3_snprintf(30, z+x, "database name:");
19168	utf8_printf(out, "%-36s %s\n", z, sqlite3_column_database_name(pStmt,i));
19169	sqlite3_snprintf(30, z+x, "table name:");
19170	utf8_printf(out, "%-36s %s\n", z, sqlite3_column_table_name(pStmt,i));
19171	sqlite3_snprintf(30, z+x, "origin name:");
19172	utf8_printf(out, "%-36s %s\n", z, sqlite3_column_origin_name(pStmt,i));
19173	#endif
19174	}
19175	}
19176
19177	if( pArg->statsOn==3 ){
19178	if( pArg->pStmt ){
19179	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP,bReset);
19180	raw_printf(pArg->out, "VM-steps: %d\n", iCur);
19181	}
19182	return 0;
19183	}
19184
19185	displayStatLine(pArg, "Memory Used:",
19186	"%lld (max %lld) bytes", SQLITE_STATUS_MEMORY_USED, bReset);
19187	displayStatLine(pArg, "Number of Outstanding Allocations:",
19188	"%lld (max %lld)", SQLITE_STATUS_MALLOC_COUNT, bReset);
19189	if( pArg->shellFlgs & SHFLG_Pagecache ){
19190	displayStatLine(pArg, "Number of Pcache Pages Used:",
19191	"%lld (max %lld) pages", SQLITE_STATUS_PAGECACHE_USED, bReset);
19192	}
19193	displayStatLine(pArg, "Number of Pcache Overflow Bytes:",
19194	"%lld (max %lld) bytes", SQLITE_STATUS_PAGECACHE_OVERFLOW, bReset);
19195	displayStatLine(pArg, "Largest Allocation:",
19196	"%lld bytes", SQLITE_STATUS_MALLOC_SIZE, bReset);
19197	displayStatLine(pArg, "Largest Pcache Allocation:",
19198	"%lld bytes", SQLITE_STATUS_PAGECACHE_SIZE, bReset);
19199	#ifdef YYTRACKMAXSTACKDEPTH
19200	displayStatLine(pArg, "Deepest Parser Stack:",
19201	"%lld (max %lld)", SQLITE_STATUS_PARSER_STACK, bReset);
19202	#endif
19203
19204	if( db ){
19205	if( pArg->shellFlgs & SHFLG_Lookaside ){
19206	iHiwtr = iCur = -1;
19207	sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED,
19208	&iCur, &iHiwtr, bReset);
19209	raw_printf(pArg->out,
19210	"Lookaside Slots Used: %d (max %d)\n",
19211	iCur, iHiwtr);
19212	sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT,
19213	&iCur, &iHiwtr, bReset);
19214	raw_printf(pArg->out, "Successful lookaside attempts: %d\n",
19215	iHiwtr);
19216	sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE,
19217	&iCur, &iHiwtr, bReset);
19218	raw_printf(pArg->out, "Lookaside failures due to size: %d\n",
19219	iHiwtr);
19220	sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL,
19221	&iCur, &iHiwtr, bReset);
19222	raw_printf(pArg->out, "Lookaside failures due to OOM: %d\n",
19223	iHiwtr);
19224	}
19225	iHiwtr = iCur = -1;
19226	sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);
19227	raw_printf(pArg->out, "Pager Heap Usage: %d bytes\n",
19228	iCur);
19229	iHiwtr = iCur = -1;
19230	sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1);
19231	raw_printf(pArg->out, "Page cache hits: %d\n", iCur);
19232	iHiwtr = iCur = -1;
19233	sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1);
19234	raw_printf(pArg->out, "Page cache misses: %d\n", iCur);
19235	iHiwtr = iCur = -1;
19236	sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1);
19237	raw_printf(pArg->out, "Page cache writes: %d\n", iCur);
19238	iHiwtr = iCur = -1;
19239	sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_SPILL, &iCur, &iHiwtr, 1);
19240	raw_printf(pArg->out, "Page cache spills: %d\n", iCur);
19241	iHiwtr = iCur = -1;
19242	sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset);
19243	raw_printf(pArg->out, "Schema Heap Usage: %d bytes\n",
19244	iCur);
19245	iHiwtr = iCur = -1;
19246	sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset);
19247	raw_printf(pArg->out, "Statement Heap/Lookaside Usage: %d bytes\n",
19248	iCur);
19249	}
19250
19251	if( pArg->pStmt ){
19252	int iHit, iMiss;
19253	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP,
19254	bReset);
19255	raw_printf(pArg->out, "Fullscan Steps: %d\n", iCur);
19256	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset);
19257	raw_printf(pArg->out, "Sort Operations: %d\n", iCur);
19258	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX,bReset);
19259	raw_printf(pArg->out, "Autoindex Inserts: %d\n", iCur);
19260	iHit = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FILTER_HIT,
19261	bReset);
19262	iMiss = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FILTER_MISS,
19263	bReset);
19264	if( iHit \|\| iMiss ){
19265	raw_printf(pArg->out, "Bloom filter bypass taken: %d/%d\n",
19266	iHit, iHit+iMiss);
19267	}
19268	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset);
19269	raw_printf(pArg->out, "Virtual Machine Steps: %d\n", iCur);
19270	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_REPREPARE,bReset);
19271	raw_printf(pArg->out, "Reprepare operations: %d\n", iCur);
19272	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_RUN, bReset);
19273	raw_printf(pArg->out, "Number of times run: %d\n", iCur);
19274	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_MEMUSED, bReset);
19275	raw_printf(pArg->out, "Memory used by prepared stmt: %d\n", iCur);
19276	}
19277
19278	#ifdef __linux__
19279	displayLinuxIoStats(pArg->out);
19280	#endif
19281
19282	/* Do not remove this machine readable comment: extra-stats-output-here */
19283
19284	return 0;
	@@ -19509,11 +20264,11 @@
19509	#ifndef SQLITE_ENABLE_STMT_SCANSTATUS
19510	UNUSED_PARAMETER(db);
19511	UNUSED_PARAMETER(pArg);
19512	#else
19513	if( pArg->scanstatsOn==3 ){
19514	const char *zSql =
19515	" SELECT addr, opcode, p1, p2, p3, p4, p5, comment, nexec,"
19516	" round(ncycle*100.0 / (sum(ncycle) OVER ()), 2)\|\|'%' AS cycles"
19517	" FROM bytecode(?)";
19518
19519	int rc = SQLITE_OK;
	@@ -19655,21 +20410,21 @@
19655	#define BOX_1234 "\342\224\274" /* U+253c -\|- */
19656
19657	/* Draw horizontal line N characters long using unicode box
19658	** characters
19659	*/
19660	static void print_box_line(FILE *out, int N){
19661	const char zDash[] =
19662	BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24
19663	BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24;
19664	const int nDash = sizeof(zDash) - 1;
19665	N *= 3;
19666	while( N>nDash ){
19667	utf8_printf(out, zDash);
19668	N -= nDash;
19669	}
19670	utf8_printf(out, "%.*s", N, zDash);
19671	}
19672
19673	/*
19674	** Draw a horizontal separator for a MODE_Box table.
19675	*/
	@@ -19680,19 +20435,19 @@
19680	const char *zSep2,
19681	const char *zSep3
19682	){
19683	int i;
19684	if( nArg>0 ){
19685	utf8_printf(p->out, "%s", zSep1);
19686	print_box_line(p->out, p->actualWidth[0]+2);
19687	for(i=1; i<nArg; i++){
19688	utf8_printf(p->out, "%s", zSep2);
19689	print_box_line(p->out, p->actualWidth[i]+2);
19690	}
19691	utf8_printf(p->out, "%s", zSep3);
19692	}
19693	fputs("\n", p->out);
19694	}
19695
19696	/*
19697	** z[] is a line of text that is to be displayed the .mode box or table or
19698	** similar tabular formats. z[] might contain control characters such
	@@ -19951,15 +20706,15 @@
19951	rowSep = "\n";
19952	if( p->showHeader ){
19953	for(i=0; i<nColumn; i++){
19954	w = p->actualWidth[i];
19955	if( p->colWidth[i]<0 ) w = -w;
19956	utf8_width_print(p->out, w, azData[i]);
19957	fputs(i==nColumn-1?"\n":" ", p->out);
19958	}
19959	for(i=0; i<nColumn; i++){
19960	print_dashes(p->out, p->actualWidth[i]);
19961	fputs(i==nColumn-1?"\n":" ", p->out);
19962	}
19963	}
19964	break;
19965	}
	@@ -19969,12 +20724,12 @@
19969	print_row_separator(p, nColumn, "+");
19970	fputs("\| ", p->out);
19971	for(i=0; i<nColumn; i++){
19972	w = p->actualWidth[i];
19973	n = strlenChar(azData[i]);
19974	utf8_printf(p->out, "%s%s%s", (w-n)/2, "", azData[i], (w-n+1)/2, "");
19975	fputs(i==nColumn-1?" \|\n":" \| ", p->out);
19976	}
19977	print_row_separator(p, nColumn, "+");
19978	break;
19979	}
19980	case MODE_Markdown: {
	@@ -19982,66 +20737,66 @@
19982	rowSep = " \|\n";
19983	fputs("\| ", p->out);
19984	for(i=0; i<nColumn; i++){
19985	w = p->actualWidth[i];
19986	n = strlenChar(azData[i]);
19987	utf8_printf(p->out, "%s%s%s", (w-n)/2, "", azData[i], (w-n+1)/2, "");
19988	fputs(i==nColumn-1?" \|\n":" \| ", p->out);
19989	}
19990	print_row_separator(p, nColumn, "\|");
19991	break;
19992	}
19993	case MODE_Box: {
19994	colSep = " " BOX_13 " ";
19995	rowSep = " " BOX_13 "\n";
19996	print_box_row_separator(p, nColumn, BOX_23, BOX_234, BOX_34);
19997	utf8_printf(p->out, BOX_13 " ");
19998	for(i=0; i<nColumn; i++){
19999	w = p->actualWidth[i];
20000	n = strlenChar(azData[i]);
20001	utf8_printf(p->out, "%s%s%s%s",
20002	(w-n)/2, "", azData[i], (w-n+1)/2, "",
20003	i==nColumn-1?" "BOX_13"\n":" "BOX_13" ");
20004	}
20005	print_box_row_separator(p, nColumn, BOX_123, BOX_1234, BOX_134);
20006	break;
20007	}
20008	}
20009	for(i=nColumn, j=0; i<nTotal; i++, j++){
20010	if( j==0 && p->cMode!=MODE_Column ){
20011	utf8_printf(p->out, "%s", p->cMode==MODE_Box?BOX_13" ":"\| ");
20012	}
20013	z = azData[i];
20014	if( z==0 ) z = p->nullValue;
20015	w = p->actualWidth[j];
20016	if( p->colWidth[j]<0 ) w = -w;
20017	utf8_width_print(p->out, w, z);
20018	if( j==nColumn-1 ){
20019	utf8_printf(p->out, "%s", rowSep);
20020	if( bMultiLineRowExists && abRowDiv[i/nColumn-1] && i+1<nTotal ){
20021	if( p->cMode==MODE_Table ){
20022	print_row_separator(p, nColumn, "+");
20023	}else if( p->cMode==MODE_Box ){
20024	print_box_row_separator(p, nColumn, BOX_123, BOX_1234, BOX_134);
20025	}else if( p->cMode==MODE_Column ){
20026	raw_printf(p->out, "\n");
20027	}
20028	}
20029	j = -1;
20030	if( seenInterrupt ) goto columnar_end;
20031	}else{
20032	utf8_printf(p->out, "%s", colSep);
20033	}
20034	}
20035	if( p->cMode==MODE_Table ){
20036	print_row_separator(p, nColumn, "+");
20037	}else if( p->cMode==MODE_Box ){
20038	print_box_row_separator(p, nColumn, BOX_12, BOX_124, BOX_14);
20039	}
20040	columnar_end:
20041	if( seenInterrupt ){
20042	utf8_printf(p->out, "Interrupt\n");
20043	}
20044	nData = (nRow+1)*nColumn;
20045	for(i=0; i<nData; i++){
20046	z = azData[i];
20047	if( z!=zEmpty && z!=zShowNull ) free(azData[i]);
	@@ -20176,34 +20931,33 @@
20176	int rc = SQLITE_OK;
20177	sqlite3expert *p = pState->expert.pExpert;
20178	assert( p );
20179	assert( bCancel \|\| pzErr==0 \|\| *pzErr==0 );
20180	if( bCancel==0 ){
20181	FILE *out = pState->out;
20182	int bVerbose = pState->expert.bVerbose;
20183
20184	rc = sqlite3_expert_analyze(p, pzErr);
20185	if( rc==SQLITE_OK ){
20186	int nQuery = sqlite3_expert_count(p);
20187	int i;
20188
20189	if( bVerbose ){
20190	const char *zCand = sqlite3_expert_report(p,0,EXPERT_REPORT_CANDIDATES);
20191	raw_printf(out, "-- Candidates -----------------------------\n");
20192	raw_printf(out, "%s\n", zCand);
20193	}
20194	for(i=0; i<nQuery; i++){
20195	const char *zSql = sqlite3_expert_report(p, i, EXPERT_REPORT_SQL);
20196	const char *zIdx = sqlite3_expert_report(p, i, EXPERT_REPORT_INDEXES);
20197	const char *zEQP = sqlite3_expert_report(p, i, EXPERT_REPORT_PLAN);
20198	if( zIdx==0 ) zIdx = "(no new indexes)\n";
20199	if( bVerbose ){
20200	raw_printf(out, "-- Query %d --------------------------------\n",i+1);
20201	raw_printf(out, "%s\n\n", zSql);
20202	}
20203	raw_printf(out, "%s\n", zIdx);
20204	raw_printf(out, "%s\n", zEQP);
20205	}
20206	}
20207	}
20208	sqlite3_expert_destroy(p);
20209	pState->expert.pExpert = 0;
	@@ -20234,31 +20988,30 @@
20234	if( n>=2 && 0==cli_strncmp(z, "-verbose", n) ){
20235	pState->expert.bVerbose = 1;
20236	}
20237	else if( n>=2 && 0==cli_strncmp(z, "-sample", n) ){
20238	if( i==(nArg-1) ){
20239	raw_printf(stderr, "option requires an argument: %s\n", z);
20240	rc = SQLITE_ERROR;
20241	}else{
20242	iSample = (int)integerValue(azArg[++i]);
20243	if( iSample<0 \|\| iSample>100 ){
20244	raw_printf(stderr, "value out of range: %s\n", azArg[i]);
20245	rc = SQLITE_ERROR;
20246	}
20247	}
20248	}
20249	else{
20250	raw_printf(stderr, "unknown option: %s\n", z);
20251	rc = SQLITE_ERROR;
20252	}
20253	}
20254
20255	if( rc==SQLITE_OK ){
20256	pState->expert.pExpert = sqlite3_expert_new(pState->db, &zErr);
20257	if( pState->expert.pExpert==0 ){
20258	raw_printf(stderr, "sqlite3_expert_new: %s\n",
20259	zErr ? zErr : "out of memory");
20260	rc = SQLITE_ERROR;
20261	}else{
20262	sqlite3_expert_config(
20263	pState->expert.pExpert, EXPERT_CONFIG_SAMPLE, iSample
20264	);
	@@ -20581,33 +21334,33 @@
20581	if( zType==0 ) return 0;
20582	dataOnly = (p->shellFlgs & SHFLG_DumpDataOnly)!=0;
20583	noSys = (p->shellFlgs & SHFLG_DumpNoSys)!=0;
20584
20585	if( cli_strcmp(zTable, "sqlite_sequence")==0 && !noSys ){
20586	if( !dataOnly ) raw_printf(p->out, "DELETE FROM sqlite_sequence;\n");
20587	}else if( sqlite3_strglob("sqlite_stat?", zTable)==0 && !noSys ){
20588	if( !dataOnly ) raw_printf(p->out, "ANALYZE sqlite_schema;\n");
20589	}else if( cli_strncmp(zTable, "sqlite_", 7)==0 ){
20590	return 0;
20591	}else if( dataOnly ){
20592	/* no-op */
20593	}else if( cli_strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
20594	char *zIns;
20595	if( !p->writableSchema ){
20596	raw_printf(p->out, "PRAGMA writable_schema=ON;\n");
20597	p->writableSchema = 1;
20598	}
20599	zIns = sqlite3_mprintf(
20600	"INSERT INTO sqlite_schema(type,name,tbl_name,rootpage,sql)"
20601	"VALUES('table','%q','%q',0,'%q');",
20602	zTable, zTable, zSql);
20603	shell_check_oom(zIns);
20604	utf8_printf(p->out, "%s\n", zIns);
20605	sqlite3_free(zIns);
20606	return 0;
20607	}else{
20608	printSchemaLine(p->out, zSql, ";\n");
20609	}
20610
20611	if( cli_strcmp(zType, "table")==0 ){
20612	ShellText sSelect;
20613	ShellText sTable;
	@@ -20661,11 +21414,11 @@
20661	savedMode = p->mode;
20662	p->zDestTable = sTable.z;
20663	p->mode = p->cMode = MODE_Insert;
20664	rc = shell_exec(p, sSelect.z, 0);
20665	if( (rc&0xff)==SQLITE_CORRUPT ){
20666	raw_printf(p->out, "/**** CORRUPTION ERROR *****/\n");
20667	toggleSelectOrder(p->db);
20668	shell_exec(p, sSelect.z, 0);
20669	toggleSelectOrder(p->db);
20670	}
20671	p->zDestTable = savedDestTable;
	@@ -20692,22 +21445,22 @@
20692	char *zErr = 0;
20693	rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr);
20694	if( rc==SQLITE_CORRUPT ){
20695	char *zQ2;
20696	int len = strlen30(zQuery);
20697	raw_printf(p->out, "/**** CORRUPTION ERROR *****/\n");
20698	if( zErr ){
20699	utf8_printf(p->out, "/**** %s ****/\n", zErr);
20700	sqlite3_free(zErr);
20701	zErr = 0;
20702	}
20703	zQ2 = malloc( len+100 );
20704	if( zQ2==0 ) return rc;
20705	sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery);
20706	rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr);
20707	if( rc ){
20708	utf8_printf(p->out, "/**** ERROR: %s ****/\n", zErr);
20709	}else{
20710	rc = SQLITE_CORRUPT;
20711	}
20712	sqlite3_free(zErr);
20713	free(zQ2);
	@@ -21059,24 +21812,24 @@
21059	hh &= ~HH_Summary;
21060	break;
21061	}
21062	if( ((hw^hh)&HH_Undoc)==0 ){
21063	if( (hh&HH_Summary)!=0 ){
21064	utf8_printf(out, ".%s\n", azHelp[i]+1);
21065	++n;
21066	}else if( (hw&HW_SummaryOnly)==0 ){
21067	utf8_printf(out, "%s\n", azHelp[i]);
21068	}
21069	}
21070	}
21071	}else{
21072	/* Seek documented commands for which zPattern is an exact prefix */
21073	zPat = sqlite3_mprintf(".%s*", zPattern);
21074	shell_check_oom(zPat);
21075	for(i=0; i<ArraySize(azHelp); i++){
21076	if( sqlite3_strglob(zPat, azHelp[i])==0 ){
21077	utf8_printf(out, "%s\n", azHelp[i]);
21078	j = i+1;
21079	n++;
21080	}
21081	}
21082	sqlite3_free(zPat);
	@@ -21083,11 +21836,11 @@
21083	if( n ){
21084	if( n==1 ){
21085	/* when zPattern is a prefix of exactly one command, then include
21086	** the details of that command, which should begin at offset j */
21087	while( j<ArraySize(azHelp)-1 && azHelp[j][0]==' ' ){
21088	utf8_printf(out, "%s\n", azHelp[j]);
21089	j++;
21090	}
21091	}
21092	return n;
21093	}
	@@ -21100,14 +21853,14 @@
21100	while( i<ArraySize(azHelp)-1 && azHelp[i+1][0]==' ' ) ++i;
21101	continue;
21102	}
21103	if( azHelp[i][0]=='.' ) j = i;
21104	if( sqlite3_strlike(zPat, azHelp[i], 0)==0 ){
21105	utf8_printf(out, "%s\n", azHelp[j]);
21106	while( j<ArraySize(azHelp)-1 && azHelp[j+1][0]==' ' ){
21107	j++;
21108	utf8_printf(out, "%s\n", azHelp[j]);
21109	}
21110	i = j;
21111	n++;
21112	}
21113	}
	@@ -21141,27 +21894,27 @@
21141	char *pBuf;
21142	int rc;
21143	if( in==0 ) return 0;
21144	rc = fseek(in, 0, SEEK_END);
21145	if( rc!=0 ){
21146	raw_printf(stderr, "Error: '%s' not seekable\n", zName);
21147	fclose(in);
21148	return 0;
21149	}
21150	nIn = ftell(in);
21151	rewind(in);
21152	pBuf = sqlite3_malloc64( nIn+1 );
21153	if( pBuf==0 ){
21154	raw_printf(stderr, "Error: out of memory\n");
21155	fclose(in);
21156	return 0;
21157	}
21158	nRead = fread(pBuf, nIn, 1, in);
21159	fclose(in);
21160	if( nRead!=1 ){
21161	sqlite3_free(pBuf);
21162	raw_printf(stderr, "Error: cannot read '%s'\n", zName);
21163	return 0;
21164	}
21165	pBuf[nIn] = 0;
21166	if( pnByte ) *pnByte = nIn;
21167	return pBuf;
	@@ -21278,11 +22031,11 @@
21278	unsigned int x[16];
21279	char zLine[1000];
21280	if( zDbFilename ){
21281	in = fopen(zDbFilename, "r");
21282	if( in==0 ){
21283	utf8_printf(stderr, "cannot open \"%s\" for reading\n", zDbFilename);
21284	return 0;
21285	}
21286	nLine = 0;
21287	}else{
21288	in = p->in;
	@@ -21299,11 +22052,11 @@
21299	n = (n+pgsz-1)&~(pgsz-1); /* Round n up to the next multiple of pgsz */
21300	a = sqlite3_malloc( n ? n : 1 );
21301	shell_check_oom(a);
21302	memset(a, 0, n);
21303	if( pgsz<512 \|\| pgsz>65536 \|\| (pgsz & (pgsz-1))!=0 ){
21304	utf8_printf(stderr, "invalid pagesize\n");
21305	goto readHexDb_error;
21306	}
21307	for(nLine++; fgets(zLine, sizeof(zLine), in)!=0; nLine++){
21308	rc = sscanf(zLine, "\| page %d offset %d", &j, &k);
21309	if( rc==2 ){
	@@ -21341,11 +22094,11 @@
21341	if(cli_strncmp(zLine, "\| end ", 6)==0 ) break;
21342	}
21343	p->lineno = nLine;
21344	}
21345	sqlite3_free(a);
21346	utf8_printf(stderr,"Error on line %d of --hexdb input\n", nLine);
21347	return 0;
21348	}
21349	#endif /* SQLITE_OMIT_DESERIALIZE */
21350
21351	/*
	@@ -21417,26 +22170,23 @@
21417	break;
21418	}
21419	}
21420	globalDb = p->db;
21421	if( p->db==0 \|\| SQLITE_OK!=sqlite3_errcode(p->db) ){
21422	utf8_printf(stderr,"Error: unable to open database \"%s\": %s\n",
21423	zDbFilename, sqlite3_errmsg(p->db));
21424	if( (openFlags & OPEN_DB_KEEPALIVE)==0 ){
21425	exit(1);
21426	}
21427	sqlite3_close(p->db);
21428	sqlite3_open(":memory:", &p->db);
21429	if( p->db==0 \|\| SQLITE_OK!=sqlite3_errcode(p->db) ){
21430	utf8_printf(stderr,
21431	"Also: unable to open substitute in-memory database.\n"
21432	);
21433	exit(1);
21434	}else{
21435	utf8_printf(stderr,
21436	"Notice: using substitute in-memory database instead of \"%s\"\n",
21437	zDbFilename);
21438	}
21439	}
21440	sqlite3_db_config(p->db, SQLITE_DBCONFIG_STMT_SCANSTATUS, (int)0, (int*)0);
21441
21442	/* Reflect the use or absence of --unsafe-testing invocation. */
	@@ -21539,11 +22289,11 @@
21539	}
21540	rc = sqlite3_deserialize(p->db, "main", aData, nData, nData,
21541	SQLITE_DESERIALIZE_RESIZEABLE \|
21542	SQLITE_DESERIALIZE_FREEONCLOSE);
21543	if( rc ){
21544	utf8_printf(stderr, "Error: sqlite3_deserialize() returns %d\n", rc);
21545	}
21546	if( p->szMax>0 ){
21547	sqlite3_file_control(p->db, "main", SQLITE_FCNTL_SIZE_LIMIT, &p->szMax);
21548	}
21549	}
	@@ -21563,12 +22313,11 @@
21563	** Attempt to close the database connection. Report errors.
21564	*/
21565	void close_db(sqlite3 *db){
21566	int rc = sqlite3_close(db);
21567	if( rc ){
21568	utf8_printf(stderr, "Error: sqlite3_close() returns %d: %s\n",
21569	rc, sqlite3_errmsg(db));
21570	}
21571	}
21572
21573	#if HAVE_READLINE \|\| HAVE_EDITLINE
21574	/*
	@@ -21725,12 +22474,11 @@
21725	return 1;
21726	}
21727	if( sqlite3_stricmp(zArg, "off")==0 \|\| sqlite3_stricmp(zArg,"no")==0 ){
21728	return 0;
21729	}
21730	utf8_printf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
21731	zArg);
21732	return 0;
21733	}
21734
21735	/*
21736	** Set or clear a shell flag according to a boolean value.
	@@ -21764,11 +22512,11 @@
21764	}else if( cli_strcmp(zFile, "off")==0 ){
21765	f = 0;
21766	}else{
21767	f = fopen(zFile, bTextMode ? "w" : "wb");
21768	if( f==0 ){
21769	utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile);
21770	}
21771	}
21772	return f;
21773	}
21774
	@@ -21786,11 +22534,11 @@
21786	sqlite3_stmt *pStmt;
21787	const char *zSql;
21788	i64 nSql;
21789	if( p->traceOut==0 ) return 0;
21790	if( mType==SQLITE_TRACE_CLOSE ){
21791	utf8_printf(p->traceOut, "-- closing database connection\n");
21792	return 0;
21793	}
21794	if( mType!=SQLITE_TRACE_ROW && pX!=0 && ((const char*)pX)[0]=='-' ){
21795	zSql = (const char*)pX;
21796	}else{
	@@ -21817,16 +22565,16 @@
21817	if( nSql>1000000000 ) nSql = 1000000000;
21818	while( nSql>0 && zSql[nSql-1]==';' ){ nSql--; }
21819	switch( mType ){
21820	case SQLITE_TRACE_ROW:
21821	case SQLITE_TRACE_STMT: {
21822	utf8_printf(p->traceOut, "%.*s;\n", (int)nSql, zSql);
21823	break;
21824	}
21825	case SQLITE_TRACE_PROFILE: {
21826	sqlite3_int64 nNanosec = pX ? (sqlite3_int64)pX : 0;
21827	utf8_printf(p->traceOut, "%.*s; -- %lld ns\n", (int)nSql, zSql, nNanosec);
21828	break;
21829	}
21830	}
21831	return 0;
21832	}
	@@ -21929,16 +22677,15 @@
21929	do{ p->n--; }while( p->z[p->n]!=cQuote );
21930	p->cTerm = c;
21931	break;
21932	}
21933	if( pc==cQuote && c!='\r' ){
21934	utf8_printf(stderr, "%s:%d: unescaped %c character\n",
21935	p->zFile, p->nLine, cQuote);
21936	}
21937	if( c==EOF ){
21938	utf8_printf(stderr, "%s:%d: unterminated %c-quoted field\n",
21939	p->zFile, startLine, cQuote);
21940	p->cTerm = c;
21941	break;
21942	}
21943	import_append_char(p, c);
21944	ppc = pc;
	@@ -22032,13 +22779,12 @@
22032
22033	zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable);
22034	shell_check_oom(zQuery);
22035	rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
22036	if( rc ){
22037	utf8_printf(stderr, "Error %d: %s on [%s]\n",
22038	sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
22039	zQuery);
22040	goto end_data_xfer;
22041	}
22042	n = sqlite3_column_count(pQuery);
22043	zInsert = sqlite3_malloc64(200 + nTable + n*3);
22044	shell_check_oom(zInsert);
	@@ -22050,13 +22796,12 @@
22050	i += 2;
22051	}
22052	memcpy(zInsert+i, ");", 3);
22053	rc = sqlite3_prepare_v2(newDb, zInsert, -1, &pInsert, 0);
22054	if( rc ){
22055	utf8_printf(stderr, "Error %d: %s on [%s]\n",
22056	sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb),
22057	zInsert);
22058	goto end_data_xfer;
22059	}
22060	for(k=0; k<2; k++){
22061	while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
22062	for(i=0; i<n; i++){
	@@ -22087,12 +22832,12 @@
22087	}
22088	}
22089	} /* End for */
22090	rc = sqlite3_step(pInsert);
22091	if( rc!=SQLITE_OK && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
22092	utf8_printf(stderr, "Error %d: %s\n", sqlite3_extended_errcode(newDb),
22093	sqlite3_errmsg(newDb));
22094	}
22095	sqlite3_reset(pInsert);
22096	cnt++;
22097	if( (cnt%spinRate)==0 ){
22098	printf("%c\b", "\|/-\\"[(cnt/spinRate)%4]);
	@@ -22105,11 +22850,11 @@
22105	zQuery = sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;",
22106	zTable);
22107	shell_check_oom(zQuery);
22108	rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
22109	if( rc ){
22110	utf8_printf(stderr, "Warning: cannot step \"%s\" backwards", zTable);
22111	break;
22112	}
22113	} /* End for(k=0...) */
22114
22115	end_data_xfer:
	@@ -22142,62 +22887,60 @@
22142	zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_schema"
22143	" WHERE %s ORDER BY rowid ASC", zWhere);
22144	shell_check_oom(zQuery);
22145	rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
22146	if( rc ){
22147	utf8_printf(stderr, "Error: (%d) %s on [%s]\n",
22148	sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
22149	zQuery);
22150	goto end_schema_xfer;
22151	}
22152	while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
22153	zName = sqlite3_column_text(pQuery, 0);
22154	zSql = sqlite3_column_text(pQuery, 1);
22155	if( zName==0 \|\| zSql==0 ) continue;
22156	if( sqlite3_stricmp((char*)zName, "sqlite_sequence")!=0 ){
22157	printf("%s... ", zName); fflush(stdout);
22158	sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
22159	if( zErrMsg ){
22160	utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
22161	sqlite3_free(zErrMsg);
22162	zErrMsg = 0;
22163	}
22164	}
22165	if( xForEach ){
22166	xForEach(p, newDb, (const char*)zName);
22167	}
22168	printf("done\n");
22169	}
22170	if( rc!=SQLITE_DONE ){
22171	sqlite3_finalize(pQuery);
22172	sqlite3_free(zQuery);
22173	zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_schema"
22174	" WHERE %s ORDER BY rowid DESC", zWhere);
22175	shell_check_oom(zQuery);
22176	rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
22177	if( rc ){
22178	utf8_printf(stderr, "Error: (%d) %s on [%s]\n",
22179	sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
22180	zQuery);
22181	goto end_schema_xfer;
22182	}
22183	while( sqlite3_step(pQuery)==SQLITE_ROW ){
22184	zName = sqlite3_column_text(pQuery, 0);
22185	zSql = sqlite3_column_text(pQuery, 1);
22186	if( zName==0 \|\| zSql==0 ) continue;
22187	if( sqlite3_stricmp((char*)zName, "sqlite_sequence")==0 ) continue;
22188	printf("%s... ", zName); fflush(stdout);
22189	sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
22190	if( zErrMsg ){
22191	utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
22192	sqlite3_free(zErrMsg);
22193	zErrMsg = 0;
22194	}
22195	if( xForEach ){
22196	xForEach(p, newDb, (const char*)zName);
22197	}
22198	printf("done\n");
22199	}
22200	}
22201	end_schema_xfer:
22202	sqlite3_finalize(pQuery);
22203	sqlite3_free(zQuery);
	@@ -22210,17 +22953,16 @@
22210	*/
22211	static void tryToClone(ShellState p, const char zNewDb){
22212	int rc;
22213	sqlite3 *newDb = 0;
22214	if( access(zNewDb,0)==0 ){
22215	utf8_printf(stderr, "File \"%s\" already exists.\n", zNewDb);
22216	return;
22217	}
22218	rc = sqlite3_open(zNewDb, &newDb);
22219	if( rc ){
22220	utf8_printf(stderr, "Cannot create output database: %s\n",
22221	sqlite3_errmsg(newDb));
22222	}else{
22223	sqlite3_exec(p->db, "PRAGMA writable_schema=ON;", 0, 0, 0);
22224	sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0);
22225	tryToCloneSchema(p, newDb, "type='table'", tryToCloneData);
22226	tryToCloneSchema(p, newDb, "type!='table'", 0);
	@@ -22227,10 +22969,22 @@
22227	sqlite3_exec(newDb, "COMMIT;", 0, 0, 0);
22228	sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
22229	}
22230	close_db(newDb);
22231	}












22232
22233	/*
22234	** Change the output file back to stdout.
22235	**
22236	** If the p->doXdgOpen flag is set, that means the output was being
	@@ -22255,11 +23009,11 @@
22255	"xdg-open";
22256	#endif
22257	char *zCmd;
22258	zCmd = sqlite3_mprintf("%s %s", zXdgOpenCmd, p->zTempFile);
22259	if( system(zCmd) ){
22260	utf8_printf(stderr, "Failed: [%s]\n", zCmd);
22261	}else{
22262	/* Give the start/open/xdg-open command some time to get
22263	** going before we continue, and potential delete the
22264	** p->zTempFile data file out from under it */
22265	sqlite3_sleep(2000);
	@@ -22270,11 +23024,16 @@
22270	}
22271	#endif /* !defined(SQLITE_NOHAVE_SYSTEM) */
22272	}
22273	p->outfile[0] = 0;
22274	p->out = stdout;

22275	}




22276
22277	/*
22278	** Run an SQL command and return the single integer result.
22279	*/
22280	static int db_int(sqlite3 db, const char zSql){
	@@ -22341,11 +23100,11 @@
22341	if( p->db==0 ) return 1;
22342	rc = sqlite3_prepare_v2(p->db,
22343	"SELECT data FROM sqlite_dbpage(?1) WHERE pgno=1",
22344	-1, &pStmt, 0);
22345	if( rc ){
22346	utf8_printf(stderr, "error: %s\n", sqlite3_errmsg(p->db));
22347	sqlite3_finalize(pStmt);
22348	return 1;
22349	}
22350	sqlite3_bind_text(pStmt, 1, zDb, -1, SQLITE_STATIC);
22351	if( sqlite3_step(pStmt)==SQLITE_ROW
	@@ -22354,32 +23113,32 @@
22354	const u8 *pb = sqlite3_column_blob(pStmt,0);
22355	shell_check_oom(pb);
22356	memcpy(aHdr, pb, 100);
22357	sqlite3_finalize(pStmt);
22358	}else{
22359	raw_printf(stderr, "unable to read database header\n");
22360	sqlite3_finalize(pStmt);
22361	return 1;
22362	}
22363	i = get2byteInt(aHdr+16);
22364	if( i==1 ) i = 65536;
22365	utf8_printf(p->out, "%-20s %d\n", "database page size:", i);
22366	utf8_printf(p->out, "%-20s %d\n", "write format:", aHdr[18]);
22367	utf8_printf(p->out, "%-20s %d\n", "read format:", aHdr[19]);
22368	utf8_printf(p->out, "%-20s %d\n", "reserved bytes:", aHdr[20]);
22369	for(i=0; i<ArraySize(aField); i++){
22370	int ofst = aField[i].ofst;
22371	unsigned int val = get4byteInt(aHdr + ofst);
22372	utf8_printf(p->out, "%-20s %u", aField[i].zName, val);
22373	switch( ofst ){
22374	case 56: {
22375	if( val==1 ) raw_printf(p->out, " (utf8)");
22376	if( val==2 ) raw_printf(p->out, " (utf16le)");
22377	if( val==3 ) raw_printf(p->out, " (utf16be)");
22378	}
22379	}
22380	raw_printf(p->out, "\n");
22381	}
22382	if( zDb==0 ){
22383	zSchemaTab = sqlite3_mprintf("main.sqlite_schema");
22384	}else if( cli_strcmp(zDb,"temp")==0 ){
22385	zSchemaTab = sqlite3_mprintf("%s", "sqlite_temp_schema");
	@@ -22388,25 +23147,25 @@
22388	}
22389	for(i=0; i<ArraySize(aQuery); i++){
22390	char *zSql = sqlite3_mprintf(aQuery[i].zSql, zSchemaTab);
22391	int val = db_int(p->db, zSql);
22392	sqlite3_free(zSql);
22393	utf8_printf(p->out, "%-20s %d\n", aQuery[i].zName, val);
22394	}
22395	sqlite3_free(zSchemaTab);
22396	sqlite3_file_control(p->db, zDb, SQLITE_FCNTL_DATA_VERSION, &iDataVersion);
22397	utf8_printf(p->out, "%-20s %u\n", "data version", iDataVersion);
22398	return 0;
22399	}
22400	#endif /* SQLITE_SHELL_HAVE_RECOVER */
22401
22402	/*
22403	** Print the current sqlite3_errmsg() value to stderr and return 1.
22404	*/
22405	static int shellDatabaseError(sqlite3 *db){
22406	const char *zErr = sqlite3_errmsg(db);
22407	utf8_printf(stderr, "Error: %s\n", zErr);
22408	return 1;
22409	}
22410
22411	/*
22412	** Compare the pattern in zGlob[] against the text in z[]. Return TRUE
	@@ -22637,11 +23396,10 @@
22637	ShellState pState, / Current shell tool state */
22638	char *azArg, / Array of arguments passed to dot command */
22639	int nArg /* Number of entries in azArg[] */
22640	){
22641	sqlite3 db = pState->db; / Database handle to query "main" db of */
22642	FILE out = pState->out; / Stream to write non-error output to */
22643	int bVerbose = 0; /* If -verbose is present */
22644	int bGroupByParent = 0; /* If -groupbyparent is present */
22645	int i; /* To iterate through azArg[] */
22646	const char zIndent = ""; / How much to indent CREATE INDEX by */
22647	int rc; /* Return code */
	@@ -22719,13 +23477,11 @@
22719	else if( n>1 && sqlite3_strnicmp("-groupbyparent", azArg[i], n)==0 ){
22720	bGroupByParent = 1;
22721	zIndent = " ";
22722	}
22723	else{
22724	raw_printf(stderr, "Usage: %s %s ?-verbose? ?-groupbyparent?\n",
22725	azArg[0], azArg[1]
22726	);
22727	return SQLITE_ERROR;
22728	}
22729	}
22730
22731	/* Register the fkey_collate_clause() SQL function */
	@@ -22765,44 +23521,44 @@
22765	}
22766	rc = sqlite3_finalize(pExplain);
22767	if( rc!=SQLITE_OK ) break;
22768
22769	if( res<0 ){
22770	raw_printf(stderr, "Error: internal error");
22771	break;
22772	}else{
22773	if( bGroupByParent
22774	&& (bVerbose \|\| res==0)
22775	&& (zPrev==0 \|\| sqlite3_stricmp(zParent, zPrev))
22776	){
22777	raw_printf(out, "-- Parent table %s\n", zParent);
22778	sqlite3_free(zPrev);
22779	zPrev = sqlite3_mprintf("%s", zParent);
22780	}
22781
22782	if( res==0 ){
22783	raw_printf(out, "%s%s --> %s\n", zIndent, zCI, zTarget);
22784	}else if( bVerbose ){
22785	raw_printf(out, "%s/* no extra indexes required for %s -> %s */\n",
22786	zIndent, zFrom, zTarget
22787	);
22788	}
22789	}
22790	}
22791	sqlite3_free(zPrev);
22792
22793	if( rc!=SQLITE_OK ){
22794	raw_printf(stderr, "%s\n", sqlite3_errmsg(db));
22795	}
22796
22797	rc2 = sqlite3_finalize(pSql);
22798	if( rc==SQLITE_OK && rc2!=SQLITE_OK ){
22799	rc = rc2;
22800	raw_printf(stderr, "%s\n", sqlite3_errmsg(db));
22801	}
22802	}else{
22803	raw_printf(stderr, "%s\n", sqlite3_errmsg(db));
22804	}
22805
22806	return rc;
22807	}
22808
	@@ -22818,13 +23574,13 @@
22818	n = (nArg>=2 ? strlen30(azArg[1]) : 0);
22819	if( n<1 \|\| sqlite3_strnicmp(azArg[1], "fkey-indexes", n) ) goto usage;
22820	return lintFkeyIndexes(pState, azArg, nArg);
22821
22822	usage:
22823	raw_printf(stderr, "Usage %s sub-command ?switches...?\n", azArg[0]);
22824	raw_printf(stderr, "Where sub-commands are:\n");
22825	raw_printf(stderr, " fkey-indexes\n");
22826	return SQLITE_ERROR;
22827	}
22828
22829	#if !defined SQLITE_OMIT_VIRTUALTABLE
22830	static void shellPrepare(
	@@ -22835,13 +23591,11 @@
22835	){
22836	*ppStmt = 0;
22837	if( *pRc==SQLITE_OK ){
22838	int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0);
22839	if( rc!=SQLITE_OK ){
22840	raw_printf(stderr, "sql error: %s (%d)\n",
22841	sqlite3_errmsg(db), sqlite3_errcode(db)
22842	);
22843	*pRc = rc;
22844	}
22845	}
22846	}
22847
	@@ -22888,11 +23642,11 @@
22888	if( pStmt ){
22889	sqlite3 *db = sqlite3_db_handle(pStmt);
22890	int rc = sqlite3_finalize(pStmt);
22891	if( *pRc==SQLITE_OK ){
22892	if( rc!=SQLITE_OK ){
22893	raw_printf(stderr, "SQL error: %s\n", sqlite3_errmsg(db));
22894	}
22895	*pRc = rc;
22896	}
22897	}
22898	}
	@@ -22909,11 +23663,11 @@
22909	){
22910	int rc = sqlite3_reset(pStmt);
22911	if( *pRc==SQLITE_OK ){
22912	if( rc!=SQLITE_OK ){
22913	sqlite3 *db = sqlite3_db_handle(pStmt);
22914	raw_printf(stderr, "SQL error: %s\n", sqlite3_errmsg(db));
22915	}
22916	*pRc = rc;
22917	}
22918	}
22919	#endif /* !defined SQLITE_OMIT_VIRTUALTABLE */
	@@ -22959,15 +23713,15 @@
22959	va_list ap;
22960	char *z;
22961	va_start(ap, zFmt);
22962	z = sqlite3_vmprintf(zFmt, ap);
22963	va_end(ap);
22964	utf8_printf(stderr, "Error: %s\n", z);
22965	if( pAr->fromCmdLine ){
22966	utf8_printf(stderr, "Use \"-A\" for more help\n");
22967	}else{
22968	utf8_printf(stderr, "Use \".archive --help\" for more help\n");
22969	}
22970	sqlite3_free(z);
22971	return SQLITE_ERROR;
22972	}
22973
	@@ -23063,11 +23817,11 @@
23063	};
23064	int nSwitch = sizeof(aSwitch) / sizeof(struct ArSwitch);
23065	struct ArSwitch *pEnd = &aSwitch[nSwitch];
23066
23067	if( nArg<=1 ){
23068	utf8_printf(stderr, "Wrong number of arguments. Usage:\n");
23069	return arUsage(stderr);
23070	}else{
23071	char *z = azArg[1];
23072	if( z[0]!='-' ){
23073	/* Traditional style [tar] invocation */
	@@ -23169,11 +23923,11 @@
23169	}
23170	}
23171	}
23172	}
23173	if( pAr->eCmd==0 ){
23174	utf8_printf(stderr, "Required argument missing. Usage:\n");
23175	return arUsage(stderr);
23176	}
23177	return SQLITE_OK;
23178	}
23179
	@@ -23212,11 +23966,11 @@
23212	if( SQLITE_ROW==sqlite3_step(pTest) ){
23213	bOk = 1;
23214	}
23215	shellReset(&rc, pTest);
23216	if( rc==SQLITE_OK && bOk==0 ){
23217	utf8_printf(stderr, "not found in archive: %s\n", z);
23218	rc = SQLITE_ERROR;
23219	}
23220	}
23221	shellFinalize(&rc, pTest);
23222	}
	@@ -23279,30 +24033,26 @@
23279	arWhereClause(&rc, pAr, &zWhere);
23280
23281	shellPreparePrintf(pAr->db, &rc, &pSql, zSql, azCols[pAr->bVerbose],
23282	pAr->zSrcTable, zWhere);
23283	if( pAr->bDryRun ){
23284	utf8_printf(pAr->p->out, "%s\n", sqlite3_sql(pSql));
23285	}else{
23286	while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){
23287	if( pAr->bVerbose ){
23288	utf8_printf(pAr->p->out, "%s % 10d %s %s\n",
23289	sqlite3_column_text(pSql, 0),
23290	sqlite3_column_int(pSql, 1),
23291	sqlite3_column_text(pSql, 2),
23292	sqlite3_column_text(pSql, 3)
23293	);
23294	}else{
23295	utf8_printf(pAr->p->out, "%s\n", sqlite3_column_text(pSql, 0));
23296	}
23297	}
23298	}
23299	shellFinalize(&rc, pSql);
23300	sqlite3_free(zWhere);
23301	return rc;
23302	}
23303
23304
23305	/*
23306	** Implementation of .ar "Remove" command.
23307	*/
23308	static int arRemoveCommand(ArCommand *pAr){
	@@ -23318,11 +24068,11 @@
23318	}
23319	if( rc==SQLITE_OK ){
23320	zSql = sqlite3_mprintf("DELETE FROM %s WHERE %s;",
23321	pAr->zSrcTable, zWhere);
23322	if( pAr->bDryRun ){
23323	utf8_printf(pAr->p->out, "%s\n", zSql);
23324	}else{
23325	char *zErr = 0;
23326	rc = sqlite3_exec(pAr->db, "SAVEPOINT ar;", 0, 0, 0);
23327	if( rc==SQLITE_OK ){
23328	rc = sqlite3_exec(pAr->db, zSql, 0, 0, &zErr);
	@@ -23331,11 +24081,11 @@
23331	}else{
23332	rc = sqlite3_exec(pAr->db, "RELEASE ar;", 0, 0, 0);
23333	}
23334	}
23335	if( zErr ){
23336	utf8_printf(stdout, "ERROR: %s\n", zErr);
23337	sqlite3_free(zErr);
23338	}
23339	}
23340	}
23341	sqlite3_free(zWhere);
	@@ -23395,15 +24145,15 @@
23395	** populating them changes the timestamp). */
23396	for(i=0; i<2; i++){
23397	j = sqlite3_bind_parameter_index(pSql, "$dirOnly");
23398	sqlite3_bind_int(pSql, j, i);
23399	if( pAr->bDryRun ){
23400	utf8_printf(pAr->p->out, "%s\n", sqlite3_sql(pSql));
23401	}else{
23402	while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){
23403	if( i==0 && pAr->bVerbose ){
23404	utf8_printf(pAr->p->out, "%s\n", sqlite3_column_text(pSql, 0));
23405	}
23406	}
23407	}
23408	shellReset(&rc, pSql);
23409	}
	@@ -23419,17 +24169,17 @@
23419	** Run the SQL statement in zSql. Or if doing a --dryrun, merely print it out.
23420	*/
23421	static int arExecSql(ArCommand pAr, const char zSql){
23422	int rc;
23423	if( pAr->bDryRun ){
23424	utf8_printf(pAr->p->out, "%s\n", zSql);
23425	rc = SQLITE_OK;
23426	}else{
23427	char *zErr = 0;
23428	rc = sqlite3_exec(pAr->db, zSql, 0, 0, &zErr);
23429	if( zErr ){
23430	utf8_printf(stdout, "ERROR: %s\n", zErr);
23431	sqlite3_free(zErr);
23432	}
23433	}
23434	return rc;
23435	}
	@@ -23600,19 +24350,17 @@
23600	}else{
23601	flags = SQLITE_OPEN_READONLY;
23602	}
23603	cmd.db = 0;
23604	if( cmd.bDryRun ){
23605	utf8_printf(pState->out, "-- open database '%s'%s\n", cmd.zFile,
23606	eDbType==SHELL_OPEN_APPENDVFS ? " using 'apndvfs'" : "");
23607	}
23608	rc = sqlite3_open_v2(cmd.zFile, &cmd.db, flags,
23609	eDbType==SHELL_OPEN_APPENDVFS ? "apndvfs" : 0);
23610	if( rc!=SQLITE_OK ){
23611	utf8_printf(stderr, "cannot open file: %s (%s)\n",
23612	cmd.zFile, sqlite3_errmsg(cmd.db)
23613	);
23614	goto end_ar_command;
23615	}
23616	sqlite3_fileio_init(cmd.db, 0, 0);
23617	sqlite3_sqlar_init(cmd.db, 0, 0);
23618	sqlite3_create_function(cmd.db, "shell_putsnl", 1, SQLITE_UTF8, cmd.p,
	@@ -23621,11 +24369,11 @@
23621	}
23622	if( cmd.zSrcTable==0 && cmd.bZip==0 && cmd.eCmd!=AR_CMD_HELP ){
23623	if( cmd.eCmd!=AR_CMD_CREATE
23624	&& sqlite3_table_column_metadata(cmd.db,0,"sqlar","name",0,0,0,0,0)
23625	){
23626	utf8_printf(stderr, "database does not contain an 'sqlar' table\n");
23627	rc = SQLITE_ERROR;
23628	goto end_ar_command;
23629	}
23630	cmd.zSrcTable = sqlite3_mprintf("sqlar");
23631	}
	@@ -23679,11 +24427,11 @@
23679	** This function is used as a callback by the recover extension. Simply
23680	** print the supplied SQL statement to stdout.
23681	*/
23682	static int recoverSqlCb(void pCtx, const char zSql){
23683	ShellState pState = (ShellState)pCtx;
23684	utf8_printf(pState->out, "%s;\n", zSql);
23685	return SQLITE_OK;
23686	}
23687
23688	/*
23689	** This function is called to recover data from the database. A script
	@@ -23722,11 +24470,11 @@
23722	}else
23723	if( n<=10 && memcmp("-no-rowids", z, n)==0 ){
23724	bRowids = 0;
23725	}
23726	else{
23727	utf8_printf(stderr, "unexpected option: %s\n", azArg[i]);
23728	showHelp(pState->out, azArg[0]);
23729	return 1;
23730	}
23731	}
23732
	@@ -23741,11 +24489,11 @@
23741
23742	sqlite3_recover_run(p);
23743	if( sqlite3_recover_errcode(p)!=SQLITE_OK ){
23744	const char *zErr = sqlite3_recover_errmsg(p);
23745	int errCode = sqlite3_recover_errcode(p);
23746	raw_printf(stderr, "sql error: %s (%d)\n", zErr, errCode);
23747	}
23748	rc = sqlite3_recover_finish(p);
23749	return rc;
23750	}
23751	#endif /* SQLITE_SHELL_HAVE_RECOVER */
	@@ -23766,11 +24514,11 @@
23766	*/
23767	#ifdef SHELL_DEBUG
23768	#define rc_err_oom_die(rc) \
23769	if( rc==SQLITE_NOMEM ) shell_check_oom(0); \
23770	else if(!(rc==SQLITE_OK\|\|rc==SQLITE_DONE)) \
23771	fprintf(stderr,"E:%d\n",rc), assert(0)
23772	#else
23773	static void rc_err_oom_die(int rc){
23774	if( rc==SQLITE_NOMEM ) shell_check_oom(0);
23775	assert(rc==SQLITE_OK\|\|rc==SQLITE_DONE);
23776	}
	@@ -23906,10 +24654,11 @@
23906	#ifdef SHELL_COLFIX_DB
23907	if(*zCOL_DB!=':')
23908	sqlite3_exec(*pDb,"drop table if exists ColNames;"
23909	"drop view if exists RepeatedNames;",0,0,0);
23910	#endif

23911	rc = sqlite3_exec(*pDb, zTabMake, 0, 0, 0);
23912	rc_err_oom_die(rc);
23913	}
23914	assert(*pDb!=0);
23915	rc = sqlite3_prepare_v2(*pDb, zTabFill, -1, &pStmt, 0);
	@@ -24019,11 +24768,11 @@
24019	clearTempFile(p);
24020
24021	#ifndef SQLITE_OMIT_AUTHORIZATION
24022	if( c=='a' && cli_strncmp(azArg[0], "auth", n)==0 ){
24023	if( nArg!=2 ){
24024	raw_printf(stderr, "Usage: .auth ON\|OFF\n");
24025	rc = 1;
24026	goto meta_command_exit;
24027	}
24028	open_db(p, 0);
24029	if( booleanValue(azArg[1]) ){
	@@ -24066,32 +24815,32 @@
24066	}else
24067	if( cli_strcmp(z, "-async")==0 ){
24068	bAsync = 1;
24069	}else
24070	{
24071	utf8_printf(stderr, "unknown option: %s\n", azArg[j]);
24072	return 1;
24073	}
24074	}else if( zDestFile==0 ){
24075	zDestFile = azArg[j];
24076	}else if( zDb==0 ){
24077	zDb = zDestFile;
24078	zDestFile = azArg[j];
24079	}else{
24080	raw_printf(stderr, "Usage: .backup ?DB? ?OPTIONS? FILENAME\n");
24081	return 1;
24082	}
24083	}
24084	if( zDestFile==0 ){
24085	raw_printf(stderr, "missing FILENAME argument on .backup\n");
24086	return 1;
24087	}
24088	if( zDb==0 ) zDb = "main";
24089	rc = sqlite3_open_v2(zDestFile, &pDest,
24090	SQLITE_OPEN_READWRITE\|SQLITE_OPEN_CREATE, zVfs);
24091	if( rc!=SQLITE_OK ){
24092	utf8_printf(stderr, "Error: cannot open \"%s\"\n", zDestFile);
24093	close_db(pDest);
24094	return 1;
24095	}
24096	if( bAsync ){
24097	sqlite3_exec(pDest, "PRAGMA synchronous=OFF; PRAGMA journal_mode=OFF;",
	@@ -24098,20 +24847,20 @@
24098	0, 0, 0);
24099	}
24100	open_db(p, 0);
24101	pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
24102	if( pBackup==0 ){
24103	utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
24104	close_db(pDest);
24105	return 1;
24106	}
24107	while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
24108	sqlite3_backup_finish(pBackup);
24109	if( rc==SQLITE_DONE ){
24110	rc = 0;
24111	}else{
24112	utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
24113	rc = 1;
24114	}
24115	close_db(pDest);
24116	}else
24117	#endif /* !defined(SQLITE_SHELL_FIDDLE) */
	@@ -24118,11 +24867,11 @@
24118
24119	if( c=='b' && n>=3 && cli_strncmp(azArg[0], "bail", n)==0 ){
24120	if( nArg==2 ){
24121	bail_on_error = booleanValue(azArg[1]);
24122	}else{
24123	raw_printf(stderr, "Usage: .bail on\|off\n");
24124	rc = 1;
24125	}
24126	}else
24127
24128	/* Undocumented. Legacy only. See "crnl" below */
	@@ -24132,13 +24881,12 @@
24132	setBinaryMode(p->out, 1);
24133	}else{
24134	setTextMode(p->out, 1);
24135	}
24136	}else{
24137	raw_printf(stderr, "The \".binary\" command is deprecated."
24138	" Use \".crnl\" instead.\n");
24139	raw_printf(stderr, "Usage: .binary on\|off\n");
24140	rc = 1;
24141	}
24142	}else
24143
24144	/* The undocumented ".breakpoint" command causes a call to the no-op
	@@ -24158,25 +24906,25 @@
24158	sqlite3_free(z);
24159	#else
24160	rc = chdir(azArg[1]);
24161	#endif
24162	if( rc ){
24163	utf8_printf(stderr, "Cannot change to directory \"%s\"\n", azArg[1]);
24164	rc = 1;
24165	}
24166	}else{
24167	raw_printf(stderr, "Usage: .cd DIRECTORY\n");
24168	rc = 1;
24169	}
24170	}else
24171	#endif /* !defined(SQLITE_SHELL_FIDDLE) */
24172
24173	if( c=='c' && n>=3 && cli_strncmp(azArg[0], "changes", n)==0 ){
24174	if( nArg==2 ){
24175	setOrClearFlag(p, SHFLG_CountChanges, azArg[1]);
24176	}else{
24177	raw_printf(stderr, "Usage: .changes on\|off\n");
24178	rc = 1;
24179	}
24180	}else
24181
24182	#ifndef SQLITE_SHELL_FIDDLE
	@@ -24186,21 +24934,20 @@
24186	*/
24187	if( c=='c' && n>=3 && cli_strncmp(azArg[0], "check", n)==0 ){
24188	char *zRes = 0;
24189	output_reset(p);
24190	if( nArg!=2 ){
24191	raw_printf(stderr, "Usage: .check GLOB-PATTERN\n");
24192	rc = 2;
24193	}else if( (zRes = readFile("testcase-out.txt", 0))==0 ){
24194	rc = 2;
24195	}else if( testcase_glob(azArg[1],zRes)==0 ){
24196	utf8_printf(stderr,
24197	"testcase-%s FAILED\n Expected: [%s]\n Got: [%s]\n",
24198	p->zTestcase, azArg[1], zRes);
24199	rc = 1;
24200	}else{
24201	utf8_printf(stdout, "testcase-%s ok\n", p->zTestcase);
24202	p->nCheck++;
24203	}
24204	sqlite3_free(zRes);
24205	}else
24206	#endif /* !defined(SQLITE_SHELL_FIDDLE) */
	@@ -24209,11 +24956,11 @@
24209	if( c=='c' && cli_strncmp(azArg[0], "clone", n)==0 ){
24210	failIfSafeMode(p, "cannot run .clone in safe mode");
24211	if( nArg==2 ){
24212	tryToClone(p, azArg[1]);
24213	}else{
24214	raw_printf(stderr, "Usage: .clone FILENAME\n");
24215	rc = 1;
24216	}
24217	}else
24218	#endif /* !defined(SQLITE_SHELL_FIDDLE) */
24219
	@@ -24229,13 +24976,13 @@
24229	zFile = "(memory)";
24230	}else if( zFile[0]==0 ){
24231	zFile = "(temporary-file)";
24232	}
24233	if( p->pAuxDb == &p->aAuxDb[i] ){
24234	utf8_printf(stdout, "ACTIVE %d: %s\n", i, zFile);
24235	}else if( p->aAuxDb[i].db!=0 ){
24236	utf8_printf(stdout, " %d: %s\n", i, zFile);
24237	}
24238	}
24239	}else if( nArg==2 && IsDigit(azArg[1][0]) && azArg[1][1]==0 ){
24240	int i = azArg[1][0] - '0';
24241	if( p->pAuxDb != &p->aAuxDb[i] && i>=0 && i<ArraySize(p->aAuxDb) ){
	@@ -24248,19 +24995,19 @@
24248	&& IsDigit(azArg[2][0]) && azArg[2][1]==0 ){
24249	int i = azArg[2][0] - '0';
24250	if( i<0 \|\| i>=ArraySize(p->aAuxDb) ){
24251	/* No-op */
24252	}else if( p->pAuxDb == &p->aAuxDb[i] ){
24253	raw_printf(stderr, "cannot close the active database connection\n");
24254	rc = 1;
24255	}else if( p->aAuxDb[i].db ){
24256	session_close_all(p, i);
24257	close_db(p->aAuxDb[i].db);
24258	p->aAuxDb[i].db = 0;
24259	}
24260	}else{
24261	raw_printf(stderr, "Usage: .connection [close] [CONNECTION-NUMBER]\n");
24262	rc = 1;
24263	}
24264	}else
24265
24266	if( c=='c' && n==4 && cli_strncmp(azArg[0], "crnl", n)==0 ){
	@@ -24270,13 +25017,13 @@
24270	}else{
24271	setBinaryMode(p->out, 1);
24272	}
24273	}else{
24274	#if !defined(_WIN32) && !defined(WIN32)
24275	raw_printf(stderr, "The \".crnl\" is a no-op on non-Windows machines.\n");
24276	#endif
24277	raw_printf(stderr, "Usage: .crnl on\|off\n");
24278	rc = 1;
24279	}
24280	}else
24281
24282	if( c=='d' && n>1 && cli_strncmp(azArg[0], "databases", n)==0 ){
	@@ -24285,11 +25032,11 @@
24285	sqlite3_stmt *pStmt;
24286	int i;
24287	open_db(p, 0);
24288	rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
24289	if( rc ){
24290	utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
24291	rc = 1;
24292	}else{
24293	while( sqlite3_step(pStmt)==SQLITE_ROW ){
24294	const char zSchema = (const char )sqlite3_column_text(pStmt,1);
24295	const char zFile = (const char)sqlite3_column_text(pStmt,2);
	@@ -24304,15 +25051,13 @@
24304	sqlite3_finalize(pStmt);
24305	for(i=0; i<nName; i++){
24306	int eTxn = sqlite3_txn_state(p->db, azName[i*2]);
24307	int bRdonly = sqlite3_db_readonly(p->db, azName[i*2]);
24308	const char z = azName[i2+1];
24309	utf8_printf(p->out, "%s: %s %s%s\n",
24310	azName[i*2],
24311	z && z[0] ? z : "\"\"",
24312	bRdonly ? "r/o" : "r/w",
24313	eTxn==SQLITE_TXN_NONE ? "" :
24314	eTxn==SQLITE_TXN_READ ? " read-txn" : " write-txn");
24315	free(azName[i*2]);
24316	free(azName[i*2+1]);
24317	}
24318	sqlite3_free(azName);
	@@ -24348,16 +25093,16 @@
24348	if( nArg>1 && cli_strcmp(azArg[1], aDbConfig[ii].zName)!=0 ) continue;
24349	if( nArg>=3 ){
24350	sqlite3_db_config(p->db, aDbConfig[ii].op, booleanValue(azArg[2]), 0);
24351	}
24352	sqlite3_db_config(p->db, aDbConfig[ii].op, -1, &v);
24353	utf8_printf(p->out, "%19s %s\n", aDbConfig[ii].zName, v ? "on" : "off");
24354	if( nArg>1 ) break;
24355	}
24356	if( nArg>1 && ii==ArraySize(aDbConfig) ){
24357	utf8_printf(stderr, "Error: unknown dbconfig \"%s\"\n", azArg[1]);
24358	utf8_printf(stderr, "Enter \".dbconfig\" with no arguments for a list\n");
24359	}
24360	}else
24361
24362	#if SQLITE_SHELL_HAVE_RECOVER
24363	if( c=='d' && n>=3 && cli_strncmp(azArg[0], "dbinfo", n)==0 ){
	@@ -24383,12 +25128,12 @@
24383	if( azArg[i][0]=='-' ){
24384	const char *z = azArg[i]+1;
24385	if( z[0]=='-' ) z++;
24386	if( cli_strcmp(z,"preserve-rowids")==0 ){
24387	#ifdef SQLITE_OMIT_VIRTUALTABLE
24388	raw_printf(stderr, "The --preserve-rowids option is not compatible"
24389	" with SQLITE_OMIT_VIRTUALTABLE\n");
24390	rc = 1;
24391	sqlite3_free(zLike);
24392	goto meta_command_exit;
24393	#else
24394	ShellSetFlag(p, SHFLG_PreserveRowid);
	@@ -24402,11 +25147,11 @@
24402	}else
24403	if( cli_strcmp(z,"nosys")==0 ){
24404	ShellSetFlag(p, SHFLG_DumpNoSys);
24405	}else
24406	{
24407	raw_printf(stderr, "Unknown option \"%s\" on \".dump\"\n", azArg[i]);
24408	rc = 1;
24409	sqlite3_free(zLike);
24410	goto meta_command_exit;
24411	}
24412	}else{
	@@ -24436,12 +25181,12 @@
24436
24437	if( (p->shellFlgs & SHFLG_DumpDataOnly)==0 ){
24438	/* When playing back a "dump", the content might appear in an order
24439	** which causes immediate foreign key constraints to be violated.
24440	** So disable foreign-key constraint enforcement to prevent problems. */
24441	raw_printf(p->out, "PRAGMA foreign_keys=OFF;\n");
24442	raw_printf(p->out, "BEGIN TRANSACTION;\n");
24443	}
24444	p->writableSchema = 0;
24445	p->showHeader = 0;
24446	/* Set writable_schema=ON since doing so forces SQLite to initialize
24447	** as much of the schema as it can even if the sqlite_schema table is
	@@ -24468,27 +25213,27 @@
24468	run_table_dump_query(p, zSql);
24469	sqlite3_free(zSql);
24470	}
24471	sqlite3_free(zLike);
24472	if( p->writableSchema ){
24473	raw_printf(p->out, "PRAGMA writable_schema=OFF;\n");
24474	p->writableSchema = 0;
24475	}
24476	sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
24477	sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0);
24478	if( (p->shellFlgs & SHFLG_DumpDataOnly)==0 ){
24479	raw_printf(p->out, p->nErr?"ROLLBACK; -- due to errors\n":"COMMIT;\n");
24480	}
24481	p->showHeader = savedShowHeader;
24482	p->shellFlgs = savedShellFlags;
24483	}else
24484
24485	if( c=='e' && cli_strncmp(azArg[0], "echo", n)==0 ){
24486	if( nArg==2 ){
24487	setOrClearFlag(p, SHFLG_Echo, azArg[1]);
24488	}else{
24489	raw_printf(stderr, "Usage: .echo on\|off\n");
24490	rc = 1;
24491	}
24492	}else
24493
24494	if( c=='e' && cli_strncmp(azArg[0], "eqp", n)==0 ){
	@@ -24515,11 +25260,11 @@
24515	#endif
24516	}else{
24517	p->autoEQP = (u8)booleanValue(azArg[1]);
24518	}
24519	}else{
24520	raw_printf(stderr, "Usage: .eqp off\|on\|trace\|trigger\|full\n");
24521	rc = 1;
24522	}
24523	}else
24524
24525	#ifndef SQLITE_SHELL_FIDDLE
	@@ -24554,13 +25299,12 @@
24554	}else
24555
24556	#ifndef SQLITE_OMIT_VIRTUALTABLE
24557	if( c=='e' && cli_strncmp(azArg[0], "expert", n)==0 ){
24558	if( p->bSafeMode ){
24559	raw_printf(stderr,
24560	"Cannot run experimental commands such as \"%s\" in safe mode\n",
24561	azArg[0]);
24562	rc = 1;
24563	}else{
24564	open_db(p, 0);
24565	expertDotCommand(p, azArg, nArg);
24566	}
	@@ -24612,14 +25356,13 @@
24612	if( zCmd[0]=='-' && zCmd[1] ) zCmd++;
24613	}
24614
24615	/* --help lists all file-controls */
24616	if( cli_strcmp(zCmd,"help")==0 ){
24617	utf8_printf(p->out, "Available file-controls:\n");
24618	for(i=0; i<ArraySize(aCtrl); i++){
24619	utf8_printf(p->out, " .filectrl %s %s\n",
24620	aCtrl[i].zCtrlName, aCtrl[i].zUsage);
24621	}
24622	rc = 1;
24623	goto meta_command_exit;
24624	}
24625
	@@ -24630,20 +25373,20 @@
24630	if( cli_strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){
24631	if( filectrl<0 ){
24632	filectrl = aCtrl[i].ctrlCode;
24633	iCtrl = i;
24634	}else{
24635	utf8_printf(stderr, "Error: ambiguous file-control: \"%s\"\n"
24636	"Use \".filectrl --help\" for help\n", zCmd);
24637	rc = 1;
24638	goto meta_command_exit;
24639	}
24640	}
24641	}
24642	if( filectrl<0 ){
24643	utf8_printf(stderr,"Error: unknown file-control: %s\n"
24644	"Use \".filectrl --help\" for help\n", zCmd);
24645	}else{
24646	switch(filectrl){
24647	case SQLITE_FCNTL_SIZE_LIMIT: {
24648	if( nArg!=2 && nArg!=3 ) break;
24649	iRes = nArg==3 ? integerValue(azArg[2]) : -1;
	@@ -24682,11 +25425,11 @@
24682	case SQLITE_FCNTL_TEMPFILENAME: {
24683	char *z = 0;
24684	if( nArg!=2 ) break;
24685	sqlite3_file_control(p->db, zSchema, filectrl, &z);
24686	if( z ){
24687	utf8_printf(p->out, "%s\n", z);
24688	sqlite3_free(z);
24689	}
24690	isOk = 2;
24691	break;
24692	}
	@@ -24696,23 +25439,23 @@
24696	x = atoi(azArg[2]);
24697	sqlite3_file_control(p->db, zSchema, filectrl, &x);
24698	}
24699	x = -1;
24700	sqlite3_file_control(p->db, zSchema, filectrl, &x);
24701	utf8_printf(p->out,"%d\n", x);
24702	isOk = 2;
24703	break;
24704	}
24705	}
24706	}
24707	if( isOk==0 && iCtrl>=0 ){
24708	utf8_printf(p->out, "Usage: .filectrl %s %s\n", zCmd,aCtrl[iCtrl].zUsage);
24709	rc = 1;
24710	}else if( isOk==1 ){
24711	char zBuf[100];
24712	sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", iRes);
24713	raw_printf(p->out, "%s\n", zBuf);
24714	}
24715	}else
24716
24717	if( c=='f' && cli_strncmp(azArg[0], "fullschema", n)==0 ){
24718	ShellState data;
	@@ -24723,11 +25466,11 @@
24723	if( nArg==2 && optionMatch(azArg[1], "indent") ){
24724	data.cMode = data.mode = MODE_Pretty;
24725	nArg = 1;
24726	}
24727	if( nArg!=1 ){
24728	raw_printf(stderr, "Usage: .fullschema ?--indent?\n");
24729	rc = 1;
24730	goto meta_command_exit;
24731	}
24732	open_db(p, 0);
24733	rc = sqlite3_exec(p->db,
	@@ -24749,37 +25492,37 @@
24749	doStats = sqlite3_step(pStmt)==SQLITE_ROW;
24750	sqlite3_finalize(pStmt);
24751	}
24752	}
24753	if( doStats==0 ){
24754	raw_printf(p->out, "/* No STAT tables available */\n");
24755	}else{
24756	raw_printf(p->out, "ANALYZE sqlite_schema;\n");
24757	data.cMode = data.mode = MODE_Insert;
24758	data.zDestTable = "sqlite_stat1";
24759	shell_exec(&data, "SELECT * FROM sqlite_stat1", 0);
24760	data.zDestTable = "sqlite_stat4";
24761	shell_exec(&data, "SELECT * FROM sqlite_stat4", 0);
24762	raw_printf(p->out, "ANALYZE sqlite_schema;\n");
24763	}
24764	}else
24765
24766	if( c=='h' && cli_strncmp(azArg[0], "headers", n)==0 ){
24767	if( nArg==2 ){
24768	p->showHeader = booleanValue(azArg[1]);
24769	p->shellFlgs \|= SHFLG_HeaderSet;
24770	}else{
24771	raw_printf(stderr, "Usage: .headers on\|off\n");
24772	rc = 1;
24773	}
24774	}else
24775
24776	if( c=='h' && cli_strncmp(azArg[0], "help", n)==0 ){
24777	if( nArg>=2 ){
24778	n = showHelp(p->out, azArg[1]);
24779	if( n==0 ){
24780	utf8_printf(p->out, "Nothing matches '%s'\n", azArg[1]);
24781	}
24782	}else{
24783	showHelp(p->out, 0);
24784	}
24785	}else
	@@ -24819,11 +25562,11 @@
24819	if( zFile==0 ){
24820	zFile = z;
24821	}else if( zTable==0 ){
24822	zTable = z;
24823	}else{
24824	utf8_printf(p->out, "ERROR: extra argument: \"%s\". Usage:\n", z);
24825	showHelp(p->out, "import");
24826	goto meta_command_exit;
24827	}
24828	}else if( cli_strcmp(z,"-v")==0 ){
24829	eVerbose++;
	@@ -24840,18 +25583,18 @@
24840	sCtx.cColSep = ',';
24841	sCtx.cRowSep = '\n';
24842	xRead = csv_read_one_field;
24843	useOutputMode = 0;
24844	}else{
24845	utf8_printf(p->out, "ERROR: unknown option: \"%s\". Usage:\n", z);
24846	showHelp(p->out, "import");
24847	goto meta_command_exit;
24848	}
24849	}
24850	if( zTable==0 ){
24851	utf8_printf(p->out, "ERROR: missing %s argument. Usage:\n",
24852	zFile==0 ? "FILE" : "TABLE");
24853	showHelp(p->out, "import");
24854	goto meta_command_exit;
24855	}
24856	seenInterrupt = 0;
24857	open_db(p, 0);
	@@ -24858,24 +25601,21 @@
24858	if( useOutputMode ){
24859	/* If neither the --csv or --ascii options are specified, then set
24860	** the column and row separator characters from the output mode. */
24861	nSep = strlen30(p->colSeparator);
24862	if( nSep==0 ){
24863	raw_printf(stderr,
24864	"Error: non-null column separator required for import\n");
24865	goto meta_command_exit;
24866	}
24867	if( nSep>1 ){
24868	raw_printf(stderr,
24869	"Error: multi-character column separators not allowed"
24870	" for import\n");
24871	goto meta_command_exit;
24872	}
24873	nSep = strlen30(p->rowSeparator);
24874	if( nSep==0 ){
24875	raw_printf(stderr,
24876	"Error: non-null row separator required for import\n");
24877	goto meta_command_exit;
24878	}
24879	if( nSep==2 && p->mode==MODE_Csv
24880	&& cli_strcmp(p->rowSeparator,SEP_CrLf)==0
24881	){
	@@ -24885,22 +25625,22 @@
24885	** and output row separators. */
24886	sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
24887	nSep = strlen30(p->rowSeparator);
24888	}
24889	if( nSep>1 ){
24890	raw_printf(stderr, "Error: multi-character row separators not allowed"
24891	" for import\n");
24892	goto meta_command_exit;
24893	}
24894	sCtx.cColSep = (u8)p->colSeparator[0];
24895	sCtx.cRowSep = (u8)p->rowSeparator[0];
24896	}
24897	sCtx.zFile = zFile;
24898	sCtx.nLine = 1;
24899	if( sCtx.zFile[0]=='\|' ){
24900	#ifdef SQLITE_OMIT_POPEN
24901	raw_printf(stderr, "Error: pipes are not supported in this OS\n");
24902	goto meta_command_exit;
24903	#else
24904	sCtx.in = popen(sCtx.zFile+1, "r");
24905	sCtx.zFile = "<pipe>";
24906	sCtx.xCloser = pclose;
	@@ -24908,23 +25648,23 @@
24908	}else{
24909	sCtx.in = fopen(sCtx.zFile, "rb");
24910	sCtx.xCloser = fclose;
24911	}
24912	if( sCtx.in==0 ){
24913	utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile);
24914	goto meta_command_exit;
24915	}
24916	if( eVerbose>=2 \|\| (eVerbose>=1 && useOutputMode) ){
24917	char zSep[2];
24918	zSep[1] = 0;
24919	zSep[0] = sCtx.cColSep;
24920	utf8_printf(p->out, "Column separator ");
24921	output_c_string(p->out, zSep);
24922	utf8_printf(p->out, ", row separator ");
24923	zSep[0] = sCtx.cRowSep;
24924	output_c_string(p->out, zSep);
24925	utf8_printf(p->out, "\n");
24926	}
24927	sCtx.z = sqlite3_malloc64(120);
24928	if( sCtx.z==0 ){
24929	import_cleanup(&sCtx);
24930	shell_out_of_memory();
	@@ -24955,18 +25695,18 @@
24955	zAutoColumn(sCtx.z, &dbCols, 0);
24956	if( sCtx.cTerm!=sCtx.cColSep ) break;
24957	}
24958	zColDefs = zAutoColumn(0, &dbCols, &zRenames);
24959	if( zRenames!=0 ){
24960	utf8_printf((stdin_is_interactive && p->in==stdin)? p->out : stderr,
24961	"Columns renamed during .import %s due to duplicates:\n"
24962	"%s\n", sCtx.zFile, zRenames);
24963	sqlite3_free(zRenames);
24964	}
24965	assert(dbCols==0);
24966	if( zColDefs==0 ){
24967	utf8_printf(stderr,"%s: empty file\n", sCtx.zFile);
24968	import_fail:
24969	sqlite3_free(zCreate);
24970	sqlite3_free(zSql);
24971	sqlite3_free(zFullTabName);
24972	import_cleanup(&sCtx);
	@@ -24973,24 +25713,24 @@
24973	rc = 1;
24974	goto meta_command_exit;
24975	}
24976	zCreate = sqlite3_mprintf("%z%z\n", zCreate, zColDefs);
24977	if( eVerbose>=1 ){
24978	utf8_printf(p->out, "%s\n", zCreate);
24979	}
24980	rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
24981	if( rc ){
24982	utf8_printf(stderr, "%s failed:\n%s\n", zCreate, sqlite3_errmsg(p->db));
24983	goto import_fail;
24984	}
24985	sqlite3_free(zCreate);
24986	zCreate = 0;
24987	rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
24988	}
24989	if( rc ){
24990	if (pStmt) sqlite3_finalize(pStmt);
24991	utf8_printf(stderr,"Error: %s\n", sqlite3_errmsg(p->db));
24992	goto import_fail;
24993	}
24994	sqlite3_free(zSql);
24995	nCol = sqlite3_column_count(pStmt);
24996	sqlite3_finalize(pStmt);
	@@ -25008,15 +25748,15 @@
25008	zSql[j++] = '?';
25009	}
25010	zSql[j++] = ')';
25011	zSql[j] = 0;
25012	if( eVerbose>=2 ){
25013	utf8_printf(p->out, "Insert using: %s\n", zSql);
25014	}
25015	rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
25016	if( rc ){
25017	utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
25018	if (pStmt) sqlite3_finalize(pStmt);
25019	goto import_fail;
25020	}
25021	sqlite3_free(zSql);
25022	sqlite3_free(zFullTabName);
	@@ -25045,32 +25785,31 @@
25045	if( z==0 && (xRead==csv_read_one_field) && i==nCol-1 && i>0 ){
25046	z = "";
25047	}
25048	sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT);
25049	if( i<nCol-1 && sCtx.cTerm!=sCtx.cColSep ){
25050	utf8_printf(stderr, "%s:%d: expected %d columns but found %d - "
25051	"filling the rest with NULL\n",
25052	sCtx.zFile, startLine, nCol, i+1);
25053	i += 2;
25054	while( i<=nCol ){ sqlite3_bind_null(pStmt, i); i++; }
25055	}
25056	}
25057	if( sCtx.cTerm==sCtx.cColSep ){
25058	do{
25059	xRead(&sCtx);
25060	i++;
25061	}while( sCtx.cTerm==sCtx.cColSep );
25062	utf8_printf(stderr, "%s:%d: expected %d columns but found %d - "
25063	"extras ignored\n",
25064	sCtx.zFile, startLine, nCol, i);
25065	}
25066	if( i>=nCol ){
25067	sqlite3_step(pStmt);
25068	rc = sqlite3_reset(pStmt);
25069	if( rc!=SQLITE_OK ){
25070	utf8_printf(stderr, "%s:%d: INSERT failed: %s\n", sCtx.zFile,
25071	startLine, sqlite3_errmsg(p->db));
25072	sCtx.nErr++;
25073	}else{
25074	sCtx.nRow++;
25075	}
25076	}
	@@ -25078,13 +25817,12 @@
25078
25079	import_cleanup(&sCtx);
25080	sqlite3_finalize(pStmt);
25081	if( needCommit ) sqlite3_exec(p->db, "COMMIT", 0, 0, 0);
25082	if( eVerbose>0 ){
25083	utf8_printf(p->out,
25084	"Added %d rows with %d errors using %d lines of input\n",
25085	sCtx.nRow, sCtx.nErr, sCtx.nLine-1);
25086	}
25087	}else
25088	#endif /* !defined(SQLITE_SHELL_FIDDLE) */
25089
25090	#ifndef SQLITE_UNTESTABLE
	@@ -25095,18 +25833,18 @@
25095	int tnum = 0;
25096	int isWO = 0; /* True if making an imposter of a WITHOUT ROWID table */
25097	int lenPK = 0; /* Length of the PRIMARY KEY string for isWO tables */
25098	int i;
25099	if( !ShellHasFlag(p,SHFLG_TestingMode) ){
25100	utf8_printf(stderr, ".%s unavailable without --unsafe-testing\n",
25101	"imposter");
25102	rc = 1;
25103	goto meta_command_exit;
25104	}
25105	if( !(nArg==3 \|\| (nArg==2 && sqlite3_stricmp(azArg[1],"off")==0)) ){
25106	utf8_printf(stderr, "Usage: .imposter INDEX IMPOSTER\n"
25107	" .imposter off\n");
25108	/* Also allowed, but not documented:
25109	**
25110	** .imposter TABLE IMPOSTER
25111	**
25112	** where TABLE is a WITHOUT ROWID table. In that case, the
	@@ -25161,11 +25899,11 @@
25161	zCollist = sqlite3_mprintf("%z,\"%w\"", zCollist, zCol);
25162	}
25163	}
25164	sqlite3_finalize(pStmt);
25165	if( i==0 \|\| tnum==0 ){
25166	utf8_printf(stderr, "no such index: \"%s\"\n", azArg[1]);
25167	rc = 1;
25168	sqlite3_free(zCollist);
25169	goto meta_command_exit;
25170	}
25171	if( lenPK==0 ) lenPK = 100000;
	@@ -25176,20 +25914,18 @@
25176	rc = sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 1, tnum);
25177	if( rc==SQLITE_OK ){
25178	rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
25179	sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 0);
25180	if( rc ){
25181	utf8_printf(stderr, "Error in [%s]: %s\n", zSql, sqlite3_errmsg(p->db));
25182	}else{
25183	utf8_printf(stdout, "%s;\n", zSql);
25184	raw_printf(stdout,
25185	"WARNING: writing to an imposter table will corrupt the \"%s\" %s!\n",
25186	azArg[1], isWO ? "table" : "index"
25187	);
25188	}
25189	}else{
25190	raw_printf(stderr, "SQLITE_TESTCTRL_IMPOSTER returns %d\n", rc);
25191	rc = 1;
25192	}
25193	sqlite3_free(zSql);
25194	}else
25195	#endif /* !defined(SQLITE_OMIT_TEST_CONTROL) */
	@@ -25205,11 +25941,11 @@
25205	sqlite3IoTrace = iotracePrintf;
25206	iotrace = stdout;
25207	}else{
25208	iotrace = fopen(azArg[1], "w");
25209	if( iotrace==0 ){
25210	utf8_printf(stderr, "Error: cannot open \"%s\"\n", azArg[1]);
25211	sqlite3IoTrace = 0;
25212	rc = 1;
25213	}else{
25214	sqlite3IoTrace = iotracePrintf;
25215	}
	@@ -25237,15 +25973,15 @@
25237	};
25238	int i, n2;
25239	open_db(p, 0);
25240	if( nArg==1 ){
25241	for(i=0; i<ArraySize(aLimit); i++){
25242	printf("%20s %d\n", aLimit[i].zLimitName,
25243	sqlite3_limit(p->db, aLimit[i].limitCode, -1));
25244	}
25245	}else if( nArg>3 ){
25246	raw_printf(stderr, "Usage: .limit NAME ?NEW-VALUE?\n");
25247	rc = 1;
25248	goto meta_command_exit;
25249	}else{
25250	int iLimit = -1;
25251	n2 = strlen30(azArg[1]);
	@@ -25252,29 +25988,29 @@
25252	for(i=0; i<ArraySize(aLimit); i++){
25253	if( sqlite3_strnicmp(aLimit[i].zLimitName, azArg[1], n2)==0 ){
25254	if( iLimit<0 ){
25255	iLimit = i;
25256	}else{
25257	utf8_printf(stderr, "ambiguous limit: \"%s\"\n", azArg[1]);
25258	rc = 1;
25259	goto meta_command_exit;
25260	}
25261	}
25262	}
25263	if( iLimit<0 ){
25264	utf8_printf(stderr, "unknown limit: \"%s\"\n"
25265	"enter \".limits\" with no arguments for a list.\n",
25266	azArg[1]);
25267	rc = 1;
25268	goto meta_command_exit;
25269	}
25270	if( nArg==3 ){
25271	sqlite3_limit(p->db, aLimit[iLimit].limitCode,
25272	(int)integerValue(azArg[2]));
25273	}
25274	printf("%20s %d\n", aLimit[iLimit].zLimitName,
25275	sqlite3_limit(p->db, aLimit[iLimit].limitCode, -1));
25276	}
25277	}else
25278
25279	if( c=='l' && n>2 && cli_strncmp(azArg[0], "lint", n)==0 ){
25280	open_db(p, 0);
	@@ -25286,38 +26022,38 @@
25286	const char zFile, zProc;
25287	char *zErrMsg = 0;
25288	failIfSafeMode(p, "cannot run .load in safe mode");
25289	if( nArg<2 \|\| azArg[1][0]==0 ){
25290	/* Must have a non-empty FILE. (Will not load self.) */
25291	raw_printf(stderr, "Usage: .load FILE ?ENTRYPOINT?\n");
25292	rc = 1;
25293	goto meta_command_exit;
25294	}
25295	zFile = azArg[1];
25296	zProc = nArg>=3 ? azArg[2] : 0;
25297	open_db(p, 0);
25298	rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
25299	if( rc!=SQLITE_OK ){
25300	utf8_printf(stderr, "Error: %s\n", zErrMsg);
25301	sqlite3_free(zErrMsg);
25302	rc = 1;
25303	}
25304	}else
25305	#endif
25306
25307	if( c=='l' && cli_strncmp(azArg[0], "log", n)==0 ){
25308	if( nArg!=2 ){
25309	raw_printf(stderr, "Usage: .log FILENAME\n");
25310	rc = 1;
25311	}else{
25312	const char *zFile = azArg[1];
25313	if( p->bSafeMode
25314	&& cli_strcmp(zFile,"on")!=0
25315	&& cli_strcmp(zFile,"off")!=0
25316	){
25317	raw_printf(stdout, "cannot set .log to anything other "
25318	"than \"on\" or \"off\"\n");
25319	zFile = "off";
25320	}
25321	output_file_close(p->pLog);
25322	if( cli_strcmp(zFile,"on")==0 ) zFile = "stdout";
25323	p->pLog = output_file_open(zFile, 0);
	@@ -25352,37 +26088,35 @@
25352	cmOpts = cmo;
25353	}
25354	}else if( zTabname==0 ){
25355	zTabname = z;
25356	}else if( z[0]=='-' ){
25357	utf8_printf(stderr, "unknown option: %s\n", z);
25358	utf8_printf(stderr, "options:\n"
25359	" --noquote\n"
25360	" --quote\n"
25361	" --wordwrap on/off\n"
25362	" --wrap N\n"
25363	" --ww\n");
25364	rc = 1;
25365	goto meta_command_exit;
25366	}else{
25367	utf8_printf(stderr, "extra argument: \"%s\"\n", z);
25368	rc = 1;
25369	goto meta_command_exit;
25370	}
25371	}
25372	if( zMode==0 ){
25373	if( p->mode==MODE_Column
25374	\|\| (p->mode>=MODE_Markdown && p->mode<=MODE_Box)
25375	){
25376	raw_printf
25377	(p->out,
25378	"current output mode: %s --wrap %d --wordwrap %s --%squote\n",
25379	modeDescr[p->mode], p->cmOpts.iWrap,
25380	p->cmOpts.bWordWrap ? "on" : "off",
25381	p->cmOpts.bQuote ? "" : "no");
25382	}else{
25383	raw_printf(p->out, "current output mode: %s\n", modeDescr[p->mode]);
25384	}
25385	zMode = modeDescr[p->mode];
25386	}
25387	n2 = strlen30(zMode);
25388	if( cli_strncmp(zMode,"lines",n2)==0 ){
	@@ -25437,26 +26171,26 @@
25437	}else if( cli_strncmp(zMode,"off",n2)==0 ){
25438	p->mode = MODE_Off;
25439	}else if( cli_strncmp(zMode,"json",n2)==0 ){
25440	p->mode = MODE_Json;
25441	}else{
25442	raw_printf(stderr, "Error: mode should be one of: "
25443	"ascii box column csv html insert json line list markdown "
25444	"qbox quote table tabs tcl\n");
25445	rc = 1;
25446	}
25447	p->cMode = p->mode;
25448	}else
25449
25450	#ifndef SQLITE_SHELL_FIDDLE
25451	if( c=='n' && cli_strcmp(azArg[0], "nonce")==0 ){
25452	if( nArg!=2 ){
25453	raw_printf(stderr, "Usage: .nonce NONCE\n");
25454	rc = 1;
25455	}else if( p->zNonce==0 \|\| cli_strcmp(azArg[1],p->zNonce)!=0 ){
25456	raw_printf(stderr, "line %d: incorrect nonce: \"%s\"\n",
25457	p->lineno, azArg[1]);
25458	exit(1);
25459	}else{
25460	p->bSafeMode = 0;
25461	return 0; /* Return immediately to bypass the safe mode reset
25462	** at the end of this procedure */
	@@ -25467,11 +26201,11 @@
25467	if( c=='n' && cli_strncmp(azArg[0], "nullvalue", n)==0 ){
25468	if( nArg==2 ){
25469	sqlite3_snprintf(sizeof(p->nullValue), p->nullValue,
25470	"%.*s", (int)ArraySize(p->nullValue)-1, azArg[1]);
25471	}else{
25472	raw_printf(stderr, "Usage: .nullvalue STRING\n");
25473	rc = 1;
25474	}
25475	}else
25476
25477	if( c=='o' && cli_strncmp(azArg[0], "open", n)==0 && n>=2 ){
	@@ -25506,15 +26240,15 @@
25506	p->szMax = integerValue(azArg[++iName]);
25507	#endif /* SQLITE_OMIT_DESERIALIZE */
25508	}else
25509	#endif /* !SQLITE_SHELL_FIDDLE */
25510	if( z[0]=='-' ){
25511	utf8_printf(stderr, "unknown option: %s\n", z);
25512	rc = 1;
25513	goto meta_command_exit;
25514	}else if( zFN ){
25515	utf8_printf(stderr, "extra argument: \"%s\"\n", z);
25516	rc = 1;
25517	goto meta_command_exit;
25518	}else{
25519	zFN = z;
25520	}
	@@ -25552,11 +26286,11 @@
25552	zNewFilename = 0;
25553	}
25554	p->pAuxDb->zDbFilename = zNewFilename;
25555	open_db(p, OPEN_DB_KEEPALIVE);
25556	if( p->db==0 ){
25557	utf8_printf(stderr, "Error: cannot open '%s'\n", zNewFilename);
25558	sqlite3_free(zNewFilename);
25559	}else{
25560	p->pAuxDb->zFreeOnClose = zNewFilename;
25561	}
25562	}
	@@ -25576,13 +26310,13 @@
25576	char *zFile = 0;
25577	int bTxtMode = 0;
25578	int i;
25579	int eMode = 0;
25580	int bOnce = 0; /* 0: .output, 1: .once, 2: .excel */
25581	unsigned char zBOM[4]; /* Byte-order mark to using if --bom is present */

25582
25583	zBOM[0] = 0;
25584	failIfSafeMode(p, "cannot run .%s in safe mode", azArg[0]);
25585	if( c=='e' ){
25586	eMode = 'x';
25587	bOnce = 2;
25588	}else if( cli_strncmp(azArg[0],"once",n)==0 ){
	@@ -25591,21 +26325,17 @@
25591	for(i=1; i<nArg; i++){
25592	char *z = azArg[i];
25593	if( z[0]=='-' ){
25594	if( z[1]=='-' ) z++;
25595	if( cli_strcmp(z,"-bom")==0 ){
25596	zBOM[0] = 0xef;
25597	zBOM[1] = 0xbb;
25598	zBOM[2] = 0xbf;
25599	zBOM[3] = 0;
25600	}else if( c!='e' && cli_strcmp(z,"-x")==0 ){
25601	eMode = 'x'; /* spreadsheet */
25602	}else if( c!='e' && cli_strcmp(z,"-e")==0 ){
25603	eMode = 'e'; /* text editor */
25604	}else{
25605	utf8_printf(p->out, "ERROR: unknown option: \"%s\". Usage:\n",
25606	azArg[i]);
25607	showHelp(p->out, azArg[0]);
25608	rc = 1;
25609	goto meta_command_exit;
25610	}
25611	}else if( zFile==0 && eMode!='e' && eMode!='x' ){
	@@ -25613,12 +26343,11 @@
25613	if( zFile && zFile[0]=='\|' ){
25614	while( i+1<nArg ) zFile = sqlite3_mprintf("%z %s", zFile, azArg[++i]);
25615	break;
25616	}
25617	}else{
25618	utf8_printf(p->out,"ERROR: extra parameter: \"%s\". Usage:\n",
25619	azArg[i]);
25620	showHelp(p->out, azArg[0]);
25621	rc = 1;
25622	sqlite3_free(zFile);
25623	goto meta_command_exit;
25624	}
	@@ -25653,34 +26382,34 @@
25653	}
25654	#endif /* SQLITE_NOHAVE_SYSTEM */
25655	shell_check_oom(zFile);
25656	if( zFile[0]=='\|' ){
25657	#ifdef SQLITE_OMIT_POPEN
25658	raw_printf(stderr, "Error: pipes are not supported in this OS\n");
25659	rc = 1;
25660	p->out = stdout;
25661	#else
25662	p->out = popen(zFile + 1, "w");
25663	if( p->out==0 ){
25664	utf8_printf(stderr,"Error: cannot open pipe \"%s\"\n", zFile + 1);
25665	p->out = stdout;
25666	rc = 1;
25667	}else{
25668	if( zBOM[0] ) fwrite(zBOM, 1, 3, p->out);

25669	sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
25670	}
25671	#endif
25672	}else{
25673	p->out = output_file_open(zFile, bTxtMode);
25674	if( p->out==0 ){
25675	if( cli_strcmp(zFile,"off")!=0 ){
25676	utf8_printf(stderr,"Error: cannot write to \"%s\"\n", zFile);
25677	}
25678	p->out = stdout;
25679	rc = 1;
25680	} else {
25681	if( zBOM[0] ) fwrite(zBOM, 1, 3, p->out);

25682	sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
25683	}
25684	}
25685	sqlite3_free(zFile);
25686	}else
	@@ -25717,12 +26446,12 @@
25717	if( len ){
25718	rx = sqlite3_prepare_v2(p->db,
25719	"SELECT key, quote(value) "
25720	"FROM temp.sqlite_parameters;", -1, &pStmt, 0);
25721	while( rx==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){
25722	utf8_printf(p->out, "%-*s %s\n", len, sqlite3_column_text(pStmt,0),
25723	sqlite3_column_text(pStmt,1));
25724	}
25725	sqlite3_finalize(pStmt);
25726	}
25727	}else
25728
	@@ -25762,11 +26491,11 @@
25762	"VALUES(%Q,%Q);", zKey, zValue);
25763	shell_check_oom(zSql);
25764	rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
25765	sqlite3_free(zSql);
25766	if( rx!=SQLITE_OK ){
25767	utf8_printf(p->out, "Error: %s\n", sqlite3_errmsg(p->db));
25768	sqlite3_finalize(pStmt);
25769	pStmt = 0;
25770	rc = 1;
25771	}
25772	}
	@@ -25791,14 +26520,14 @@
25791	}else
25792
25793	if( c=='p' && n>=3 && cli_strncmp(azArg[0], "print", n)==0 ){
25794	int i;
25795	for(i=1; i<nArg; i++){
25796	if( i>1 ) raw_printf(p->out, " ");
25797	utf8_printf(p->out, "%s", azArg[i]);
25798	}
25799	raw_printf(p->out, "\n");
25800	}else
25801
25802	#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
25803	if( c=='p' && n>=3 && cli_strncmp(azArg[0], "progress", n)==0 ){
25804	int i;
	@@ -25823,19 +26552,19 @@
25823	p->flgProgress \|= SHELL_PROGRESS_ONCE;
25824	continue;
25825	}
25826	if( cli_strcmp(z,"limit")==0 ){
25827	if( i+1>=nArg ){
25828	utf8_printf(stderr, "Error: missing argument on --limit\n");
25829	rc = 1;
25830	goto meta_command_exit;
25831	}else{
25832	p->mxProgress = (int)integerValue(azArg[++i]);
25833	}
25834	continue;
25835	}
25836	utf8_printf(stderr, "Error: unknown option: \"%s\"\n", azArg[i]);
25837	rc = 1;
25838	goto meta_command_exit;
25839	}else{
25840	nn = (int)integerValue(z);
25841	}
	@@ -25864,31 +26593,31 @@
25864	if( c=='r' && n>=3 && cli_strncmp(azArg[0], "read", n)==0 ){
25865	FILE *inSaved = p->in;
25866	int savedLineno = p->lineno;
25867	failIfSafeMode(p, "cannot run .read in safe mode");
25868	if( nArg!=2 ){
25869	raw_printf(stderr, "Usage: .read FILE\n");
25870	rc = 1;
25871	goto meta_command_exit;
25872	}
25873	if( azArg[1][0]=='\|' ){
25874	#ifdef SQLITE_OMIT_POPEN
25875	raw_printf(stderr, "Error: pipes are not supported in this OS\n");
25876	rc = 1;
25877	p->out = stdout;
25878	#else
25879	p->in = popen(azArg[1]+1, "r");
25880	if( p->in==0 ){
25881	utf8_printf(stderr, "Error: cannot open \"%s\"\n", azArg[1]);
25882	rc = 1;
25883	}else{
25884	rc = process_input(p);
25885	pclose(p->in);
25886	}
25887	#endif
25888	}else if( (p->in = openChrSource(azArg[1]))==0 ){
25889	utf8_printf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
25890	rc = 1;
25891	}else{
25892	rc = process_input(p);
25893	fclose(p->in);
25894	}
	@@ -25911,24 +26640,24 @@
25911	zDb = "main";
25912	}else if( nArg==3 ){
25913	zSrcFile = azArg[2];
25914	zDb = azArg[1];
25915	}else{
25916	raw_printf(stderr, "Usage: .restore ?DB? FILE\n");
25917	rc = 1;
25918	goto meta_command_exit;
25919	}
25920	rc = sqlite3_open(zSrcFile, &pSrc);
25921	if( rc!=SQLITE_OK ){
25922	utf8_printf(stderr, "Error: cannot open \"%s\"\n", zSrcFile);
25923	close_db(pSrc);
25924	return 1;
25925	}
25926	open_db(p, 0);
25927	pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
25928	if( pBackup==0 ){
25929	utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
25930	close_db(pSrc);
25931	return 1;
25932	}
25933	while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
25934	\|\| rc==SQLITE_BUSY ){
	@@ -25939,14 +26668,14 @@
25939	}
25940	sqlite3_backup_finish(pBackup);
25941	if( rc==SQLITE_DONE ){
25942	rc = 0;
25943	}else if( rc==SQLITE_BUSY \|\| rc==SQLITE_LOCKED ){
25944	raw_printf(stderr, "Error: source database is busy\n");
25945	rc = 1;
25946	}else{
25947	utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
25948	rc = 1;
25949	}
25950	close_db(pSrc);
25951	}else
25952	#endif /* !defined(SQLITE_SHELL_FIDDLE) */
	@@ -25963,15 +26692,19 @@
25963	}
25964	open_db(p, 0);
25965	sqlite3_db_config(
25966	p->db, SQLITE_DBCONFIG_STMT_SCANSTATUS, p->scanstatsOn, (int*)0
25967	);
25968	#ifndef SQLITE_ENABLE_STMT_SCANSTATUS
25969	raw_printf(stderr, "Warning: .scanstats not available in this build.\n");




25970	#endif
25971	}else{
25972	raw_printf(stderr, "Usage: .scanstats on\|off\|est\n");
25973	rc = 1;
25974	}
25975	}else
25976
25977	if( c=='s' && cli_strncmp(azArg[0], "schema", n)==0 ){
	@@ -25996,18 +26729,17 @@
25996	}else if( optionMatch(azArg[ii],"debug") ){
25997	bDebug = 1;
25998	}else if( optionMatch(azArg[ii],"nosys") ){
25999	bNoSystemTabs = 1;
26000	}else if( azArg[ii][0]=='-' ){
26001	utf8_printf(stderr, "Unknown option: \"%s\"\n", azArg[ii]);
26002	rc = 1;
26003	goto meta_command_exit;
26004	}else if( zName==0 ){
26005	zName = azArg[ii];
26006	}else{
26007	raw_printf(stderr,
26008	"Usage: .schema ?--indent? ?--nosys? ?LIKE-PATTERN?\n");
26009	rc = 1;
26010	goto meta_command_exit;
26011	}
26012	}
26013	if( zName!=0 ){
	@@ -26036,11 +26768,11 @@
26036	if( zDiv ){
26037	sqlite3_stmt *pStmt = 0;
26038	rc = sqlite3_prepare_v2(p->db, "SELECT name FROM pragma_database_list",
26039	-1, &pStmt, 0);
26040	if( rc ){
26041	utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
26042	sqlite3_finalize(pStmt);
26043	rc = 1;
26044	goto meta_command_exit;
26045	}
26046	appendText(&sSelect, "SELECT sql FROM", 0);
	@@ -26098,22 +26830,22 @@
26098	appendText(&sSelect, "name NOT LIKE 'sqlite_%%' AND ", 0);
26099	}
26100	appendText(&sSelect, "sql IS NOT NULL"
26101	" ORDER BY snum, rowid", 0);
26102	if( bDebug ){
26103	utf8_printf(p->out, "SQL: %s;\n", sSelect.z);
26104	}else{
26105	rc = sqlite3_exec(p->db, sSelect.z, callback, &data, &zErrMsg);
26106	}
26107	freeText(&sSelect);
26108	}
26109	if( zErrMsg ){
26110	utf8_printf(stderr,"Error: %s\n", zErrMsg);
26111	sqlite3_free(zErrMsg);
26112	rc = 1;
26113	}else if( rc != SQLITE_OK ){
26114	raw_printf(stderr,"Error: querying schema information\n");
26115	rc = 1;
26116	}else{
26117	rc = 0;
26118	}
26119	}else
	@@ -26155,15 +26887,15 @@
26155	*/
26156	if( cli_strcmp(azCmd[0],"attach")==0 ){
26157	if( nCmd!=2 ) goto session_syntax_error;
26158	if( pSession->p==0 ){
26159	session_not_open:
26160	raw_printf(stderr, "ERROR: No sessions are open\n");
26161	}else{
26162	rc = sqlite3session_attach(pSession->p, azCmd[1]);
26163	if( rc ){
26164	raw_printf(stderr, "ERROR: sqlite3session_attach() returns %d\n", rc);
26165	rc = 0;
26166	}
26167	}
26168	}else
26169
	@@ -26178,28 +26910,27 @@
26178	failIfSafeMode(p, "cannot run \".session %s\" in safe mode", azCmd[0]);
26179	if( nCmd!=2 ) goto session_syntax_error;
26180	if( pSession->p==0 ) goto session_not_open;
26181	out = fopen(azCmd[1], "wb");
26182	if( out==0 ){
26183	utf8_printf(stderr, "ERROR: cannot open \"%s\" for writing\n",
26184	azCmd[1]);
26185	}else{
26186	int szChng;
26187	void *pChng;
26188	if( azCmd[0][0]=='c' ){
26189	rc = sqlite3session_changeset(pSession->p, &szChng, &pChng);
26190	}else{
26191	rc = sqlite3session_patchset(pSession->p, &szChng, &pChng);
26192	}
26193	if( rc ){
26194	printf("Error: error code %d\n", rc);
26195	rc = 0;
26196	}
26197	if( pChng
26198	&& fwrite(pChng, szChng, 1, out)!=1 ){
26199	raw_printf(stderr, "ERROR: Failed to write entire %d-byte output\n",
26200	szChng);
26201	}
26202	sqlite3_free(pChng);
26203	fclose(out);
26204	}
26205	}else
	@@ -26222,12 +26953,11 @@
26222	int ii;
26223	if( nCmd>2 ) goto session_syntax_error;
26224	ii = nCmd==1 ? -1 : booleanValue(azCmd[1]);
26225	if( pAuxDb->nSession ){
26226	ii = sqlite3session_enable(pSession->p, ii);
26227	utf8_printf(p->out, "session %s enable flag = %d\n",
26228	pSession->zName, ii);
26229	}
26230	}else
26231
26232	/* .session filter GLOB ....
26233	** Set a list of GLOB patterns of table names to be excluded.
	@@ -26240,14 +26970,11 @@
26240	sqlite3_free(pSession->azFilter[ii]);
26241	}
26242	sqlite3_free(pSession->azFilter);
26243	nByte = sizeof(pSession->azFilter[0])*(nCmd-1);
26244	pSession->azFilter = sqlite3_malloc( nByte );
26245	if( pSession->azFilter==0 ){
26246	raw_printf(stderr, "Error: out or memory\n");
26247	exit(1);
26248	}
26249	for(ii=1; ii<nCmd; ii++){
26250	char *x = pSession->azFilter[ii-1] = sqlite3_mprintf("%s", azCmd[ii]);
26251	shell_check_oom(x);
26252	}
26253	pSession->nFilter = ii-1;
	@@ -26261,12 +26988,11 @@
26261	int ii;
26262	if( nCmd>2 ) goto session_syntax_error;
26263	ii = nCmd==1 ? -1 : booleanValue(azCmd[1]);
26264	if( pAuxDb->nSession ){
26265	ii = sqlite3session_indirect(pSession->p, ii);
26266	utf8_printf(p->out, "session %s indirect flag = %d\n",
26267	pSession->zName, ii);
26268	}
26269	}else
26270
26271	/* .session isempty
26272	** Determine if the session is empty
	@@ -26274,21 +27000,20 @@
26274	if( cli_strcmp(azCmd[0], "isempty")==0 ){
26275	int ii;
26276	if( nCmd!=1 ) goto session_syntax_error;
26277	if( pAuxDb->nSession ){
26278	ii = sqlite3session_isempty(pSession->p);
26279	utf8_printf(p->out, "session %s isempty flag = %d\n",
26280	pSession->zName, ii);
26281	}
26282	}else
26283
26284	/* .session list
26285	** List all currently open sessions
26286	*/
26287	if( cli_strcmp(azCmd[0],"list")==0 ){
26288	for(i=0; i<pAuxDb->nSession; i++){
26289	utf8_printf(p->out, "%d %s\n", i, pAuxDb->aSession[i].zName);
26290	}
26291	}else
26292
26293	/* .session open DB NAME
26294	** Open a new session called NAME on the attached database DB.
	@@ -26299,23 +27024,22 @@
26299	if( nCmd!=3 ) goto session_syntax_error;
26300	zName = azCmd[2];
26301	if( zName[0]==0 ) goto session_syntax_error;
26302	for(i=0; i<pAuxDb->nSession; i++){
26303	if( cli_strcmp(pAuxDb->aSession[i].zName,zName)==0 ){
26304	utf8_printf(stderr, "Session \"%s\" already exists\n", zName);
26305	goto meta_command_exit;
26306	}
26307	}
26308	if( pAuxDb->nSession>=ArraySize(pAuxDb->aSession) ){
26309	raw_printf(stderr,
26310	"Maximum of %d sessions\n", ArraySize(pAuxDb->aSession));
26311	goto meta_command_exit;
26312	}
26313	pSession = &pAuxDb->aSession[pAuxDb->nSession];
26314	rc = sqlite3session_create(p->db, azCmd[1], &pSession->p);
26315	if( rc ){
26316	raw_printf(stderr, "Cannot open session: error code=%d\n", rc);
26317	rc = 0;
26318	goto meta_command_exit;
26319	}
26320	pSession->nFilter = 0;
26321	sqlite3session_table_filter(pSession->p, session_filter, pSession);
	@@ -26335,20 +27059,20 @@
26335	if( c=='s' && n>=10 && cli_strncmp(azArg[0], "selftest-", 9)==0 ){
26336	if( cli_strncmp(azArg[0]+9, "boolean", n-9)==0 ){
26337	int i, v;
26338	for(i=1; i<nArg; i++){
26339	v = booleanValue(azArg[i]);
26340	utf8_printf(p->out, "%s: %d 0x%x\n", azArg[i], v, v);
26341	}
26342	}
26343	if( cli_strncmp(azArg[0]+9, "integer", n-9)==0 ){
26344	int i; sqlite3_int64 v;
26345	for(i=1; i<nArg; i++){
26346	char zBuf[200];
26347	v = integerValue(azArg[i]);
26348	sqlite3_snprintf(sizeof(zBuf),zBuf,"%s: %lld 0x%llx\n", azArg[i],v,v);
26349	utf8_printf(p->out, "%s", zBuf);
26350	}
26351	}
26352	}else
26353	#endif
26354
	@@ -26371,13 +27095,12 @@
26371	}else
26372	if( cli_strcmp(z,"-v")==0 ){
26373	bVerbose++;
26374	}else
26375	{
26376	utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
26377	azArg[i], azArg[0]);
26378	raw_printf(stderr, "Should be one of: --init -v\n");
26379	rc = 1;
26380	goto meta_command_exit;
26381	}
26382	}
26383	if( sqlite3_table_column_metadata(p->db,"main","selftest",0,0,0,0,0,0)
	@@ -26402,11 +27125,11 @@
26402	"VALUES(0,'memo','Missing SELFTEST table - default checks only',''),"
26403	" (1,'run','PRAGMA integrity_check','ok')",
26404	-1, &pStmt, 0);
26405	}
26406	if( rc ){
26407	raw_printf(stderr, "Error querying the selftest table\n");
26408	rc = 1;
26409	sqlite3_finalize(pStmt);
26410	goto meta_command_exit;
26411	}
26412	for(i=1; sqlite3_step(pStmt)==SQLITE_ROW; i++){
	@@ -26418,52 +27141,51 @@
26418	if( zOp==0 ) continue;
26419	if( zSql==0 ) continue;
26420	if( zAns==0 ) continue;
26421	k = 0;
26422	if( bVerbose>0 ){
26423	printf("%d: %s %s\n", tno, zOp, zSql);
26424	}
26425	if( cli_strcmp(zOp,"memo")==0 ){
26426	utf8_printf(p->out, "%s\n", zSql);
26427	}else
26428	if( cli_strcmp(zOp,"run")==0 ){
26429	char *zErrMsg = 0;
26430	str.n = 0;
26431	str.z[0] = 0;
26432	rc = sqlite3_exec(p->db, zSql, captureOutputCallback, &str, &zErrMsg);
26433	nTest++;
26434	if( bVerbose ){
26435	utf8_printf(p->out, "Result: %s\n", str.z);
26436	}
26437	if( rc \|\| zErrMsg ){
26438	nErr++;
26439	rc = 1;
26440	utf8_printf(p->out, "%d: error-code-%d: %s\n", tno, rc, zErrMsg);
26441	sqlite3_free(zErrMsg);
26442	}else if( cli_strcmp(zAns,str.z)!=0 ){
26443	nErr++;
26444	rc = 1;
26445	utf8_printf(p->out, "%d: Expected: [%s]\n", tno, zAns);
26446	utf8_printf(p->out, "%d: Got: [%s]\n", tno, str.z);
26447	}
26448	}else
26449	{
26450	utf8_printf(stderr,
26451	"Unknown operation \"%s\" on selftest line %d\n", zOp, tno);
26452	rc = 1;
26453	break;
26454	}
26455	} /* End loop over rows of content from SELFTEST */
26456	sqlite3_finalize(pStmt);
26457	} /* End loop over k */
26458	freeText(&str);
26459	utf8_printf(p->out, "%d errors out of %d tests\n", nErr, nTest);
26460	}else
26461
26462	if( c=='s' && cli_strncmp(azArg[0], "separator", n)==0 ){
26463	if( nArg<2 \|\| nArg>3 ){
26464	raw_printf(stderr, "Usage: .separator COL ?ROW?\n");
26465	rc = 1;
26466	}
26467	if( nArg>=2 ){
26468	sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator,
26469	"%.*s", (int)ArraySize(p->colSeparator)-1, azArg[1]);
	@@ -26502,18 +27224,17 @@
26502	}else
26503	if( cli_strcmp(z,"debug")==0 ){
26504	bDebug = 1;
26505	}else
26506	{
26507	utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
26508	azArg[i], azArg[0]);
26509	showHelp(p->out, azArg[0]);
26510	rc = 1;
26511	goto meta_command_exit;
26512	}
26513	}else if( zLike ){
26514	raw_printf(stderr, "Usage: .sha3sum ?OPTIONS? ?LIKE-PATTERN?\n");
26515	rc = 1;
26516	goto meta_command_exit;
26517	}else{
26518	zLike = z;
26519	bSeparate = 1;
	@@ -26581,11 +27302,11 @@
26581	}
26582	shell_check_oom(zSql);
26583	freeText(&sQuery);
26584	freeText(&sSql);
26585	if( bDebug ){
26586	utf8_printf(p->out, "%s\n", zSql);
26587	}else{
26588	shell_exec(p, zSql, 0);
26589	}
26590	#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) && !defined(SQLITE_OMIT_VIRTUALTABLE)
26591	{
	@@ -26611,11 +27332,11 @@
26611	"\|\|group_concat('CAST(CAST('\|\|cname\|\|' AS BLOB) AS TEXT)<>'\|\|cname\n"
26612	"\|\| ' AND typeof('\|\|cname\|\|')=''text'' ',\n"
26613	"' OR ') as query, tname from tabcols group by tname)"
26614	, zRevText);
26615	shell_check_oom(zRevText);
26616	if( bDebug ) utf8_printf(p->out, "%s\n", zRevText);
26617	lrc = sqlite3_prepare_v2(p->db, zRevText, -1, &pStmt, 0);
26618	if( lrc!=SQLITE_OK ){
26619	/* assert(lrc==SQLITE_NOMEM); // might also be SQLITE_ERROR if the
26620	** user does cruel and unnatural things like ".limit expr_depth 0". */
26621	rc = 1;
	@@ -26624,29 +27345,28 @@
26624	lrc = SQLITE_ROW==sqlite3_step(pStmt);
26625	if( lrc ){
26626	const char zGenQuery = (char)sqlite3_column_text(pStmt,0);
26627	sqlite3_stmt *pCheckStmt;
26628	lrc = sqlite3_prepare_v2(p->db, zGenQuery, -1, &pCheckStmt, 0);
26629	if( bDebug ) utf8_printf(p->out, "%s\n", zGenQuery);
26630	if( lrc!=SQLITE_OK ){
26631	rc = 1;
26632	}else{
26633	if( SQLITE_ROW==sqlite3_step(pCheckStmt) ){
26634	double countIrreversible = sqlite3_column_double(pCheckStmt, 0);
26635	if( countIrreversible>0 ){
26636	int sz = (int)(countIrreversible + 0.5);
26637	utf8_printf(stderr,
26638	"Digest includes %d invalidly encoded text field%s.\n",
26639	sz, (sz>1)? "s": "");
26640	}
26641	}
26642	sqlite3_finalize(pCheckStmt);
26643	}
26644	sqlite3_finalize(pStmt);
26645	}
26646	}
26647	if( rc ) utf8_printf(stderr, ".sha3sum failed.\n");
26648	sqlite3_free(zRevText);
26649	}
26650	#endif /* !defined(_OMIT_SCHEMA_PRAGMAS) && !defined(_OMIT_VIRTUALTABLE) */
26651	sqlite3_free(zSql);
26652	}else
	@@ -26658,76 +27378,77 @@
26658	){
26659	char *zCmd;
26660	int i, x;
26661	failIfSafeMode(p, "cannot run .%s in safe mode", azArg[0]);
26662	if( nArg<2 ){
26663	raw_printf(stderr, "Usage: .system COMMAND\n");
26664	rc = 1;
26665	goto meta_command_exit;
26666	}
26667	zCmd = sqlite3_mprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]);
26668	for(i=2; i<nArg && zCmd!=0; i++){
26669	zCmd = sqlite3_mprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"",
26670	zCmd, azArg[i]);
26671	}

26672	x = zCmd!=0 ? system(zCmd) : 1;

26673	sqlite3_free(zCmd);
26674	if( x ) raw_printf(stderr, "System command returns %d\n", x);
26675	}else
26676	#endif /* !defined(SQLITE_NOHAVE_SYSTEM) && !defined(SQLITE_SHELL_FIDDLE) */
26677
26678	if( c=='s' && cli_strncmp(azArg[0], "show", n)==0 ){
26679	static const char *azBool[] = { "off", "on", "trigger", "full"};
26680	const char *zOut;
26681	int i;
26682	if( nArg!=1 ){
26683	raw_printf(stderr, "Usage: .show\n");
26684	rc = 1;
26685	goto meta_command_exit;
26686	}
26687	utf8_printf(p->out, "%12.12s: %s\n","echo",
26688	azBool[ShellHasFlag(p, SHFLG_Echo)]);
26689	utf8_printf(p->out, "%12.12s: %s\n","eqp", azBool[p->autoEQP&3]);
26690	utf8_printf(p->out, "%12.12s: %s\n","explain",
26691	p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off");
26692	utf8_printf(p->out,"%12.12s: %s\n","headers", azBool[p->showHeader!=0]);
26693	if( p->mode==MODE_Column
26694	\|\| (p->mode>=MODE_Markdown && p->mode<=MODE_Box)
26695	){
26696	utf8_printf
26697	(p->out, "%12.12s: %s --wrap %d --wordwrap %s --%squote\n", "mode",
26698	modeDescr[p->mode], p->cmOpts.iWrap,
26699	p->cmOpts.bWordWrap ? "on" : "off",
26700	p->cmOpts.bQuote ? "" : "no");
26701	}else{
26702	utf8_printf(p->out, "%12.12s: %s\n","mode", modeDescr[p->mode]);
26703	}
26704	utf8_printf(p->out, "%12.12s: ", "nullvalue");
26705	output_c_string(p->out, p->nullValue);
26706	raw_printf(p->out, "\n");
26707	utf8_printf(p->out,"%12.12s: %s\n","output",
26708	strlen30(p->outfile) ? p->outfile : "stdout");
26709	utf8_printf(p->out,"%12.12s: ", "colseparator");
26710	output_c_string(p->out, p->colSeparator);
26711	raw_printf(p->out, "\n");
26712	utf8_printf(p->out,"%12.12s: ", "rowseparator");
26713	output_c_string(p->out, p->rowSeparator);
26714	raw_printf(p->out, "\n");
26715	switch( p->statsOn ){
26716	case 0: zOut = "off"; break;
26717	default: zOut = "on"; break;
26718	case 2: zOut = "stmt"; break;
26719	case 3: zOut = "vmstep"; break;
26720	}
26721	utf8_printf(p->out, "%12.12s: %s\n","stats", zOut);
26722	utf8_printf(p->out, "%12.12s: ", "width");
26723	for (i=0;i<p->nWidth;i++) {
26724	raw_printf(p->out, "%d ", p->colWidth[i]);
26725	}
26726	raw_printf(p->out, "\n");
26727	utf8_printf(p->out, "%12.12s: %s\n", "filename",
26728	p->pAuxDb->zDbFilename ? p->pAuxDb->zDbFilename : "");
26729	}else
26730
26731	if( c=='s' && cli_strncmp(azArg[0], "stats", n)==0 ){
26732	if( nArg==2 ){
26733	if( cli_strcmp(azArg[1],"stmt")==0 ){
	@@ -26738,11 +27459,11 @@
26738	p->statsOn = (u8)booleanValue(azArg[1]);
26739	}
26740	}else if( nArg==1 ){
26741	display_stats(p->db, p, 0);
26742	}else{
26743	raw_printf(stderr, "Usage: .stats ?on\|off\|stmt\|vmstep?\n");
26744	rc = 1;
26745	}
26746	}else
26747
26748	if( (c=='t' && n>1 && cli_strncmp(azArg[0], "tables", n)==0)
	@@ -26764,11 +27485,11 @@
26764
26765	if( nArg>2 && c=='i' ){
26766	/* It is an historical accident that the .indexes command shows an error
26767	** when called with the wrong number of arguments whereas the .tables
26768	** command does not. */
26769	raw_printf(stderr, "Usage: .indexes ?LIKE-PATTERN?\n");
26770	rc = 1;
26771	sqlite3_finalize(pStmt);
26772	goto meta_command_exit;
26773	}
26774	for(ii=0; sqlite3_step(pStmt)==SQLITE_ROW; ii++){
	@@ -26840,14 +27561,13 @@
26840	if( nPrintCol<1 ) nPrintCol = 1;
26841	nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
26842	for(i=0; i<nPrintRow; i++){
26843	for(j=i; j<nRow; j+=nPrintRow){
26844	char *zSp = j<nPrintRow ? "" : " ";
26845	utf8_printf(p->out, "%s%-*s", zSp, maxlen,
26846	azResult[j] ? azResult[j]:"");
26847	}
26848	raw_printf(p->out, "\n");
26849	}
26850	}
26851
26852	for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]);
26853	sqlite3_free(azResult);
	@@ -26857,11 +27577,11 @@
26857	/* Begin redirecting output to the file "testcase-out.txt" */
26858	if( c=='t' && cli_strcmp(azArg[0],"testcase")==0 ){
26859	output_reset(p);
26860	p->out = output_file_open("testcase-out.txt", 0);
26861	if( p->out==0 ){
26862	raw_printf(stderr, "Error: cannot open 'testcase-out.txt'\n");
26863	}
26864	if( nArg>=2 ){
26865	sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "%s", azArg[1]);
26866	}else{
26867	sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "?");
	@@ -26898,11 +27618,11 @@
26898	{"prng_save", SQLITE_TESTCTRL_PRNG_SAVE, 0, "" },
26899	{"prng_seed", SQLITE_TESTCTRL_PRNG_SEED, 0, "SEED ?db?" },
26900	{"seek_count", SQLITE_TESTCTRL_SEEK_COUNT, 0, "" },
26901	{"sorter_mmap", SQLITE_TESTCTRL_SORTER_MMAP, 0, "NMAX" },
26902	{"tune", SQLITE_TESTCTRL_TUNE, 1, "ID VALUE" },
26903	{"uselongdouble", SQLITE_TESTCTRL_USELONGDOUBLE,0,"?BOOLEAN\|\"default\"?"},
26904	};
26905	int testctrl = -1;
26906	int iCtrl = -1;
26907	int rc2 = 0; /* 0: usage. 1: %d 2: %x 3: no-output */
26908	int isOk = 0;
	@@ -26918,15 +27638,15 @@
26918	if( zCmd[0]=='-' && zCmd[1] ) zCmd++;
26919	}
26920
26921	/* --help lists all test-controls */
26922	if( cli_strcmp(zCmd,"help")==0 ){
26923	utf8_printf(p->out, "Available test-controls:\n");
26924	for(i=0; i<ArraySize(aCtrl); i++){
26925	if( aCtrl[i].unSafe && !ShellHasFlag(p,SHFLG_TestingMode) ) continue;
26926	utf8_printf(p->out, " .testctrl %s %s\n",
26927	aCtrl[i].zCtrlName, aCtrl[i].zUsage);
26928	}
26929	rc = 1;
26930	goto meta_command_exit;
26931	}
26932
	@@ -26938,20 +27658,20 @@
26938	if( cli_strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){
26939	if( testctrl<0 ){
26940	testctrl = aCtrl[i].ctrlCode;
26941	iCtrl = i;
26942	}else{
26943	utf8_printf(stderr, "Error: ambiguous test-control: \"%s\"\n"
26944	"Use \".testctrl --help\" for help\n", zCmd);
26945	rc = 1;
26946	goto meta_command_exit;
26947	}
26948	}
26949	}
26950	if( testctrl<0 ){
26951	utf8_printf(stderr,"Error: unknown test-control: %s\n"
26952	"Use \".testctrl --help\" for help\n", zCmd);
26953	}else{
26954	switch(testctrl){
26955
26956	/* sqlite3_test_control(int, db, int) */
26957	case SQLITE_TESTCTRL_OPTIMIZATIONS:
	@@ -26987,11 +27707,11 @@
26987	if( nArg==3 \|\| nArg==4 ){
26988	int ii = (int)integerValue(azArg[2]);
26989	sqlite3 *db;
26990	if( ii==0 && cli_strcmp(azArg[2],"random")==0 ){
26991	sqlite3_randomness(sizeof(ii),&ii);
26992	printf("-- random seed: %d\n", ii);
26993	}
26994	if( nArg==3 ){
26995	db = 0;
26996	}else{
26997	db = p->db;
	@@ -27055,11 +27775,11 @@
27055	break;
27056
27057	case SQLITE_TESTCTRL_SEEK_COUNT: {
27058	u64 x = 0;
27059	rc2 = sqlite3_test_control(testctrl, p->db, &x);
27060	utf8_printf(p->out, "%llu\n", x);
27061	isOk = 3;
27062	break;
27063	}
27064
27065	#ifdef YYCOVERAGE
	@@ -27086,15 +27806,15 @@
27086	int id = 1;
27087	while(1){
27088	int val = 0;
27089	rc2 = sqlite3_test_control(testctrl, -id, &val);
27090	if( rc2!=SQLITE_OK ) break;
27091	if( id>1 ) utf8_printf(p->out, " ");
27092	utf8_printf(p->out, "%d: %d", id, val);
27093	id++;
27094	}
27095	if( id>1 ) utf8_printf(p->out, "\n");
27096	isOk = 3;
27097	}
27098	break;
27099	}
27100	#endif
	@@ -27106,16 +27826,16 @@
27106	}
27107	break;
27108	}
27109	}
27110	if( isOk==0 && iCtrl>=0 ){
27111	utf8_printf(p->out, "Usage: .testctrl %s %s\n", zCmd,aCtrl[iCtrl].zUsage);
27112	rc = 1;
27113	}else if( isOk==1 ){
27114	raw_printf(p->out, "%d\n", rc2);
27115	}else if( isOk==2 ){
27116	raw_printf(p->out, "0x%08x\n", rc2);
27117	}
27118	}else
27119	#endif /* !defined(SQLITE_UNTESTABLE) */
27120
27121	if( c=='t' && n>4 && cli_strncmp(azArg[0], "timeout", n)==0 ){
	@@ -27125,15 +27845,15 @@
27125
27126	if( c=='t' && n>=5 && cli_strncmp(azArg[0], "timer", n)==0 ){
27127	if( nArg==2 ){
27128	enableTimer = booleanValue(azArg[1]);
27129	if( enableTimer && !HAS_TIMER ){
27130	raw_printf(stderr, "Error: timer not available on this system.\n");
27131	enableTimer = 0;
27132	}
27133	}else{
27134	raw_printf(stderr, "Usage: .timer on\|off\n");
27135	rc = 1;
27136	}
27137	}else
27138
27139	#ifndef SQLITE_OMIT_TRACE
	@@ -27166,11 +27886,11 @@
27166	}
27167	else if( optionMatch(z, "close") ){
27168	mType \|= SQLITE_TRACE_CLOSE;
27169	}
27170	else {
27171	raw_printf(stderr, "Unknown option \"%s\" on \".trace\"\n", z);
27172	rc = 1;
27173	goto meta_command_exit;
27174	}
27175	}else{
27176	output_file_close(p->traceOut);
	@@ -27190,11 +27910,11 @@
27190	if( c=='u' && cli_strncmp(azArg[0], "unmodule", n)==0 ){
27191	int ii;
27192	int lenOpt;
27193	char *zOpt;
27194	if( nArg<2 ){
27195	raw_printf(stderr, "Usage: .unmodule [--allexcept] NAME ...\n");
27196	rc = 1;
27197	goto meta_command_exit;
27198	}
27199	open_db(p, 0);
27200	zOpt = azArg[1];
	@@ -27212,100 +27932,100 @@
27212	#endif
27213
27214	#if SQLITE_USER_AUTHENTICATION
27215	if( c=='u' && cli_strncmp(azArg[0], "user", n)==0 ){
27216	if( nArg<2 ){
27217	raw_printf(stderr, "Usage: .user SUBCOMMAND ...\n");
27218	rc = 1;
27219	goto meta_command_exit;
27220	}
27221	open_db(p, 0);
27222	if( cli_strcmp(azArg[1],"login")==0 ){
27223	if( nArg!=4 ){
27224	raw_printf(stderr, "Usage: .user login USER PASSWORD\n");
27225	rc = 1;
27226	goto meta_command_exit;
27227	}
27228	rc = sqlite3_user_authenticate(p->db, azArg[2], azArg[3],
27229	strlen30(azArg[3]));
27230	if( rc ){
27231	utf8_printf(stderr, "Authentication failed for user %s\n", azArg[2]);
27232	rc = 1;
27233	}
27234	}else if( cli_strcmp(azArg[1],"add")==0 ){
27235	if( nArg!=5 ){
27236	raw_printf(stderr, "Usage: .user add USER PASSWORD ISADMIN\n");
27237	rc = 1;
27238	goto meta_command_exit;
27239	}
27240	rc = sqlite3_user_add(p->db, azArg[2], azArg[3], strlen30(azArg[3]),
27241	booleanValue(azArg[4]));
27242	if( rc ){
27243	raw_printf(stderr, "User-Add failed: %d\n", rc);
27244	rc = 1;
27245	}
27246	}else if( cli_strcmp(azArg[1],"edit")==0 ){
27247	if( nArg!=5 ){
27248	raw_printf(stderr, "Usage: .user edit USER PASSWORD ISADMIN\n");
27249	rc = 1;
27250	goto meta_command_exit;
27251	}
27252	rc = sqlite3_user_change(p->db, azArg[2], azArg[3], strlen30(azArg[3]),
27253	booleanValue(azArg[4]));
27254	if( rc ){
27255	raw_printf(stderr, "User-Edit failed: %d\n", rc);
27256	rc = 1;
27257	}
27258	}else if( cli_strcmp(azArg[1],"delete")==0 ){
27259	if( nArg!=3 ){
27260	raw_printf(stderr, "Usage: .user delete USER\n");
27261	rc = 1;
27262	goto meta_command_exit;
27263	}
27264	rc = sqlite3_user_delete(p->db, azArg[2]);
27265	if( rc ){
27266	raw_printf(stderr, "User-Delete failed: %d\n", rc);
27267	rc = 1;
27268	}
27269	}else{
27270	raw_printf(stderr, "Usage: .user login\|add\|edit\|delete ...\n");
27271	rc = 1;
27272	goto meta_command_exit;
27273	}
27274	}else
27275	#endif /* SQLITE_USER_AUTHENTICATION */
27276
27277	if( c=='v' && cli_strncmp(azArg[0], "version", n)==0 ){
27278	char zPtrSz = sizeof(void)==8 ? "64-bit" : "32-bit";
27279	utf8_printf(p->out, "SQLite %s %s\n" /extra-version-info/,
27280	sqlite3_libversion(), sqlite3_sourceid());
27281	#if SQLITE_HAVE_ZLIB
27282	utf8_printf(p->out, "zlib version %s\n", zlibVersion());
27283	#endif
27284	#define CTIMEOPT_VAL_(opt) #opt
27285	#define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt)
27286	#if defined(__clang__) && defined(__clang_major__)
27287	utf8_printf(p->out, "clang-" CTIMEOPT_VAL(__clang_major__) "."
27288	CTIMEOPT_VAL(__clang_minor__) "."
27289	CTIMEOPT_VAL(__clang_patchlevel__) " (%s)\n", zPtrSz);
27290	#elif defined(_MSC_VER)
27291	utf8_printf(p->out, "msvc-" CTIMEOPT_VAL(_MSC_VER) " (%s)\n", zPtrSz);
27292	#elif defined(__GNUC__) && defined(__VERSION__)
27293	utf8_printf(p->out, "gcc-" __VERSION__ " (%s)\n", zPtrSz);
27294	#endif
27295	}else
27296
27297	if( c=='v' && cli_strncmp(azArg[0], "vfsinfo", n)==0 ){
27298	const char *zDbName = nArg==2 ? azArg[1] : "main";
27299	sqlite3_vfs *pVfs = 0;
27300	if( p->db ){
27301	sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFS_POINTER, &pVfs);
27302	if( pVfs ){
27303	utf8_printf(p->out, "vfs.zName = \"%s\"\n", pVfs->zName);
27304	raw_printf(p->out, "vfs.iVersion = %d\n", pVfs->iVersion);
27305	raw_printf(p->out, "vfs.szOsFile = %d\n", pVfs->szOsFile);
27306	raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname);
27307	}
27308	}
27309	}else
27310
27311	if( c=='v' && cli_strncmp(azArg[0], "vfslist", n)==0 ){
	@@ -27313,17 +28033,17 @@
27313	sqlite3_vfs *pCurrent = 0;
27314	if( p->db ){
27315	sqlite3_file_control(p->db, "main", SQLITE_FCNTL_VFS_POINTER, &pCurrent);
27316	}
27317	for(pVfs=sqlite3_vfs_find(0); pVfs; pVfs=pVfs->pNext){
27318	utf8_printf(p->out, "vfs.zName = \"%s\"%s\n", pVfs->zName,
27319	pVfs==pCurrent ? " <--- CURRENT" : "");
27320	raw_printf(p->out, "vfs.iVersion = %d\n", pVfs->iVersion);
27321	raw_printf(p->out, "vfs.szOsFile = %d\n", pVfs->szOsFile);
27322	raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname);
27323	if( pVfs->pNext ){
27324	raw_printf(p->out, "-----------------------------------\n");
27325	}
27326	}
27327	}else
27328
27329	if( c=='v' && cli_strncmp(azArg[0], "vfsname", n)==0 ){
	@@ -27330,11 +28050,11 @@
27330	const char *zDbName = nArg==2 ? azArg[1] : "main";
27331	char *zVfsName = 0;
27332	if( p->db ){
27333	sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName);
27334	if( zVfsName ){
27335	utf8_printf(p->out, "%s\n", zVfsName);
27336	sqlite3_free(zVfsName);
27337	}
27338	}
27339	}else
27340
	@@ -27354,12 +28074,12 @@
27354	p->colWidth[j-1] = (int)integerValue(azArg[j]);
27355	}
27356	}else
27357
27358	{
27359	utf8_printf(stderr, "Error: unknown command or invalid arguments: "
27360	" \"%s\". Enter \".help\" for help\n", azArg[0]);
27361	rc = 1;
27362	}
27363
27364	meta_command_exit:
27365	if( p->outCount ){
	@@ -27545,26 +28265,26 @@
27545	sqlite3_snprintf(sizeof(zPrefix), zPrefix,
27546	"%s near line %d:", zErrorType, startline);
27547	}else{
27548	sqlite3_snprintf(sizeof(zPrefix), zPrefix, "%s:", zErrorType);
27549	}
27550	utf8_printf(stderr, "%s %s\n", zPrefix, zErrorTail);
27551	sqlite3_free(zErrMsg);
27552	zErrMsg = 0;
27553	return 1;
27554	}else if( ShellHasFlag(p, SHFLG_CountChanges) ){
27555	char zLineBuf[2000];
27556	sqlite3_snprintf(sizeof(zLineBuf), zLineBuf,
27557	"changes: %lld total_changes: %lld",
27558	sqlite3_changes64(p->db), sqlite3_total_changes64(p->db));
27559	raw_printf(p->out, "%s\n", zLineBuf);
27560	}
27561	return 0;
27562	}
27563
27564	static void echo_group_input(ShellState p, const char zDo){
27565	if( ShellHasFlag(p, SHFLG_Echo) ) utf8_printf(p->out, "%s\n", zDo);
27566	}
27567
27568	#ifdef SQLITE_SHELL_FIDDLE
27569	/*
27570	** Alternate one_input_line() impl for wasm mode. This is not in the primary
	@@ -27618,12 +28338,12 @@
27618	i64 startline = 0; /* Line number for start of current input */
27619	QuickScanState qss = QSS_Start; /* Accumulated line status (so far) */
27620
27621	if( p->inputNesting==MAX_INPUT_NESTING ){
27622	/* This will be more informative in a later version. */
27623	utf8_printf(stderr,"Input nesting limit (%d) reached at line %d."
27624	" Check recursion.\n", MAX_INPUT_NESTING, p->lineno);
27625	return 1;
27626	}
27627	++p->inputNesting;
27628	p->lineno = 0;
27629	CONTINUE_PROMPT_RESET;
	@@ -27630,11 +28350,11 @@
27630	while( errCnt==0 \|\| !bail_on_error \|\| (p->in==0 && stdin_is_interactive) ){
27631	fflush(p->out);
27632	zLine = one_input_line(p->in, zLine, nSql>0);
27633	if( zLine==0 ){
27634	/* End of input */
27635	if( p->in==0 && stdin_is_interactive ) printf("\n");
27636	break;
27637	}
27638	if( seenInterrupt ){
27639	if( p->in!=0 ) break;
27640	seenInterrupt = 0;
	@@ -27840,27 +28560,27 @@
27840	sqliterc = find_xdg_config();
27841	}
27842	if( sqliterc == NULL ){
27843	home_dir = find_home_dir(0);
27844	if( home_dir==0 ){
27845	raw_printf(stderr, "-- warning: cannot find home directory;"
27846	" cannot read ~/.sqliterc\n");
27847	return;
27848	}
27849	zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir);
27850	shell_check_oom(zBuf);
27851	sqliterc = zBuf;
27852	}
27853	p->in = fopen(sqliterc,"rb");
27854	if( p->in ){
27855	if( stdin_is_interactive ){
27856	utf8_printf(stderr,"-- Loading resources from %s\n",sqliterc);
27857	}
27858	if( process_input(p) && bail_on_error ) exit(1);
27859	fclose(p->in);
27860	}else if( sqliterc_override!=0 ){
27861	utf8_printf(stderr,"cannot open: \"%s\"\n", sqliterc);
27862	if( bail_on_error ) exit(1);
27863	}
27864	p->in = inSaved;
27865	p->lineno = savedLineno;
27866	sqlite3_free(zBuf);
	@@ -27906,13 +28626,10 @@
27906	" -mmap N default mmap size set to N\n"
27907	#ifdef SQLITE_ENABLE_MULTIPLEX
27908	" -multiplex enable the multiplexor VFS\n"
27909	#endif
27910	" -newline SEP set output row separator. Default: '\\n'\n"
27911	#if SHELL_WIN_UTF8_OPT
27912	" -no-utf8 do not try to set up UTF-8 output (for legacy)\n"
27913	#endif
27914	" -nofollow refuse to open symbolic links to database files\n"
27915	" -nonce STRING set the safe-mode escape nonce\n"
27916	" -nullvalue TEXT set text string for NULL values. Default ''\n"
27917	" -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n"
27918	" -pcachetrace trace all page cache operations\n"
	@@ -27925,13 +28642,10 @@
27925	#endif
27926	" -stats print memory stats before each finalize\n"
27927	" -table set output mode to 'table'\n"
27928	" -tabs set output mode to 'tabs'\n"
27929	" -unsafe-testing allow unsafe commands and modes for testing\n"
27930	#if SHELL_WIN_UTF8_OPT && 0 /* Option is accepted, but is now the default. */
27931	" -utf8 setup interactive console code page for UTF-8\n"
27932	#endif
27933	" -version show SQLite version\n"
27934	" -vfs NAME use NAME as the default VFS\n"
27935	#ifdef SQLITE_ENABLE_VFSTRACE
27936	" -vfstrace enable tracing of all VFS calls\n"
27937	#endif
	@@ -27938,18 +28652,17 @@
27938	#ifdef SQLITE_HAVE_ZLIB
27939	" -zip open the file as a ZIP Archive\n"
27940	#endif
27941	;
27942	static void usage(int showDetail){
27943	utf8_printf(stderr,
27944	"Usage: %s [OPTIONS] [FILENAME [SQL]]\n"
27945	"FILENAME is the name of an SQLite database. A new database is created\n"
27946	"if the file does not previously exist. Defaults to :memory:.\n", Argv0);
27947	if( showDetail ){
27948	utf8_printf(stderr, "OPTIONS include:\n%s", zOptions);
27949	}else{
27950	raw_printf(stderr, "Use the -help option for additional information\n");
27951	}
27952	exit(1);
27953	}
27954
27955	/*
	@@ -27956,12 +28669,12 @@
27956	** Internal check: Verify that the SQLite is uninitialized. Print a
27957	** error message if it is initialized.
27958	*/
27959	static void verify_uninitialized(void){
27960	if( sqlite3_config(-1)==SQLITE_MISUSE ){
27961	utf8_printf(stdout, "WARNING: attempt to configure SQLite after"
27962	" initialization.\n");
27963	}
27964	}
27965
27966	/*
27967	** Initialize the state information in data
	@@ -27986,46 +28699,45 @@
27986	}
27987
27988	/*
27989	** Output text to the console in a font that attracts extra attention.
27990	*/
27991	#ifdef _WIN32
27992	static void printBold(const char *zText){
27993	#if !SQLITE_OS_WINRT
27994	HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
27995	CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo;
27996	GetConsoleScreenBufferInfo(out, &defaultScreenInfo);
27997	SetConsoleTextAttribute(out,
27998	FOREGROUND_RED\|FOREGROUND_INTENSITY
27999	);
28000	#endif
28001	printf("%s", zText);
28002	#if !SQLITE_OS_WINRT
28003	SetConsoleTextAttribute(out, defaultScreenInfo.wAttributes);
28004	#endif
28005	}
28006	#else
28007	static void printBold(const char *zText){
28008	printf("\033[1m%s\033[0m", zText);
28009	}
28010	#endif
28011
28012	/*
28013	** Get the argument to an --option. Throw an error and die if no argument
28014	** is available.
28015	*/
28016	static char cmdline_option_value(int argc, char *argv, int i){
28017	if( i==argc ){
28018	utf8_printf(stderr, "%s: Error: missing argument to %s\n",
28019	argv[0], argv[argc-1]);
28020	exit(1);
28021	}
28022	return argv[i];
28023	}
28024
28025	static void sayAbnormalExit(void){
28026	if( seenInterrupt ) fprintf(stderr, "Program interrupted.\n");
28027	}
28028
28029	#ifndef SQLITE_SHELL_IS_UTF8
28030	# if (defined(_WIN32) \|\| defined(WIN32)) \
28031	&& (defined(_MSC_VER) \|\| (defined(UNICODE) && defined(__GNUC__)))
	@@ -28051,10 +28763,11 @@
28051	char *zErrMsg = 0;
28052	#ifdef SQLITE_SHELL_FIDDLE
28053	# define data shellState
28054	#else
28055	ShellState data;

28056	#endif
28057	const char *zInitFile = 0;
28058	int i;
28059	int rc = 0;
28060	int warnInmemoryDb = 0;
	@@ -28072,27 +28785,24 @@
28072	#ifdef SQLITE_SHELL_FIDDLE
28073	stdin_is_interactive = 0;
28074	stdout_is_console = 1;
28075	data.wasm.zDefaultDbName = "/fiddle.sqlite3";
28076	#else
28077	stdin_is_interactive = isatty(0);
28078	stdout_is_console = isatty(1);
28079	#endif
28080	#if SHELL_WIN_UTF8_OPT
28081	probe_console(); /* Check for console I/O and UTF-8 capability. */
28082	if( !mbcs_opted ) atexit(console_restore);
28083	#endif
28084	atexit(sayAbnormalExit);
28085	#ifdef SQLITE_DEBUG
28086	mem_main_enter = sqlite3_memory_used();
28087	#endif
28088	#if !defined(_WIN32_WCE)
28089	if( getenv("SQLITE_DEBUG_BREAK") ){
28090	if( isatty(0) && isatty(2) ){
28091	fprintf(stderr,
28092	"attach debugger to process %d and press any key to continue.\n",
28093	GETPID());
28094	fgetc(stdin);
28095	}else{
28096	#if defined(_WIN32) \|\| defined(WIN32)
28097	#if SQLITE_OS_WINRT
28098	__debugbreak();
	@@ -28108,18 +28818,18 @@
28108	/* Register a valid signal handler early, before much else is done. */
28109	#ifdef SIGINT
28110	signal(SIGINT, interrupt_handler);
28111	#elif (defined(_WIN32) \|\| defined(WIN32)) && !defined(_WIN32_WCE)
28112	if( !SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE) ){
28113	fprintf(stderr, "No ^C handler.\n");
28114	}
28115	#endif
28116
28117	#if USE_SYSTEM_SQLITE+0!=1
28118	if( cli_strncmp(sqlite3_sourceid(),SQLITE_SOURCE_ID,60)!=0 ){
28119	utf8_printf(stderr, "SQLite header and source version mismatch\n%s\n%s\n",
28120	sqlite3_sourceid(), SQLITE_SOURCE_ID);
28121	exit(1);
28122	}
28123	#endif
28124	main_init(&data);
28125
	@@ -28211,18 +28921,11 @@
28211	** informational messages (like from process_sqliterc) before
28212	** we do the actual processing of arguments later in a second pass.
28213	*/
28214	stdin_is_interactive = 0;
28215	}else if( cli_strcmp(z,"-utf8")==0 ){
28216	#if SHELL_WIN_UTF8_OPT
28217	/* Option accepted, but is ignored except for this diagnostic. */
28218	if( mbcs_opted ) fprintf(stderr, "Cannot do UTF-8 at this console.\n");
28219	#endif /* SHELL_WIN_UTF8_OPT */
28220	}else if( cli_strcmp(z,"-no-utf8")==0 ){
28221	#if SHELL_WIN_UTF8_OPT
28222	mbcs_opted = 1;
28223	#endif /* SHELL_WIN_UTF8_OPT */
28224	}else if( cli_strcmp(z,"-heap")==0 ){
28225	#if defined(SQLITE_ENABLE_MEMSYS3) \|\| defined(SQLITE_ENABLE_MEMSYS5)
28226	const char *zSize;
28227	sqlite3_int64 szHeap;
28228
	@@ -28353,30 +29056,21 @@
28353	if( zVfs ){
28354	sqlite3_vfs *pVfs = sqlite3_vfs_find(zVfs);
28355	if( pVfs ){
28356	sqlite3_vfs_register(pVfs, 1);
28357	}else{
28358	utf8_printf(stderr, "no such VFS: \"%s\"\n", zVfs);
28359	exit(1);
28360	}
28361	}
28362	#if SHELL_WIN_UTF8_OPT
28363	/* Get indicated Windows console setup done before running invocation commands. */
28364	if( in_console \|\| out_console ){
28365	console_prepare_utf8();
28366	}
28367	if( !in_console ){
28368	setBinaryMode(stdin, 0);
28369	}
28370	#endif
28371
28372	if( data.pAuxDb->zDbFilename==0 ){
28373	#ifndef SQLITE_OMIT_MEMORYDB
28374	data.pAuxDb->zDbFilename = ":memory:";
28375	warnInmemoryDb = argc==1;
28376	#else
28377	utf8_printf(stderr,"%s: Error: no database filename specified\n", Argv0);
28378	return 1;
28379	#endif
28380	}
28381	data.out = stdout;
28382	#ifndef SQLITE_SHELL_FIDDLE
	@@ -28489,12 +29183,12 @@
28489	*/
28490	ShellSetFlag(&data, SHFLG_Backslash);
28491	}else if( cli_strcmp(z,"-bail")==0 ){
28492	/* No-op. The bail_on_error flag should already be set. */
28493	}else if( cli_strcmp(z,"-version")==0 ){
28494	printf("%s %s (%d-bit)\n", sqlite3_libversion(), sqlite3_sourceid(),
28495	8(int)sizeof(char));
28496	return 0;
28497	}else if( cli_strcmp(z,"-interactive")==0 ){
28498	/* already handled */
28499	}else if( cli_strcmp(z,"-batch")==0 ){
28500	/* already handled */
	@@ -28546,22 +29240,22 @@
28546	if( rc && bail_on_error ) return rc==2 ? 0 : rc;
28547	}else{
28548	open_db(&data, 0);
28549	rc = shell_exec(&data, z, &zErrMsg);
28550	if( zErrMsg!=0 ){
28551	utf8_printf(stderr,"Error: %s\n", zErrMsg);
28552	if( bail_on_error ) return rc!=0 ? rc : 1;
28553	}else if( rc!=0 ){
28554	utf8_printf(stderr,"Error: unable to process SQL \"%s\"\n", z);
28555	if( bail_on_error ) return rc;
28556	}
28557	}
28558	#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB)
28559	}else if( cli_strncmp(z, "-A", 2)==0 ){
28560	if( nCmd>0 ){
28561	utf8_printf(stderr, "Error: cannot mix regular SQL or dot-commands"
28562	" with \"%s\"\n", z);
28563	return 1;
28564	}
28565	open_db(&data, OPEN_DB_ZIPFILE);
28566	if( z[2] ){
28567	argv[i] = &z[2];
	@@ -28575,12 +29269,12 @@
28575	}else if( cli_strcmp(z,"-safe")==0 ){
28576	data.bSafeMode = data.bSafeModePersist = 1;
28577	}else if( cli_strcmp(z,"-unsafe-testing")==0 ){
28578	/* Acted upon in first pass. */
28579	}else{
28580	utf8_printf(stderr,"%s: Error: unknown option: %s\n", Argv0, z);
28581	raw_printf(stderr,"Use -help for a list of options.\n");
28582	return 1;
28583	}
28584	data.cMode = data.mode;
28585	}
28586
	@@ -28600,13 +29294,13 @@
28600	open_db(&data, 0);
28601	echo_group_input(&data, azCmd[i]);
28602	rc = shell_exec(&data, azCmd[i], &zErrMsg);
28603	if( zErrMsg \|\| rc ){
28604	if( zErrMsg!=0 ){
28605	utf8_printf(stderr,"Error: %s\n", zErrMsg);
28606	}else{
28607	utf8_printf(stderr,"Error: unable to process SQL: %s\n", azCmd[i]);
28608	}
28609	sqlite3_free(zErrMsg);
28610	free(azCmd);
28611	return rc!=0 ? rc : 1;
28612	}
	@@ -28616,30 +29310,24 @@
28616	/* Run commands received from standard input
28617	*/
28618	if( stdin_is_interactive ){
28619	char *zHome;
28620	char *zHistory;
28621	const char *zCharset = "";
28622	int nHistory;
28623	#if SHELL_WIN_UTF8_OPT
28624	switch( console_utf8_in+2*console_utf8_out ){
28625	default: case 0: break;
28626	case 1: zCharset = " (utf8 in)"; break;
28627	case 2: zCharset = " (utf8 out)"; break;
28628	case 3: zCharset = " (utf8 I/O)"; break;
28629	}
28630	#endif
28631	printf(
28632	"SQLite version %s %.19s%s\n" /extra-version-info/
28633	"Enter \".help\" for usage hints.\n",
28634	sqlite3_libversion(), sqlite3_sourceid(), zCharset
28635	);
28636	if( warnInmemoryDb ){
28637	printf("Connected to a ");
28638	printBold("transient in-memory database");
28639	printf(".\nUse \".open FILENAME\" to reopen on a "
28640	"persistent database.\n");
28641	}
28642	zHistory = getenv("SQLITE_HISTORY");
28643	if( zHistory ){
28644	zHistory = strdup(zHistory);
28645	}else if( (zHome = find_home_dir(0))!=0 ){
	@@ -28695,12 +29383,12 @@
28695	/* Clear the global data structure so that valgrind will detect memory
28696	** leaks */
28697	memset(&data, 0, sizeof(data));
28698	#ifdef SQLITE_DEBUG
28699	if( sqlite3_memory_used()>mem_main_enter ){
28700	utf8_printf(stderr, "Memory leaked: %u bytes\n",
28701	(unsigned int)(sqlite3_memory_used()-mem_main_enter));
28702	}
28703	#endif
28704	#endif /* !SQLITE_SHELL_FIDDLE */
28705	return rc;
28706	}
28707

	--- extsrc/shell.c
	+++ extsrc/shell.c
	@@ -250,33 +250,1023 @@
250	#define WIN32_LEAN_AND_MEAN
251	#include <windows.h>
252
253	/* string conversion routines only needed on Win32 */
254	extern char *sqlite3_win32_unicode_to_utf8(LPCWSTR);


255	extern LPWSTR sqlite3_win32_utf8_to_unicode(const char *zText);
256	#endif
257
258	/* Use console I/O package as a direct INCLUDE. */
259	#define SQLITE_INTERNAL_LINKAGE static
260
261	#ifdef SQLITE_SHELL_FIDDLE
262	/* Deselect most features from the console I/O package for Fiddle. */
263	# define SQLITE_CIO_NO_REDIRECT
264	# define SQLITE_CIO_NO_CLASSIFY
265	# define SQLITE_CIO_NO_TRANSLATE
266	# define SQLITE_CIO_NO_SETMODE
267	#endif
268	/*********************** Begin ../ext/consio/console_io.h ****************/
269	/*
270	** 2023 November 1
271	**
272	** The author disclaims copyright to this source code. In place of
273	** a legal notice, here is a blessing:
274	**
275	** May you do good and not evil.
276	** May you find forgiveness for yourself and forgive others.
277	** May you share freely, never taking more than you give.
278	**
279	********************************************************************************
280	** This file exposes various interfaces used for console and other I/O
281	** by the SQLite project command-line tools. These interfaces are used
282	** at either source conglomeration time, compilation time, or run time.
283	** This source provides for either inclusion into conglomerated,
284	** "single-source" forms or separate compilation then linking.
285	**
286	** Platform dependencies are "hidden" here by various stratagems so
287	** that, provided certain conditions are met, the programs using this
288	** source or object code compiled from it need no explicit conditional
289	** compilation in their source for their console and stream I/O.
290	**
291	** The symbols and functionality exposed here are not a public API.
292	** This code may change in tandem with other project code as needed.
293	**
294	** When this .h file and its companion .c are directly incorporated into
295	** a source conglomeration (such as shell.c), the preprocessor symbol
296	** CIO_WIN_WC_XLATE is defined as 0 or 1, reflecting whether console I/O
297	** translation for Windows is effected for the build.
298	*/
299
300	#ifndef SQLITE_INTERNAL_LINKAGE
301	# define SQLITE_INTERNAL_LINKAGE extern /* external to translation unit */
302	# include <stdio.h>
303	#else
304	# define SHELL_NO_SYSINC /* Better yet, modify mkshellc.tcl for this. */
305	#endif
306
307	#ifndef SQLITE3_H
308	/* # include "sqlite3.h" */
309	#endif
310
311	#ifndef SQLITE_CIO_NO_CLASSIFY
312
313	/* Define enum for use with following function. */
314	typedef enum StreamsAreConsole {
315	SAC_NoConsole = 0,
316	SAC_InConsole = 1, SAC_OutConsole = 2, SAC_ErrConsole = 4,
317	SAC_AnyConsole = 0x7
318	} StreamsAreConsole;
319
320	/*
321	** Classify the three standard I/O streams according to whether
322	** they are connected to a console attached to the process.
323	**
324	** Returns the bit-wise OR of SAC_{In,Out,Err}Console values,
325	** or SAC_NoConsole if none of the streams reaches a console.
326	**
327	** This function should be called before any I/O is done with
328	** the given streams. As a side-effect, the given inputs are
329	** recorded so that later I/O operations on them may be done
330	** differently than the C library FILE* I/O would be done,
331	** iff the stream is used for the I/O functions that follow,
332	** and to support the ones that use an implicit stream.
333	**
334	** On some platforms, stream or console mode alteration (aka
335	** "Setup") may be made which is undone by consoleRestore().
336	*/
337	SQLITE_INTERNAL_LINKAGE StreamsAreConsole
338	consoleClassifySetup( FILE pfIn, FILE pfOut, FILE *pfErr );
339	/* A usual call for convenience: */
340	#define SQLITE_STD_CONSOLE_INIT() consoleClassifySetup(stdin,stdout,stderr)
341
342	/*
343	** After an initial call to consoleClassifySetup(...), renew
344	** the same setup it effected. (A call not after is an error.)
345	** This will restore state altered by consoleRestore();
346	**
347	** Applications which run an inferior (child) process which
348	** inherits the same I/O streams may call this function after
349	** such a process exits to guard against console mode changes.
350	*/
351	SQLITE_INTERNAL_LINKAGE void consoleRenewSetup(void);
352
353	/*
354	** Undo any side-effects left by consoleClassifySetup(...).
355	**
356	** This should be called after consoleClassifySetup() and
357	** before the process terminates normally. It is suitable
358	** for use with the atexit() C library procedure. After
359	** this call, no console I/O should be done until one of
360	** console{Classify or Renew}Setup(...) is called again.
361	**
362	** Applications which run an inferior (child) process that
363	** inherits the same I/O streams might call this procedure
364	** before so that said process will have a console setup
365	** however users have configured it or come to expect.
366	*/
367	SQLITE_INTERNAL_LINKAGE void SQLITE_CDECL consoleRestore( void );
368
369	#else /* defined(SQLITE_CIO_NO_CLASSIFY) */
370	# define consoleClassifySetup(i,o,e)
371	# define consoleRenewSetup()
372	# define consoleRestore()
373	#endif /* defined(SQLITE_CIO_NO_CLASSIFY) */
374
375	#ifndef SQLITE_CIO_NO_REDIRECT
376	/*
377	** Set stream to be used for the functions below which write
378	** to "the designated X stream", where X is Output or Error.
379	** Returns the previous value.
380	**
381	** Alternatively, pass the special value, invalidFileStream,
382	** to get the designated stream value without setting it.
383	**
384	** Before the designated streams are set, they default to
385	** those passed to consoleClassifySetup(...), and before
386	** that is called they default to stdout and stderr.
387	**
388	** It is error to close a stream so designated, then, without
389	** designating another, use the corresponding {o,e}Emit(...).
390	*/
391	SQLITE_INTERNAL_LINKAGE FILE *invalidFileStream;
392	SQLITE_INTERNAL_LINKAGE FILE setOutputStream(FILE pf);
393	# ifdef CONSIO_SET_ERROR_STREAM
394	SQLITE_INTERNAL_LINKAGE FILE setErrorStream(FILE pf);
395	# endif
396	#else
397	# define setOutputStream(pf)
398	# define setErrorStream(pf)
399	#endif /* !defined(SQLITE_CIO_NO_REDIRECT) */
400
401	#ifndef SQLITE_CIO_NO_TRANSLATE
402	/*
403	** Emit output like fprintf(). If the output is going to the
404	** console and translation from UTF-8 is necessary, perform
405	** the needed translation. Otherwise, write formatted output
406	** to the provided stream almost as-is, possibly with newline
407	** translation as specified by set{Binary,Text}Mode().
408	*/
409	SQLITE_INTERNAL_LINKAGE int fPrintfUtf8(FILE pfO, const char zFormat, ...);
410	/* Like fPrintfUtf8 except stream is always the designated output. */
411	SQLITE_INTERNAL_LINKAGE int oPrintfUtf8(const char *zFormat, ...);
412	/* Like fPrintfUtf8 except stream is always the designated error. */
413	SQLITE_INTERNAL_LINKAGE int ePrintfUtf8(const char *zFormat, ...);
414
415	/*
416	** Emit output like fputs(). If the output is going to the
417	** console and translation from UTF-8 is necessary, perform
418	** the needed translation. Otherwise, write given text to the
419	** provided stream almost as-is, possibly with newline
420	** translation as specified by set{Binary,Text}Mode().
421	*/
422	SQLITE_INTERNAL_LINKAGE int fPutsUtf8(const char z, FILE pfO);
423	/* Like fPutsUtf8 except stream is always the designated output. */
424	SQLITE_INTERNAL_LINKAGE int oPutsUtf8(const char *z);
425	/* Like fPutsUtf8 except stream is always the designated error. */
426	SQLITE_INTERNAL_LINKAGE int ePutsUtf8(const char *z);
427
428	/*
429	** Emit output like fPutsUtf8(), except that the length of the
430	** accepted char or character sequence is limited by nAccept.
431	**
432	** Returns the number of accepted char values.
433	*/
434	#ifdef CONSIO_SPUTB
435	SQLITE_INTERNAL_LINKAGE int
436	fPutbUtf8(FILE pfOut, const char cBuf, int nAccept);
437	#endif
438	/* Like fPutbUtf8 except stream is always the designated output. */
439	SQLITE_INTERNAL_LINKAGE int
440	oPutbUtf8(const char *cBuf, int nAccept);
441	/* Like fPutbUtf8 except stream is always the designated error. */
442	#ifdef CONSIO_EPUTB
443	SQLITE_INTERNAL_LINKAGE int
444	ePutbUtf8(const char *cBuf, int nAccept);
445	#endif
446
447	/*
448	** Collect input like fgets(...) with special provisions for input
449	** from the console on platforms that require same. Defers to the
450	** C library fgets() when input is not from the console. Newline
451	** translation may be done as set by set{Binary,Text}Mode(). As a
452	** convenience, pfIn==NULL is treated as stdin.
453	*/
454	SQLITE_INTERNAL_LINKAGE char* fGetsUtf8(char cBuf, int ncMax, FILE pfIn);
455	/* Like fGetsUtf8 except stream is always the designated input. */
456	/* SQLITE_INTERNAL_LINKAGE char* iGetsUtf8(char cBuf, int ncMax); /
457
458	#endif /* !defined(SQLITE_CIO_NO_TRANSLATE) */
459
460	#ifndef SQLITE_CIO_NO_SETMODE
461	/*
462	** Set given stream for binary mode, where newline translation is
463	** not done, or for text mode where, for some platforms, newlines
464	** are translated to the platform's conventional char sequence.
465	** If bFlush true, flush the stream.
466	**
467	** An additional side-effect is that if the stream is one passed
468	** to consoleClassifySetup() as an output, it is flushed first.
469	**
470	** Note that binary/text mode has no effect on console I/O
471	** translation. On all platforms, newline to the console starts
472	** a new line and CR,LF chars from the console become a newline.
473	*/
474	SQLITE_INTERNAL_LINKAGE void setBinaryMode(FILE *, short bFlush);
475	SQLITE_INTERNAL_LINKAGE void setTextMode(FILE *, short bFlush);
476	#endif
477
478	#ifdef SQLITE_CIO_PROMPTED_IN
479	typedef struct Prompts {
480	int numPrompts;
481	const char **azPrompts;
482	} Prompts;
483
484	/*
485	** Macros for use of a line editor.
486	**
487	** The following macros define operations involving use of a
488	** line-editing library or simple console interaction.
489	** A "T" argument is a text (char *) buffer or filename.
490	** A "N" argument is an integer.
491	**
492	** SHELL_ADD_HISTORY(T) // Record text as line(s) of history.
493	** SHELL_READ_HISTORY(T) // Read history from file named by T.
494	** SHELL_WRITE_HISTORY(T) // Write history to file named by T.
495	** SHELL_STIFLE_HISTORY(N) // Limit history to N entries.
496	**
497	** A console program which does interactive console input is
498	** expected to call:
499	** SHELL_READ_HISTORY(T) before collecting such input;
500	** SHELL_ADD_HISTORY(T) as record-worthy input is taken;
501	** SHELL_STIFLE_HISTORY(N) after console input ceases; then
502	** SHELL_WRITE_HISTORY(T) before the program exits.
503	*/
504
505	/*
506	** Retrieve a single line of input text from an input stream.
507	**
508	** If pfIn is the input stream passed to consoleClassifySetup(),
509	** and azPrompt is not NULL, then a prompt is issued before the
510	** line is collected, as selected by the isContinuation flag.
511	** Array azPrompt[{0,1}] holds the {main,continuation} prompt.
512	**
513	** If zBufPrior is not NULL then it is a buffer from a prior
514	** call to this routine that can be reused, or will be freed.
515	**
516	** The result is stored in space obtained from malloc() and
517	** must either be freed by the caller or else passed back to
518	** this function as zBufPrior for reuse.
519	**
520	** This function may call upon services of a line-editing
521	** library to interactively collect line edited input.
522	*/
523	SQLITE_INTERNAL_LINKAGE char *
524	shellGetLine(FILE pfIn, char zBufPrior, int nLen,
525	short isContinuation, Prompts azPrompt);
526	#endif /* defined(SQLITE_CIO_PROMPTED_IN) */
527	/*
528	** TBD: Define an interface for application(s) to generate
529	** completion candidates for use by the line-editor.
530	**
531	** This may be premature; the CLI is the only application
532	** that does this. Yet, getting line-editing melded into
533	** console I/O is desirable because a line-editing library
534	** may have to establish console operating mode, possibly
535	** in a way that interferes with the above functionality.
536	*/
537
538	#if !(defined(SQLITE_CIO_NO_UTF8SCAN)&&defined(SQLITE_CIO_NO_TRANSLATE))
539	/* Skip over as much z[] input char sequence as is valid UTF-8,
540	** limited per nAccept char's or whole characters and containing
541	** no char cn such that ((1<<cn) & ccm)!=0. On return, the
542	** sequence z:return (inclusive:exclusive) is validated UTF-8.
543	** Limit: nAccept>=0 => char count, nAccept<0 => character
544	*/
545	SQLITE_INTERNAL_LINKAGE const char*
546	zSkipValidUtf8(const char *z, int nAccept, long ccm);
547
548	#endif
549
550	/*********************** End ../ext/consio/console_io.h ******************/
551	/*********************** Begin ../ext/consio/console_io.c ****************/
552	/*
553	** 2023 November 4
554	**
555	** The author disclaims copyright to this source code. In place of
556	** a legal notice, here is a blessing:
557	**
558	** May you do good and not evil.
559	** May you find forgiveness for yourself and forgive others.
560	** May you share freely, never taking more than you give.
561	**
562	********************************************************************************
563	** This file implements various interfaces used for console and stream I/O
564	** by the SQLite project command-line tools, as explained in console_io.h .
565	** Functions prefixed by "SQLITE_INTERNAL_LINKAGE" behave as described there.
566	*/
567
568	#ifndef SQLITE_CDECL
569	# define SQLITE_CDECL
570	#endif
571
572	#ifndef SHELL_NO_SYSINC
573	# include <stdarg.h>
574	# include <string.h>
575	# include <stdlib.h>
576	# include <limits.h>
577	# include <assert.h>
578	# include "console_io.h"
579	/* # include "sqlite3.h" */
580	#endif
581
582	#ifndef SQLITE_CIO_NO_TRANSLATE
583	# if (defined(_WIN32) \|\| defined(WIN32)) && !SQLITE_OS_WINRT
584	# ifndef SHELL_NO_SYSINC
585	# include <io.h>
586	# include <fcntl.h>
587	# undef WIN32_LEAN_AND_MEAN
588	# define WIN32_LEAN_AND_MEAN
589	# include <windows.h>
590	# endif
591	# define CIO_WIN_WC_XLATE 1 /* Use WCHAR Windows APIs for console I/O */
592	# else
593	# ifndef SHELL_NO_SYSINC
594	# include <unistd.h>
595	# endif
596	# define CIO_WIN_WC_XLATE 0 /* Use plain C library stream I/O at console */
597	# endif
598	#else
599	# define CIO_WIN_WC_XLATE 0 /* Not exposing translation routines at all */
600	#endif
601
602	#if CIO_WIN_WC_XLATE
603	/* Character used to represent a known-incomplete UTF-8 char group (�) */
604	static WCHAR cBadGroup = 0xfffd;
605	#endif
606
607	#if CIO_WIN_WC_XLATE
608	static HANDLE handleOfFile(FILE *pf){
609	int fileDesc = _fileno(pf);
610	union { intptr_t osfh; HANDLE fh; } fid = {
611	(fileDesc>=0)? _get_osfhandle(fileDesc) : (intptr_t)INVALID_HANDLE_VALUE
612	};
613	return fid.fh;
614	}
615	#endif
616
617	#ifndef SQLITE_CIO_NO_TRANSLATE
618	typedef struct PerStreamTags {
619	# if CIO_WIN_WC_XLATE
620	HANDLE hx;
621	DWORD consMode;
622	char acIncomplete[4];
623	# else
624	short reachesConsole;
625	# endif
626	FILE *pf;
627	} PerStreamTags;
628
629	/* Define NULL-like value for things which can validly be 0. */
630	# define SHELL_INVALID_FILE_PTR ((FILE *)~0)
631	# if CIO_WIN_WC_XLATE
632	# define SHELL_INVALID_CONS_MODE 0xFFFF0000
633	# endif
634
635	# if CIO_WIN_WC_XLATE
636	# define PST_INITIALIZER { INVALID_HANDLE_VALUE, SHELL_INVALID_CONS_MODE, \
637	{0,0,0,0}, SHELL_INVALID_FILE_PTR }
638	# else
639	# define PST_INITIALIZER { 0, SHELL_INVALID_FILE_PTR }
640	# endif
641
642	/* Quickly say whether a known output is going to the console. */
643	# if CIO_WIN_WC_XLATE
644	static short pstReachesConsole(PerStreamTags *ppst){
645	return (ppst->hx != INVALID_HANDLE_VALUE);
646	}
647	# else
648	# define pstReachesConsole(ppst) 0
649	# endif
650
651	# if CIO_WIN_WC_XLATE
652	static void restoreConsoleArb(PerStreamTags *ppst){
653	if( pstReachesConsole(ppst) ) SetConsoleMode(ppst->hx, ppst->consMode);
654	}
655	# else
656	# define restoreConsoleArb(ppst)
657	# endif
658
659	/* Say whether FILE* appears to be a console, collect associated info. */
660	static short streamOfConsole(FILE pf, / out / PerStreamTags ppst){
661	# if CIO_WIN_WC_XLATE
662	short rv = 0;
663	DWORD dwCM = SHELL_INVALID_CONS_MODE;
664	HANDLE fh = handleOfFile(pf);
665	ppst->pf = pf;
666	if( INVALID_HANDLE_VALUE != fh ){
667	rv = (GetFileType(fh) == FILE_TYPE_CHAR && GetConsoleMode(fh,&dwCM));
668	}
669	ppst->hx = (rv)? fh : INVALID_HANDLE_VALUE;
670	ppst->consMode = dwCM;
671	return rv;
672	# else
673	ppst->pf = pf;
674	ppst->reachesConsole = ( (short)isatty(fileno(pf)) );
675	return ppst->reachesConsole;
676	# endif
677	}
678
679	# if CIO_WIN_WC_XLATE
680	/* Define console modes for use with the Windows Console API. */
681	# define SHELL_CONI_MODE \
682	(ENABLE_ECHO_INPUT \| ENABLE_INSERT_MODE \| ENABLE_LINE_INPUT \| 0x80 \
683	\| ENABLE_QUICK_EDIT_MODE \| ENABLE_EXTENDED_FLAGS \| ENABLE_PROCESSED_INPUT)
684	# define SHELL_CONO_MODE (ENABLE_PROCESSED_OUTPUT \| ENABLE_WRAP_AT_EOL_OUTPUT \
685	\| ENABLE_VIRTUAL_TERMINAL_PROCESSING)
686	# endif
687
688	typedef struct ConsoleInfo {
689	PerStreamTags pstSetup[3];
690	PerStreamTags pstDesignated[3];
691	StreamsAreConsole sacSetup;
692	} ConsoleInfo;
693
694	static short isValidStreamInfo(PerStreamTags *ppst){
695	return (ppst->pf != SHELL_INVALID_FILE_PTR);
696	}
697
698	static ConsoleInfo consoleInfo = {
699	{ /* pstSetup */ PST_INITIALIZER, PST_INITIALIZER, PST_INITIALIZER },
700	{ /* pstDesignated[] */ PST_INITIALIZER, PST_INITIALIZER, PST_INITIALIZER },
701	SAC_NoConsole /* sacSetup */
702	};
703
704	SQLITE_INTERNAL_LINKAGE FILE* invalidFileStream = (FILE *)~0;
705
706	# if CIO_WIN_WC_XLATE
707	static void maybeSetupAsConsole(PerStreamTags *ppst, short odir){
708	if( pstReachesConsole(ppst) ){
709	DWORD cm = odir? SHELL_CONO_MODE : SHELL_CONI_MODE;
710	SetConsoleMode(ppst->hx, cm);
711	}
712	}
713	# else
714	# define maybeSetupAsConsole(ppst,odir)
715	# endif
716
717	SQLITE_INTERNAL_LINKAGE void consoleRenewSetup(void){
718	# if CIO_WIN_WC_XLATE
719	int ix = 0;
720	while( ix < 6 ){
721	PerStreamTags *ppst = (ix<3)?
722	&consoleInfo.pstSetup[ix] : &consoleInfo.pstDesignated[ix-3];
723	maybeSetupAsConsole(ppst, (ix % 3)>0);
724	++ix;
725	}
726	# endif
727	}
728
729	SQLITE_INTERNAL_LINKAGE StreamsAreConsole
730	consoleClassifySetup( FILE pfIn, FILE pfOut, FILE *pfErr ){
731	StreamsAreConsole rv = SAC_NoConsole;
732	FILE* apf[3] = { pfIn, pfOut, pfErr };
733	int ix;
734	for( ix = 2; ix >= 0; --ix ){
735	PerStreamTags *ppst = &consoleInfo.pstSetup[ix];
736	if( streamOfConsole(apf[ix], ppst) ){
737	rv \|= (SAC_InConsole<<ix);
738	}
739	consoleInfo.pstDesignated[ix] = *ppst;
740	if( ix > 0 ) fflush(apf[ix]);
741	}
742	consoleInfo.sacSetup = rv;
743	consoleRenewSetup();
744	return rv;
745	}
746
747	SQLITE_INTERNAL_LINKAGE void SQLITE_CDECL consoleRestore( void ){
748	# if CIO_WIN_WC_XLATE
749	static ConsoleInfo *pci = &consoleInfo;
750	if( pci->sacSetup ){
751	int ix;
752	for( ix=0; ix<3; ++ix ){
753	if( pci->sacSetup & (SAC_InConsole<<ix) ){
754	PerStreamTags *ppst = &pci->pstSetup[ix];
755	SetConsoleMode(ppst->hx, ppst->consMode);
756	}
757	}
758	}
759	# endif
760	}
761	#endif /* !defined(SQLITE_CIO_NO_TRANSLATE) */
762
763	#ifdef SQLITE_CIO_INPUT_REDIR
764	/* Say whether given FILE* is among those known, via either
765	** consoleClassifySetup() or set{Output,Error}Stream, as
766	** readable, and return an associated PerStreamTags pointer
767	** if so. Otherwise, return 0.
768	*/
769	static PerStreamTags * isKnownReadable(FILE *pf){
770	static PerStreamTags *apst[] = {
771	&consoleInfo.pstDesignated[0], &consoleInfo.pstSetup[0], 0
772	};
773	int ix = 0;
774	do {
775	if( apst[ix]->pf == pf ) break;
776	} while( apst[++ix] != 0 );
777	return apst[ix];
778	}
779	#endif
780
781	#ifndef SQLITE_CIO_NO_TRANSLATE
782	/* Say whether given FILE* is among those known, via either
783	** consoleClassifySetup() or set{Output,Error}Stream, as
784	** writable, and return an associated PerStreamTags pointer
785	** if so. Otherwise, return 0.
786	*/
787	static PerStreamTags * isKnownWritable(FILE *pf){
788	static PerStreamTags *apst[] = {
789	&consoleInfo.pstDesignated[1], &consoleInfo.pstDesignated[2],
790	&consoleInfo.pstSetup[1], &consoleInfo.pstSetup[2], 0
791	};
792	int ix = 0;
793	do {
794	if( apst[ix]->pf == pf ) break;
795	} while( apst[++ix] != 0 );
796	return apst[ix];
797	}
798
799	static FILE designateEmitStream(FILE pf, unsigned chix){
800	FILE *rv = consoleInfo.pstDesignated[chix].pf;
801	if( pf == invalidFileStream ) return rv;
802	else{
803	/* Setting a possibly new output stream. */
804	PerStreamTags *ppst = isKnownWritable(pf);
805	if( ppst != 0 ){
806	PerStreamTags pst = *ppst;
807	consoleInfo.pstDesignated[chix] = pst;
808	}else streamOfConsole(pf, &consoleInfo.pstDesignated[chix]);
809	}
810	return rv;
811	}
812
813	SQLITE_INTERNAL_LINKAGE FILE setOutputStream(FILE pf){
814	return designateEmitStream(pf, 1);
815	}
816	# ifdef CONSIO_SET_ERROR_STREAM
817	SQLITE_INTERNAL_LINKAGE FILE setErrorStream(FILE pf){
818	return designateEmitStream(pf, 2);
819	}
820	# endif
821	#endif /* !defined(SQLITE_CIO_NO_TRANSLATE) */
822
823	#ifndef SQLITE_CIO_NO_SETMODE
824	# if CIO_WIN_WC_XLATE
825	static void setModeFlushQ(FILE *pf, short bFlush, int mode){
826	if( bFlush ) fflush(pf);
827	_setmode(_fileno(pf), mode);
828	}
829	# else
830	# define setModeFlushQ(f, b, m) if(b) fflush(f)
831	# endif
832
833	SQLITE_INTERNAL_LINKAGE void setBinaryMode(FILE *pf, short bFlush){
834	setModeFlushQ(pf, bFlush, _O_BINARY);
835	}
836	SQLITE_INTERNAL_LINKAGE void setTextMode(FILE *pf, short bFlush){
837	setModeFlushQ(pf, bFlush, _O_TEXT);
838	}
839	# undef setModeFlushQ
840
841	#else /* defined(SQLITE_CIO_NO_SETMODE) */
842	# define setBinaryMode(f, bFlush) do{ if((bFlush)) fflush(f); }while(0)
843	# define setTextMode(f, bFlush) do{ if((bFlush)) fflush(f); }while(0)
844	#endif /* defined(SQLITE_CIO_NO_SETMODE) */
845
846	#ifndef SQLITE_CIO_NO_TRANSLATE
847	# if CIO_WIN_WC_XLATE
848	/* Write buffer cBuf as output to stream known to reach console,
849	** limited to ncTake char's. Return ncTake on success, else 0. */
850	static int conZstrEmit(PerStreamTags ppst, const char z, int ncTake){
851	int rv = 0;
852	if( z!=NULL ){
853	int nwc = MultiByteToWideChar(CP_UTF8,0, z,ncTake, 0,0);
854	if( nwc > 0 ){
855	WCHAR zw = sqlite3_malloc64(nwcsizeof(WCHAR));
856	if( zw!=NULL ){
857	nwc = MultiByteToWideChar(CP_UTF8,0, z,ncTake, zw,nwc);
858	if( nwc > 0 ){
859	/* Translation from UTF-8 to UTF-16, then WCHARs out. */
860	if( WriteConsoleW(ppst->hx, zw,nwc, 0, NULL) ){
861	rv = ncTake;
862	}
863	}
864	sqlite3_free(zw);
865	}
866	}
867	}
868	return rv;
869	}
870
871	/* For {f,o,e}PrintfUtf8() when stream is known to reach console. */
872	static int conioVmPrintf(PerStreamTags ppst, const char zFormat, va_list ap){
873	char *z = sqlite3_vmprintf(zFormat, ap);
874	if( z ){
875	int rv = conZstrEmit(ppst, z, (int)strlen(z));
876	sqlite3_free(z);
877	return rv;
878	}else return 0;
879	}
880	# endif /* CIO_WIN_WC_XLATE */
881
882	# ifdef CONSIO_GET_EMIT_STREAM
883	static PerStreamTags * getDesignatedEmitStream(FILE *pf, unsigned chix,
884	PerStreamTags *ppst){
885	PerStreamTags *rv = isKnownWritable(pf);
886	short isValid = (rv!=0)? isValidStreamInfo(rv) : 0;
887	if( rv != 0 && isValid ) return rv;
888	streamOfConsole(pf, ppst);
889	return ppst;
890	}
891	# endif
892
893	/* Get stream info, either for designated output or error stream when
894	** chix equals 1 or 2, or for an arbitrary stream when chix == 0.
895	** In either case, ppst references a caller-owned PerStreamTags
896	** struct which may be filled in if none of the known writable
897	** streams is being held by consoleInfo. The ppf parameter is a
898	** byref output when chix!=0 and a byref input when chix==0.
899	*/
900	static PerStreamTags *
901	getEmitStreamInfo(unsigned chix, PerStreamTags *ppst,
902	/* in/out / FILE *ppf){
903	PerStreamTags *ppstTry;
904	FILE *pfEmit;
905	if( chix > 0 ){
906	ppstTry = &consoleInfo.pstDesignated[chix];
907	if( !isValidStreamInfo(ppstTry) ){
908	ppstTry = &consoleInfo.pstSetup[chix];
909	pfEmit = ppst->pf;
910	}else pfEmit = ppstTry->pf;
911	if( !isValidStreamInfo(ppstTry) ){
912	pfEmit = (chix > 1)? stderr : stdout;
913	ppstTry = ppst;
914	streamOfConsole(pfEmit, ppstTry);
915	}
916	*ppf = pfEmit;
917	}else{
918	ppstTry = isKnownWritable(*ppf);
919	if( ppstTry != 0 ) return ppstTry;
920	streamOfConsole(*ppf, ppst);
921	return ppst;
922	}
923	return ppstTry;
924	}
925
926	SQLITE_INTERNAL_LINKAGE int oPrintfUtf8(const char *zFormat, ...){
927	va_list ap;
928	int rv;
929	FILE *pfOut;
930	PerStreamTags pst = PST_INITIALIZER; /* for unknown streams */
931	# if CIO_WIN_WC_XLATE
932	PerStreamTags *ppst = getEmitStreamInfo(1, &pst, &pfOut);
933	# else
934	getEmitStreamInfo(1, &pst, &pfOut);
935	# endif
936	assert(zFormat!=0);
937	va_start(ap, zFormat);
938	# if CIO_WIN_WC_XLATE
939	if( pstReachesConsole(ppst) ){
940	rv = conioVmPrintf(ppst, zFormat, ap);
941	}else{
942	# endif
943	rv = vfprintf(pfOut, zFormat, ap);
944	# if CIO_WIN_WC_XLATE
945	}
946	# endif
947	va_end(ap);
948	return rv;
949	}
950
951	SQLITE_INTERNAL_LINKAGE int ePrintfUtf8(const char *zFormat, ...){
952	va_list ap;
953	int rv;
954	FILE *pfErr;
955	PerStreamTags pst = PST_INITIALIZER; /* for unknown streams */
956	# if CIO_WIN_WC_XLATE
957	PerStreamTags *ppst = getEmitStreamInfo(2, &pst, &pfErr);
958	# else
959	getEmitStreamInfo(2, &pst, &pfErr);
960	# endif
961	assert(zFormat!=0);
962	va_start(ap, zFormat);
963	# if CIO_WIN_WC_XLATE
964	if( pstReachesConsole(ppst) ){
965	rv = conioVmPrintf(ppst, zFormat, ap);
966	}else{
967	# endif
968	rv = vfprintf(pfErr, zFormat, ap);
969	# if CIO_WIN_WC_XLATE
970	}
971	# endif
972	va_end(ap);
973	return rv;
974	}
975
976	SQLITE_INTERNAL_LINKAGE int fPrintfUtf8(FILE pfO, const char zFormat, ...){
977	va_list ap;
978	int rv;
979	PerStreamTags pst = PST_INITIALIZER; /* for unknown streams */
980	# if CIO_WIN_WC_XLATE
981	PerStreamTags *ppst = getEmitStreamInfo(0, &pst, &pfO);
982	# else
983	getEmitStreamInfo(0, &pst, &pfO);
984	# endif
985	assert(zFormat!=0);
986	va_start(ap, zFormat);
987	# if CIO_WIN_WC_XLATE
988	if( pstReachesConsole(ppst) ){
989	maybeSetupAsConsole(ppst, 1);
990	rv = conioVmPrintf(ppst, zFormat, ap);
991	if( 0 == isKnownWritable(ppst->pf) ) restoreConsoleArb(ppst);
992	}else{
993	# endif
994	rv = vfprintf(pfO, zFormat, ap);
995	# if CIO_WIN_WC_XLATE
996	}
997	# endif
998	va_end(ap);
999	return rv;
1000	}
1001
1002	SQLITE_INTERNAL_LINKAGE int fPutsUtf8(const char z, FILE pfO){
1003	PerStreamTags pst = PST_INITIALIZER; /* for unknown streams */
1004	# if CIO_WIN_WC_XLATE
1005	PerStreamTags *ppst = getEmitStreamInfo(0, &pst, &pfO);
1006	# else
1007	getEmitStreamInfo(0, &pst, &pfO);
1008	# endif
1009	assert(z!=0);
1010	# if CIO_WIN_WC_XLATE
1011	if( pstReachesConsole(ppst) ){
1012	int rv;
1013	maybeSetupAsConsole(ppst, 1);
1014	rv = conZstrEmit(ppst, z, (int)strlen(z));
1015	if( 0 == isKnownWritable(ppst->pf) ) restoreConsoleArb(ppst);
1016	return rv;
1017	}else {
1018	# endif
1019	return (fputs(z, pfO)<0)? 0 : (int)strlen(z);
1020	# if CIO_WIN_WC_XLATE
1021	}
1022	# endif
1023	}
1024
1025	SQLITE_INTERNAL_LINKAGE int ePutsUtf8(const char *z){
1026	FILE *pfErr;
1027	PerStreamTags pst = PST_INITIALIZER; /* for unknown streams */
1028	# if CIO_WIN_WC_XLATE
1029	PerStreamTags *ppst = getEmitStreamInfo(2, &pst, &pfErr);
1030	# else
1031	getEmitStreamInfo(2, &pst, &pfErr);
1032	# endif
1033	assert(z!=0);
1034	# if CIO_WIN_WC_XLATE
1035	if( pstReachesConsole(ppst) ) return conZstrEmit(ppst, z, (int)strlen(z));
1036	else {
1037	# endif
1038	return (fputs(z, pfErr)<0)? 0 : (int)strlen(z);
1039	# if CIO_WIN_WC_XLATE
1040	}
1041	# endif
1042	}
1043
1044	SQLITE_INTERNAL_LINKAGE int oPutsUtf8(const char *z){
1045	FILE *pfOut;
1046	PerStreamTags pst = PST_INITIALIZER; /* for unknown streams */
1047	# if CIO_WIN_WC_XLATE
1048	PerStreamTags *ppst = getEmitStreamInfo(1, &pst, &pfOut);
1049	# else
1050	getEmitStreamInfo(1, &pst, &pfOut);
1051	# endif
1052	assert(z!=0);
1053	# if CIO_WIN_WC_XLATE
1054	if( pstReachesConsole(ppst) ) return conZstrEmit(ppst, z, (int)strlen(z));
1055	else {
1056	# endif
1057	return (fputs(z, pfOut)<0)? 0 : (int)strlen(z);
1058	# if CIO_WIN_WC_XLATE
1059	}
1060	# endif
1061	}
1062
1063	#endif /* !defined(SQLITE_CIO_NO_TRANSLATE) */
1064
1065	#if !(defined(SQLITE_CIO_NO_UTF8SCAN) && defined(SQLITE_CIO_NO_TRANSLATE))
1066	/* Skip over as much z[] input char sequence as is valid UTF-8,
1067	** limited per nAccept char's or whole characters and containing
1068	** no char cn such that ((1<<cn) & ccm)!=0. On return, the
1069	** sequence z:return (inclusive:exclusive) is validated UTF-8.
1070	** Limit: nAccept>=0 => char count, nAccept<0 => character
1071	*/
1072	SQLITE_INTERNAL_LINKAGE const char*
1073	zSkipValidUtf8(const char *z, int nAccept, long ccm){
1074	int ng = (nAccept<0)? -nAccept : 0;
1075	const char *pcLimit = (nAccept>=0)? z+nAccept : 0;
1076	assert(z!=0);
1077	while( (pcLimit)? (z<pcLimit) : (ng-- != 0) ){
1078	char c = *z;
1079	if( (c & 0x80) == 0 ){
1080	if( ccm != 0L && c < 0x20 && ((1L<<c) & ccm) != 0 ) return z;
1081	++z; /* ASCII */
1082	}else if( (c & 0xC0) != 0xC0 ) return z; /* not a lead byte */
1083	else{
1084	const char zt = z+1; / Got lead byte, look at trail bytes.*/
1085	do{
1086	if( pcLimit && zt >= pcLimit ) return z;
1087	else{
1088	char ct = *zt++;
1089	if( ct==0 \|\| (zt-z)>4 \|\| (ct & 0xC0)!=0x80 ){
1090	/* Trailing bytes are too few, too many, or invalid. */
1091	return z;
1092	}
1093	}
1094	} while( ((c <<= 1) & 0x40) == 0x40 ); /* Eat lead byte's count. */
1095	z = zt;
1096	}
1097	}
1098	return z;
1099	}
1100	#endif /!(defined(SQLITE_CIO_NO_UTF8SCAN)&&defined(SQLITE_CIO_NO_TRANSLATE))/
1101
1102	#ifndef SQLITE_CIO_NO_TRANSLATE
1103
1104	#ifdef CONSIO_SPUTB
1105	SQLITE_INTERNAL_LINKAGE int
1106	fPutbUtf8(FILE pfO, const char cBuf, int nAccept){
1107	assert(pfO!=0);
1108	# if CIO_WIN_WC_XLATE
1109	PerStreamTags pst = PST_INITIALIZER; /* for unknown streams */
1110	PerStreamTags *ppst = getEmitStreamInfo(0, &pst, &pfO);
1111	if( pstReachesConsole(ppst) ){
1112	int rv;
1113	maybeSetupAsConsole(ppst, 1);
1114	rv = conZstrEmit(ppst, cBuf, nAccept);
1115	if( 0 == isKnownWritable(ppst->pf) ) restoreConsoleArb(ppst);
1116	return rv;
1117	}else {
1118	# endif
1119	return (int)fwrite(cBuf, 1, nAccept, pfO);
1120	# if CIO_WIN_WC_XLATE
1121	}
1122	# endif
1123	}
1124	#endif /* defined(CONSIO_SPUTB) */
1125
1126	SQLITE_INTERNAL_LINKAGE int
1127	oPutbUtf8(const char *cBuf, int nAccept){
1128	FILE *pfOut;
1129	PerStreamTags pst = PST_INITIALIZER; /* for unknown streams */
1130	# if CIO_WIN_WC_XLATE
1131	PerStreamTags *ppst = getEmitStreamInfo(1, &pst, &pfOut);
1132	# else
1133	getEmitStreamInfo(1, &pst, &pfOut);
1134	# endif
1135	# if CIO_WIN_WC_XLATE
1136	if( pstReachesConsole(ppst) ){
1137	return conZstrEmit(ppst, cBuf, nAccept);
1138	}else {
1139	# endif
1140	return (int)fwrite(cBuf, 1, nAccept, pfOut);
1141	# if CIO_WIN_WC_XLATE
1142	}
1143	# endif
1144	}
1145
1146	# ifdef CONSIO_EPUTB
1147	SQLITE_INTERNAL_LINKAGE int
1148	ePutbUtf8(const char *cBuf, int nAccept){
1149	FILE *pfErr;
1150	PerStreamTags pst = PST_INITIALIZER; /* for unknown streams */
1151	PerStreamTags *ppst = getEmitStreamInfo(2, &pst, &pfErr);
1152	# if CIO_WIN_WC_XLATE
1153	if( pstReachesConsole(ppst) ){
1154	return conZstrEmit(ppst, cBuf, nAccept);
1155	}else {
1156	# endif
1157	return (int)fwrite(cBuf, 1, nAccept, pfErr);
1158	# if CIO_WIN_WC_XLATE
1159	}
1160	# endif
1161	}
1162	# endif /* defined(CONSIO_EPUTB) */
1163
1164	SQLITE_INTERNAL_LINKAGE char* fGetsUtf8(char cBuf, int ncMax, FILE pfIn){
1165	if( pfIn==0 ) pfIn = stdin;
1166	# if CIO_WIN_WC_XLATE
1167	if( pfIn == consoleInfo.pstSetup[0].pf
1168	&& (consoleInfo.sacSetup & SAC_InConsole)!=0 ){
1169	# if CIO_WIN_WC_XLATE==1
1170	# define SHELL_GULP 150 /* Count of WCHARS to be gulped at a time */
1171	WCHAR wcBuf[SHELL_GULP+1];
1172	int lend = 0, noc = 0;
1173	if( ncMax > 0 ) cBuf[0] = 0;
1174	while( noc < ncMax-8-1 && !lend ){
1175	/* There is room for at least 2 more characters and a 0-terminator. */
1176	int na = (ncMax > SHELL_GULP*4+1 + noc)? SHELL_GULP : (ncMax-1 - noc)/4;
1177	# undef SHELL_GULP
1178	DWORD nbr = 0;
1179	BOOL bRC = ReadConsoleW(consoleInfo.pstSetup[0].hx, wcBuf, na, &nbr, 0);
1180	if( bRC && nbr>0 && (wcBuf[nbr-1]&0xF800)==0xD800 ){
1181	/* Last WHAR read is first of a UTF-16 surrogate pair. Grab its mate. */
1182	DWORD nbrx;
1183	bRC &= ReadConsoleW(consoleInfo.pstSetup[0].hx, wcBuf+nbr, 1, &nbrx, 0);
1184	if( bRC ) nbr += nbrx;
1185	}
1186	if( !bRC \|\| (noc==0 && nbr==0) ) return 0;
1187	if( nbr > 0 ){
1188	int nmb = WideCharToMultiByte(CP_UTF8, 0, wcBuf,nbr,0,0,0,0);
1189	if( nmb != 0 && noc+nmb <= ncMax ){
1190	int iseg = noc;
1191	nmb = WideCharToMultiByte(CP_UTF8, 0, wcBuf,nbr,cBuf+noc,nmb,0,0);
1192	noc += nmb;
1193	/* Fixup line-ends as coded by Windows for CR (or "Enter".)
1194	** This is done without regard for any setMode{Text,Binary}()
1195	** call that might have been done on the interactive input.
1196	*/
1197	if( noc > 0 ){
1198	if( cBuf[noc-1]=='\n' ){
1199	lend = 1;
1200	if( noc > 1 && cBuf[noc-2]=='\r' ) cBuf[--noc-1] = '\n';
1201	}
1202	}
1203	/* Check for ^Z (anywhere in line) too, to act as EOF. */
1204	while( iseg < noc ){
1205	if( cBuf[iseg]=='\x1a' ){
1206	noc = iseg; /* Chop ^Z and anything following. */
1207	lend = 1; /* Counts as end of line too. */
1208	break;
1209	}
1210	++iseg;
1211	}
1212	}else break; /* Drop apparent garbage in. (Could assert.) */
1213	}else break;
1214	}
1215	/* If got nothing, (after ^Z chop), must be at end-of-file. */
1216	if( noc > 0 ){
1217	cBuf[noc] = 0;
1218	return cBuf;
1219	}else return 0;
1220	# endif
1221	}else{
1222	# endif
1223	return fgets(cBuf, ncMax, pfIn);
1224	# if CIO_WIN_WC_XLATE
1225	}
1226	# endif
1227	}
1228	#endif /* !defined(SQLITE_CIO_NO_TRANSLATE) */
1229
1230	#undef SHELL_INVALID_FILE_PTR
1231
1232	/*********************** End ../ext/consio/console_io.c ******************/
1233
1234	#ifndef SQLITE_SHELL_FIDDLE
1235	/* From here onward, fgets() is redirected to the console_io library. */
1236	# define fgets(b,n,f) fGetsUtf8(b,n,f)
1237	/*
1238	* Define macros for emitting output text in various ways:
1239	* sputz(s, z) => emit 0-terminated string z to given stream s
1240	* sputf(s, f, ...) => emit varargs per format f to given stream s
1241	* oputz(z) => emit 0-terminated string z to default stream
1242	* oputf(f, ...) => emit varargs per format f to default stream
1243	* eputz(z) => emit 0-terminated string z to error stream
1244	* eputf(f, ...) => emit varargs per format f to error stream
1245	* oputb(b, n) => emit char buffer b[0..n-1] to default stream
1246	*
1247	* Note that the default stream is whatever has been last set via:
1248	* setOutputStream(FILE *pf)
1249	* This is normally the stream that CLI normal output goes to.
1250	* For the stand-alone CLI, it is stdout with no .output redirect.
1251	*/
1252	# define sputz(s,z) fPutsUtf8(z,s)
1253	# define sputf fPrintfUtf8
1254	# define oputz(z) oPutsUtf8(z)
1255	# define oputf oPrintfUtf8
1256	# define eputz(z) ePutsUtf8(z)
1257	# define eputf ePrintfUtf8
1258	# define oputb(buf,na) oPutbUtf8(buf,na)
1259	#else
1260	/* For Fiddle, all console handling and emit redirection is omitted. */
1261	# define sputz(fp,z) fputs(z,fp)
1262	# define sputf(fp,fmt, ...) fprintf(fp,fmt,__VA_ARGS__)
1263	# define oputz(z) fputs(z,stdout)
1264	# define oputf(fmt, ...) printf(fmt,__VA_ARGS__)
1265	# define eputz(z) fputs(z,stderr)
1266	# define eputf(fmt, ...) fprintf(stderr,fmt,__VA_ARGS__)
1267	# define oputb(buf,na) fwrite(buf,1,na,stdout)
1268	#endif
1269
1270	/* True if the timer is enabled */
1271	static int enableTimer = 0;
1272
	@@ -347,14 +1337,14 @@
1337	static void endTimer(void){
1338	if( enableTimer ){
1339	sqlite3_int64 iEnd = timeOfDay();
1340	struct rusage sEnd;
1341	getrusage(RUSAGE_SELF, &sEnd);
1342	oputf("Run Time: real %.3f user %f sys %f\n",
1343	(iEnd - iBegin)*0.001,
1344	timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
1345	timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
1346	}
1347	}
1348
1349	#define BEGIN_TIMER beginTimer()
1350	#define END_TIMER endTimer()
	@@ -426,14 +1416,14 @@
1416	static void endTimer(void){
1417	if( enableTimer && getProcessTimesAddr){
1418	FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd;
1419	sqlite3_int64 ftWallEnd = timeOfDay();
1420	getProcessTimesAddr(hProcess,&ftCreation,&ftExit,&ftKernelEnd,&ftUserEnd);
1421	oputf("Run Time: real %.3f user %f sys %f\n",
1422	(ftWallEnd - ftWallBegin)*0.001,
1423	timeDiff(&ftUserBegin, &ftUserEnd),
1424	timeDiff(&ftKernelBegin, &ftKernelEnd));
1425	}
1426	}
1427
1428	#define BEGIN_TIMER beginTimer()
1429	#define END_TIMER endTimer()
	@@ -466,32 +1456,13 @@
1456	** is true. Otherwise, assume stdin is connected to a file or pipe.
1457	*/
1458	static int stdin_is_interactive = 1;
1459
1460	/*
1461	** On Windows systems we need to know if standard output is a console
1462	** in order to show that UTF-16 translation is done in the sign-on
1463	** banner. The following variable is true if it is the console.



















1464	*/
1465	static int stdout_is_console = 1;
1466
1467	/*
1468	** The following is the open SQLite database. We make a pointer
	@@ -609,255 +1580,21 @@
1580	shell_strncpy(dynPrompt.dynamicPrompt, ")x!", 4);
1581	}else{
1582	shell_strncpy(dynPrompt.dynamicPrompt, "(x.", 4);
1583	dynPrompt.dynamicPrompt[2] = (char)('0'+dynPrompt.inParenLevel);
1584	}
1585	shell_strncpy(dynPrompt.dynamicPrompt+3, continuePrompt+3,
1586	PROMPT_LEN_MAX-4);
1587	}
1588	}
1589	return dynPrompt.dynamicPrompt;
1590	}
1591	#endif /* !defined(SQLITE_OMIT_DYNAPROMPT) */
1592











































































































































































































































1593	/* Indicate out-of-memory and exit. */
1594	static void shell_out_of_memory(void){
1595	eputz("Error: out of memory\n");
1596	exit(1);
1597	}
1598
1599	/* Check a pointer to see if it is NULL. If it is NULL, exit with an
1600	** out-of-memory error.
	@@ -885,22 +1622,22 @@
1622	char *z;
1623	if( iotrace==0 ) return;
1624	va_start(ap, zFormat);
1625	z = sqlite3_vmprintf(zFormat, ap);
1626	va_end(ap);
1627	sputf(iotrace, "%s", z);
1628	sqlite3_free(z);
1629	}
1630	#endif
1631
1632	/*
1633	** Output string zUtf to Out stream as w characters. If w is negative,
1634	** then right-justify the text. W is the width in UTF-8 characters, not
1635	** in bytes. This is different from the %.s specification in printf
1636	** since with %.s the width is measured in bytes, not characters.
1637	*/
1638	static void utf8_width_print(int w, const char *zUtf){
1639	int i;
1640	int n;
1641	int aw = w<0 ? -w : w;
1642	if( zUtf==0 ) zUtf = "";
1643	for(i=n=0; zUtf[i]; i++){
	@@ -911,15 +1648,15 @@
1648	break;
1649	}
1650	}
1651	}
1652	if( n>=aw ){
1653	oputf("%.*s", i, zUtf);
1654	}else if( w<0 ){
1655	oputf("%*s%s", aw-n, "", zUtf);
1656	}else{
1657	oputf("%s%*s", zUtf, aw-n, "");
1658	}
1659	}
1660
1661
1662	/*
	@@ -975,11 +1712,11 @@
1712	** Return open FILE * if zFile exists, can be opened for read
1713	** and is an ordinary file or a character stream source.
1714	** Otherwise return 0.
1715	*/
1716	static FILE * openChrSource(const char *zFile){
1717	#if defined(_WIN32) \|\| defined(WIN32)
1718	struct _stat x = {0};
1719	# define STAT_CHR_SRC(mode) ((mode & (_S_IFCHR\|_S_IFIFO\|_S_IFREG))!=0)
1720	/* On Windows, open first, then check the stream nature. This order
1721	** is necessary because _stat() and sibs, when checking a named pipe,
1722	** effectively break the pipe as its supplier sees it. */
	@@ -1038,27 +1775,10 @@
1775	if( n>0 && zLine[n-1]=='\r' ) n--;
1776	zLine[n] = 0;
1777	break;
1778	}
1779	}

















1780	return zLine;
1781	}
1782
1783	/*
1784	** Retrieve a single line of input text.
	@@ -1081,11 +1801,11 @@
1801	if( in!=0 ){
1802	zResult = local_getline(zPrior, in);
1803	}else{
1804	zPrompt = isContinuation ? CONTINUATION_PROMPT : mainPrompt;
1805	#if SHELL_USE_LOCAL_GETLINE
1806	sputz(stdout, zPrompt);
1807	fflush(stdout);
1808	do{
1809	zResult = local_getline(zPrior, stdin);
1810	zPrior = 0;
1811	/* ^C trap creates a false EOF, so let "interrupt" thread catch up. */
	@@ -1328,11 +2048,11 @@
2048	double r = sqlite3_value_double(apVal[0]);
2049	int n = nVal>=2 ? sqlite3_value_int(apVal[1]) : 26;
2050	char z[400];
2051	if( n<1 ) n = 1;
2052	if( n>350 ) n = 350;
2053	sqlite3_snprintf(sizeof(z), z, "%#+.*e", n, r);
2054	sqlite3_result_text(pCtx, z, -1, SQLITE_TRANSIENT);
2055	}
2056
2057
2058	/*
	@@ -17614,11 +18334,11 @@
18334	** A callback for the sqlite3_log() interface.
18335	*/
18336	static void shellLog(void pArg, int iErrCode, const char zMsg){
18337	ShellState p = (ShellState)pArg;
18338	if( p->pLog==0 ) return;
18339	sputf(p->pLog, "(%d) %s\n", iErrCode, zMsg);
18340	fflush(p->pLog);
18341	}
18342
18343	/*
18344	** SQL function: shell_putsnl(X)
	@@ -17629,13 +18349,13 @@
18349	static void shellPutsFunc(
18350	sqlite3_context *pCtx,
18351	int nVal,
18352	sqlite3_value **apVal
18353	){
18354	/* Unused: (ShellState)sqlite3_user_data(pCtx); /
18355	(void)nVal;
18356	oputf("%s\n", sqlite3_value_text(apVal[0]));
18357	sqlite3_result_value(pCtx, apVal[0]);
18358	}
18359
18360	/*
18361	** If in safe mode, print an error message described by the arguments
	@@ -17650,12 +18370,11 @@
18370	va_list ap;
18371	char *zMsg;
18372	va_start(ap, zErrMsg);
18373	zMsg = sqlite3_vmprintf(zErrMsg, ap);
18374	va_end(ap);
18375	eputf("line %d: %s\n", p->lineno, zMsg);

18376	exit(1);
18377	}
18378	}
18379
18380	/*
	@@ -17819,11 +18538,11 @@
18538	}
18539
18540	/*
18541	** Output the given string as a hex-encoded blob (eg. X'1234' )
18542	*/
18543	static void output_hex_blob(const void *pBlob, int nBlob){
18544	int i;
18545	unsigned char aBlob = (unsigned char)pBlob;
18546
18547	char zStr = sqlite3_malloc(nBlob2 + 1);
18548	shell_check_oom(zStr);
	@@ -17836,11 +18555,11 @@
18555	zStr[i*2] = aHex[ (aBlob[i] >> 4) ];
18556	zStr[i*2+1] = aHex[ (aBlob[i] & 0x0F) ];
18557	}
18558	zStr[i*2] = '\0';
18559
18560	oputf("X'%s'", zStr);
18561	sqlite3_free(zStr);
18562	}
18563
18564	/*
18565	** Find a string that is not found anywhere in z[]. Return a pointer
	@@ -17866,39 +18585,46 @@
18585	/*
18586	** Output the given string as a quoted string using SQL quoting conventions.
18587	**
18588	** See also: output_quoted_escaped_string()
18589	*/
18590	static void output_quoted_string(const char *z){
18591	int i;
18592	char c;
18593	#ifndef SQLITE_SHELL_FIDDLE
18594	FILE *pfO = setOutputStream(invalidFileStream);
18595	setBinaryMode(pfO, 1);
18596	#endif
18597	if( z==0 ) return;
18598	for(i=0; (c = z[i])!=0 && c!='\''; i++){}
18599	if( c==0 ){
18600	oputf("'%s'",z);
18601	}else{
18602	oputz("'");
18603	while( *z ){
18604	for(i=0; (c = z[i])!=0 && c!='\''; i++){}
18605	if( c=='\'' ) i++;
18606	if( i ){
18607	oputf("%.*s", i, z);
18608	z += i;
18609	}
18610	if( c=='\'' ){
18611	oputz("'");
18612	continue;
18613	}
18614	if( c==0 ){
18615	break;
18616	}
18617	z++;
18618	}
18619	oputz("'");
18620	}
18621	#ifndef SQLITE_SHELL_FIDDLE
18622	setTextMode(pfO, 1);
18623	#else
18624	setTextMode(stdout, 1);
18625	#endif
18626	}
18627
18628	/*
18629	** Output the given string as a quoted string using SQL quoting conventions.
18630	** Additionallly , escape the "\n" and "\r" characters so that they do not
	@@ -17906,17 +18632,20 @@
18632	** systems.
18633	**
18634	** This is like output_quoted_string() but with the addition of the \r\n
18635	** escape mechanism.
18636	*/
18637	static void output_quoted_escaped_string(const char *z){
18638	int i;
18639	char c;
18640	#ifndef SQLITE_SHELL_FIDDLE
18641	FILE *pfO = setOutputStream(invalidFileStream);
18642	setBinaryMode(pfO, 1);
18643	#endif
18644	for(i=0; (c = z[i])!=0 && c!='\'' && c!='\n' && c!='\r'; i++){}
18645	if( c==0 ){
18646	oputf("'%s'",z);
18647	}else{
18648	const char *zNL = 0;
18649	const char *zCR = 0;
18650	int nNL = 0;
18651	int nCR = 0;
	@@ -17924,121 +18653,167 @@
18653	for(i=0; z[i]; i++){
18654	if( z[i]=='\n' ) nNL++;
18655	if( z[i]=='\r' ) nCR++;
18656	}
18657	if( nNL ){
18658	oputz("replace(");
18659	zNL = unused_string(z, "\\n", "\\012", zBuf1);
18660	}
18661	if( nCR ){
18662	oputz("replace(");
18663	zCR = unused_string(z, "\\r", "\\015", zBuf2);
18664	}
18665	oputz("'");
18666	while( *z ){
18667	for(i=0; (c = z[i])!=0 && c!='\n' && c!='\r' && c!='\''; i++){}
18668	if( c=='\'' ) i++;
18669	if( i ){
18670	oputf("%.*s", i, z);
18671	z += i;
18672	}
18673	if( c=='\'' ){
18674	oputz("'");
18675	continue;
18676	}
18677	if( c==0 ){
18678	break;
18679	}
18680	z++;
18681	if( c=='\n' ){
18682	oputz(zNL);
18683	continue;
18684	}
18685	oputz(zCR);
18686	}
18687	oputz("'");
18688	if( nCR ){
18689	oputf(",'%s',char(13))", zCR);
18690	}
18691	if( nNL ){
18692	oputf(",'%s',char(10))", zNL);
18693	}
18694	}
18695	#ifndef SQLITE_SHELL_FIDDLE
18696	setTextMode(pfO, 1);
18697	#else
18698	setTextMode(stdout, 1);
18699	#endif
18700	}
18701
18702	/*
18703	** Find earliest of chars within s specified in zAny.
18704	** With ns == ~0, is like strpbrk(s,zAny) and s must be 0-terminated.
18705	*/
18706	static const char anyOfInStr(const char s, const char *zAny, size_t ns){
18707	const char *pcFirst = 0;
18708	if( ns == ~(size_t)0 ) ns = strlen(s);
18709	while(*zAny){
18710	const char pc = (const char)memchr(s, *zAny&0xff, ns);
18711	if( pc ){
18712	pcFirst = pc;
18713	ns = pcFirst - s;
18714	}
18715	++zAny;
18716	}
18717	return pcFirst;
18718	}
18719	/*
18720	** Output the given string as a quoted according to C or TCL quoting rules.
18721	*/
18722	static void output_c_string(const char *z){
18723	char c;
18724	static const char *zq = "\"";
18725	static long ctrlMask = ~0L;
18726	static const char zDQBSRO = "\"\\\x7f"; / double-quote, backslash, rubout */
18727	char ace[3] = "\\?";
18728	char cbsSay;
18729	oputz(zq);
18730	while( *z!=0 ){
18731	const char *pcDQBSRO = anyOfInStr(z, zDQBSRO, ~(size_t)0);
18732	const char *pcPast = zSkipValidUtf8(z, INT_MAX, ctrlMask);
18733	const char *pcEnd = (pcDQBSRO && pcDQBSRO < pcPast)? pcDQBSRO : pcPast;
18734	if( pcEnd > z ) oputb(z, (int)(pcEnd-z));
18735	if( (c = *pcEnd)==0 ) break;
18736	++pcEnd;
18737	switch( c ){
18738	case '\\': case '"':
18739	cbsSay = (char)c;
18740	break;
18741	case '\t': cbsSay = 't'; break;
18742	case '\n': cbsSay = 'n'; break;
18743	case '\r': cbsSay = 'r'; break;
18744	case '\f': cbsSay = 'f'; break;
18745	default: cbsSay = 0; break;
18746	}
18747	if( cbsSay ){
18748	ace[1] = cbsSay;
18749	oputz(ace);
18750	}else if( !isprint(c&0xff) ){
18751	oputf("\\%03o", c&0xff);
18752	}else{
18753	ace[1] = (char)c;
18754	oputz(ace+1);
18755	}
18756	z = pcEnd;
18757	}
18758	oputz(zq);
18759	}
18760
18761	/*
18762	** Output the given string as a quoted according to JSON quoting rules.
18763	*/
18764	static void output_json_string(const char *z, i64 n){
18765	char c;
18766	static const char *zq = "\"";
18767	static long ctrlMask = ~0L;
18768	static const char *zDQBS = "\"\\";
18769	const char *pcLimit;
18770	char ace[3] = "\\?";
18771	char cbsSay;
18772
18773	if( z==0 ) z = "";
18774	pcLimit = z + ((n<0)? strlen(z) : (size_t)n);
18775	oputz(zq);
18776	while( z < pcLimit ){
18777	const char *pcDQBS = anyOfInStr(z, zDQBS, pcLimit-z);
18778	const char *pcPast = zSkipValidUtf8(z, (int)(pcLimit-z), ctrlMask);
18779	const char *pcEnd = (pcDQBS && pcDQBS < pcPast)? pcDQBS : pcPast;
18780	if( pcEnd > z ){
18781	oputb(z, (int)(pcEnd-z));
18782	z = pcEnd;
18783	}
18784	if( z >= pcLimit ) break;
18785	c = *(z++);
18786	switch( c ){
18787	case '"': case '\\':
18788	cbsSay = (char)c;
18789	break;
18790	case '\b': cbsSay = 'b'; break;
18791	case '\f': cbsSay = 'f'; break;
18792	case '\n': cbsSay = 'n'; break;
18793	case '\r': cbsSay = 'r'; break;
18794	case '\t': cbsSay = 't'; break;
18795	default: cbsSay = 0; break;
18796	}
18797	if( cbsSay ){
18798	ace[1] = cbsSay;
18799	oputz(ace);
18800	}else if( c<=0x1f ){
18801	oputf("u%04x", c);
18802	}else{
18803	ace[1] = (char)c;
18804	oputz(ace+1);
18805	}
18806	}
18807	oputz(zq);












18808	}
18809
18810	/*
18811	** Output the given string with characters that are special to
18812	** HTML escaped.
18813	*/
18814	static void output_html_string(const char *z){
18815	int i;
18816	if( z==0 ) z = "";
18817	while( *z ){
18818	for(i=0; z[i]
18819	&& z[i]!='<'
	@@ -18046,22 +18821,22 @@
18821	&& z[i]!='>'
18822	&& z[i]!='\"'
18823	&& z[i]!='\'';
18824	i++){}
18825	if( i>0 ){
18826	oputf("%.*s",i,z);
18827	}
18828	if( z[i]=='<' ){
18829	oputz("<");
18830	}else if( z[i]=='&' ){
18831	oputz("&");
18832	}else if( z[i]=='>' ){
18833	oputz(">");
18834	}else if( z[i]=='\"' ){
18835	oputz(""");
18836	}else if( z[i]=='\'' ){
18837	oputz("'");
18838	}else{
18839	break;
18840	}
18841	z += i + 1;
18842	}
	@@ -18095,13 +18870,12 @@
18870	** the separator, which may or may not be a comma. p->nullValue is
18871	** the null value. Strings are quoted if necessary. The separator
18872	** is only issued if bSep is true.
18873	*/
18874	static void output_csv(ShellState p, const char z, int bSep){

18875	if( z==0 ){
18876	oputf("%s",p->nullValue);
18877	}else{
18878	unsigned i;
18879	for(i=0; z[i]; i++){
18880	if( needCsvQuote[((unsigned char*)z)[i]] ){
18881	i = 0;
	@@ -18109,18 +18883,18 @@
18883	}
18884	}
18885	if( i==0 \|\| strstr(z, p->colSeparator)!=0 ){
18886	char *zQuoted = sqlite3_mprintf("\"%w\"", z);
18887	shell_check_oom(zQuoted);
18888	oputz(zQuoted);
18889	sqlite3_free(zQuoted);
18890	}else{
18891	oputz(z);
18892	}
18893	}
18894	if( bSep ){
18895	oputz(p->colSeparator);
18896	}
18897	}
18898
18899	/*
18900	** This routine runs when the user presses Ctrl-C
	@@ -18224,20 +18998,20 @@
18998	const char *az[4];
18999	az[0] = zA1;
19000	az[1] = zA2;
19001	az[2] = zA3;
19002	az[3] = zA4;
19003	oputf("authorizer: %s", azAction[op]);
19004	for(i=0; i<4; i++){
19005	oputz(" ");
19006	if( az[i] ){
19007	output_c_string(az[i]);
19008	}else{
19009	oputz("NULL");
19010	}
19011	}
19012	oputz("\n");
19013	if( p->bSafeMode ) (void)safeModeAuth(pClientData, op, zA1, zA2, zA3, zA4);
19014	return SQLITE_OK;
19015	}
19016	#endif
19017
	@@ -18249,11 +19023,11 @@
19023	**
19024	** If the schema statement in z[] contains a start-of-comment and if
19025	** sqlite3_complete() returns false, try to terminate the comment before
19026	** printing the result. https://sqlite.org/forum/forumpost/d7be961c5c
19027	*/
19028	static void printSchemaLine(const char z, const char zTail){
19029	char *zToFree = 0;
19030	if( z==0 ) return;
19031	if( zTail==0 ) return;
19032	if( zTail[0]==';' && (strstr(z, "/*")!=0 \|\| strstr(z,"--")!=0) ){
19033	const char *zOrig = z;
	@@ -18271,20 +19045,20 @@
19045	}
19046	sqlite3_free(zNew);
19047	}
19048	}
19049	if( sqlite3_strglob("CREATE TABLE ['\"]*", z)==0 ){
19050	oputf("CREATE TABLE IF NOT EXISTS %s%s", z+13, zTail);
19051	}else{
19052	oputf("%s%s", z, zTail);
19053	}
19054	sqlite3_free(zToFree);
19055	}
19056	static void printSchemaLineN(char z, int n, const char zTail){
19057	char c = z[n];
19058	z[n] = 0;
19059	printSchemaLine(z, zTail);
19060	z[n] = c;
19061	}
19062
19063	/*
19064	** Return true if string z[] has nothing but whitespace and comments to the
	@@ -18308,11 +19082,11 @@
19082	EQPGraphRow *pNew;
19083	i64 nText;
19084	if( zText==0 ) return;
19085	nText = strlen(zText);
19086	if( p->autoEQPtest ){
19087	oputf("%d,%d,%s\n", iEqpId, p2, zText);
19088	}
19089	pNew = sqlite3_malloc64( sizeof(*pNew) + nText );
19090	shell_check_oom(pNew);
19091	pNew->iEqpId = iEqpId;
19092	pNew->iParentId = p2;
	@@ -18356,12 +19130,11 @@
19130	i64 n = strlen(p->sGraph.zPrefix);
19131	char *z;
19132	for(pRow = eqp_next_row(p, iEqpId, 0); pRow; pRow = pNext){
19133	pNext = eqp_next_row(p, iEqpId, pRow);
19134	z = pRow->zText;
19135	oputf("%s%s%s\n", p->sGraph.zPrefix, pNext ? "\|--" : "`--", z);

19136	if( n<(i64)sizeof(p->sGraph.zPrefix)-7 ){
19137	memcpy(&p->sGraph.zPrefix[n], pNext ? "\| " : " ", 4);
19138	eqp_render_level(p, pRow->iEqpId);
19139	p->sGraph.zPrefix[n] = 0;
19140	}
	@@ -18377,17 +19150,17 @@
19150	if( pRow->zText[0]=='-' ){
19151	if( pRow->pNext==0 ){
19152	eqp_reset(p);
19153	return;
19154	}
19155	oputf("%s\n", pRow->zText+3);
19156	p->sGraph.pRow = pRow->pNext;
19157	sqlite3_free(pRow);
19158	}else if( nCycle>0 ){
19159	oputf("QUERY PLAN (cycles=%lld [100%%])\n", nCycle);
19160	}else{
19161	oputz("QUERY PLAN\n");
19162	}
19163	p->sGraph.zPrefix[0] = 0;
19164	eqp_render_level(p, 0);
19165	eqp_reset(p);
19166	}
	@@ -18399,33 +19172,33 @@
19172	*/
19173	static int progress_handler(void *pClientData) {
19174	ShellState p = (ShellState)pClientData;
19175	p->nProgress++;
19176	if( p->nProgress>=p->mxProgress && p->mxProgress>0 ){
19177	oputf("Progress limit reached (%u)\n", p->nProgress);
19178	if( p->flgProgress & SHELL_PROGRESS_RESET ) p->nProgress = 0;
19179	if( p->flgProgress & SHELL_PROGRESS_ONCE ) p->mxProgress = 0;
19180	return 1;
19181	}
19182	if( (p->flgProgress & SHELL_PROGRESS_QUIET)==0 ){
19183	oputf("Progress %u\n", p->nProgress);
19184	}
19185	return 0;
19186	}
19187	#endif /* SQLITE_OMIT_PROGRESS_CALLBACK */
19188
19189	/*
19190	** Print N dashes
19191	*/
19192	static void print_dashes(int N){
19193	const char zDash[] = "--------------------------------------------------";
19194	const int nDash = sizeof(zDash) - 1;
19195	while( N>nDash ){
19196	oputz(zDash);
19197	N -= nDash;
19198	}
19199	oputf("%.*s", N, zDash);
19200	}
19201
19202	/*
19203	** Print a markdown or table-style row separator using ascii-art
19204	*/
	@@ -18434,19 +19207,19 @@
19207	int nArg,
19208	const char *zSep
19209	){
19210	int i;
19211	if( nArg>0 ){
19212	oputz(zSep);
19213	print_dashes(p->actualWidth[0]+2);
19214	for(i=1; i<nArg; i++){
19215	oputz(zSep);
19216	print_dashes(p->actualWidth[i]+2);
19217	}
19218	oputz(zSep);
19219	}
19220	oputz("\n");
19221	}
19222
19223	/*
19224	** This is the callback routine that the shell
19225	** invokes for each row of a query result.
	@@ -18472,14 +19245,14 @@
19245	if( azArg==0 ) break;
19246	for(i=0; i<nArg; i++){
19247	int len = strlen30(azCol[i] ? azCol[i] : "");
19248	if( len>w ) w = len;
19249	}
19250	if( p->cnt++>0 ) oputz(p->rowSeparator);
19251	for(i=0; i<nArg; i++){
19252	oputf("%*s = %s%s", w, azCol[i],
19253	azArg[i] ? azArg[i] : p->nullValue, p->rowSeparator);
19254	}
19255	break;
19256	}
19257	case MODE_ScanExp:
19258	case MODE_Explain: {
	@@ -18502,16 +19275,16 @@
19275	if( nArg>nWidth ) nArg = nWidth;
19276
19277	/* If this is the first row seen, print out the headers */
19278	if( p->cnt++==0 ){
19279	for(i=0; i<nArg; i++){
19280	utf8_width_print(aWidth[i], azCol[ aMap[i] ]);
19281	oputz(i==nArg-1 ? "\n" : " ");
19282	}
19283	for(i=0; i<nArg; i++){
19284	print_dashes(aWidth[i]);
19285	oputz(i==nArg-1 ? "\n" : " ");
19286	}
19287	}
19288
19289	/* If there is no data, exit early. */
19290	if( azArg==0 ) break;
	@@ -18525,21 +19298,21 @@
19298	w = strlenChar(zVal);
19299	zSep = " ";
19300	}
19301	if( i==iIndent && p->aiIndent && p->pStmt ){
19302	if( p->iIndent<p->nIndent ){
19303	oputf("%*.s", p->aiIndent[p->iIndent], "");
19304	}
19305	p->iIndent++;
19306	}
19307	utf8_width_print(w, zVal ? zVal : p->nullValue);
19308	oputz(i==nArg-1 ? "\n" : zSep);
19309	}
19310	break;
19311	}
19312	case MODE_Semi: { /* .schema and .fullschema output */
19313	printSchemaLine(azArg[0], ";\n");
19314	break;
19315	}
19316	case MODE_Pretty: { /* .schema and .fullschema with --indent */
19317	char *z;
19318	int j;
	@@ -18550,11 +19323,11 @@
19323	assert( nArg==1 );
19324	if( azArg[0]==0 ) break;
19325	if( sqlite3_strlike("CREATE VIEW%", azArg[0], 0)==0
19326	\|\| sqlite3_strlike("CREATE TRIG%", azArg[0], 0)==0
19327	){
19328	oputf("%s;\n", azArg[0]);
19329	break;
19330	}
19331	z = sqlite3_mprintf("%s", azArg[0]);
19332	shell_check_oom(z);
19333	j = 0;
	@@ -18583,166 +19356,161 @@
19356	}else if( c=='(' ){
19357	nParen++;
19358	}else if( c==')' ){
19359	nParen--;
19360	if( nLine>0 && nParen==0 && j>0 ){
19361	printSchemaLineN(z, j, "\n");
19362	j = 0;
19363	}
19364	}
19365	z[j++] = c;
19366	if( nParen==1 && cEnd==0
19367	&& (c=='(' \|\| c=='\n' \|\| (c==',' && !wsToEol(z+i+1)))
19368	){
19369	if( c=='\n' ) j--;
19370	printSchemaLineN(z, j, "\n ");
19371	j = 0;
19372	nLine++;
19373	while( IsSpace(z[i+1]) ){ i++; }
19374	}
19375	}
19376	z[j] = 0;
19377	}
19378	printSchemaLine(z, ";\n");
19379	sqlite3_free(z);
19380	break;
19381	}
19382	case MODE_List: {
19383	if( p->cnt++==0 && p->showHeader ){
19384	for(i=0; i<nArg; i++){
19385	oputf("%s%s",azCol[i], i==nArg-1 ? p->rowSeparator : p->colSeparator);

19386	}
19387	}
19388	if( azArg==0 ) break;
19389	for(i=0; i<nArg; i++){
19390	char *z = azArg[i];
19391	if( z==0 ) z = p->nullValue;
19392	oputz(z);
19393	oputz((i<nArg-1)? p->colSeparator : p->rowSeparator);




19394	}
19395	break;
19396	}
19397	case MODE_Html: {
19398	if( p->cnt++==0 && p->showHeader ){
19399	oputz("<TR>");
19400	for(i=0; i<nArg; i++){
19401	oputz("<TH>");
19402	output_html_string(azCol[i]);
19403	oputz("</TH>\n");
19404	}
19405	oputz("</TR>\n");
19406	}
19407	if( azArg==0 ) break;
19408	oputz("<TR>");
19409	for(i=0; i<nArg; i++){
19410	oputz("<TD>");
19411	output_html_string(azArg[i] ? azArg[i] : p->nullValue);
19412	oputz("</TD>\n");
19413	}
19414	oputz("</TR>\n");
19415	break;
19416	}
19417	case MODE_Tcl: {
19418	if( p->cnt++==0 && p->showHeader ){
19419	for(i=0; i<nArg; i++){
19420	output_c_string(azCol[i] ? azCol[i] : "");
19421	if(i<nArg-1) oputz(p->colSeparator);
19422	}
19423	oputz(p->rowSeparator);
19424	}
19425	if( azArg==0 ) break;
19426	for(i=0; i<nArg; i++){
19427	output_c_string(azArg[i] ? azArg[i] : p->nullValue);
19428	if(i<nArg-1) oputz(p->colSeparator);
19429	}
19430	oputz(p->rowSeparator);
19431	break;
19432	}
19433	case MODE_Csv: {
19434	setBinaryMode(p->out, 1);
19435	if( p->cnt++==0 && p->showHeader ){
19436	for(i=0; i<nArg; i++){
19437	output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
19438	}
19439	oputz(p->rowSeparator);
19440	}
19441	if( nArg>0 ){
19442	for(i=0; i<nArg; i++){
19443	output_csv(p, azArg[i], i<nArg-1);
19444	}
19445	oputz(p->rowSeparator);
19446	}
19447	setTextMode(p->out, 1);
19448	break;
19449	}
19450	case MODE_Insert: {
19451	if( azArg==0 ) break;
19452	oputf("INSERT INTO %s",p->zDestTable);
19453	if( p->showHeader ){
19454	oputz("(");
19455	for(i=0; i<nArg; i++){
19456	if( i>0 ) oputz(",");
19457	if( quoteChar(azCol[i]) ){
19458	char *z = sqlite3_mprintf("\"%w\"", azCol[i]);
19459	shell_check_oom(z);
19460	oputz(z);
19461	sqlite3_free(z);
19462	}else{
19463	oputf("%s", azCol[i]);
19464	}
19465	}
19466	oputz(")");
19467	}
19468	p->cnt++;
19469	for(i=0; i<nArg; i++){
19470	oputz(i>0 ? "," : " VALUES(");
19471	if( (azArg[i]==0) \|\| (aiType && aiType[i]==SQLITE_NULL) ){
19472	oputz("NULL");
19473	}else if( aiType && aiType[i]==SQLITE_TEXT ){
19474	if( ShellHasFlag(p, SHFLG_Newlines) ){
19475	output_quoted_string(azArg[i]);
19476	}else{
19477	output_quoted_escaped_string(azArg[i]);
19478	}
19479	}else if( aiType && aiType[i]==SQLITE_INTEGER ){
19480	oputz(azArg[i]);
19481	}else if( aiType && aiType[i]==SQLITE_FLOAT ){
19482	char z[50];
19483	double r = sqlite3_column_double(p->pStmt, i);
19484	sqlite3_uint64 ur;
19485	memcpy(&ur,&r,sizeof(r));
19486	if( ur==0x7ff0000000000000LL ){
19487	oputz("9.0e+999");
19488	}else if( ur==0xfff0000000000000LL ){
19489	oputz("-9.0e+999");
19490	}else{
19491	sqlite3_int64 ir = (sqlite3_int64)r;
19492	if( r==(double)ir ){
19493	sqlite3_snprintf(50,z,"%lld.0", ir);
19494	}else{
19495	sqlite3_snprintf(50,z,"%!.20g", r);
19496	}
19497	oputz(z);
19498	}
19499	}else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
19500	const void *pBlob = sqlite3_column_blob(p->pStmt, i);
19501	int nBlob = sqlite3_column_bytes(p->pStmt, i);
19502	output_hex_blob(pBlob, nBlob);
19503	}else if( isNumber(azArg[i], 0) ){
19504	oputz(azArg[i]);
19505	}else if( ShellHasFlag(p, SHFLG_Newlines) ){
19506	output_quoted_string(azArg[i]);
19507	}else{
19508	output_quoted_escaped_string(azArg[i]);
19509	}
19510	}
19511	oputz(");\n");
19512	break;
19513	}
19514	case MODE_Json: {
19515	if( azArg==0 ) break;
19516	if( p->cnt==0 ){
	@@ -18750,93 +19518,93 @@
19518	}else{
19519	fputs(",\n{", p->out);
19520	}
19521	p->cnt++;
19522	for(i=0; i<nArg; i++){
19523	output_json_string(azCol[i], -1);
19524	oputz(":");
19525	if( (azArg[i]==0) \|\| (aiType && aiType[i]==SQLITE_NULL) ){
19526	oputz("null");
19527	}else if( aiType && aiType[i]==SQLITE_FLOAT ){
19528	char z[50];
19529	double r = sqlite3_column_double(p->pStmt, i);
19530	sqlite3_uint64 ur;
19531	memcpy(&ur,&r,sizeof(r));
19532	if( ur==0x7ff0000000000000LL ){
19533	oputz("9.0e+999");
19534	}else if( ur==0xfff0000000000000LL ){
19535	oputz("-9.0e+999");
19536	}else{
19537	sqlite3_snprintf(50,z,"%!.20g", r);
19538	oputz(z);
19539	}
19540	}else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
19541	const void *pBlob = sqlite3_column_blob(p->pStmt, i);
19542	int nBlob = sqlite3_column_bytes(p->pStmt, i);
19543	output_json_string(pBlob, nBlob);
19544	}else if( aiType && aiType[i]==SQLITE_TEXT ){
19545	output_json_string(azArg[i], -1);
19546	}else{
19547	oputz(azArg[i]);
19548	}
19549	if( i<nArg-1 ){
19550	oputz(",");
19551	}
19552	}
19553	oputz("}");
19554	break;
19555	}
19556	case MODE_Quote: {
19557	if( azArg==0 ) break;
19558	if( p->cnt==0 && p->showHeader ){
19559	for(i=0; i<nArg; i++){
19560	if( i>0 ) fputs(p->colSeparator, p->out);
19561	output_quoted_string(azCol[i]);
19562	}
19563	fputs(p->rowSeparator, p->out);
19564	}
19565	p->cnt++;
19566	for(i=0; i<nArg; i++){
19567	if( i>0 ) fputs(p->colSeparator, p->out);
19568	if( (azArg[i]==0) \|\| (aiType && aiType[i]==SQLITE_NULL) ){
19569	oputz("NULL");
19570	}else if( aiType && aiType[i]==SQLITE_TEXT ){
19571	output_quoted_string(azArg[i]);
19572	}else if( aiType && aiType[i]==SQLITE_INTEGER ){
19573	oputz(azArg[i]);
19574	}else if( aiType && aiType[i]==SQLITE_FLOAT ){
19575	char z[50];
19576	double r = sqlite3_column_double(p->pStmt, i);
19577	sqlite3_snprintf(50,z,"%!.20g", r);
19578	oputz(z);
19579	}else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
19580	const void *pBlob = sqlite3_column_blob(p->pStmt, i);
19581	int nBlob = sqlite3_column_bytes(p->pStmt, i);
19582	output_hex_blob(pBlob, nBlob);
19583	}else if( isNumber(azArg[i], 0) ){
19584	oputz(azArg[i]);
19585	}else{
19586	output_quoted_string(azArg[i]);
19587	}
19588	}
19589	fputs(p->rowSeparator, p->out);
19590	break;
19591	}
19592	case MODE_Ascii: {
19593	if( p->cnt++==0 && p->showHeader ){
19594	for(i=0; i<nArg; i++){
19595	if( i>0 ) oputz(p->colSeparator);
19596	oputz(azCol[i] ? azCol[i] : "");
19597	}
19598	oputz(p->rowSeparator);
19599	}
19600	if( azArg==0 ) break;
19601	for(i=0; i<nArg; i++){
19602	if( i>0 ) oputz(p->colSeparator);
19603	oputz(azArg[i] ? azArg[i] : p->nullValue);
19604	}
19605	oputz(p->rowSeparator);
19606	break;
19607	}
19608	case MODE_EQP: {
19609	eqp_append(p, atoi(azArg[0]), atoi(azArg[1]), azArg[3]);
19610	break;
	@@ -18911,11 +19679,11 @@
19679	"INSERT INTO selftest(tno,op,cmd,ans)"
19680	" SELECT rowid*10,op,cmd,ans FROM [_shell$self];\n"
19681	"DROP TABLE [_shell$self];"
19682	,0,0,&zErrMsg);
19683	if( zErrMsg ){
19684	eputf("SELFTEST initialization failure: %s\n", zErrMsg);
19685	sqlite3_free(zErrMsg);
19686	}
19687	sqlite3_exec(p->db, "RELEASE selftest_init",0,0,0);
19688	}
19689
	@@ -19014,37 +19782,36 @@
19782	int i;
19783	const char *z;
19784	rc = sqlite3_prepare_v2(p->db, zSelect, -1, &pSelect, 0);
19785	if( rc!=SQLITE_OK \|\| !pSelect ){
19786	char *zContext = shell_error_context(zSelect, p->db);
19787	oputf("/** ERROR: (%d) %s ***/\n%s",
19788	rc, sqlite3_errmsg(p->db), zContext);
19789	sqlite3_free(zContext);
19790	if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
19791	return rc;
19792	}
19793	rc = sqlite3_step(pSelect);
19794	nResult = sqlite3_column_count(pSelect);
19795	while( rc==SQLITE_ROW ){
19796	z = (const char*)sqlite3_column_text(pSelect, 0);
19797	oputf("%s", z);
19798	for(i=1; i<nResult; i++){
19799	oputf(",%s", sqlite3_column_text(pSelect, i));
19800	}
19801	if( z==0 ) z = "";
19802	while( z[0] && (z[0]!='-' \|\| z[1]!='-') ) z++;
19803	if( z[0] ){
19804	oputz("\n;\n");
19805	}else{
19806	oputz(";\n");
19807	}
19808	rc = sqlite3_step(pSelect);
19809	}
19810	rc = sqlite3_finalize(pSelect);
19811	if( rc!=SQLITE_OK ){
19812	oputf("/** ERROR: (%d) %s ***/\n", rc, sqlite3_errmsg(p->db));

19813	if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
19814	}
19815	return rc;
19816	}
19817
	@@ -19076,11 +19843,11 @@
19843
19844	#ifdef __linux__
19845	/*
19846	** Attempt to display I/O stats on Linux using /proc/PID/io
19847	*/
19848	static void displayLinuxIoStats(void){
19849	FILE *in;
19850	char z[200];
19851	sqlite3_snprintf(sizeof(z), z, "/proc/%d/io", getpid());
19852	in = fopen(z, "rb");
19853	if( in==0 ) return;
	@@ -19099,11 +19866,11 @@
19866	};
19867	int i;
19868	for(i=0; i<ArraySize(aTrans); i++){
19869	int n = strlen30(aTrans[i].zPattern);
19870	if( cli_strncmp(aTrans[i].zPattern, z, n)==0 ){
19871	oputf("%-36s %s", aTrans[i].zDesc, &z[n]);
19872	break;
19873	}
19874	}
19875	}
19876	fclose(in);
	@@ -19112,11 +19879,10 @@
19879
19880	/*
19881	** Display a single line of status using 64-bit values.
19882	*/
19883	static void displayStatLine(

19884	char zLabel, / Label for this one line */
19885	char zFormat, / Format for the result */
19886	int iStatusCtrl, /* Which status to display */
19887	int bReset /* True to reset the stats */
19888	){
	@@ -19131,11 +19897,11 @@
19897	if( nPercent>1 ){
19898	sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iCur, iHiwtr);
19899	}else{
19900	sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iHiwtr);
19901	}
19902	oputf("%-36s %s\n", zLabel, zLine);
19903	}
19904
19905	/*
19906	** Display memory stats.
19907	*/
	@@ -19144,141 +19910,130 @@
19910	ShellState pArg, / Pointer to ShellState */
19911	int bReset /* True to reset the stats */
19912	){
19913	int iCur;
19914	int iHiwtr;

19915	if( pArg==0 \|\| pArg->out==0 ) return 0;

19916
19917	if( pArg->pStmt && pArg->statsOn==2 ){
19918	int nCol, i, x;
19919	sqlite3_stmt *pStmt = pArg->pStmt;
19920	char z[100];
19921	nCol = sqlite3_column_count(pStmt);
19922	oputf("%-36s %d\n", "Number of output columns:", nCol);
19923	for(i=0; i<nCol; i++){
19924	sqlite3_snprintf(sizeof(z),z,"Column %d %nname:", i, &x);
19925	oputf("%-36s %s\n", z, sqlite3_column_name(pStmt,i));
19926	#ifndef SQLITE_OMIT_DECLTYPE
19927	sqlite3_snprintf(30, z+x, "declared type:");
19928	oputf("%-36s %s\n", z, sqlite3_column_decltype(pStmt, i));
19929	#endif
19930	#ifdef SQLITE_ENABLE_COLUMN_METADATA
19931	sqlite3_snprintf(30, z+x, "database name:");
19932	oputf("%-36s %s\n", z, sqlite3_column_database_name(pStmt,i));
19933	sqlite3_snprintf(30, z+x, "table name:");
19934	oputf("%-36s %s\n", z, sqlite3_column_table_name(pStmt,i));
19935	sqlite3_snprintf(30, z+x, "origin name:");
19936	oputf("%-36s %s\n", z, sqlite3_column_origin_name(pStmt,i));
19937	#endif
19938	}
19939	}
19940
19941	if( pArg->statsOn==3 ){
19942	if( pArg->pStmt ){
19943	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP,bReset);
19944	oputf("VM-steps: %d\n", iCur);
19945	}
19946	return 0;
19947	}
19948
19949	displayStatLine("Memory Used:",
19950	"%lld (max %lld) bytes", SQLITE_STATUS_MEMORY_USED, bReset);
19951	displayStatLine("Number of Outstanding Allocations:",
19952	"%lld (max %lld)", SQLITE_STATUS_MALLOC_COUNT, bReset);
19953	if( pArg->shellFlgs & SHFLG_Pagecache ){
19954	displayStatLine("Number of Pcache Pages Used:",
19955	"%lld (max %lld) pages", SQLITE_STATUS_PAGECACHE_USED, bReset);
19956	}
19957	displayStatLine("Number of Pcache Overflow Bytes:",
19958	"%lld (max %lld) bytes", SQLITE_STATUS_PAGECACHE_OVERFLOW, bReset);
19959	displayStatLine("Largest Allocation:",
19960	"%lld bytes", SQLITE_STATUS_MALLOC_SIZE, bReset);
19961	displayStatLine("Largest Pcache Allocation:",
19962	"%lld bytes", SQLITE_STATUS_PAGECACHE_SIZE, bReset);
19963	#ifdef YYTRACKMAXSTACKDEPTH
19964	displayStatLine("Deepest Parser Stack:",
19965	"%lld (max %lld)", SQLITE_STATUS_PARSER_STACK, bReset);
19966	#endif
19967
19968	if( db ){
19969	if( pArg->shellFlgs & SHFLG_Lookaside ){
19970	iHiwtr = iCur = -1;
19971	sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED,
19972	&iCur, &iHiwtr, bReset);
19973	oputf("Lookaside Slots Used: %d (max %d)\n", iCur, iHiwtr);


19974	sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT,
19975	&iCur, &iHiwtr, bReset);
19976	oputf("Successful lookaside attempts: %d\n", iHiwtr);

19977	sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE,
19978	&iCur, &iHiwtr, bReset);
19979	oputf("Lookaside failures due to size: %d\n", iHiwtr);

19980	sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL,
19981	&iCur, &iHiwtr, bReset);
19982	oputf("Lookaside failures due to OOM: %d\n", iHiwtr);

19983	}
19984	iHiwtr = iCur = -1;
19985	sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);
19986	oputf("Pager Heap Usage: %d bytes\n", iCur);

19987	iHiwtr = iCur = -1;
19988	sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1);
19989	oputf("Page cache hits: %d\n", iCur);
19990	iHiwtr = iCur = -1;
19991	sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1);
19992	oputf("Page cache misses: %d\n", iCur);
19993	iHiwtr = iCur = -1;
19994	sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1);
19995	oputf("Page cache writes: %d\n", iCur);
19996	iHiwtr = iCur = -1;
19997	sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_SPILL, &iCur, &iHiwtr, 1);
19998	oputf("Page cache spills: %d\n", iCur);
19999	iHiwtr = iCur = -1;
20000	sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset);
20001	oputf("Schema Heap Usage: %d bytes\n", iCur);

20002	iHiwtr = iCur = -1;
20003	sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset);
20004	oputf("Statement Heap/Lookaside Usage: %d bytes\n", iCur);

20005	}
20006
20007	if( pArg->pStmt ){
20008	int iHit, iMiss;
20009	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP,
20010	bReset);
20011	oputf("Fullscan Steps: %d\n", iCur);
20012	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset);
20013	oputf("Sort Operations: %d\n", iCur);
20014	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX,bReset);
20015	oputf("Autoindex Inserts: %d\n", iCur);
20016	iHit = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FILTER_HIT,
20017	bReset);
20018	iMiss = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FILTER_MISS,
20019	bReset);
20020	if( iHit \|\| iMiss ){
20021	oputf("Bloom filter bypass taken: %d/%d\n", iHit, iHit+iMiss);

20022	}
20023	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset);
20024	oputf("Virtual Machine Steps: %d\n", iCur);
20025	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_REPREPARE,bReset);
20026	oputf("Reprepare operations: %d\n", iCur);
20027	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_RUN, bReset);
20028	oputf("Number of times run: %d\n", iCur);
20029	iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_MEMUSED, bReset);
20030	oputf("Memory used by prepared stmt: %d\n", iCur);
20031	}
20032
20033	#ifdef __linux__
20034	displayLinuxIoStats();
20035	#endif
20036
20037	/* Do not remove this machine readable comment: extra-stats-output-here */
20038
20039	return 0;
	@@ -19509,11 +20264,11 @@
20264	#ifndef SQLITE_ENABLE_STMT_SCANSTATUS
20265	UNUSED_PARAMETER(db);
20266	UNUSED_PARAMETER(pArg);
20267	#else
20268	if( pArg->scanstatsOn==3 ){
20269	const char *zSql =
20270	" SELECT addr, opcode, p1, p2, p3, p4, p5, comment, nexec,"
20271	" round(ncycle*100.0 / (sum(ncycle) OVER ()), 2)\|\|'%' AS cycles"
20272	" FROM bytecode(?)";
20273
20274	int rc = SQLITE_OK;
	@@ -19655,21 +20410,21 @@
20410	#define BOX_1234 "\342\224\274" /* U+253c -\|- */
20411
20412	/* Draw horizontal line N characters long using unicode box
20413	** characters
20414	*/
20415	static void print_box_line(int N){
20416	const char zDash[] =
20417	BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24
20418	BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24;
20419	const int nDash = sizeof(zDash) - 1;
20420	N *= 3;
20421	while( N>nDash ){
20422	oputz(zDash);
20423	N -= nDash;
20424	}
20425	oputf("%.*s", N, zDash);
20426	}
20427
20428	/*
20429	** Draw a horizontal separator for a MODE_Box table.
20430	*/
	@@ -19680,19 +20435,19 @@
20435	const char *zSep2,
20436	const char *zSep3
20437	){
20438	int i;
20439	if( nArg>0 ){
20440	oputz(zSep1);
20441	print_box_line(p->actualWidth[0]+2);
20442	for(i=1; i<nArg; i++){
20443	oputz(zSep2);
20444	print_box_line(p->actualWidth[i]+2);
20445	}
20446	oputz(zSep3);
20447	}
20448	oputz("\n");
20449	}
20450
20451	/*
20452	** z[] is a line of text that is to be displayed the .mode box or table or
20453	** similar tabular formats. z[] might contain control characters such
	@@ -19951,15 +20706,15 @@
20706	rowSep = "\n";
20707	if( p->showHeader ){
20708	for(i=0; i<nColumn; i++){
20709	w = p->actualWidth[i];
20710	if( p->colWidth[i]<0 ) w = -w;
20711	utf8_width_print(w, azData[i]);
20712	fputs(i==nColumn-1?"\n":" ", p->out);
20713	}
20714	for(i=0; i<nColumn; i++){
20715	print_dashes(p->actualWidth[i]);
20716	fputs(i==nColumn-1?"\n":" ", p->out);
20717	}
20718	}
20719	break;
20720	}
	@@ -19969,12 +20724,12 @@
20724	print_row_separator(p, nColumn, "+");
20725	fputs("\| ", p->out);
20726	for(i=0; i<nColumn; i++){
20727	w = p->actualWidth[i];
20728	n = strlenChar(azData[i]);
20729	oputf("%s%s%s", (w-n)/2, "", azData[i], (w-n+1)/2, "");
20730	oputz(i==nColumn-1?" \|\n":" \| ");
20731	}
20732	print_row_separator(p, nColumn, "+");
20733	break;
20734	}
20735	case MODE_Markdown: {
	@@ -19982,66 +20737,66 @@
20737	rowSep = " \|\n";
20738	fputs("\| ", p->out);
20739	for(i=0; i<nColumn; i++){
20740	w = p->actualWidth[i];
20741	n = strlenChar(azData[i]);
20742	oputf("%s%s%s", (w-n)/2, "", azData[i], (w-n+1)/2, "");
20743	oputz(i==nColumn-1?" \|\n":" \| ");
20744	}
20745	print_row_separator(p, nColumn, "\|");
20746	break;
20747	}
20748	case MODE_Box: {
20749	colSep = " " BOX_13 " ";
20750	rowSep = " " BOX_13 "\n";
20751	print_box_row_separator(p, nColumn, BOX_23, BOX_234, BOX_34);
20752	oputz(BOX_13 " ");
20753	for(i=0; i<nColumn; i++){
20754	w = p->actualWidth[i];
20755	n = strlenChar(azData[i]);
20756	oputf("%s%s%s%s",
20757	(w-n)/2, "", azData[i], (w-n+1)/2, "",
20758	i==nColumn-1?" "BOX_13"\n":" "BOX_13" ");
20759	}
20760	print_box_row_separator(p, nColumn, BOX_123, BOX_1234, BOX_134);
20761	break;
20762	}
20763	}
20764	for(i=nColumn, j=0; i<nTotal; i++, j++){
20765	if( j==0 && p->cMode!=MODE_Column ){
20766	oputz(p->cMode==MODE_Box?BOX_13" ":"\| ");
20767	}
20768	z = azData[i];
20769	if( z==0 ) z = p->nullValue;
20770	w = p->actualWidth[j];
20771	if( p->colWidth[j]<0 ) w = -w;
20772	utf8_width_print(w, z);
20773	if( j==nColumn-1 ){
20774	oputz(rowSep);
20775	if( bMultiLineRowExists && abRowDiv[i/nColumn-1] && i+1<nTotal ){
20776	if( p->cMode==MODE_Table ){
20777	print_row_separator(p, nColumn, "+");
20778	}else if( p->cMode==MODE_Box ){
20779	print_box_row_separator(p, nColumn, BOX_123, BOX_1234, BOX_134);
20780	}else if( p->cMode==MODE_Column ){
20781	oputz("\n");
20782	}
20783	}
20784	j = -1;
20785	if( seenInterrupt ) goto columnar_end;
20786	}else{
20787	oputz(colSep);
20788	}
20789	}
20790	if( p->cMode==MODE_Table ){
20791	print_row_separator(p, nColumn, "+");
20792	}else if( p->cMode==MODE_Box ){
20793	print_box_row_separator(p, nColumn, BOX_12, BOX_124, BOX_14);
20794	}
20795	columnar_end:
20796	if( seenInterrupt ){
20797	oputz("Interrupt\n");
20798	}
20799	nData = (nRow+1)*nColumn;
20800	for(i=0; i<nData; i++){
20801	z = azData[i];
20802	if( z!=zEmpty && z!=zShowNull ) free(azData[i]);
	@@ -20176,34 +20931,33 @@
20931	int rc = SQLITE_OK;
20932	sqlite3expert *p = pState->expert.pExpert;
20933	assert( p );
20934	assert( bCancel \|\| pzErr==0 \|\| *pzErr==0 );
20935	if( bCancel==0 ){

20936	int bVerbose = pState->expert.bVerbose;
20937
20938	rc = sqlite3_expert_analyze(p, pzErr);
20939	if( rc==SQLITE_OK ){
20940	int nQuery = sqlite3_expert_count(p);
20941	int i;
20942
20943	if( bVerbose ){
20944	const char *zCand = sqlite3_expert_report(p,0,EXPERT_REPORT_CANDIDATES);
20945	oputz("-- Candidates -----------------------------\n");
20946	oputf("%s\n", zCand);
20947	}
20948	for(i=0; i<nQuery; i++){
20949	const char *zSql = sqlite3_expert_report(p, i, EXPERT_REPORT_SQL);
20950	const char *zIdx = sqlite3_expert_report(p, i, EXPERT_REPORT_INDEXES);
20951	const char *zEQP = sqlite3_expert_report(p, i, EXPERT_REPORT_PLAN);
20952	if( zIdx==0 ) zIdx = "(no new indexes)\n";
20953	if( bVerbose ){
20954	oputf("-- Query %d --------------------------------\n",i+1);
20955	oputf("%s\n\n", zSql);
20956	}
20957	oputf("%s\n", zIdx);
20958	oputf("%s\n", zEQP);
20959	}
20960	}
20961	}
20962	sqlite3_expert_destroy(p);
20963	pState->expert.pExpert = 0;
	@@ -20234,31 +20988,30 @@
20988	if( n>=2 && 0==cli_strncmp(z, "-verbose", n) ){
20989	pState->expert.bVerbose = 1;
20990	}
20991	else if( n>=2 && 0==cli_strncmp(z, "-sample", n) ){
20992	if( i==(nArg-1) ){
20993	eputf("option requires an argument: %s\n", z);
20994	rc = SQLITE_ERROR;
20995	}else{
20996	iSample = (int)integerValue(azArg[++i]);
20997	if( iSample<0 \|\| iSample>100 ){
20998	eputf("value out of range: %s\n", azArg[i]);
20999	rc = SQLITE_ERROR;
21000	}
21001	}
21002	}
21003	else{
21004	eputf("unknown option: %s\n", z);
21005	rc = SQLITE_ERROR;
21006	}
21007	}
21008
21009	if( rc==SQLITE_OK ){
21010	pState->expert.pExpert = sqlite3_expert_new(pState->db, &zErr);
21011	if( pState->expert.pExpert==0 ){
21012	eputf("sqlite3_expert_new: %s\n", zErr ? zErr : "out of memory");

21013	rc = SQLITE_ERROR;
21014	}else{
21015	sqlite3_expert_config(
21016	pState->expert.pExpert, EXPERT_CONFIG_SAMPLE, iSample
21017	);
	@@ -20581,33 +21334,33 @@
21334	if( zType==0 ) return 0;
21335	dataOnly = (p->shellFlgs & SHFLG_DumpDataOnly)!=0;
21336	noSys = (p->shellFlgs & SHFLG_DumpNoSys)!=0;
21337
21338	if( cli_strcmp(zTable, "sqlite_sequence")==0 && !noSys ){
21339	if( !dataOnly ) oputz("DELETE FROM sqlite_sequence;\n");
21340	}else if( sqlite3_strglob("sqlite_stat?", zTable)==0 && !noSys ){
21341	if( !dataOnly ) oputz("ANALYZE sqlite_schema;\n");
21342	}else if( cli_strncmp(zTable, "sqlite_", 7)==0 ){
21343	return 0;
21344	}else if( dataOnly ){
21345	/* no-op */
21346	}else if( cli_strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
21347	char *zIns;
21348	if( !p->writableSchema ){
21349	oputz("PRAGMA writable_schema=ON;\n");
21350	p->writableSchema = 1;
21351	}
21352	zIns = sqlite3_mprintf(
21353	"INSERT INTO sqlite_schema(type,name,tbl_name,rootpage,sql)"
21354	"VALUES('table','%q','%q',0,'%q');",
21355	zTable, zTable, zSql);
21356	shell_check_oom(zIns);
21357	oputf("%s\n", zIns);
21358	sqlite3_free(zIns);
21359	return 0;
21360	}else{
21361	printSchemaLine(zSql, ";\n");
21362	}
21363
21364	if( cli_strcmp(zType, "table")==0 ){
21365	ShellText sSelect;
21366	ShellText sTable;
	@@ -20661,11 +21414,11 @@
21414	savedMode = p->mode;
21415	p->zDestTable = sTable.z;
21416	p->mode = p->cMode = MODE_Insert;
21417	rc = shell_exec(p, sSelect.z, 0);
21418	if( (rc&0xff)==SQLITE_CORRUPT ){
21419	oputz("/**** CORRUPTION ERROR *****/\n");
21420	toggleSelectOrder(p->db);
21421	shell_exec(p, sSelect.z, 0);
21422	toggleSelectOrder(p->db);
21423	}
21424	p->zDestTable = savedDestTable;
	@@ -20692,22 +21445,22 @@
21445	char *zErr = 0;
21446	rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr);
21447	if( rc==SQLITE_CORRUPT ){
21448	char *zQ2;
21449	int len = strlen30(zQuery);
21450	oputz("/**** CORRUPTION ERROR *****/\n");
21451	if( zErr ){
21452	oputf("/**** %s ****/\n", zErr);
21453	sqlite3_free(zErr);
21454	zErr = 0;
21455	}
21456	zQ2 = malloc( len+100 );
21457	if( zQ2==0 ) return rc;
21458	sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery);
21459	rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr);
21460	if( rc ){
21461	oputf("/**** ERROR: %s ****/\n", zErr);
21462	}else{
21463	rc = SQLITE_CORRUPT;
21464	}
21465	sqlite3_free(zErr);
21466	free(zQ2);
	@@ -21059,24 +21812,24 @@
21812	hh &= ~HH_Summary;
21813	break;
21814	}
21815	if( ((hw^hh)&HH_Undoc)==0 ){
21816	if( (hh&HH_Summary)!=0 ){
21817	sputf(out, ".%s\n", azHelp[i]+1);
21818	++n;
21819	}else if( (hw&HW_SummaryOnly)==0 ){
21820	sputf(out, "%s\n", azHelp[i]);
21821	}
21822	}
21823	}
21824	}else{
21825	/* Seek documented commands for which zPattern is an exact prefix */
21826	zPat = sqlite3_mprintf(".%s*", zPattern);
21827	shell_check_oom(zPat);
21828	for(i=0; i<ArraySize(azHelp); i++){
21829	if( sqlite3_strglob(zPat, azHelp[i])==0 ){
21830	sputf(out, "%s\n", azHelp[i]);
21831	j = i+1;
21832	n++;
21833	}
21834	}
21835	sqlite3_free(zPat);
	@@ -21083,11 +21836,11 @@
21836	if( n ){
21837	if( n==1 ){
21838	/* when zPattern is a prefix of exactly one command, then include
21839	** the details of that command, which should begin at offset j */
21840	while( j<ArraySize(azHelp)-1 && azHelp[j][0]==' ' ){
21841	sputf(out, "%s\n", azHelp[j]);
21842	j++;
21843	}
21844	}
21845	return n;
21846	}
	@@ -21100,14 +21853,14 @@
21853	while( i<ArraySize(azHelp)-1 && azHelp[i+1][0]==' ' ) ++i;
21854	continue;
21855	}
21856	if( azHelp[i][0]=='.' ) j = i;
21857	if( sqlite3_strlike(zPat, azHelp[i], 0)==0 ){
21858	sputf(out, "%s\n", azHelp[j]);
21859	while( j<ArraySize(azHelp)-1 && azHelp[j+1][0]==' ' ){
21860	j++;
21861	sputf(out, "%s\n", azHelp[j]);
21862	}
21863	i = j;
21864	n++;
21865	}
21866	}
	@@ -21141,27 +21894,27 @@
21894	char *pBuf;
21895	int rc;
21896	if( in==0 ) return 0;
21897	rc = fseek(in, 0, SEEK_END);
21898	if( rc!=0 ){
21899	eputf("Error: '%s' not seekable\n", zName);
21900	fclose(in);
21901	return 0;
21902	}
21903	nIn = ftell(in);
21904	rewind(in);
21905	pBuf = sqlite3_malloc64( nIn+1 );
21906	if( pBuf==0 ){
21907	eputz("Error: out of memory\n");
21908	fclose(in);
21909	return 0;
21910	}
21911	nRead = fread(pBuf, nIn, 1, in);
21912	fclose(in);
21913	if( nRead!=1 ){
21914	sqlite3_free(pBuf);
21915	eputf("Error: cannot read '%s'\n", zName);
21916	return 0;
21917	}
21918	pBuf[nIn] = 0;
21919	if( pnByte ) *pnByte = nIn;
21920	return pBuf;
	@@ -21278,11 +22031,11 @@
22031	unsigned int x[16];
22032	char zLine[1000];
22033	if( zDbFilename ){
22034	in = fopen(zDbFilename, "r");
22035	if( in==0 ){
22036	eputf("cannot open \"%s\" for reading\n", zDbFilename);
22037	return 0;
22038	}
22039	nLine = 0;
22040	}else{
22041	in = p->in;
	@@ -21299,11 +22052,11 @@
22052	n = (n+pgsz-1)&~(pgsz-1); /* Round n up to the next multiple of pgsz */
22053	a = sqlite3_malloc( n ? n : 1 );
22054	shell_check_oom(a);
22055	memset(a, 0, n);
22056	if( pgsz<512 \|\| pgsz>65536 \|\| (pgsz & (pgsz-1))!=0 ){
22057	eputz("invalid pagesize\n");
22058	goto readHexDb_error;
22059	}
22060	for(nLine++; fgets(zLine, sizeof(zLine), in)!=0; nLine++){
22061	rc = sscanf(zLine, "\| page %d offset %d", &j, &k);
22062	if( rc==2 ){
	@@ -21341,11 +22094,11 @@
22094	if(cli_strncmp(zLine, "\| end ", 6)==0 ) break;
22095	}
22096	p->lineno = nLine;
22097	}
22098	sqlite3_free(a);
22099	eputf("Error on line %d of --hexdb input\n", nLine);
22100	return 0;
22101	}
22102	#endif /* SQLITE_OMIT_DESERIALIZE */
22103
22104	/*
	@@ -21417,26 +22170,23 @@
22170	break;
22171	}
22172	}
22173	globalDb = p->db;
22174	if( p->db==0 \|\| SQLITE_OK!=sqlite3_errcode(p->db) ){
22175	eputf("Error: unable to open database \"%s\": %s\n",
22176	zDbFilename, sqlite3_errmsg(p->db));
22177	if( (openFlags & OPEN_DB_KEEPALIVE)==0 ){
22178	exit(1);
22179	}
22180	sqlite3_close(p->db);
22181	sqlite3_open(":memory:", &p->db);
22182	if( p->db==0 \|\| SQLITE_OK!=sqlite3_errcode(p->db) ){
22183	eputz("Also: unable to open substitute in-memory database.\n");


22184	exit(1);
22185	}else{
22186	eputf("Notice: using substitute in-memory database instead of \"%s\"\n",
22187	zDbFilename);

22188	}
22189	}
22190	sqlite3_db_config(p->db, SQLITE_DBCONFIG_STMT_SCANSTATUS, (int)0, (int*)0);
22191
22192	/* Reflect the use or absence of --unsafe-testing invocation. */
	@@ -21539,11 +22289,11 @@
22289	}
22290	rc = sqlite3_deserialize(p->db, "main", aData, nData, nData,
22291	SQLITE_DESERIALIZE_RESIZEABLE \|
22292	SQLITE_DESERIALIZE_FREEONCLOSE);
22293	if( rc ){
22294	eputf("Error: sqlite3_deserialize() returns %d\n", rc);
22295	}
22296	if( p->szMax>0 ){
22297	sqlite3_file_control(p->db, "main", SQLITE_FCNTL_SIZE_LIMIT, &p->szMax);
22298	}
22299	}
	@@ -21563,12 +22313,11 @@
22313	** Attempt to close the database connection. Report errors.
22314	*/
22315	void close_db(sqlite3 *db){
22316	int rc = sqlite3_close(db);
22317	if( rc ){
22318	eputf("Error: sqlite3_close() returns %d: %s\n", rc, sqlite3_errmsg(db));

22319	}
22320	}
22321
22322	#if HAVE_READLINE \|\| HAVE_EDITLINE
22323	/*
	@@ -21725,12 +22474,11 @@
22474	return 1;
22475	}
22476	if( sqlite3_stricmp(zArg, "off")==0 \|\| sqlite3_stricmp(zArg,"no")==0 ){
22477	return 0;
22478	}
22479	eputf("ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n", zArg);

22480	return 0;
22481	}
22482
22483	/*
22484	** Set or clear a shell flag according to a boolean value.
	@@ -21764,11 +22512,11 @@
22512	}else if( cli_strcmp(zFile, "off")==0 ){
22513	f = 0;
22514	}else{
22515	f = fopen(zFile, bTextMode ? "w" : "wb");
22516	if( f==0 ){
22517	eputf("Error: cannot open \"%s\"\n", zFile);
22518	}
22519	}
22520	return f;
22521	}
22522
	@@ -21786,11 +22534,11 @@
22534	sqlite3_stmt *pStmt;
22535	const char *zSql;
22536	i64 nSql;
22537	if( p->traceOut==0 ) return 0;
22538	if( mType==SQLITE_TRACE_CLOSE ){
22539	sputz(p->traceOut, "-- closing database connection\n");
22540	return 0;
22541	}
22542	if( mType!=SQLITE_TRACE_ROW && pX!=0 && ((const char*)pX)[0]=='-' ){
22543	zSql = (const char*)pX;
22544	}else{
	@@ -21817,16 +22565,16 @@
22565	if( nSql>1000000000 ) nSql = 1000000000;
22566	while( nSql>0 && zSql[nSql-1]==';' ){ nSql--; }
22567	switch( mType ){
22568	case SQLITE_TRACE_ROW:
22569	case SQLITE_TRACE_STMT: {
22570	sputf(p->traceOut, "%.*s;\n", (int)nSql, zSql);
22571	break;
22572	}
22573	case SQLITE_TRACE_PROFILE: {
22574	sqlite3_int64 nNanosec = pX ? (sqlite3_int64)pX : 0;
22575	sputf(p->traceOut, "%.*s; -- %lld ns\n", (int)nSql, zSql, nNanosec);
22576	break;
22577	}
22578	}
22579	return 0;
22580	}
	@@ -21929,16 +22677,15 @@
22677	do{ p->n--; }while( p->z[p->n]!=cQuote );
22678	p->cTerm = c;
22679	break;
22680	}
22681	if( pc==cQuote && c!='\r' ){
22682	eputf("%s:%d: unescaped %c character\n", p->zFile, p->nLine, cQuote);

22683	}
22684	if( c==EOF ){
22685	eputf("%s:%d: unterminated %c-quoted field\n",
22686	p->zFile, startLine, cQuote);
22687	p->cTerm = c;
22688	break;
22689	}
22690	import_append_char(p, c);
22691	ppc = pc;
	@@ -22032,13 +22779,12 @@
22779
22780	zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable);
22781	shell_check_oom(zQuery);
22782	rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
22783	if( rc ){
22784	eputf("Error %d: %s on [%s]\n",
22785	sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), zQuery);

22786	goto end_data_xfer;
22787	}
22788	n = sqlite3_column_count(pQuery);
22789	zInsert = sqlite3_malloc64(200 + nTable + n*3);
22790	shell_check_oom(zInsert);
	@@ -22050,13 +22796,12 @@
22796	i += 2;
22797	}
22798	memcpy(zInsert+i, ");", 3);
22799	rc = sqlite3_prepare_v2(newDb, zInsert, -1, &pInsert, 0);
22800	if( rc ){
22801	eputf("Error %d: %s on [%s]\n",
22802	sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb), zInsert);

22803	goto end_data_xfer;
22804	}
22805	for(k=0; k<2; k++){
22806	while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
22807	for(i=0; i<n; i++){
	@@ -22087,12 +22832,12 @@
22832	}
22833	}
22834	} /* End for */
22835	rc = sqlite3_step(pInsert);
22836	if( rc!=SQLITE_OK && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
22837	eputf("Error %d: %s\n",
22838	sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb));
22839	}
22840	sqlite3_reset(pInsert);
22841	cnt++;
22842	if( (cnt%spinRate)==0 ){
22843	printf("%c\b", "\|/-\\"[(cnt/spinRate)%4]);
	@@ -22105,11 +22850,11 @@
22850	zQuery = sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;",
22851	zTable);
22852	shell_check_oom(zQuery);
22853	rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
22854	if( rc ){
22855	eputf("Warning: cannot step \"%s\" backwards", zTable);
22856	break;
22857	}
22858	} /* End for(k=0...) */
22859
22860	end_data_xfer:
	@@ -22142,62 +22887,60 @@
22887	zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_schema"
22888	" WHERE %s ORDER BY rowid ASC", zWhere);
22889	shell_check_oom(zQuery);
22890	rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
22891	if( rc ){
22892	eputf("Error: (%d) %s on [%s]\n", sqlite3_extended_errcode(p->db),
22893	sqlite3_errmsg(p->db), zQuery);

22894	goto end_schema_xfer;
22895	}
22896	while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
22897	zName = sqlite3_column_text(pQuery, 0);
22898	zSql = sqlite3_column_text(pQuery, 1);
22899	if( zName==0 \|\| zSql==0 ) continue;
22900	if( sqlite3_stricmp((char*)zName, "sqlite_sequence")!=0 ){
22901	sputf(stdout, "%s... ", zName); fflush(stdout);
22902	sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
22903	if( zErrMsg ){
22904	eputf("Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
22905	sqlite3_free(zErrMsg);
22906	zErrMsg = 0;
22907	}
22908	}
22909	if( xForEach ){
22910	xForEach(p, newDb, (const char*)zName);
22911	}
22912	sputz(stdout, "done\n");
22913	}
22914	if( rc!=SQLITE_DONE ){
22915	sqlite3_finalize(pQuery);
22916	sqlite3_free(zQuery);
22917	zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_schema"
22918	" WHERE %s ORDER BY rowid DESC", zWhere);
22919	shell_check_oom(zQuery);
22920	rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
22921	if( rc ){
22922	eputf("Error: (%d) %s on [%s]\n",
22923	sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), zQuery);

22924	goto end_schema_xfer;
22925	}
22926	while( sqlite3_step(pQuery)==SQLITE_ROW ){
22927	zName = sqlite3_column_text(pQuery, 0);
22928	zSql = sqlite3_column_text(pQuery, 1);
22929	if( zName==0 \|\| zSql==0 ) continue;
22930	if( sqlite3_stricmp((char*)zName, "sqlite_sequence")==0 ) continue;
22931	sputf(stdout, "%s... ", zName); fflush(stdout);
22932	sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
22933	if( zErrMsg ){
22934	eputf("Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
22935	sqlite3_free(zErrMsg);
22936	zErrMsg = 0;
22937	}
22938	if( xForEach ){
22939	xForEach(p, newDb, (const char*)zName);
22940	}
22941	sputz(stdout, "done\n");
22942	}
22943	}
22944	end_schema_xfer:
22945	sqlite3_finalize(pQuery);
22946	sqlite3_free(zQuery);
	@@ -22210,17 +22953,16 @@
22953	*/
22954	static void tryToClone(ShellState p, const char zNewDb){
22955	int rc;
22956	sqlite3 *newDb = 0;
22957	if( access(zNewDb,0)==0 ){
22958	eputf("File \"%s\" already exists.\n", zNewDb);
22959	return;
22960	}
22961	rc = sqlite3_open(zNewDb, &newDb);
22962	if( rc ){
22963	eputf("Cannot create output database: %s\n", sqlite3_errmsg(newDb));

22964	}else{
22965	sqlite3_exec(p->db, "PRAGMA writable_schema=ON;", 0, 0, 0);
22966	sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0);
22967	tryToCloneSchema(p, newDb, "type='table'", tryToCloneData);
22968	tryToCloneSchema(p, newDb, "type!='table'", 0);
	@@ -22227,10 +22969,22 @@
22969	sqlite3_exec(newDb, "COMMIT;", 0, 0, 0);
22970	sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
22971	}
22972	close_db(newDb);
22973	}
22974
22975	#ifndef SQLITE_SHELL_FIDDLE
22976	/*
22977	** Change the output stream (file or pipe or console) to something else.
22978	*/
22979	static void output_redir(ShellState p, FILE pfNew){
22980	if( p->out != stdout ) eputz("Output already redirected.\n");
22981	else{
22982	p->out = pfNew;
22983	setOutputStream(pfNew);
22984	}
22985	}
22986
22987	/*
22988	** Change the output file back to stdout.
22989	**
22990	** If the p->doXdgOpen flag is set, that means the output was being
	@@ -22255,11 +23009,11 @@
23009	"xdg-open";
23010	#endif
23011	char *zCmd;
23012	zCmd = sqlite3_mprintf("%s %s", zXdgOpenCmd, p->zTempFile);
23013	if( system(zCmd) ){
23014	eputf("Failed: [%s]\n", zCmd);
23015	}else{
23016	/* Give the start/open/xdg-open command some time to get
23017	** going before we continue, and potential delete the
23018	** p->zTempFile data file out from under it */
23019	sqlite3_sleep(2000);
	@@ -22270,11 +23024,16 @@
23024	}
23025	#endif /* !defined(SQLITE_NOHAVE_SYSTEM) */
23026	}
23027	p->outfile[0] = 0;
23028	p->out = stdout;
23029	setOutputStream(stdout);
23030	}
23031	#else
23032	# define output_redir(SS,pfO)
23033	# define output_reset(SS)
23034	#endif
23035
23036	/*
23037	** Run an SQL command and return the single integer result.
23038	*/
23039	static int db_int(sqlite3 db, const char zSql){
	@@ -22341,11 +23100,11 @@
23100	if( p->db==0 ) return 1;
23101	rc = sqlite3_prepare_v2(p->db,
23102	"SELECT data FROM sqlite_dbpage(?1) WHERE pgno=1",
23103	-1, &pStmt, 0);
23104	if( rc ){
23105	eputf("error: %s\n", sqlite3_errmsg(p->db));
23106	sqlite3_finalize(pStmt);
23107	return 1;
23108	}
23109	sqlite3_bind_text(pStmt, 1, zDb, -1, SQLITE_STATIC);
23110	if( sqlite3_step(pStmt)==SQLITE_ROW
	@@ -22354,32 +23113,32 @@
23113	const u8 *pb = sqlite3_column_blob(pStmt,0);
23114	shell_check_oom(pb);
23115	memcpy(aHdr, pb, 100);
23116	sqlite3_finalize(pStmt);
23117	}else{
23118	eputz("unable to read database header\n");
23119	sqlite3_finalize(pStmt);
23120	return 1;
23121	}
23122	i = get2byteInt(aHdr+16);
23123	if( i==1 ) i = 65536;
23124	oputf("%-20s %d\n", "database page size:", i);
23125	oputf("%-20s %d\n", "write format:", aHdr[18]);
23126	oputf("%-20s %d\n", "read format:", aHdr[19]);
23127	oputf("%-20s %d\n", "reserved bytes:", aHdr[20]);
23128	for(i=0; i<ArraySize(aField); i++){
23129	int ofst = aField[i].ofst;
23130	unsigned int val = get4byteInt(aHdr + ofst);
23131	oputf("%-20s %u", aField[i].zName, val);
23132	switch( ofst ){
23133	case 56: {
23134	if( val==1 ) oputz(" (utf8)");
23135	if( val==2 ) oputz(" (utf16le)");
23136	if( val==3 ) oputz(" (utf16be)");
23137	}
23138	}
23139	oputz("\n");
23140	}
23141	if( zDb==0 ){
23142	zSchemaTab = sqlite3_mprintf("main.sqlite_schema");
23143	}else if( cli_strcmp(zDb,"temp")==0 ){
23144	zSchemaTab = sqlite3_mprintf("%s", "sqlite_temp_schema");
	@@ -22388,25 +23147,25 @@
23147	}
23148	for(i=0; i<ArraySize(aQuery); i++){
23149	char *zSql = sqlite3_mprintf(aQuery[i].zSql, zSchemaTab);
23150	int val = db_int(p->db, zSql);
23151	sqlite3_free(zSql);
23152	oputf("%-20s %d\n", aQuery[i].zName, val);
23153	}
23154	sqlite3_free(zSchemaTab);
23155	sqlite3_file_control(p->db, zDb, SQLITE_FCNTL_DATA_VERSION, &iDataVersion);
23156	oputf("%-20s %u\n", "data version", iDataVersion);
23157	return 0;
23158	}
23159	#endif /* SQLITE_SHELL_HAVE_RECOVER */
23160
23161	/*
23162	** Print the current sqlite3_errmsg() value to stderr and return 1.
23163	*/
23164	static int shellDatabaseError(sqlite3 *db){
23165	const char *zErr = sqlite3_errmsg(db);
23166	eputf("Error: %s\n", zErr);
23167	return 1;
23168	}
23169
23170	/*
23171	** Compare the pattern in zGlob[] against the text in z[]. Return TRUE
	@@ -22637,11 +23396,10 @@
23396	ShellState pState, / Current shell tool state */
23397	char *azArg, / Array of arguments passed to dot command */
23398	int nArg /* Number of entries in azArg[] */
23399	){
23400	sqlite3 db = pState->db; / Database handle to query "main" db of */

23401	int bVerbose = 0; /* If -verbose is present */
23402	int bGroupByParent = 0; /* If -groupbyparent is present */
23403	int i; /* To iterate through azArg[] */
23404	const char zIndent = ""; / How much to indent CREATE INDEX by */
23405	int rc; /* Return code */
	@@ -22719,13 +23477,11 @@
23477	else if( n>1 && sqlite3_strnicmp("-groupbyparent", azArg[i], n)==0 ){
23478	bGroupByParent = 1;
23479	zIndent = " ";
23480	}
23481	else{
23482	eputf("Usage: %s %s ?-verbose? ?-groupbyparent?\n", azArg[0], azArg[1]);


23483	return SQLITE_ERROR;
23484	}
23485	}
23486
23487	/* Register the fkey_collate_clause() SQL function */
	@@ -22765,44 +23521,44 @@
23521	}
23522	rc = sqlite3_finalize(pExplain);
23523	if( rc!=SQLITE_OK ) break;
23524
23525	if( res<0 ){
23526	eputz("Error: internal error");
23527	break;
23528	}else{
23529	if( bGroupByParent
23530	&& (bVerbose \|\| res==0)
23531	&& (zPrev==0 \|\| sqlite3_stricmp(zParent, zPrev))
23532	){
23533	oputf("-- Parent table %s\n", zParent);
23534	sqlite3_free(zPrev);
23535	zPrev = sqlite3_mprintf("%s", zParent);
23536	}
23537
23538	if( res==0 ){
23539	oputf("%s%s --> %s\n", zIndent, zCI, zTarget);
23540	}else if( bVerbose ){
23541	oputf("%s/* no extra indexes required for %s -> %s */\n",
23542	zIndent, zFrom, zTarget
23543	);
23544	}
23545	}
23546	}
23547	sqlite3_free(zPrev);
23548
23549	if( rc!=SQLITE_OK ){
23550	eputf("%s\n", sqlite3_errmsg(db));
23551	}
23552
23553	rc2 = sqlite3_finalize(pSql);
23554	if( rc==SQLITE_OK && rc2!=SQLITE_OK ){
23555	rc = rc2;
23556	eputf("%s\n", sqlite3_errmsg(db));
23557	}
23558	}else{
23559	eputf("%s\n", sqlite3_errmsg(db));
23560	}
23561
23562	return rc;
23563	}
23564
	@@ -22818,13 +23574,13 @@
23574	n = (nArg>=2 ? strlen30(azArg[1]) : 0);
23575	if( n<1 \|\| sqlite3_strnicmp(azArg[1], "fkey-indexes", n) ) goto usage;
23576	return lintFkeyIndexes(pState, azArg, nArg);
23577
23578	usage:
23579	eputf("Usage %s sub-command ?switches...?\n", azArg[0]);
23580	eputz("Where sub-commands are:\n");
23581	eputz(" fkey-indexes\n");
23582	return SQLITE_ERROR;
23583	}
23584
23585	#if !defined SQLITE_OMIT_VIRTUALTABLE
23586	static void shellPrepare(
	@@ -22835,13 +23591,11 @@
23591	){
23592	*ppStmt = 0;
23593	if( *pRc==SQLITE_OK ){
23594	int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0);
23595	if( rc!=SQLITE_OK ){
23596	eputf("sql error: %s (%d)\n", sqlite3_errmsg(db), sqlite3_errcode(db));


23597	*pRc = rc;
23598	}
23599	}
23600	}
23601
	@@ -22888,11 +23642,11 @@
23642	if( pStmt ){
23643	sqlite3 *db = sqlite3_db_handle(pStmt);
23644	int rc = sqlite3_finalize(pStmt);
23645	if( *pRc==SQLITE_OK ){
23646	if( rc!=SQLITE_OK ){
23647	eputf("SQL error: %s\n", sqlite3_errmsg(db));
23648	}
23649	*pRc = rc;
23650	}
23651	}
23652	}
	@@ -22909,11 +23663,11 @@
23663	){
23664	int rc = sqlite3_reset(pStmt);
23665	if( *pRc==SQLITE_OK ){
23666	if( rc!=SQLITE_OK ){
23667	sqlite3 *db = sqlite3_db_handle(pStmt);
23668	eputf("SQL error: %s\n", sqlite3_errmsg(db));
23669	}
23670	*pRc = rc;
23671	}
23672	}
23673	#endif /* !defined SQLITE_OMIT_VIRTUALTABLE */
	@@ -22959,15 +23713,15 @@
23713	va_list ap;
23714	char *z;
23715	va_start(ap, zFmt);
23716	z = sqlite3_vmprintf(zFmt, ap);
23717	va_end(ap);
23718	eputf("Error: %s\n", z);
23719	if( pAr->fromCmdLine ){
23720	eputz("Use \"-A\" for more help\n");
23721	}else{
23722	eputz("Use \".archive --help\" for more help\n");
23723	}
23724	sqlite3_free(z);
23725	return SQLITE_ERROR;
23726	}
23727
	@@ -23063,11 +23817,11 @@
23817	};
23818	int nSwitch = sizeof(aSwitch) / sizeof(struct ArSwitch);
23819	struct ArSwitch *pEnd = &aSwitch[nSwitch];
23820
23821	if( nArg<=1 ){
23822	eputz("Wrong number of arguments. Usage:\n");
23823	return arUsage(stderr);
23824	}else{
23825	char *z = azArg[1];
23826	if( z[0]!='-' ){
23827	/* Traditional style [tar] invocation */
	@@ -23169,11 +23923,11 @@
23923	}
23924	}
23925	}
23926	}
23927	if( pAr->eCmd==0 ){
23928	eputz("Required argument missing. Usage:\n");
23929	return arUsage(stderr);
23930	}
23931	return SQLITE_OK;
23932	}
23933
	@@ -23212,11 +23966,11 @@
23966	if( SQLITE_ROW==sqlite3_step(pTest) ){
23967	bOk = 1;
23968	}
23969	shellReset(&rc, pTest);
23970	if( rc==SQLITE_OK && bOk==0 ){
23971	eputf("not found in archive: %s\n", z);
23972	rc = SQLITE_ERROR;
23973	}
23974	}
23975	shellFinalize(&rc, pTest);
23976	}
	@@ -23279,30 +24033,26 @@
24033	arWhereClause(&rc, pAr, &zWhere);
24034
24035	shellPreparePrintf(pAr->db, &rc, &pSql, zSql, azCols[pAr->bVerbose],
24036	pAr->zSrcTable, zWhere);
24037	if( pAr->bDryRun ){
24038	oputf("%s\n", sqlite3_sql(pSql));
24039	}else{
24040	while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){
24041	if( pAr->bVerbose ){
24042	oputf("%s % 10d %s %s\n",
24043	sqlite3_column_text(pSql, 0), sqlite3_column_int(pSql, 1),
24044	sqlite3_column_text(pSql, 2),sqlite3_column_text(pSql, 3));



24045	}else{
24046	oputf("%s\n", sqlite3_column_text(pSql, 0));
24047	}
24048	}
24049	}
24050	shellFinalize(&rc, pSql);
24051	sqlite3_free(zWhere);
24052	return rc;
24053	}

24054
24055	/*
24056	** Implementation of .ar "Remove" command.
24057	*/
24058	static int arRemoveCommand(ArCommand *pAr){
	@@ -23318,11 +24068,11 @@
24068	}
24069	if( rc==SQLITE_OK ){
24070	zSql = sqlite3_mprintf("DELETE FROM %s WHERE %s;",
24071	pAr->zSrcTable, zWhere);
24072	if( pAr->bDryRun ){
24073	oputf("%s\n", zSql);
24074	}else{
24075	char *zErr = 0;
24076	rc = sqlite3_exec(pAr->db, "SAVEPOINT ar;", 0, 0, 0);
24077	if( rc==SQLITE_OK ){
24078	rc = sqlite3_exec(pAr->db, zSql, 0, 0, &zErr);
	@@ -23331,11 +24081,11 @@
24081	}else{
24082	rc = sqlite3_exec(pAr->db, "RELEASE ar;", 0, 0, 0);
24083	}
24084	}
24085	if( zErr ){
24086	sputf(stdout, "ERROR: %s\n", zErr); /* stdout? */
24087	sqlite3_free(zErr);
24088	}
24089	}
24090	}
24091	sqlite3_free(zWhere);
	@@ -23395,15 +24145,15 @@
24145	** populating them changes the timestamp). */
24146	for(i=0; i<2; i++){
24147	j = sqlite3_bind_parameter_index(pSql, "$dirOnly");
24148	sqlite3_bind_int(pSql, j, i);
24149	if( pAr->bDryRun ){
24150	oputf("%s\n", sqlite3_sql(pSql));
24151	}else{
24152	while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){
24153	if( i==0 && pAr->bVerbose ){
24154	oputf("%s\n", sqlite3_column_text(pSql, 0));
24155	}
24156	}
24157	}
24158	shellReset(&rc, pSql);
24159	}
	@@ -23419,17 +24169,17 @@
24169	** Run the SQL statement in zSql. Or if doing a --dryrun, merely print it out.
24170	*/
24171	static int arExecSql(ArCommand pAr, const char zSql){
24172	int rc;
24173	if( pAr->bDryRun ){
24174	oputf("%s\n", zSql);
24175	rc = SQLITE_OK;
24176	}else{
24177	char *zErr = 0;
24178	rc = sqlite3_exec(pAr->db, zSql, 0, 0, &zErr);
24179	if( zErr ){
24180	sputf(stdout, "ERROR: %s\n", zErr);
24181	sqlite3_free(zErr);
24182	}
24183	}
24184	return rc;
24185	}
	@@ -23600,19 +24350,17 @@
24350	}else{
24351	flags = SQLITE_OPEN_READONLY;
24352	}
24353	cmd.db = 0;
24354	if( cmd.bDryRun ){
24355	oputf("-- open database '%s'%s\n", cmd.zFile,
24356	eDbType==SHELL_OPEN_APPENDVFS ? " using 'apndvfs'" : "");
24357	}
24358	rc = sqlite3_open_v2(cmd.zFile, &cmd.db, flags,
24359	eDbType==SHELL_OPEN_APPENDVFS ? "apndvfs" : 0);
24360	if( rc!=SQLITE_OK ){
24361	eputf("cannot open file: %s (%s)\n", cmd.zFile, sqlite3_errmsg(cmd.db));


24362	goto end_ar_command;
24363	}
24364	sqlite3_fileio_init(cmd.db, 0, 0);
24365	sqlite3_sqlar_init(cmd.db, 0, 0);
24366	sqlite3_create_function(cmd.db, "shell_putsnl", 1, SQLITE_UTF8, cmd.p,
	@@ -23621,11 +24369,11 @@
24369	}
24370	if( cmd.zSrcTable==0 && cmd.bZip==0 && cmd.eCmd!=AR_CMD_HELP ){
24371	if( cmd.eCmd!=AR_CMD_CREATE
24372	&& sqlite3_table_column_metadata(cmd.db,0,"sqlar","name",0,0,0,0,0)
24373	){
24374	eputz("database does not contain an 'sqlar' table\n");
24375	rc = SQLITE_ERROR;
24376	goto end_ar_command;
24377	}
24378	cmd.zSrcTable = sqlite3_mprintf("sqlar");
24379	}
	@@ -23679,11 +24427,11 @@
24427	** This function is used as a callback by the recover extension. Simply
24428	** print the supplied SQL statement to stdout.
24429	*/
24430	static int recoverSqlCb(void pCtx, const char zSql){
24431	ShellState pState = (ShellState)pCtx;
24432	sputf(pState->out, "%s;\n", zSql);
24433	return SQLITE_OK;
24434	}
24435
24436	/*
24437	** This function is called to recover data from the database. A script
	@@ -23722,11 +24470,11 @@
24470	}else
24471	if( n<=10 && memcmp("-no-rowids", z, n)==0 ){
24472	bRowids = 0;
24473	}
24474	else{
24475	eputf("unexpected option: %s\n", azArg[i]);
24476	showHelp(pState->out, azArg[0]);
24477	return 1;
24478	}
24479	}
24480
	@@ -23741,11 +24489,11 @@
24489
24490	sqlite3_recover_run(p);
24491	if( sqlite3_recover_errcode(p)!=SQLITE_OK ){
24492	const char *zErr = sqlite3_recover_errmsg(p);
24493	int errCode = sqlite3_recover_errcode(p);
24494	eputf("sql error: %s (%d)\n", zErr, errCode);
24495	}
24496	rc = sqlite3_recover_finish(p);
24497	return rc;
24498	}
24499	#endif /* SQLITE_SHELL_HAVE_RECOVER */
	@@ -23766,11 +24514,11 @@
24514	*/
24515	#ifdef SHELL_DEBUG
24516	#define rc_err_oom_die(rc) \
24517	if( rc==SQLITE_NOMEM ) shell_check_oom(0); \
24518	else if(!(rc==SQLITE_OK\|\|rc==SQLITE_DONE)) \
24519	eputf("E:%d\n",rc), assert(0)
24520	#else
24521	static void rc_err_oom_die(int rc){
24522	if( rc==SQLITE_NOMEM ) shell_check_oom(0);
24523	assert(rc==SQLITE_OK\|\|rc==SQLITE_DONE);
24524	}
	@@ -23906,10 +24654,11 @@
24654	#ifdef SHELL_COLFIX_DB
24655	if(*zCOL_DB!=':')
24656	sqlite3_exec(*pDb,"drop table if exists ColNames;"
24657	"drop view if exists RepeatedNames;",0,0,0);
24658	#endif
24659	#undef SHELL_COLFIX_DB
24660	rc = sqlite3_exec(*pDb, zTabMake, 0, 0, 0);
24661	rc_err_oom_die(rc);
24662	}
24663	assert(*pDb!=0);
24664	rc = sqlite3_prepare_v2(*pDb, zTabFill, -1, &pStmt, 0);
	@@ -24019,11 +24768,11 @@
24768	clearTempFile(p);
24769
24770	#ifndef SQLITE_OMIT_AUTHORIZATION
24771	if( c=='a' && cli_strncmp(azArg[0], "auth", n)==0 ){
24772	if( nArg!=2 ){
24773	eputz("Usage: .auth ON\|OFF\n");
24774	rc = 1;
24775	goto meta_command_exit;
24776	}
24777	open_db(p, 0);
24778	if( booleanValue(azArg[1]) ){
	@@ -24066,32 +24815,32 @@
24815	}else
24816	if( cli_strcmp(z, "-async")==0 ){
24817	bAsync = 1;
24818	}else
24819	{
24820	eputf("unknown option: %s\n", azArg[j]);
24821	return 1;
24822	}
24823	}else if( zDestFile==0 ){
24824	zDestFile = azArg[j];
24825	}else if( zDb==0 ){
24826	zDb = zDestFile;
24827	zDestFile = azArg[j];
24828	}else{
24829	eputz("Usage: .backup ?DB? ?OPTIONS? FILENAME\n");
24830	return 1;
24831	}
24832	}
24833	if( zDestFile==0 ){
24834	eputz("missing FILENAME argument on .backup\n");
24835	return 1;
24836	}
24837	if( zDb==0 ) zDb = "main";
24838	rc = sqlite3_open_v2(zDestFile, &pDest,
24839	SQLITE_OPEN_READWRITE\|SQLITE_OPEN_CREATE, zVfs);
24840	if( rc!=SQLITE_OK ){
24841	eputf("Error: cannot open \"%s\"\n", zDestFile);
24842	close_db(pDest);
24843	return 1;
24844	}
24845	if( bAsync ){
24846	sqlite3_exec(pDest, "PRAGMA synchronous=OFF; PRAGMA journal_mode=OFF;",
	@@ -24098,20 +24847,20 @@
24847	0, 0, 0);
24848	}
24849	open_db(p, 0);
24850	pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
24851	if( pBackup==0 ){
24852	eputf("Error: %s\n", sqlite3_errmsg(pDest));
24853	close_db(pDest);
24854	return 1;
24855	}
24856	while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
24857	sqlite3_backup_finish(pBackup);
24858	if( rc==SQLITE_DONE ){
24859	rc = 0;
24860	}else{
24861	eputf("Error: %s\n", sqlite3_errmsg(pDest));
24862	rc = 1;
24863	}
24864	close_db(pDest);
24865	}else
24866	#endif /* !defined(SQLITE_SHELL_FIDDLE) */
	@@ -24118,11 +24867,11 @@
24867
24868	if( c=='b' && n>=3 && cli_strncmp(azArg[0], "bail", n)==0 ){
24869	if( nArg==2 ){
24870	bail_on_error = booleanValue(azArg[1]);
24871	}else{
24872	eputz("Usage: .bail on\|off\n");
24873	rc = 1;
24874	}
24875	}else
24876
24877	/* Undocumented. Legacy only. See "crnl" below */
	@@ -24132,13 +24881,12 @@
24881	setBinaryMode(p->out, 1);
24882	}else{
24883	setTextMode(p->out, 1);
24884	}
24885	}else{
24886	eputz("The \".binary\" command is deprecated. Use \".crnl\" instead.\n"
24887	"Usage: .binary on\|off\n");

24888	rc = 1;
24889	}
24890	}else
24891
24892	/* The undocumented ".breakpoint" command causes a call to the no-op
	@@ -24158,25 +24906,25 @@
24906	sqlite3_free(z);
24907	#else
24908	rc = chdir(azArg[1]);
24909	#endif
24910	if( rc ){
24911	eputf("Cannot change to directory \"%s\"\n", azArg[1]);
24912	rc = 1;
24913	}
24914	}else{
24915	eputz("Usage: .cd DIRECTORY\n");
24916	rc = 1;
24917	}
24918	}else
24919	#endif /* !defined(SQLITE_SHELL_FIDDLE) */
24920
24921	if( c=='c' && n>=3 && cli_strncmp(azArg[0], "changes", n)==0 ){
24922	if( nArg==2 ){
24923	setOrClearFlag(p, SHFLG_CountChanges, azArg[1]);
24924	}else{
24925	eputz("Usage: .changes on\|off\n");
24926	rc = 1;
24927	}
24928	}else
24929
24930	#ifndef SQLITE_SHELL_FIDDLE
	@@ -24186,21 +24934,20 @@
24934	*/
24935	if( c=='c' && n>=3 && cli_strncmp(azArg[0], "check", n)==0 ){
24936	char *zRes = 0;
24937	output_reset(p);
24938	if( nArg!=2 ){
24939	eputz("Usage: .check GLOB-PATTERN\n");
24940	rc = 2;
24941	}else if( (zRes = readFile("testcase-out.txt", 0))==0 ){
24942	rc = 2;
24943	}else if( testcase_glob(azArg[1],zRes)==0 ){
24944	eputf("testcase-%s FAILED\n Expected: [%s]\n Got: [%s]\n",
24945	p->zTestcase, azArg[1], zRes);

24946	rc = 1;
24947	}else{
24948	oputf("testcase-%s ok\n", p->zTestcase);
24949	p->nCheck++;
24950	}
24951	sqlite3_free(zRes);
24952	}else
24953	#endif /* !defined(SQLITE_SHELL_FIDDLE) */
	@@ -24209,11 +24956,11 @@
24956	if( c=='c' && cli_strncmp(azArg[0], "clone", n)==0 ){
24957	failIfSafeMode(p, "cannot run .clone in safe mode");
24958	if( nArg==2 ){
24959	tryToClone(p, azArg[1]);
24960	}else{
24961	eputz("Usage: .clone FILENAME\n");
24962	rc = 1;
24963	}
24964	}else
24965	#endif /* !defined(SQLITE_SHELL_FIDDLE) */
24966
	@@ -24229,13 +24976,13 @@
24976	zFile = "(memory)";
24977	}else if( zFile[0]==0 ){
24978	zFile = "(temporary-file)";
24979	}
24980	if( p->pAuxDb == &p->aAuxDb[i] ){
24981	sputf(stdout, "ACTIVE %d: %s\n", i, zFile);
24982	}else if( p->aAuxDb[i].db!=0 ){
24983	sputf(stdout, " %d: %s\n", i, zFile);
24984	}
24985	}
24986	}else if( nArg==2 && IsDigit(azArg[1][0]) && azArg[1][1]==0 ){
24987	int i = azArg[1][0] - '0';
24988	if( p->pAuxDb != &p->aAuxDb[i] && i>=0 && i<ArraySize(p->aAuxDb) ){
	@@ -24248,19 +24995,19 @@
24995	&& IsDigit(azArg[2][0]) && azArg[2][1]==0 ){
24996	int i = azArg[2][0] - '0';
24997	if( i<0 \|\| i>=ArraySize(p->aAuxDb) ){
24998	/* No-op */
24999	}else if( p->pAuxDb == &p->aAuxDb[i] ){
25000	eputz("cannot close the active database connection\n");
25001	rc = 1;
25002	}else if( p->aAuxDb[i].db ){
25003	session_close_all(p, i);
25004	close_db(p->aAuxDb[i].db);
25005	p->aAuxDb[i].db = 0;
25006	}
25007	}else{
25008	eputz("Usage: .connection [close] [CONNECTION-NUMBER]\n");
25009	rc = 1;
25010	}
25011	}else
25012
25013	if( c=='c' && n==4 && cli_strncmp(azArg[0], "crnl", n)==0 ){
	@@ -24270,13 +25017,13 @@
25017	}else{
25018	setBinaryMode(p->out, 1);
25019	}
25020	}else{
25021	#if !defined(_WIN32) && !defined(WIN32)
25022	eputz("The \".crnl\" is a no-op on non-Windows machines.\n");
25023	#endif
25024	eputz("Usage: .crnl on\|off\n");
25025	rc = 1;
25026	}
25027	}else
25028
25029	if( c=='d' && n>1 && cli_strncmp(azArg[0], "databases", n)==0 ){
	@@ -24285,11 +25032,11 @@
25032	sqlite3_stmt *pStmt;
25033	int i;
25034	open_db(p, 0);
25035	rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
25036	if( rc ){
25037	eputf("Error: %s\n", sqlite3_errmsg(p->db));
25038	rc = 1;
25039	}else{
25040	while( sqlite3_step(pStmt)==SQLITE_ROW ){
25041	const char zSchema = (const char )sqlite3_column_text(pStmt,1);
25042	const char zFile = (const char)sqlite3_column_text(pStmt,2);
	@@ -24304,15 +25051,13 @@
25051	sqlite3_finalize(pStmt);
25052	for(i=0; i<nName; i++){
25053	int eTxn = sqlite3_txn_state(p->db, azName[i*2]);
25054	int bRdonly = sqlite3_db_readonly(p->db, azName[i*2]);
25055	const char z = azName[i2+1];
25056	oputf("%s: %s %s%s\n",
25057	azName[i*2], z && z[0] ? z : "\"\"", bRdonly ? "r/o" : "r/w",
25058	eTxn==SQLITE_TXN_NONE ? "" :


25059	eTxn==SQLITE_TXN_READ ? " read-txn" : " write-txn");
25060	free(azName[i*2]);
25061	free(azName[i*2+1]);
25062	}
25063	sqlite3_free(azName);
	@@ -24348,16 +25093,16 @@
25093	if( nArg>1 && cli_strcmp(azArg[1], aDbConfig[ii].zName)!=0 ) continue;
25094	if( nArg>=3 ){
25095	sqlite3_db_config(p->db, aDbConfig[ii].op, booleanValue(azArg[2]), 0);
25096	}
25097	sqlite3_db_config(p->db, aDbConfig[ii].op, -1, &v);
25098	oputf("%19s %s\n", aDbConfig[ii].zName, v ? "on" : "off");
25099	if( nArg>1 ) break;
25100	}
25101	if( nArg>1 && ii==ArraySize(aDbConfig) ){
25102	eputf("Error: unknown dbconfig \"%s\"\n", azArg[1]);
25103	eputz("Enter \".dbconfig\" with no arguments for a list\n");
25104	}
25105	}else
25106
25107	#if SQLITE_SHELL_HAVE_RECOVER
25108	if( c=='d' && n>=3 && cli_strncmp(azArg[0], "dbinfo", n)==0 ){
	@@ -24383,12 +25128,12 @@
25128	if( azArg[i][0]=='-' ){
25129	const char *z = azArg[i]+1;
25130	if( z[0]=='-' ) z++;
25131	if( cli_strcmp(z,"preserve-rowids")==0 ){
25132	#ifdef SQLITE_OMIT_VIRTUALTABLE
25133	eputz("The --preserve-rowids option is not compatible"
25134	" with SQLITE_OMIT_VIRTUALTABLE\n");
25135	rc = 1;
25136	sqlite3_free(zLike);
25137	goto meta_command_exit;
25138	#else
25139	ShellSetFlag(p, SHFLG_PreserveRowid);
	@@ -24402,11 +25147,11 @@
25147	}else
25148	if( cli_strcmp(z,"nosys")==0 ){
25149	ShellSetFlag(p, SHFLG_DumpNoSys);
25150	}else
25151	{
25152	eputf("Unknown option \"%s\" on \".dump\"\n", azArg[i]);
25153	rc = 1;
25154	sqlite3_free(zLike);
25155	goto meta_command_exit;
25156	}
25157	}else{
	@@ -24436,12 +25181,12 @@
25181
25182	if( (p->shellFlgs & SHFLG_DumpDataOnly)==0 ){
25183	/* When playing back a "dump", the content might appear in an order
25184	** which causes immediate foreign key constraints to be violated.
25185	** So disable foreign-key constraint enforcement to prevent problems. */
25186	oputz("PRAGMA foreign_keys=OFF;\n");
25187	oputz("BEGIN TRANSACTION;\n");
25188	}
25189	p->writableSchema = 0;
25190	p->showHeader = 0;
25191	/* Set writable_schema=ON since doing so forces SQLite to initialize
25192	** as much of the schema as it can even if the sqlite_schema table is
	@@ -24468,27 +25213,27 @@
25213	run_table_dump_query(p, zSql);
25214	sqlite3_free(zSql);
25215	}
25216	sqlite3_free(zLike);
25217	if( p->writableSchema ){
25218	oputz("PRAGMA writable_schema=OFF;\n");
25219	p->writableSchema = 0;
25220	}
25221	sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
25222	sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0);
25223	if( (p->shellFlgs & SHFLG_DumpDataOnly)==0 ){
25224	oputz(p->nErr?"ROLLBACK; -- due to errors\n":"COMMIT;\n");
25225	}
25226	p->showHeader = savedShowHeader;
25227	p->shellFlgs = savedShellFlags;
25228	}else
25229
25230	if( c=='e' && cli_strncmp(azArg[0], "echo", n)==0 ){
25231	if( nArg==2 ){
25232	setOrClearFlag(p, SHFLG_Echo, azArg[1]);
25233	}else{
25234	eputz("Usage: .echo on\|off\n");
25235	rc = 1;
25236	}
25237	}else
25238
25239	if( c=='e' && cli_strncmp(azArg[0], "eqp", n)==0 ){
	@@ -24515,11 +25260,11 @@
25260	#endif
25261	}else{
25262	p->autoEQP = (u8)booleanValue(azArg[1]);
25263	}
25264	}else{
25265	eputz("Usage: .eqp off\|on\|trace\|trigger\|full\n");
25266	rc = 1;
25267	}
25268	}else
25269
25270	#ifndef SQLITE_SHELL_FIDDLE
	@@ -24554,13 +25299,12 @@
25299	}else
25300
25301	#ifndef SQLITE_OMIT_VIRTUALTABLE
25302	if( c=='e' && cli_strncmp(azArg[0], "expert", n)==0 ){
25303	if( p->bSafeMode ){
25304	eputf("Cannot run experimental commands such as \"%s\" in safe mode\n",
25305	azArg[0]);

25306	rc = 1;
25307	}else{
25308	open_db(p, 0);
25309	expertDotCommand(p, azArg, nArg);
25310	}
	@@ -24612,14 +25356,13 @@
25356	if( zCmd[0]=='-' && zCmd[1] ) zCmd++;
25357	}
25358
25359	/* --help lists all file-controls */
25360	if( cli_strcmp(zCmd,"help")==0 ){
25361	oputz("Available file-controls:\n");
25362	for(i=0; i<ArraySize(aCtrl); i++){
25363	oputf(" .filectrl %s %s\n", aCtrl[i].zCtrlName, aCtrl[i].zUsage);

25364	}
25365	rc = 1;
25366	goto meta_command_exit;
25367	}
25368
	@@ -24630,20 +25373,20 @@
25373	if( cli_strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){
25374	if( filectrl<0 ){
25375	filectrl = aCtrl[i].ctrlCode;
25376	iCtrl = i;
25377	}else{
25378	eputf("Error: ambiguous file-control: \"%s\"\n"
25379	"Use \".filectrl --help\" for help\n", zCmd);
25380	rc = 1;
25381	goto meta_command_exit;
25382	}
25383	}
25384	}
25385	if( filectrl<0 ){
25386	eputf("Error: unknown file-control: %s\n"
25387	"Use \".filectrl --help\" for help\n", zCmd);
25388	}else{
25389	switch(filectrl){
25390	case SQLITE_FCNTL_SIZE_LIMIT: {
25391	if( nArg!=2 && nArg!=3 ) break;
25392	iRes = nArg==3 ? integerValue(azArg[2]) : -1;
	@@ -24682,11 +25425,11 @@
25425	case SQLITE_FCNTL_TEMPFILENAME: {
25426	char *z = 0;
25427	if( nArg!=2 ) break;
25428	sqlite3_file_control(p->db, zSchema, filectrl, &z);
25429	if( z ){
25430	oputf("%s\n", z);
25431	sqlite3_free(z);
25432	}
25433	isOk = 2;
25434	break;
25435	}
	@@ -24696,23 +25439,23 @@
25439	x = atoi(azArg[2]);
25440	sqlite3_file_control(p->db, zSchema, filectrl, &x);
25441	}
25442	x = -1;
25443	sqlite3_file_control(p->db, zSchema, filectrl, &x);
25444	oputf("%d\n", x);
25445	isOk = 2;
25446	break;
25447	}
25448	}
25449	}
25450	if( isOk==0 && iCtrl>=0 ){
25451	oputf("Usage: .filectrl %s %s\n", zCmd,aCtrl[iCtrl].zUsage);
25452	rc = 1;
25453	}else if( isOk==1 ){
25454	char zBuf[100];
25455	sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", iRes);
25456	oputf("%s\n", zBuf);
25457	}
25458	}else
25459
25460	if( c=='f' && cli_strncmp(azArg[0], "fullschema", n)==0 ){
25461	ShellState data;
	@@ -24723,11 +25466,11 @@
25466	if( nArg==2 && optionMatch(azArg[1], "indent") ){
25467	data.cMode = data.mode = MODE_Pretty;
25468	nArg = 1;
25469	}
25470	if( nArg!=1 ){
25471	eputz("Usage: .fullschema ?--indent?\n");
25472	rc = 1;
25473	goto meta_command_exit;
25474	}
25475	open_db(p, 0);
25476	rc = sqlite3_exec(p->db,
	@@ -24749,37 +25492,37 @@
25492	doStats = sqlite3_step(pStmt)==SQLITE_ROW;
25493	sqlite3_finalize(pStmt);
25494	}
25495	}
25496	if( doStats==0 ){
25497	oputz("/* No STAT tables available */\n");
25498	}else{
25499	oputz("ANALYZE sqlite_schema;\n");
25500	data.cMode = data.mode = MODE_Insert;
25501	data.zDestTable = "sqlite_stat1";
25502	shell_exec(&data, "SELECT * FROM sqlite_stat1", 0);
25503	data.zDestTable = "sqlite_stat4";
25504	shell_exec(&data, "SELECT * FROM sqlite_stat4", 0);
25505	oputz("ANALYZE sqlite_schema;\n");
25506	}
25507	}else
25508
25509	if( c=='h' && cli_strncmp(azArg[0], "headers", n)==0 ){
25510	if( nArg==2 ){
25511	p->showHeader = booleanValue(azArg[1]);
25512	p->shellFlgs \|= SHFLG_HeaderSet;
25513	}else{
25514	eputz("Usage: .headers on\|off\n");
25515	rc = 1;
25516	}
25517	}else
25518
25519	if( c=='h' && cli_strncmp(azArg[0], "help", n)==0 ){
25520	if( nArg>=2 ){
25521	n = showHelp(p->out, azArg[1]);
25522	if( n==0 ){
25523	oputf("Nothing matches '%s'\n", azArg[1]);
25524	}
25525	}else{
25526	showHelp(p->out, 0);
25527	}
25528	}else
	@@ -24819,11 +25562,11 @@
25562	if( zFile==0 ){
25563	zFile = z;
25564	}else if( zTable==0 ){
25565	zTable = z;
25566	}else{
25567	oputf("ERROR: extra argument: \"%s\". Usage:\n", z);
25568	showHelp(p->out, "import");
25569	goto meta_command_exit;
25570	}
25571	}else if( cli_strcmp(z,"-v")==0 ){
25572	eVerbose++;
	@@ -24840,18 +25583,18 @@
25583	sCtx.cColSep = ',';
25584	sCtx.cRowSep = '\n';
25585	xRead = csv_read_one_field;
25586	useOutputMode = 0;
25587	}else{
25588	oputf("ERROR: unknown option: \"%s\". Usage:\n", z);
25589	showHelp(p->out, "import");
25590	goto meta_command_exit;
25591	}
25592	}
25593	if( zTable==0 ){
25594	oputf("ERROR: missing %s argument. Usage:\n",
25595	zFile==0 ? "FILE" : "TABLE");
25596	showHelp(p->out, "import");
25597	goto meta_command_exit;
25598	}
25599	seenInterrupt = 0;
25600	open_db(p, 0);
	@@ -24858,24 +25601,21 @@
25601	if( useOutputMode ){
25602	/* If neither the --csv or --ascii options are specified, then set
25603	** the column and row separator characters from the output mode. */
25604	nSep = strlen30(p->colSeparator);
25605	if( nSep==0 ){
25606	eputz("Error: non-null column separator required for import\n");

25607	goto meta_command_exit;
25608	}
25609	if( nSep>1 ){
25610	eputz("Error: multi-character column separators not allowed"

25611	" for import\n");
25612	goto meta_command_exit;
25613	}
25614	nSep = strlen30(p->rowSeparator);
25615	if( nSep==0 ){
25616	eputz("Error: non-null row separator required for import\n");

25617	goto meta_command_exit;
25618	}
25619	if( nSep==2 && p->mode==MODE_Csv
25620	&& cli_strcmp(p->rowSeparator,SEP_CrLf)==0
25621	){
	@@ -24885,22 +25625,22 @@
25625	** and output row separators. */
25626	sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
25627	nSep = strlen30(p->rowSeparator);
25628	}
25629	if( nSep>1 ){
25630	eputz("Error: multi-character row separators not allowed"
25631	" for import\n");
25632	goto meta_command_exit;
25633	}
25634	sCtx.cColSep = (u8)p->colSeparator[0];
25635	sCtx.cRowSep = (u8)p->rowSeparator[0];
25636	}
25637	sCtx.zFile = zFile;
25638	sCtx.nLine = 1;
25639	if( sCtx.zFile[0]=='\|' ){
25640	#ifdef SQLITE_OMIT_POPEN
25641	eputz("Error: pipes are not supported in this OS\n");
25642	goto meta_command_exit;
25643	#else
25644	sCtx.in = popen(sCtx.zFile+1, "r");
25645	sCtx.zFile = "<pipe>";
25646	sCtx.xCloser = pclose;
	@@ -24908,23 +25648,23 @@
25648	}else{
25649	sCtx.in = fopen(sCtx.zFile, "rb");
25650	sCtx.xCloser = fclose;
25651	}
25652	if( sCtx.in==0 ){
25653	eputf("Error: cannot open \"%s\"\n", zFile);
25654	goto meta_command_exit;
25655	}
25656	if( eVerbose>=2 \|\| (eVerbose>=1 && useOutputMode) ){
25657	char zSep[2];
25658	zSep[1] = 0;
25659	zSep[0] = sCtx.cColSep;
25660	oputz("Column separator ");
25661	output_c_string(zSep);
25662	oputz(", row separator ");
25663	zSep[0] = sCtx.cRowSep;
25664	output_c_string(zSep);
25665	oputz("\n");
25666	}
25667	sCtx.z = sqlite3_malloc64(120);
25668	if( sCtx.z==0 ){
25669	import_cleanup(&sCtx);
25670	shell_out_of_memory();
	@@ -24955,18 +25695,18 @@
25695	zAutoColumn(sCtx.z, &dbCols, 0);
25696	if( sCtx.cTerm!=sCtx.cColSep ) break;
25697	}
25698	zColDefs = zAutoColumn(0, &dbCols, &zRenames);
25699	if( zRenames!=0 ){
25700	sputf((stdin_is_interactive && p->in==stdin)? p->out : stderr,
25701	"Columns renamed during .import %s due to duplicates:\n"
25702	"%s\n", sCtx.zFile, zRenames);
25703	sqlite3_free(zRenames);
25704	}
25705	assert(dbCols==0);
25706	if( zColDefs==0 ){
25707	eputf("%s: empty file\n", sCtx.zFile);
25708	import_fail:
25709	sqlite3_free(zCreate);
25710	sqlite3_free(zSql);
25711	sqlite3_free(zFullTabName);
25712	import_cleanup(&sCtx);
	@@ -24973,24 +25713,24 @@
25713	rc = 1;
25714	goto meta_command_exit;
25715	}
25716	zCreate = sqlite3_mprintf("%z%z\n", zCreate, zColDefs);
25717	if( eVerbose>=1 ){
25718	oputf("%s\n", zCreate);
25719	}
25720	rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
25721	if( rc ){
25722	eputf("%s failed:\n%s\n", zCreate, sqlite3_errmsg(p->db));
25723	goto import_fail;
25724	}
25725	sqlite3_free(zCreate);
25726	zCreate = 0;
25727	rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
25728	}
25729	if( rc ){
25730	if (pStmt) sqlite3_finalize(pStmt);
25731	eputf("Error: %s\n", sqlite3_errmsg(p->db));
25732	goto import_fail;
25733	}
25734	sqlite3_free(zSql);
25735	nCol = sqlite3_column_count(pStmt);
25736	sqlite3_finalize(pStmt);
	@@ -25008,15 +25748,15 @@
25748	zSql[j++] = '?';
25749	}
25750	zSql[j++] = ')';
25751	zSql[j] = 0;
25752	if( eVerbose>=2 ){
25753	oputf("Insert using: %s\n", zSql);
25754	}
25755	rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
25756	if( rc ){
25757	eputf("Error: %s\n", sqlite3_errmsg(p->db));
25758	if (pStmt) sqlite3_finalize(pStmt);
25759	goto import_fail;
25760	}
25761	sqlite3_free(zSql);
25762	sqlite3_free(zFullTabName);
	@@ -25045,32 +25785,31 @@
25785	if( z==0 && (xRead==csv_read_one_field) && i==nCol-1 && i>0 ){
25786	z = "";
25787	}
25788	sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT);
25789	if( i<nCol-1 && sCtx.cTerm!=sCtx.cColSep ){
25790	eputf("%s:%d: expected %d columns but found %d"
25791	" - filling the rest with NULL\n",
25792	sCtx.zFile, startLine, nCol, i+1);
25793	i += 2;
25794	while( i<=nCol ){ sqlite3_bind_null(pStmt, i); i++; }
25795	}
25796	}
25797	if( sCtx.cTerm==sCtx.cColSep ){
25798	do{
25799	xRead(&sCtx);
25800	i++;
25801	}while( sCtx.cTerm==sCtx.cColSep );
25802	eputf("%s:%d: expected %d columns but found %d - extras ignored\n",
25803	sCtx.zFile, startLine, nCol, i);

25804	}
25805	if( i>=nCol ){
25806	sqlite3_step(pStmt);
25807	rc = sqlite3_reset(pStmt);
25808	if( rc!=SQLITE_OK ){
25809	eputf("%s:%d: INSERT failed: %s\n",
25810	sCtx.zFile, startLine, sqlite3_errmsg(p->db));
25811	sCtx.nErr++;
25812	}else{
25813	sCtx.nRow++;
25814	}
25815	}
	@@ -25078,13 +25817,12 @@
25817
25818	import_cleanup(&sCtx);
25819	sqlite3_finalize(pStmt);
25820	if( needCommit ) sqlite3_exec(p->db, "COMMIT", 0, 0, 0);
25821	if( eVerbose>0 ){
25822	oputf("Added %d rows with %d errors using %d lines of input\n",
25823	sCtx.nRow, sCtx.nErr, sCtx.nLine-1);

25824	}
25825	}else
25826	#endif /* !defined(SQLITE_SHELL_FIDDLE) */
25827
25828	#ifndef SQLITE_UNTESTABLE
	@@ -25095,18 +25833,18 @@
25833	int tnum = 0;
25834	int isWO = 0; /* True if making an imposter of a WITHOUT ROWID table */
25835	int lenPK = 0; /* Length of the PRIMARY KEY string for isWO tables */
25836	int i;
25837	if( !ShellHasFlag(p,SHFLG_TestingMode) ){
25838	eputf(".%s unavailable without --unsafe-testing\n",
25839	"imposter");
25840	rc = 1;
25841	goto meta_command_exit;
25842	}
25843	if( !(nArg==3 \|\| (nArg==2 && sqlite3_stricmp(azArg[1],"off")==0)) ){
25844	eputz("Usage: .imposter INDEX IMPOSTER\n"
25845	" .imposter off\n");
25846	/* Also allowed, but not documented:
25847	**
25848	** .imposter TABLE IMPOSTER
25849	**
25850	** where TABLE is a WITHOUT ROWID table. In that case, the
	@@ -25161,11 +25899,11 @@
25899	zCollist = sqlite3_mprintf("%z,\"%w\"", zCollist, zCol);
25900	}
25901	}
25902	sqlite3_finalize(pStmt);
25903	if( i==0 \|\| tnum==0 ){
25904	eputf("no such index: \"%s\"\n", azArg[1]);
25905	rc = 1;
25906	sqlite3_free(zCollist);
25907	goto meta_command_exit;
25908	}
25909	if( lenPK==0 ) lenPK = 100000;
	@@ -25176,20 +25914,18 @@
25914	rc = sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 1, tnum);
25915	if( rc==SQLITE_OK ){
25916	rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
25917	sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 0);
25918	if( rc ){
25919	eputf("Error in [%s]: %s\n", zSql, sqlite3_errmsg(p->db));
25920	}else{
25921	sputf(stdout, "%s;\n", zSql);
25922	sputf(stdout, "WARNING: writing to an imposter table will corrupt"
25923	" the \"%s\" %s!\n", azArg[1], isWO ? "table" : "index");


25924	}
25925	}else{
25926	eputf("SQLITE_TESTCTRL_IMPOSTER returns %d\n", rc);
25927	rc = 1;
25928	}
25929	sqlite3_free(zSql);
25930	}else
25931	#endif /* !defined(SQLITE_OMIT_TEST_CONTROL) */
	@@ -25205,11 +25941,11 @@
25941	sqlite3IoTrace = iotracePrintf;
25942	iotrace = stdout;
25943	}else{
25944	iotrace = fopen(azArg[1], "w");
25945	if( iotrace==0 ){
25946	eputf("Error: cannot open \"%s\"\n", azArg[1]);
25947	sqlite3IoTrace = 0;
25948	rc = 1;
25949	}else{
25950	sqlite3IoTrace = iotracePrintf;
25951	}
	@@ -25237,15 +25973,15 @@
25973	};
25974	int i, n2;
25975	open_db(p, 0);
25976	if( nArg==1 ){
25977	for(i=0; i<ArraySize(aLimit); i++){
25978	sputf(stdout, "%20s %d\n", aLimit[i].zLimitName,
25979	sqlite3_limit(p->db, aLimit[i].limitCode, -1));
25980	}
25981	}else if( nArg>3 ){
25982	eputz("Usage: .limit NAME ?NEW-VALUE?\n");
25983	rc = 1;
25984	goto meta_command_exit;
25985	}else{
25986	int iLimit = -1;
25987	n2 = strlen30(azArg[1]);
	@@ -25252,29 +25988,29 @@
25988	for(i=0; i<ArraySize(aLimit); i++){
25989	if( sqlite3_strnicmp(aLimit[i].zLimitName, azArg[1], n2)==0 ){
25990	if( iLimit<0 ){
25991	iLimit = i;
25992	}else{
25993	eputf("ambiguous limit: \"%s\"\n", azArg[1]);
25994	rc = 1;
25995	goto meta_command_exit;
25996	}
25997	}
25998	}
25999	if( iLimit<0 ){
26000	eputf("unknown limit: \"%s\"\n"
26001	"enter \".limits\" with no arguments for a list.\n",
26002	azArg[1]);
26003	rc = 1;
26004	goto meta_command_exit;
26005	}
26006	if( nArg==3 ){
26007	sqlite3_limit(p->db, aLimit[iLimit].limitCode,
26008	(int)integerValue(azArg[2]));
26009	}
26010	sputf(stdout, "%20s %d\n", aLimit[iLimit].zLimitName,
26011	sqlite3_limit(p->db, aLimit[iLimit].limitCode, -1));
26012	}
26013	}else
26014
26015	if( c=='l' && n>2 && cli_strncmp(azArg[0], "lint", n)==0 ){
26016	open_db(p, 0);
	@@ -25286,38 +26022,38 @@
26022	const char zFile, zProc;
26023	char *zErrMsg = 0;
26024	failIfSafeMode(p, "cannot run .load in safe mode");
26025	if( nArg<2 \|\| azArg[1][0]==0 ){
26026	/* Must have a non-empty FILE. (Will not load self.) */
26027	eputz("Usage: .load FILE ?ENTRYPOINT?\n");
26028	rc = 1;
26029	goto meta_command_exit;
26030	}
26031	zFile = azArg[1];
26032	zProc = nArg>=3 ? azArg[2] : 0;
26033	open_db(p, 0);
26034	rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
26035	if( rc!=SQLITE_OK ){
26036	eputf("Error: %s\n", zErrMsg);
26037	sqlite3_free(zErrMsg);
26038	rc = 1;
26039	}
26040	}else
26041	#endif
26042
26043	if( c=='l' && cli_strncmp(azArg[0], "log", n)==0 ){
26044	if( nArg!=2 ){
26045	eputz("Usage: .log FILENAME\n");
26046	rc = 1;
26047	}else{
26048	const char *zFile = azArg[1];
26049	if( p->bSafeMode
26050	&& cli_strcmp(zFile,"on")!=0
26051	&& cli_strcmp(zFile,"off")!=0
26052	){
26053	sputz(stdout, "cannot set .log to anything other"
26054	" than \"on\" or \"off\"\n");
26055	zFile = "off";
26056	}
26057	output_file_close(p->pLog);
26058	if( cli_strcmp(zFile,"on")==0 ) zFile = "stdout";
26059	p->pLog = output_file_open(zFile, 0);
	@@ -25352,37 +26088,35 @@
26088	cmOpts = cmo;
26089	}
26090	}else if( zTabname==0 ){
26091	zTabname = z;
26092	}else if( z[0]=='-' ){
26093	eputf("unknown option: %s\n", z);
26094	eputz("options:\n"
26095	" --noquote\n"
26096	" --quote\n"
26097	" --wordwrap on/off\n"
26098	" --wrap N\n"
26099	" --ww\n");
26100	rc = 1;
26101	goto meta_command_exit;
26102	}else{
26103	eputf("extra argument: \"%s\"\n", z);
26104	rc = 1;
26105	goto meta_command_exit;
26106	}
26107	}
26108	if( zMode==0 ){
26109	if( p->mode==MODE_Column
26110	\|\| (p->mode>=MODE_Markdown && p->mode<=MODE_Box)
26111	){
26112	oputf("current output mode: %s --wrap %d --wordwrap %s --%squote\n",
26113	modeDescr[p->mode], p->cmOpts.iWrap,
26114	p->cmOpts.bWordWrap ? "on" : "off",
26115	p->cmOpts.bQuote ? "" : "no");


26116	}else{
26117	oputf("current output mode: %s\n", modeDescr[p->mode]);
26118	}
26119	zMode = modeDescr[p->mode];
26120	}
26121	n2 = strlen30(zMode);
26122	if( cli_strncmp(zMode,"lines",n2)==0 ){
	@@ -25437,26 +26171,26 @@
26171	}else if( cli_strncmp(zMode,"off",n2)==0 ){
26172	p->mode = MODE_Off;
26173	}else if( cli_strncmp(zMode,"json",n2)==0 ){
26174	p->mode = MODE_Json;
26175	}else{
26176	eputz("Error: mode should be one of: "
26177	"ascii box column csv html insert json line list markdown "
26178	"qbox quote table tabs tcl\n");
26179	rc = 1;
26180	}
26181	p->cMode = p->mode;
26182	}else
26183
26184	#ifndef SQLITE_SHELL_FIDDLE
26185	if( c=='n' && cli_strcmp(azArg[0], "nonce")==0 ){
26186	if( nArg!=2 ){
26187	eputz("Usage: .nonce NONCE\n");
26188	rc = 1;
26189	}else if( p->zNonce==0 \|\| cli_strcmp(azArg[1],p->zNonce)!=0 ){
26190	eputf("line %d: incorrect nonce: \"%s\"\n",
26191	p->lineno, azArg[1]);
26192	exit(1);
26193	}else{
26194	p->bSafeMode = 0;
26195	return 0; /* Return immediately to bypass the safe mode reset
26196	** at the end of this procedure */
	@@ -25467,11 +26201,11 @@
26201	if( c=='n' && cli_strncmp(azArg[0], "nullvalue", n)==0 ){
26202	if( nArg==2 ){
26203	sqlite3_snprintf(sizeof(p->nullValue), p->nullValue,
26204	"%.*s", (int)ArraySize(p->nullValue)-1, azArg[1]);
26205	}else{
26206	eputz("Usage: .nullvalue STRING\n");
26207	rc = 1;
26208	}
26209	}else
26210
26211	if( c=='o' && cli_strncmp(azArg[0], "open", n)==0 && n>=2 ){
	@@ -25506,15 +26240,15 @@
26240	p->szMax = integerValue(azArg[++iName]);
26241	#endif /* SQLITE_OMIT_DESERIALIZE */
26242	}else
26243	#endif /* !SQLITE_SHELL_FIDDLE */
26244	if( z[0]=='-' ){
26245	eputf("unknown option: %s\n", z);
26246	rc = 1;
26247	goto meta_command_exit;
26248	}else if( zFN ){
26249	eputf("extra argument: \"%s\"\n", z);
26250	rc = 1;
26251	goto meta_command_exit;
26252	}else{
26253	zFN = z;
26254	}
	@@ -25552,11 +26286,11 @@
26286	zNewFilename = 0;
26287	}
26288	p->pAuxDb->zDbFilename = zNewFilename;
26289	open_db(p, OPEN_DB_KEEPALIVE);
26290	if( p->db==0 ){
26291	eputf("Error: cannot open '%s'\n", zNewFilename);
26292	sqlite3_free(zNewFilename);
26293	}else{
26294	p->pAuxDb->zFreeOnClose = zNewFilename;
26295	}
26296	}
	@@ -25576,13 +26310,13 @@
26310	char *zFile = 0;
26311	int bTxtMode = 0;
26312	int i;
26313	int eMode = 0;
26314	int bOnce = 0; /* 0: .output, 1: .once, 2: .excel */
26315	static const char *zBomUtf8 = "\xef\xbb\xbf";
26316	const char *zBom = 0;
26317

26318	failIfSafeMode(p, "cannot run .%s in safe mode", azArg[0]);
26319	if( c=='e' ){
26320	eMode = 'x';
26321	bOnce = 2;
26322	}else if( cli_strncmp(azArg[0],"once",n)==0 ){
	@@ -25591,21 +26325,17 @@
26325	for(i=1; i<nArg; i++){
26326	char *z = azArg[i];
26327	if( z[0]=='-' ){
26328	if( z[1]=='-' ) z++;
26329	if( cli_strcmp(z,"-bom")==0 ){
26330	zBom = zBomUtf8;



26331	}else if( c!='e' && cli_strcmp(z,"-x")==0 ){
26332	eMode = 'x'; /* spreadsheet */
26333	}else if( c!='e' && cli_strcmp(z,"-e")==0 ){
26334	eMode = 'e'; /* text editor */
26335	}else{
26336	oputf("ERROR: unknown option: \"%s\". Usage:\n", azArg[i]);

26337	showHelp(p->out, azArg[0]);
26338	rc = 1;
26339	goto meta_command_exit;
26340	}
26341	}else if( zFile==0 && eMode!='e' && eMode!='x' ){
	@@ -25613,12 +26343,11 @@
26343	if( zFile && zFile[0]=='\|' ){
26344	while( i+1<nArg ) zFile = sqlite3_mprintf("%z %s", zFile, azArg[++i]);
26345	break;
26346	}
26347	}else{
26348	oputf("ERROR: extra parameter: \"%s\". Usage:\n", azArg[i]);

26349	showHelp(p->out, azArg[0]);
26350	rc = 1;
26351	sqlite3_free(zFile);
26352	goto meta_command_exit;
26353	}
	@@ -25653,34 +26382,34 @@
26382	}
26383	#endif /* SQLITE_NOHAVE_SYSTEM */
26384	shell_check_oom(zFile);
26385	if( zFile[0]=='\|' ){
26386	#ifdef SQLITE_OMIT_POPEN
26387	eputz("Error: pipes are not supported in this OS\n");
26388	rc = 1;
26389	output_redir(p, stdout);
26390	#else
26391	FILE *pfPipe = popen(zFile + 1, "w");
26392	if( pfPipe==0 ){
26393	eputf("Error: cannot open pipe \"%s\"\n", zFile + 1);

26394	rc = 1;
26395	}else{
26396	output_redir(p, pfPipe);
26397	if( zBom ) oputz(zBom);
26398	sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
26399	}
26400	#endif
26401	}else{
26402	FILE *pfFile = output_file_open(zFile, bTxtMode);
26403	if( pfFile==0 ){
26404	if( cli_strcmp(zFile,"off")!=0 ){
26405	eputf("Error: cannot write to \"%s\"\n", zFile);
26406	}

26407	rc = 1;
26408	} else {
26409	output_redir(p, pfFile);
26410	if( zBom ) oputz(zBom);
26411	sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
26412	}
26413	}
26414	sqlite3_free(zFile);
26415	}else
	@@ -25717,12 +26446,12 @@
26446	if( len ){
26447	rx = sqlite3_prepare_v2(p->db,
26448	"SELECT key, quote(value) "
26449	"FROM temp.sqlite_parameters;", -1, &pStmt, 0);
26450	while( rx==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){
26451	oputf("%-*s %s\n", len, sqlite3_column_text(pStmt,0),
26452	sqlite3_column_text(pStmt,1));
26453	}
26454	sqlite3_finalize(pStmt);
26455	}
26456	}else
26457
	@@ -25762,11 +26491,11 @@
26491	"VALUES(%Q,%Q);", zKey, zValue);
26492	shell_check_oom(zSql);
26493	rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
26494	sqlite3_free(zSql);
26495	if( rx!=SQLITE_OK ){
26496	oputf("Error: %s\n", sqlite3_errmsg(p->db));
26497	sqlite3_finalize(pStmt);
26498	pStmt = 0;
26499	rc = 1;
26500	}
26501	}
	@@ -25791,14 +26520,14 @@
26520	}else
26521
26522	if( c=='p' && n>=3 && cli_strncmp(azArg[0], "print", n)==0 ){
26523	int i;
26524	for(i=1; i<nArg; i++){
26525	if( i>1 ) oputz(" ");
26526	oputz(azArg[i]);
26527	}
26528	oputz("\n");
26529	}else
26530
26531	#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
26532	if( c=='p' && n>=3 && cli_strncmp(azArg[0], "progress", n)==0 ){
26533	int i;
	@@ -25823,19 +26552,19 @@
26552	p->flgProgress \|= SHELL_PROGRESS_ONCE;
26553	continue;
26554	}
26555	if( cli_strcmp(z,"limit")==0 ){
26556	if( i+1>=nArg ){
26557	eputz("Error: missing argument on --limit\n");
26558	rc = 1;
26559	goto meta_command_exit;
26560	}else{
26561	p->mxProgress = (int)integerValue(azArg[++i]);
26562	}
26563	continue;
26564	}
26565	eputf("Error: unknown option: \"%s\"\n", azArg[i]);
26566	rc = 1;
26567	goto meta_command_exit;
26568	}else{
26569	nn = (int)integerValue(z);
26570	}
	@@ -25864,31 +26593,31 @@
26593	if( c=='r' && n>=3 && cli_strncmp(azArg[0], "read", n)==0 ){
26594	FILE *inSaved = p->in;
26595	int savedLineno = p->lineno;
26596	failIfSafeMode(p, "cannot run .read in safe mode");
26597	if( nArg!=2 ){
26598	eputz("Usage: .read FILE\n");
26599	rc = 1;
26600	goto meta_command_exit;
26601	}
26602	if( azArg[1][0]=='\|' ){
26603	#ifdef SQLITE_OMIT_POPEN
26604	eputz("Error: pipes are not supported in this OS\n");
26605	rc = 1;
26606	p->out = stdout;
26607	#else
26608	p->in = popen(azArg[1]+1, "r");
26609	if( p->in==0 ){
26610	eputf("Error: cannot open \"%s\"\n", azArg[1]);
26611	rc = 1;
26612	}else{
26613	rc = process_input(p);
26614	pclose(p->in);
26615	}
26616	#endif
26617	}else if( (p->in = openChrSource(azArg[1]))==0 ){
26618	eputf("Error: cannot open \"%s\"\n", azArg[1]);
26619	rc = 1;
26620	}else{
26621	rc = process_input(p);
26622	fclose(p->in);
26623	}
	@@ -25911,24 +26640,24 @@
26640	zDb = "main";
26641	}else if( nArg==3 ){
26642	zSrcFile = azArg[2];
26643	zDb = azArg[1];
26644	}else{
26645	eputz("Usage: .restore ?DB? FILE\n");
26646	rc = 1;
26647	goto meta_command_exit;
26648	}
26649	rc = sqlite3_open(zSrcFile, &pSrc);
26650	if( rc!=SQLITE_OK ){
26651	eputf("Error: cannot open \"%s\"\n", zSrcFile);
26652	close_db(pSrc);
26653	return 1;
26654	}
26655	open_db(p, 0);
26656	pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
26657	if( pBackup==0 ){
26658	eputf("Error: %s\n", sqlite3_errmsg(p->db));
26659	close_db(pSrc);
26660	return 1;
26661	}
26662	while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
26663	\|\| rc==SQLITE_BUSY ){
	@@ -25939,14 +26668,14 @@
26668	}
26669	sqlite3_backup_finish(pBackup);
26670	if( rc==SQLITE_DONE ){
26671	rc = 0;
26672	}else if( rc==SQLITE_BUSY \|\| rc==SQLITE_LOCKED ){
26673	eputz("Error: source database is busy\n");
26674	rc = 1;
26675	}else{
26676	eputf("Error: %s\n", sqlite3_errmsg(p->db));
26677	rc = 1;
26678	}
26679	close_db(pSrc);
26680	}else
26681	#endif /* !defined(SQLITE_SHELL_FIDDLE) */
	@@ -25963,15 +26692,19 @@
26692	}
26693	open_db(p, 0);
26694	sqlite3_db_config(
26695	p->db, SQLITE_DBCONFIG_STMT_SCANSTATUS, p->scanstatsOn, (int*)0
26696	);
26697	#if !defined(SQLITE_ENABLE_STMT_SCANSTATUS)
26698	eputz("Warning: .scanstats not available in this build.\n");
26699	#elif !defined(SQLITE_ENABLE_BYTECODE_VTAB)
26700	if( p->scanstatsOn==3 ){
26701	eputz("Warning: \".scanstats vm\" not available in this build.\n");
26702	}
26703	#endif
26704	}else{
26705	eputz("Usage: .scanstats on\|off\|est\n");
26706	rc = 1;
26707	}
26708	}else
26709
26710	if( c=='s' && cli_strncmp(azArg[0], "schema", n)==0 ){
	@@ -25996,18 +26729,17 @@
26729	}else if( optionMatch(azArg[ii],"debug") ){
26730	bDebug = 1;
26731	}else if( optionMatch(azArg[ii],"nosys") ){
26732	bNoSystemTabs = 1;
26733	}else if( azArg[ii][0]=='-' ){
26734	eputf("Unknown option: \"%s\"\n", azArg[ii]);
26735	rc = 1;
26736	goto meta_command_exit;
26737	}else if( zName==0 ){
26738	zName = azArg[ii];
26739	}else{
26740	eputz("Usage: .schema ?--indent? ?--nosys? ?LIKE-PATTERN?\n");

26741	rc = 1;
26742	goto meta_command_exit;
26743	}
26744	}
26745	if( zName!=0 ){
	@@ -26036,11 +26768,11 @@
26768	if( zDiv ){
26769	sqlite3_stmt *pStmt = 0;
26770	rc = sqlite3_prepare_v2(p->db, "SELECT name FROM pragma_database_list",
26771	-1, &pStmt, 0);
26772	if( rc ){
26773	eputf("Error: %s\n", sqlite3_errmsg(p->db));
26774	sqlite3_finalize(pStmt);
26775	rc = 1;
26776	goto meta_command_exit;
26777	}
26778	appendText(&sSelect, "SELECT sql FROM", 0);
	@@ -26098,22 +26830,22 @@
26830	appendText(&sSelect, "name NOT LIKE 'sqlite_%%' AND ", 0);
26831	}
26832	appendText(&sSelect, "sql IS NOT NULL"
26833	" ORDER BY snum, rowid", 0);
26834	if( bDebug ){
26835	oputf("SQL: %s;\n", sSelect.z);
26836	}else{
26837	rc = sqlite3_exec(p->db, sSelect.z, callback, &data, &zErrMsg);
26838	}
26839	freeText(&sSelect);
26840	}
26841	if( zErrMsg ){
26842	eputf("Error: %s\n", zErrMsg);
26843	sqlite3_free(zErrMsg);
26844	rc = 1;
26845	}else if( rc != SQLITE_OK ){
26846	eputz("Error: querying schema information\n");
26847	rc = 1;
26848	}else{
26849	rc = 0;
26850	}
26851	}else
	@@ -26155,15 +26887,15 @@
26887	*/
26888	if( cli_strcmp(azCmd[0],"attach")==0 ){
26889	if( nCmd!=2 ) goto session_syntax_error;
26890	if( pSession->p==0 ){
26891	session_not_open:
26892	eputz("ERROR: No sessions are open\n");
26893	}else{
26894	rc = sqlite3session_attach(pSession->p, azCmd[1]);
26895	if( rc ){
26896	eputf("ERROR: sqlite3session_attach() returns %d\n",rc);
26897	rc = 0;
26898	}
26899	}
26900	}else
26901
	@@ -26178,28 +26910,27 @@
26910	failIfSafeMode(p, "cannot run \".session %s\" in safe mode", azCmd[0]);
26911	if( nCmd!=2 ) goto session_syntax_error;
26912	if( pSession->p==0 ) goto session_not_open;
26913	out = fopen(azCmd[1], "wb");
26914	if( out==0 ){
26915	eputf("ERROR: cannot open \"%s\" for writing\n",
26916	azCmd[1]);
26917	}else{
26918	int szChng;
26919	void *pChng;
26920	if( azCmd[0][0]=='c' ){
26921	rc = sqlite3session_changeset(pSession->p, &szChng, &pChng);
26922	}else{
26923	rc = sqlite3session_patchset(pSession->p, &szChng, &pChng);
26924	}
26925	if( rc ){
26926	sputf(stdout, "Error: error code %d\n", rc);
26927	rc = 0;
26928	}
26929	if( pChng
26930	&& fwrite(pChng, szChng, 1, out)!=1 ){
26931	eputf("ERROR: Failed to write entire %d-byte output\n", szChng);

26932	}
26933	sqlite3_free(pChng);
26934	fclose(out);
26935	}
26936	}else
	@@ -26222,12 +26953,11 @@
26953	int ii;
26954	if( nCmd>2 ) goto session_syntax_error;
26955	ii = nCmd==1 ? -1 : booleanValue(azCmd[1]);
26956	if( pAuxDb->nSession ){
26957	ii = sqlite3session_enable(pSession->p, ii);
26958	oputf("session %s enable flag = %d\n", pSession->zName, ii);

26959	}
26960	}else
26961
26962	/* .session filter GLOB ....
26963	** Set a list of GLOB patterns of table names to be excluded.
	@@ -26240,14 +26970,11 @@
26970	sqlite3_free(pSession->azFilter[ii]);
26971	}
26972	sqlite3_free(pSession->azFilter);
26973	nByte = sizeof(pSession->azFilter[0])*(nCmd-1);
26974	pSession->azFilter = sqlite3_malloc( nByte );
26975	shell_check_oom( pSession->azFilter );



26976	for(ii=1; ii<nCmd; ii++){
26977	char *x = pSession->azFilter[ii-1] = sqlite3_mprintf("%s", azCmd[ii]);
26978	shell_check_oom(x);
26979	}
26980	pSession->nFilter = ii-1;
	@@ -26261,12 +26988,11 @@
26988	int ii;
26989	if( nCmd>2 ) goto session_syntax_error;
26990	ii = nCmd==1 ? -1 : booleanValue(azCmd[1]);
26991	if( pAuxDb->nSession ){
26992	ii = sqlite3session_indirect(pSession->p, ii);
26993	oputf("session %s indirect flag = %d\n", pSession->zName, ii);

26994	}
26995	}else
26996
26997	/* .session isempty
26998	** Determine if the session is empty
	@@ -26274,21 +27000,20 @@
27000	if( cli_strcmp(azCmd[0], "isempty")==0 ){
27001	int ii;
27002	if( nCmd!=1 ) goto session_syntax_error;
27003	if( pAuxDb->nSession ){
27004	ii = sqlite3session_isempty(pSession->p);
27005	oputf("session %s isempty flag = %d\n", pSession->zName, ii);

27006	}
27007	}else
27008
27009	/* .session list
27010	** List all currently open sessions
27011	*/
27012	if( cli_strcmp(azCmd[0],"list")==0 ){
27013	for(i=0; i<pAuxDb->nSession; i++){
27014	oputf("%d %s\n", i, pAuxDb->aSession[i].zName);
27015	}
27016	}else
27017
27018	/* .session open DB NAME
27019	** Open a new session called NAME on the attached database DB.
	@@ -26299,23 +27024,22 @@
27024	if( nCmd!=3 ) goto session_syntax_error;
27025	zName = azCmd[2];
27026	if( zName[0]==0 ) goto session_syntax_error;
27027	for(i=0; i<pAuxDb->nSession; i++){
27028	if( cli_strcmp(pAuxDb->aSession[i].zName,zName)==0 ){
27029	eputf("Session \"%s\" already exists\n", zName);
27030	goto meta_command_exit;
27031	}
27032	}
27033	if( pAuxDb->nSession>=ArraySize(pAuxDb->aSession) ){
27034	eputf("Maximum of %d sessions\n", ArraySize(pAuxDb->aSession));

27035	goto meta_command_exit;
27036	}
27037	pSession = &pAuxDb->aSession[pAuxDb->nSession];
27038	rc = sqlite3session_create(p->db, azCmd[1], &pSession->p);
27039	if( rc ){
27040	eputf("Cannot open session: error code=%d\n", rc);
27041	rc = 0;
27042	goto meta_command_exit;
27043	}
27044	pSession->nFilter = 0;
27045	sqlite3session_table_filter(pSession->p, session_filter, pSession);
	@@ -26335,20 +27059,20 @@
27059	if( c=='s' && n>=10 && cli_strncmp(azArg[0], "selftest-", 9)==0 ){
27060	if( cli_strncmp(azArg[0]+9, "boolean", n-9)==0 ){
27061	int i, v;
27062	for(i=1; i<nArg; i++){
27063	v = booleanValue(azArg[i]);
27064	oputf("%s: %d 0x%x\n", azArg[i], v, v);
27065	}
27066	}
27067	if( cli_strncmp(azArg[0]+9, "integer", n-9)==0 ){
27068	int i; sqlite3_int64 v;
27069	for(i=1; i<nArg; i++){
27070	char zBuf[200];
27071	v = integerValue(azArg[i]);
27072	sqlite3_snprintf(sizeof(zBuf),zBuf,"%s: %lld 0x%llx\n", azArg[i],v,v);
27073	oputz(zBuf);
27074	}
27075	}
27076	}else
27077	#endif
27078
	@@ -26371,13 +27095,12 @@
27095	}else
27096	if( cli_strcmp(z,"-v")==0 ){
27097	bVerbose++;
27098	}else
27099	{
27100	eputf("Unknown option \"%s\" on \"%s\"\n", azArg[i], azArg[0]);
27101	eputz("Should be one of: --init -v\n");

27102	rc = 1;
27103	goto meta_command_exit;
27104	}
27105	}
27106	if( sqlite3_table_column_metadata(p->db,"main","selftest",0,0,0,0,0,0)
	@@ -26402,11 +27125,11 @@
27125	"VALUES(0,'memo','Missing SELFTEST table - default checks only',''),"
27126	" (1,'run','PRAGMA integrity_check','ok')",
27127	-1, &pStmt, 0);
27128	}
27129	if( rc ){
27130	eputz("Error querying the selftest table\n");
27131	rc = 1;
27132	sqlite3_finalize(pStmt);
27133	goto meta_command_exit;
27134	}
27135	for(i=1; sqlite3_step(pStmt)==SQLITE_ROW; i++){
	@@ -26418,52 +27141,51 @@
27141	if( zOp==0 ) continue;
27142	if( zSql==0 ) continue;
27143	if( zAns==0 ) continue;
27144	k = 0;
27145	if( bVerbose>0 ){
27146	sputf(stdout, "%d: %s %s\n", tno, zOp, zSql);
27147	}
27148	if( cli_strcmp(zOp,"memo")==0 ){
27149	oputf("%s\n", zSql);
27150	}else
27151	if( cli_strcmp(zOp,"run")==0 ){
27152	char *zErrMsg = 0;
27153	str.n = 0;
27154	str.z[0] = 0;
27155	rc = sqlite3_exec(p->db, zSql, captureOutputCallback, &str, &zErrMsg);
27156	nTest++;
27157	if( bVerbose ){
27158	oputf("Result: %s\n", str.z);
27159	}
27160	if( rc \|\| zErrMsg ){
27161	nErr++;
27162	rc = 1;
27163	oputf("%d: error-code-%d: %s\n", tno, rc, zErrMsg);
27164	sqlite3_free(zErrMsg);
27165	}else if( cli_strcmp(zAns,str.z)!=0 ){
27166	nErr++;
27167	rc = 1;
27168	oputf("%d: Expected: [%s]\n", tno, zAns);
27169	oputf("%d: Got: [%s]\n", tno, str.z);
27170	}
27171	}
27172	else{
27173	eputf("Unknown operation \"%s\" on selftest line %d\n", zOp, tno);

27174	rc = 1;
27175	break;
27176	}
27177	} /* End loop over rows of content from SELFTEST */
27178	sqlite3_finalize(pStmt);
27179	} /* End loop over k */
27180	freeText(&str);
27181	oputf("%d errors out of %d tests\n", nErr, nTest);
27182	}else
27183
27184	if( c=='s' && cli_strncmp(azArg[0], "separator", n)==0 ){
27185	if( nArg<2 \|\| nArg>3 ){
27186	eputz("Usage: .separator COL ?ROW?\n");
27187	rc = 1;
27188	}
27189	if( nArg>=2 ){
27190	sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator,
27191	"%.*s", (int)ArraySize(p->colSeparator)-1, azArg[1]);
	@@ -26502,18 +27224,17 @@
27224	}else
27225	if( cli_strcmp(z,"debug")==0 ){
27226	bDebug = 1;
27227	}else
27228	{
27229	eputf("Unknown option \"%s\" on \"%s\"\n", azArg[i], azArg[0]);

27230	showHelp(p->out, azArg[0]);
27231	rc = 1;
27232	goto meta_command_exit;
27233	}
27234	}else if( zLike ){
27235	eputz("Usage: .sha3sum ?OPTIONS? ?LIKE-PATTERN?\n");
27236	rc = 1;
27237	goto meta_command_exit;
27238	}else{
27239	zLike = z;
27240	bSeparate = 1;
	@@ -26581,11 +27302,11 @@
27302	}
27303	shell_check_oom(zSql);
27304	freeText(&sQuery);
27305	freeText(&sSql);
27306	if( bDebug ){
27307	oputf("%s\n", zSql);
27308	}else{
27309	shell_exec(p, zSql, 0);
27310	}
27311	#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) && !defined(SQLITE_OMIT_VIRTUALTABLE)
27312	{
	@@ -26611,11 +27332,11 @@
27332	"\|\|group_concat('CAST(CAST('\|\|cname\|\|' AS BLOB) AS TEXT)<>'\|\|cname\n"
27333	"\|\| ' AND typeof('\|\|cname\|\|')=''text'' ',\n"
27334	"' OR ') as query, tname from tabcols group by tname)"
27335	, zRevText);
27336	shell_check_oom(zRevText);
27337	if( bDebug ) oputf("%s\n", zRevText);
27338	lrc = sqlite3_prepare_v2(p->db, zRevText, -1, &pStmt, 0);
27339	if( lrc!=SQLITE_OK ){
27340	/* assert(lrc==SQLITE_NOMEM); // might also be SQLITE_ERROR if the
27341	** user does cruel and unnatural things like ".limit expr_depth 0". */
27342	rc = 1;
	@@ -26624,29 +27345,28 @@
27345	lrc = SQLITE_ROW==sqlite3_step(pStmt);
27346	if( lrc ){
27347	const char zGenQuery = (char)sqlite3_column_text(pStmt,0);
27348	sqlite3_stmt *pCheckStmt;
27349	lrc = sqlite3_prepare_v2(p->db, zGenQuery, -1, &pCheckStmt, 0);
27350	if( bDebug ) oputf("%s\n", zGenQuery);
27351	if( lrc!=SQLITE_OK ){
27352	rc = 1;
27353	}else{
27354	if( SQLITE_ROW==sqlite3_step(pCheckStmt) ){
27355	double countIrreversible = sqlite3_column_double(pCheckStmt, 0);
27356	if( countIrreversible>0 ){
27357	int sz = (int)(countIrreversible + 0.5);
27358	eputf("Digest includes %d invalidly encoded text field%s.\n",
27359	sz, (sz>1)? "s": "");

27360	}
27361	}
27362	sqlite3_finalize(pCheckStmt);
27363	}
27364	sqlite3_finalize(pStmt);
27365	}
27366	}
27367	if( rc ) eputz(".sha3sum failed.\n");
27368	sqlite3_free(zRevText);
27369	}
27370	#endif /* !defined(_OMIT_SCHEMA_PRAGMAS) && !defined(_OMIT_VIRTUALTABLE) */
27371	sqlite3_free(zSql);
27372	}else
	@@ -26658,76 +27378,77 @@
27378	){
27379	char *zCmd;
27380	int i, x;
27381	failIfSafeMode(p, "cannot run .%s in safe mode", azArg[0]);
27382	if( nArg<2 ){
27383	eputz("Usage: .system COMMAND\n");
27384	rc = 1;
27385	goto meta_command_exit;
27386	}
27387	zCmd = sqlite3_mprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]);
27388	for(i=2; i<nArg && zCmd!=0; i++){
27389	zCmd = sqlite3_mprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"",
27390	zCmd, azArg[i]);
27391	}
27392	consoleRestore();
27393	x = zCmd!=0 ? system(zCmd) : 1;
27394	consoleRenewSetup();
27395	sqlite3_free(zCmd);
27396	if( x ) eputf("System command returns %d\n", x);
27397	}else
27398	#endif /* !defined(SQLITE_NOHAVE_SYSTEM) && !defined(SQLITE_SHELL_FIDDLE) */
27399
27400	if( c=='s' && cli_strncmp(azArg[0], "show", n)==0 ){
27401	static const char *azBool[] = { "off", "on", "trigger", "full"};
27402	const char *zOut;
27403	int i;
27404	if( nArg!=1 ){
27405	eputz("Usage: .show\n");
27406	rc = 1;
27407	goto meta_command_exit;
27408	}
27409	oputf("%12.12s: %s\n","echo",
27410	azBool[ShellHasFlag(p, SHFLG_Echo)]);
27411	oputf("%12.12s: %s\n","eqp", azBool[p->autoEQP&3]);
27412	oputf("%12.12s: %s\n","explain",
27413	p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off");
27414	oputf("%12.12s: %s\n","headers", azBool[p->showHeader!=0]);
27415	if( p->mode==MODE_Column
27416	\|\| (p->mode>=MODE_Markdown && p->mode<=MODE_Box)
27417	){
27418	oputf("%12.12s: %s --wrap %d --wordwrap %s --%squote\n", "mode",
27419	modeDescr[p->mode], p->cmOpts.iWrap,
27420	p->cmOpts.bWordWrap ? "on" : "off",
27421	p->cmOpts.bQuote ? "" : "no");

27422	}else{
27423	oputf("%12.12s: %s\n","mode", modeDescr[p->mode]);
27424	}
27425	oputf("%12.12s: ", "nullvalue");
27426	output_c_string(p->nullValue);
27427	oputz("\n");
27428	oputf("%12.12s: %s\n","output",
27429	strlen30(p->outfile) ? p->outfile : "stdout");
27430	oputf("%12.12s: ", "colseparator");
27431	output_c_string(p->colSeparator);
27432	oputz("\n");
27433	oputf("%12.12s: ", "rowseparator");
27434	output_c_string(p->rowSeparator);
27435	oputz("\n");
27436	switch( p->statsOn ){
27437	case 0: zOut = "off"; break;
27438	default: zOut = "on"; break;
27439	case 2: zOut = "stmt"; break;
27440	case 3: zOut = "vmstep"; break;
27441	}
27442	oputf("%12.12s: %s\n","stats", zOut);
27443	oputf("%12.12s: ", "width");
27444	for (i=0;i<p->nWidth;i++) {
27445	oputf("%d ", p->colWidth[i]);
27446	}
27447	oputz("\n");
27448	oputf("%12.12s: %s\n", "filename",
27449	p->pAuxDb->zDbFilename ? p->pAuxDb->zDbFilename : "");
27450	}else
27451
27452	if( c=='s' && cli_strncmp(azArg[0], "stats", n)==0 ){
27453	if( nArg==2 ){
27454	if( cli_strcmp(azArg[1],"stmt")==0 ){
	@@ -26738,11 +27459,11 @@
27459	p->statsOn = (u8)booleanValue(azArg[1]);
27460	}
27461	}else if( nArg==1 ){
27462	display_stats(p->db, p, 0);
27463	}else{
27464	eputz("Usage: .stats ?on\|off\|stmt\|vmstep?\n");
27465	rc = 1;
27466	}
27467	}else
27468
27469	if( (c=='t' && n>1 && cli_strncmp(azArg[0], "tables", n)==0)
	@@ -26764,11 +27485,11 @@
27485
27486	if( nArg>2 && c=='i' ){
27487	/* It is an historical accident that the .indexes command shows an error
27488	** when called with the wrong number of arguments whereas the .tables
27489	** command does not. */
27490	eputz("Usage: .indexes ?LIKE-PATTERN?\n");
27491	rc = 1;
27492	sqlite3_finalize(pStmt);
27493	goto meta_command_exit;
27494	}
27495	for(ii=0; sqlite3_step(pStmt)==SQLITE_ROW; ii++){
	@@ -26840,14 +27561,13 @@
27561	if( nPrintCol<1 ) nPrintCol = 1;
27562	nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
27563	for(i=0; i<nPrintRow; i++){
27564	for(j=i; j<nRow; j+=nPrintRow){
27565	char *zSp = j<nPrintRow ? "" : " ";
27566	oputf("%s%-*s", zSp, maxlen, azResult[j] ? azResult[j]:"");

27567	}
27568	oputz("\n");
27569	}
27570	}
27571
27572	for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]);
27573	sqlite3_free(azResult);
	@@ -26857,11 +27577,11 @@
27577	/* Begin redirecting output to the file "testcase-out.txt" */
27578	if( c=='t' && cli_strcmp(azArg[0],"testcase")==0 ){
27579	output_reset(p);
27580	p->out = output_file_open("testcase-out.txt", 0);
27581	if( p->out==0 ){
27582	eputz("Error: cannot open 'testcase-out.txt'\n");
27583	}
27584	if( nArg>=2 ){
27585	sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "%s", azArg[1]);
27586	}else{
27587	sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "?");
	@@ -26898,11 +27618,11 @@
27618	{"prng_save", SQLITE_TESTCTRL_PRNG_SAVE, 0, "" },
27619	{"prng_seed", SQLITE_TESTCTRL_PRNG_SEED, 0, "SEED ?db?" },
27620	{"seek_count", SQLITE_TESTCTRL_SEEK_COUNT, 0, "" },
27621	{"sorter_mmap", SQLITE_TESTCTRL_SORTER_MMAP, 0, "NMAX" },
27622	{"tune", SQLITE_TESTCTRL_TUNE, 1, "ID VALUE" },
27623	{"uselongdouble", SQLITE_TESTCTRL_USELONGDOUBLE,0,"?BOOLEAN\|\"default\"?"},
27624	};
27625	int testctrl = -1;
27626	int iCtrl = -1;
27627	int rc2 = 0; /* 0: usage. 1: %d 2: %x 3: no-output */
27628	int isOk = 0;
	@@ -26918,15 +27638,15 @@
27638	if( zCmd[0]=='-' && zCmd[1] ) zCmd++;
27639	}
27640
27641	/* --help lists all test-controls */
27642	if( cli_strcmp(zCmd,"help")==0 ){
27643	oputz("Available test-controls:\n");
27644	for(i=0; i<ArraySize(aCtrl); i++){
27645	if( aCtrl[i].unSafe && !ShellHasFlag(p,SHFLG_TestingMode) ) continue;
27646	oputf(" .testctrl %s %s\n",
27647	aCtrl[i].zCtrlName, aCtrl[i].zUsage);
27648	}
27649	rc = 1;
27650	goto meta_command_exit;
27651	}
27652
	@@ -26938,20 +27658,20 @@
27658	if( cli_strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){
27659	if( testctrl<0 ){
27660	testctrl = aCtrl[i].ctrlCode;
27661	iCtrl = i;
27662	}else{
27663	eputf("Error: ambiguous test-control: \"%s\"\n"
27664	"Use \".testctrl --help\" for help\n", zCmd);
27665	rc = 1;
27666	goto meta_command_exit;
27667	}
27668	}
27669	}
27670	if( testctrl<0 ){
27671	eputf("Error: unknown test-control: %s\n"
27672	"Use \".testctrl --help\" for help\n", zCmd);
27673	}else{
27674	switch(testctrl){
27675
27676	/* sqlite3_test_control(int, db, int) */
27677	case SQLITE_TESTCTRL_OPTIMIZATIONS:
	@@ -26987,11 +27707,11 @@
27707	if( nArg==3 \|\| nArg==4 ){
27708	int ii = (int)integerValue(azArg[2]);
27709	sqlite3 *db;
27710	if( ii==0 && cli_strcmp(azArg[2],"random")==0 ){
27711	sqlite3_randomness(sizeof(ii),&ii);
27712	sputf(stdout, "-- random seed: %d\n", ii);
27713	}
27714	if( nArg==3 ){
27715	db = 0;
27716	}else{
27717	db = p->db;
	@@ -27055,11 +27775,11 @@
27775	break;
27776
27777	case SQLITE_TESTCTRL_SEEK_COUNT: {
27778	u64 x = 0;
27779	rc2 = sqlite3_test_control(testctrl, p->db, &x);
27780	oputf("%llu\n", x);
27781	isOk = 3;
27782	break;
27783	}
27784
27785	#ifdef YYCOVERAGE
	@@ -27086,15 +27806,15 @@
27806	int id = 1;
27807	while(1){
27808	int val = 0;
27809	rc2 = sqlite3_test_control(testctrl, -id, &val);
27810	if( rc2!=SQLITE_OK ) break;
27811	if( id>1 ) oputz(" ");
27812	oputf("%d: %d", id, val);
27813	id++;
27814	}
27815	if( id>1 ) oputz("\n");
27816	isOk = 3;
27817	}
27818	break;
27819	}
27820	#endif
	@@ -27106,16 +27826,16 @@
27826	}
27827	break;
27828	}
27829	}
27830	if( isOk==0 && iCtrl>=0 ){
27831	oputf("Usage: .testctrl %s %s\n", zCmd,aCtrl[iCtrl].zUsage);
27832	rc = 1;
27833	}else if( isOk==1 ){
27834	oputf("%d\n", rc2);
27835	}else if( isOk==2 ){
27836	oputf("0x%08x\n", rc2);
27837	}
27838	}else
27839	#endif /* !defined(SQLITE_UNTESTABLE) */
27840
27841	if( c=='t' && n>4 && cli_strncmp(azArg[0], "timeout", n)==0 ){
	@@ -27125,15 +27845,15 @@
27845
27846	if( c=='t' && n>=5 && cli_strncmp(azArg[0], "timer", n)==0 ){
27847	if( nArg==2 ){
27848	enableTimer = booleanValue(azArg[1]);
27849	if( enableTimer && !HAS_TIMER ){
27850	eputz("Error: timer not available on this system.\n");
27851	enableTimer = 0;
27852	}
27853	}else{
27854	eputz("Usage: .timer on\|off\n");
27855	rc = 1;
27856	}
27857	}else
27858
27859	#ifndef SQLITE_OMIT_TRACE
	@@ -27166,11 +27886,11 @@
27886	}
27887	else if( optionMatch(z, "close") ){
27888	mType \|= SQLITE_TRACE_CLOSE;
27889	}
27890	else {
27891	eputf("Unknown option \"%s\" on \".trace\"\n", z);
27892	rc = 1;
27893	goto meta_command_exit;
27894	}
27895	}else{
27896	output_file_close(p->traceOut);
	@@ -27190,11 +27910,11 @@
27910	if( c=='u' && cli_strncmp(azArg[0], "unmodule", n)==0 ){
27911	int ii;
27912	int lenOpt;
27913	char *zOpt;
27914	if( nArg<2 ){
27915	eputz("Usage: .unmodule [--allexcept] NAME ...\n");
27916	rc = 1;
27917	goto meta_command_exit;
27918	}
27919	open_db(p, 0);
27920	zOpt = azArg[1];
	@@ -27212,100 +27932,100 @@
27932	#endif
27933
27934	#if SQLITE_USER_AUTHENTICATION
27935	if( c=='u' && cli_strncmp(azArg[0], "user", n)==0 ){
27936	if( nArg<2 ){
27937	eputz("Usage: .user SUBCOMMAND ...\n");
27938	rc = 1;
27939	goto meta_command_exit;
27940	}
27941	open_db(p, 0);
27942	if( cli_strcmp(azArg[1],"login")==0 ){
27943	if( nArg!=4 ){
27944	eputz("Usage: .user login USER PASSWORD\n");
27945	rc = 1;
27946	goto meta_command_exit;
27947	}
27948	rc = sqlite3_user_authenticate(p->db, azArg[2], azArg[3],
27949	strlen30(azArg[3]));
27950	if( rc ){
27951	eputf("Authentication failed for user %s\n", azArg[2]);
27952	rc = 1;
27953	}
27954	}else if( cli_strcmp(azArg[1],"add")==0 ){
27955	if( nArg!=5 ){
27956	eputz("Usage: .user add USER PASSWORD ISADMIN\n");
27957	rc = 1;
27958	goto meta_command_exit;
27959	}
27960	rc = sqlite3_user_add(p->db, azArg[2], azArg[3], strlen30(azArg[3]),
27961	booleanValue(azArg[4]));
27962	if( rc ){
27963	eputf("User-Add failed: %d\n", rc);
27964	rc = 1;
27965	}
27966	}else if( cli_strcmp(azArg[1],"edit")==0 ){
27967	if( nArg!=5 ){
27968	eputz("Usage: .user edit USER PASSWORD ISADMIN\n");
27969	rc = 1;
27970	goto meta_command_exit;
27971	}
27972	rc = sqlite3_user_change(p->db, azArg[2], azArg[3], strlen30(azArg[3]),
27973	booleanValue(azArg[4]));
27974	if( rc ){
27975	eputf("User-Edit failed: %d\n", rc);
27976	rc = 1;
27977	}
27978	}else if( cli_strcmp(azArg[1],"delete")==0 ){
27979	if( nArg!=3 ){
27980	eputz("Usage: .user delete USER\n");
27981	rc = 1;
27982	goto meta_command_exit;
27983	}
27984	rc = sqlite3_user_delete(p->db, azArg[2]);
27985	if( rc ){
27986	eputf("User-Delete failed: %d\n", rc);
27987	rc = 1;
27988	}
27989	}else{
27990	eputz("Usage: .user login\|add\|edit\|delete ...\n");
27991	rc = 1;
27992	goto meta_command_exit;
27993	}
27994	}else
27995	#endif /* SQLITE_USER_AUTHENTICATION */
27996
27997	if( c=='v' && cli_strncmp(azArg[0], "version", n)==0 ){
27998	char zPtrSz = sizeof(void)==8 ? "64-bit" : "32-bit";
27999	oputf("SQLite %s %s\n" /extra-version-info/,
28000	sqlite3_libversion(), sqlite3_sourceid());
28001	#if SQLITE_HAVE_ZLIB
28002	oputf("zlib version %s\n", zlibVersion());
28003	#endif
28004	#define CTIMEOPT_VAL_(opt) #opt
28005	#define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt)
28006	#if defined(__clang__) && defined(__clang_major__)
28007	oputf("clang-" CTIMEOPT_VAL(__clang_major__) "."
28008	CTIMEOPT_VAL(__clang_minor__) "."
28009	CTIMEOPT_VAL(__clang_patchlevel__) " (%s)\n", zPtrSz);
28010	#elif defined(_MSC_VER)
28011	oputf("msvc-" CTIMEOPT_VAL(_MSC_VER) " (%s)\n", zPtrSz);
28012	#elif defined(__GNUC__) && defined(__VERSION__)
28013	oputf("gcc-" __VERSION__ " (%s)\n", zPtrSz);
28014	#endif
28015	}else
28016
28017	if( c=='v' && cli_strncmp(azArg[0], "vfsinfo", n)==0 ){
28018	const char *zDbName = nArg==2 ? azArg[1] : "main";
28019	sqlite3_vfs *pVfs = 0;
28020	if( p->db ){
28021	sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFS_POINTER, &pVfs);
28022	if( pVfs ){
28023	oputf("vfs.zName = \"%s\"\n", pVfs->zName);
28024	oputf("vfs.iVersion = %d\n", pVfs->iVersion);
28025	oputf("vfs.szOsFile = %d\n", pVfs->szOsFile);
28026	oputf("vfs.mxPathname = %d\n", pVfs->mxPathname);
28027	}
28028	}
28029	}else
28030
28031	if( c=='v' && cli_strncmp(azArg[0], "vfslist", n)==0 ){
	@@ -27313,17 +28033,17 @@
28033	sqlite3_vfs *pCurrent = 0;
28034	if( p->db ){
28035	sqlite3_file_control(p->db, "main", SQLITE_FCNTL_VFS_POINTER, &pCurrent);
28036	}
28037	for(pVfs=sqlite3_vfs_find(0); pVfs; pVfs=pVfs->pNext){
28038	oputf("vfs.zName = \"%s\"%s\n", pVfs->zName,
28039	pVfs==pCurrent ? " <--- CURRENT" : "");
28040	oputf("vfs.iVersion = %d\n", pVfs->iVersion);
28041	oputf("vfs.szOsFile = %d\n", pVfs->szOsFile);
28042	oputf("vfs.mxPathname = %d\n", pVfs->mxPathname);
28043	if( pVfs->pNext ){
28044	oputz("-----------------------------------\n");
28045	}
28046	}
28047	}else
28048
28049	if( c=='v' && cli_strncmp(azArg[0], "vfsname", n)==0 ){
	@@ -27330,11 +28050,11 @@
28050	const char *zDbName = nArg==2 ? azArg[1] : "main";
28051	char *zVfsName = 0;
28052	if( p->db ){
28053	sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName);
28054	if( zVfsName ){
28055	oputf("%s\n", zVfsName);
28056	sqlite3_free(zVfsName);
28057	}
28058	}
28059	}else
28060
	@@ -27354,12 +28074,12 @@
28074	p->colWidth[j-1] = (int)integerValue(azArg[j]);
28075	}
28076	}else
28077
28078	{
28079	eputf("Error: unknown command or invalid arguments: "
28080	" \"%s\". Enter \".help\" for help\n", azArg[0]);
28081	rc = 1;
28082	}
28083
28084	meta_command_exit:
28085	if( p->outCount ){
	@@ -27545,26 +28265,26 @@
28265	sqlite3_snprintf(sizeof(zPrefix), zPrefix,
28266	"%s near line %d:", zErrorType, startline);
28267	}else{
28268	sqlite3_snprintf(sizeof(zPrefix), zPrefix, "%s:", zErrorType);
28269	}
28270	eputf("%s %s\n", zPrefix, zErrorTail);
28271	sqlite3_free(zErrMsg);
28272	zErrMsg = 0;
28273	return 1;
28274	}else if( ShellHasFlag(p, SHFLG_CountChanges) ){
28275	char zLineBuf[2000];
28276	sqlite3_snprintf(sizeof(zLineBuf), zLineBuf,
28277	"changes: %lld total_changes: %lld",
28278	sqlite3_changes64(p->db), sqlite3_total_changes64(p->db));
28279	oputf("%s\n", zLineBuf);
28280	}
28281	return 0;
28282	}
28283
28284	static void echo_group_input(ShellState p, const char zDo){
28285	if( ShellHasFlag(p, SHFLG_Echo) ) oputf("%s\n", zDo);
28286	}
28287
28288	#ifdef SQLITE_SHELL_FIDDLE
28289	/*
28290	** Alternate one_input_line() impl for wasm mode. This is not in the primary
	@@ -27618,12 +28338,12 @@
28338	i64 startline = 0; /* Line number for start of current input */
28339	QuickScanState qss = QSS_Start; /* Accumulated line status (so far) */
28340
28341	if( p->inputNesting==MAX_INPUT_NESTING ){
28342	/* This will be more informative in a later version. */
28343	eputf("Input nesting limit (%d) reached at line %d."
28344	" Check recursion.\n", MAX_INPUT_NESTING, p->lineno);
28345	return 1;
28346	}
28347	++p->inputNesting;
28348	p->lineno = 0;
28349	CONTINUE_PROMPT_RESET;
	@@ -27630,11 +28350,11 @@
28350	while( errCnt==0 \|\| !bail_on_error \|\| (p->in==0 && stdin_is_interactive) ){
28351	fflush(p->out);
28352	zLine = one_input_line(p->in, zLine, nSql>0);
28353	if( zLine==0 ){
28354	/* End of input */
28355	if( p->in==0 && stdin_is_interactive ) oputz("\n");
28356	break;
28357	}
28358	if( seenInterrupt ){
28359	if( p->in!=0 ) break;
28360	seenInterrupt = 0;
	@@ -27840,27 +28560,27 @@
28560	sqliterc = find_xdg_config();
28561	}
28562	if( sqliterc == NULL ){
28563	home_dir = find_home_dir(0);
28564	if( home_dir==0 ){
28565	eputz("-- warning: cannot find home directory;"
28566	" cannot read ~/.sqliterc\n");
28567	return;
28568	}
28569	zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir);
28570	shell_check_oom(zBuf);
28571	sqliterc = zBuf;
28572	}
28573	p->in = fopen(sqliterc,"rb");
28574	if( p->in ){
28575	if( stdin_is_interactive ){
28576	eputf("-- Loading resources from %s\n", sqliterc);
28577	}
28578	if( process_input(p) && bail_on_error ) exit(1);
28579	fclose(p->in);
28580	}else if( sqliterc_override!=0 ){
28581	eputf("cannot open: \"%s\"\n", sqliterc);
28582	if( bail_on_error ) exit(1);
28583	}
28584	p->in = inSaved;
28585	p->lineno = savedLineno;
28586	sqlite3_free(zBuf);
	@@ -27906,13 +28626,10 @@
28626	" -mmap N default mmap size set to N\n"
28627	#ifdef SQLITE_ENABLE_MULTIPLEX
28628	" -multiplex enable the multiplexor VFS\n"
28629	#endif
28630	" -newline SEP set output row separator. Default: '\\n'\n"



28631	" -nofollow refuse to open symbolic links to database files\n"
28632	" -nonce STRING set the safe-mode escape nonce\n"
28633	" -nullvalue TEXT set text string for NULL values. Default ''\n"
28634	" -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n"
28635	" -pcachetrace trace all page cache operations\n"
	@@ -27925,13 +28642,10 @@
28642	#endif
28643	" -stats print memory stats before each finalize\n"
28644	" -table set output mode to 'table'\n"
28645	" -tabs set output mode to 'tabs'\n"
28646	" -unsafe-testing allow unsafe commands and modes for testing\n"



28647	" -version show SQLite version\n"
28648	" -vfs NAME use NAME as the default VFS\n"
28649	#ifdef SQLITE_ENABLE_VFSTRACE
28650	" -vfstrace enable tracing of all VFS calls\n"
28651	#endif
	@@ -27938,18 +28652,17 @@
28652	#ifdef SQLITE_HAVE_ZLIB
28653	" -zip open the file as a ZIP Archive\n"
28654	#endif
28655	;
28656	static void usage(int showDetail){
28657	eputf("Usage: %s [OPTIONS] [FILENAME [SQL]]\n"
28658	"FILENAME is the name of an SQLite database. A new database is created\n"
28659	"if the file does not previously exist. Defaults to :memory:.\n", Argv0);

28660	if( showDetail ){
28661	eputf("OPTIONS include:\n%s", zOptions);
28662	}else{
28663	eputz("Use the -help option for additional information\n");
28664	}
28665	exit(1);
28666	}
28667
28668	/*
	@@ -27956,12 +28669,12 @@
28669	** Internal check: Verify that the SQLite is uninitialized. Print a
28670	** error message if it is initialized.
28671	*/
28672	static void verify_uninitialized(void){
28673	if( sqlite3_config(-1)==SQLITE_MISUSE ){
28674	sputz(stdout, "WARNING: attempt to configure SQLite after"
28675	" initialization.\n");
28676	}
28677	}
28678
28679	/*
28680	** Initialize the state information in data
	@@ -27986,46 +28699,45 @@
28699	}
28700
28701	/*
28702	** Output text to the console in a font that attracts extra attention.
28703	*/
28704	#if defined(_WIN32) \|\| defined(WIN32)
28705	static void printBold(const char *zText){
28706	#if !SQLITE_OS_WINRT
28707	HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
28708	CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo;
28709	GetConsoleScreenBufferInfo(out, &defaultScreenInfo);
28710	SetConsoleTextAttribute(out,
28711	FOREGROUND_RED\|FOREGROUND_INTENSITY
28712	);
28713	#endif
28714	oputz(zText);
28715	#if !SQLITE_OS_WINRT
28716	SetConsoleTextAttribute(out, defaultScreenInfo.wAttributes);
28717	#endif
28718	}
28719	#else
28720	static void printBold(const char *zText){
28721	oputf("\033[1m%s\033[0m", zText);
28722	}
28723	#endif
28724
28725	/*
28726	** Get the argument to an --option. Throw an error and die if no argument
28727	** is available.
28728	*/
28729	static char cmdline_option_value(int argc, char *argv, int i){
28730	if( i==argc ){
28731	eputf("%s: Error: missing argument to %s\n", argv[0], argv[argc-1]);

28732	exit(1);
28733	}
28734	return argv[i];
28735	}
28736
28737	static void sayAbnormalExit(void){
28738	if( seenInterrupt ) eputz("Program interrupted.\n");
28739	}
28740
28741	#ifndef SQLITE_SHELL_IS_UTF8
28742	# if (defined(_WIN32) \|\| defined(WIN32)) \
28743	&& (defined(_MSC_VER) \|\| (defined(UNICODE) && defined(__GNUC__)))
	@@ -28051,10 +28763,11 @@
28763	char *zErrMsg = 0;
28764	#ifdef SQLITE_SHELL_FIDDLE
28765	# define data shellState
28766	#else
28767	ShellState data;
28768	StreamsAreConsole consStreams = SAC_NoConsole;
28769	#endif
28770	const char *zInitFile = 0;
28771	int i;
28772	int rc = 0;
28773	int warnInmemoryDb = 0;
	@@ -28072,27 +28785,24 @@
28785	#ifdef SQLITE_SHELL_FIDDLE
28786	stdin_is_interactive = 0;
28787	stdout_is_console = 1;
28788	data.wasm.zDefaultDbName = "/fiddle.sqlite3";
28789	#else
28790	consStreams = consoleClassifySetup(stdin, stdout, stderr);
28791	stdin_is_interactive = (consStreams & SAC_InConsole)!=0;
28792	stdout_is_console = (consStreams & SAC_OutConsole)!=0;
28793	atexit(consoleRestore);


28794	#endif
28795	atexit(sayAbnormalExit);
28796	#ifdef SQLITE_DEBUG
28797	mem_main_enter = sqlite3_memory_used();
28798	#endif
28799	#if !defined(_WIN32_WCE)
28800	if( getenv("SQLITE_DEBUG_BREAK") ){
28801	if( isatty(0) && isatty(2) ){
28802	eputf("attach debugger to process %d and press any key to continue.\n",
28803	GETPID());

28804	fgetc(stdin);
28805	}else{
28806	#if defined(_WIN32) \|\| defined(WIN32)
28807	#if SQLITE_OS_WINRT
28808	__debugbreak();
	@@ -28108,18 +28818,18 @@
28818	/* Register a valid signal handler early, before much else is done. */
28819	#ifdef SIGINT
28820	signal(SIGINT, interrupt_handler);
28821	#elif (defined(_WIN32) \|\| defined(WIN32)) && !defined(_WIN32_WCE)
28822	if( !SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE) ){
28823	eputz("No ^C handler.\n");
28824	}
28825	#endif
28826
28827	#if USE_SYSTEM_SQLITE+0!=1
28828	if( cli_strncmp(sqlite3_sourceid(),SQLITE_SOURCE_ID,60)!=0 ){
28829	eputf("SQLite header and source version mismatch\n%s\n%s\n",
28830	sqlite3_sourceid(), SQLITE_SOURCE_ID);
28831	exit(1);
28832	}
28833	#endif
28834	main_init(&data);
28835
	@@ -28211,18 +28921,11 @@
28921	** informational messages (like from process_sqliterc) before
28922	** we do the actual processing of arguments later in a second pass.
28923	*/
28924	stdin_is_interactive = 0;
28925	}else if( cli_strcmp(z,"-utf8")==0 ){




28926	}else if( cli_strcmp(z,"-no-utf8")==0 ){



28927	}else if( cli_strcmp(z,"-heap")==0 ){
28928	#if defined(SQLITE_ENABLE_MEMSYS3) \|\| defined(SQLITE_ENABLE_MEMSYS5)
28929	const char *zSize;
28930	sqlite3_int64 szHeap;
28931
	@@ -28353,30 +29056,21 @@
29056	if( zVfs ){
29057	sqlite3_vfs *pVfs = sqlite3_vfs_find(zVfs);
29058	if( pVfs ){
29059	sqlite3_vfs_register(pVfs, 1);
29060	}else{
29061	eputf("no such VFS: \"%s\"\n", zVfs);
29062	exit(1);
29063	}
29064	}









29065
29066	if( data.pAuxDb->zDbFilename==0 ){
29067	#ifndef SQLITE_OMIT_MEMORYDB
29068	data.pAuxDb->zDbFilename = ":memory:";
29069	warnInmemoryDb = argc==1;
29070	#else
29071	eputf("%s: Error: no database filename specified\n", Argv0);
29072	return 1;
29073	#endif
29074	}
29075	data.out = stdout;
29076	#ifndef SQLITE_SHELL_FIDDLE
	@@ -28489,12 +29183,12 @@
29183	*/
29184	ShellSetFlag(&data, SHFLG_Backslash);
29185	}else if( cli_strcmp(z,"-bail")==0 ){
29186	/* No-op. The bail_on_error flag should already be set. */
29187	}else if( cli_strcmp(z,"-version")==0 ){
29188	oputf("%s %s (%d-bit)\n", sqlite3_libversion(), sqlite3_sourceid(),
29189	8(int)sizeof(char));
29190	return 0;
29191	}else if( cli_strcmp(z,"-interactive")==0 ){
29192	/* already handled */
29193	}else if( cli_strcmp(z,"-batch")==0 ){
29194	/* already handled */
	@@ -28546,22 +29240,22 @@
29240	if( rc && bail_on_error ) return rc==2 ? 0 : rc;
29241	}else{
29242	open_db(&data, 0);
29243	rc = shell_exec(&data, z, &zErrMsg);
29244	if( zErrMsg!=0 ){
29245	eputf("Error: %s\n", zErrMsg);
29246	if( bail_on_error ) return rc!=0 ? rc : 1;
29247	}else if( rc!=0 ){
29248	eputf("Error: unable to process SQL \"%s\"\n", z);
29249	if( bail_on_error ) return rc;
29250	}
29251	}
29252	#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB)
29253	}else if( cli_strncmp(z, "-A", 2)==0 ){
29254	if( nCmd>0 ){
29255	eputf("Error: cannot mix regular SQL or dot-commands"
29256	" with \"%s\"\n", z);
29257	return 1;
29258	}
29259	open_db(&data, OPEN_DB_ZIPFILE);
29260	if( z[2] ){
29261	argv[i] = &z[2];
	@@ -28575,12 +29269,12 @@
29269	}else if( cli_strcmp(z,"-safe")==0 ){
29270	data.bSafeMode = data.bSafeModePersist = 1;
29271	}else if( cli_strcmp(z,"-unsafe-testing")==0 ){
29272	/* Acted upon in first pass. */
29273	}else{
29274	eputf("%s: Error: unknown option: %s\n", Argv0, z);
29275	eputz("Use -help for a list of options.\n");
29276	return 1;
29277	}
29278	data.cMode = data.mode;
29279	}
29280
	@@ -28600,13 +29294,13 @@
29294	open_db(&data, 0);
29295	echo_group_input(&data, azCmd[i]);
29296	rc = shell_exec(&data, azCmd[i], &zErrMsg);
29297	if( zErrMsg \|\| rc ){
29298	if( zErrMsg!=0 ){
29299	eputf("Error: %s\n", zErrMsg);
29300	}else{
29301	eputf("Error: unable to process SQL: %s\n", azCmd[i]);
29302	}
29303	sqlite3_free(zErrMsg);
29304	free(azCmd);
29305	return rc!=0 ? rc : 1;
29306	}
	@@ -28616,30 +29310,24 @@
29310	/* Run commands received from standard input
29311	*/
29312	if( stdin_is_interactive ){
29313	char *zHome;
29314	char *zHistory;

29315	int nHistory;
29316	#if CIO_WIN_WC_XLATE
29317	# define SHELL_CIO_CHAR_SET (stdout_is_console? " (UTF-16 console I/O)" : "")
29318	#else
29319	# define SHELL_CIO_CHAR_SET ""



29320	#endif
29321	oputf("SQLite version %s %.19s%s\n" /extra-version-info/
29322	"Enter \".help\" for usage hints.\n",
29323	sqlite3_libversion(), sqlite3_sourceid(), SHELL_CIO_CHAR_SET);


29324	if( warnInmemoryDb ){
29325	oputz("Connected to a ");
29326	printBold("transient in-memory database");
29327	oputz(".\nUse \".open FILENAME\" to reopen on a"
29328	" persistent database.\n");
29329	}
29330	zHistory = getenv("SQLITE_HISTORY");
29331	if( zHistory ){
29332	zHistory = strdup(zHistory);
29333	}else if( (zHome = find_home_dir(0))!=0 ){
	@@ -28695,12 +29383,12 @@
29383	/* Clear the global data structure so that valgrind will detect memory
29384	** leaks */
29385	memset(&data, 0, sizeof(data));
29386	#ifdef SQLITE_DEBUG
29387	if( sqlite3_memory_used()>mem_main_enter ){
29388	eputf("Memory leaked: %u bytes\n",
29389	(unsigned int)(sqlite3_memory_used()-mem_main_enter));
29390	}
29391	#endif
29392	#endif /* !SQLITE_SHELL_FIDDLE */
29393	return rc;
29394	}
29395

M extsrc/sqlite3.c

+196 -90

		--- extsrc/sqlite3.c
		+++ extsrc/sqlite3.c
		@@ -1,8 +1,8 @@
1	1	/******************************************************************************
2	2	** This file is an amalgamation of many separate C source files from SQLite
3		-** version 3.44.0. By combining all the individual C code files into this
	3	+** version 3.44.2. By combining all the individual C code files into this
4	4	** single large file, the entire code can be compiled as a single translation
5	5	** unit. This allows many compilers to do optimizations that would not be
6	6	** possible if the files were compiled separately. Performance improvements
7	7	** of 5% or more are commonly seen when SQLite is compiled as a single
8	8	** translation unit.
		@@ -16,11 +16,11 @@
16	16	** if you want a wrapper to interface SQLite with your choice of programming
17	17	** language. The code for the "sqlite3" command-line shell is also in a
18	18	** separate file. This file contains only code for the core SQLite library.
19	19	**
20	20	** The content in this amalgamation comes from Fossil check-in
21		-** 17129ba1ff7f0daf37100ee82d507aef7827.
	21	+** ebead0e7230cd33bcec9f95d2183069565b9.
22	22	*/
23	23	#define SQLITE_CORE 1
24	24	#define SQLITE_AMALGAMATION 1
25	25	#ifndef SQLITE_PRIVATE
26	26	# define SQLITE_PRIVATE static
		@@ -457,13 +457,13 @@
457	457	**
458	458	** See also: [sqlite3_libversion()],
459	459	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
460	460	** [sqlite_version()] and [sqlite_source_id()].
461	461	*/
462		-#define SQLITE_VERSION "3.44.0"
463		-#define SQLITE_VERSION_NUMBER 3044000
464		-#define SQLITE_SOURCE_ID "2023-11-01 11:23:50 17129ba1ff7f0daf37100ee82d507aef7827cf38de1866e2633096ae6ad81301"
	462	+#define SQLITE_VERSION "3.44.2"
	463	+#define SQLITE_VERSION_NUMBER 3044002
	464	+#define SQLITE_SOURCE_ID "2023-11-24 11:41:44 ebead0e7230cd33bcec9f95d2183069565b9e709bf745c9b5db65cc0cbf92c0f"
465	465
466	466	/*
467	467	** CAPI3REF: Run-Time Library Version Numbers
468	468	** KEYWORDS: sqlite3_version sqlite3_sourceid
469	469	**
		@@ -5884,24 +5884,39 @@
5884	5884	** function has been carefully audited and found to be free of potentially
5885	5885	** security-adverse side-effects and information-leaks.
5886	5886	** </dd>
5887	5887	**
5888	5888	** [[SQLITE_SUBTYPE]] <dt>SQLITE_SUBTYPE</dt><dd>
5889		-** The SQLITE_SUBTYPE flag indicates to SQLite that a function may call
	5889	+** The SQLITE_SUBTYPE flag indicates to SQLite that a function might call
5890	5890	** [sqlite3_value_subtype()] to inspect the sub-types of its arguments.
5891		-** Specifying this flag makes no difference for scalar or aggregate user
5892		-** functions. However, if it is not specified for a user-defined window
5893		-** function, then any sub-types belonging to arguments passed to the window
5894		-** function may be discarded before the window function is called (i.e.
5895		-** sqlite3_value_subtype() will always return 0).
	5891	+** This flag instructs SQLite to omit some corner-case optimizations that
	5892	+** might disrupt the operation of the [sqlite3_value_subtype()] function,
	5893	+** causing it to return zero rather than the correct subtype().
	5894	+** SQL functions that invokes [sqlite3_value_subtype()] should have this
	5895	+** property. If the SQLITE_SUBTYPE property is omitted, then the return
	5896	+** value from [sqlite3_value_subtype()] might sometimes be zero even though
	5897	+** a non-zero subtype was specified by the function argument expression.
	5898	+**
	5899	+** [[SQLITE_RESULT_SUBTYPE]] <dt>SQLITE_RESULT_SUBTYPE</dt><dd>
	5900	+** The SQLITE_RESULT_SUBTYPE flag indicates to SQLite that a function might call
	5901	+** [sqlite3_result_subtype()] to cause a sub-type to be associated with its
	5902	+** result.
	5903	+** Every function that invokes [sqlite3_result_subtype()] should have this
	5904	+** property. If it does not, then the call to [sqlite3_result_subtype()]
	5905	+** might become a no-op if the function is used as term in an
	5906	+** [expression index]. On the other hand, SQL functions that never invoke
	5907	+** [sqlite3_result_subtype()] should avoid setting this property, as the
	5908	+** purpose of this property is to disable certain optimizations that are
	5909	+** incompatible with subtypes.
5896	5910	** </dd>
5897	5911	** </dl>
5898	5912	*/
5899	5913	#define SQLITE_DETERMINISTIC 0x000000800
5900	5914	#define SQLITE_DIRECTONLY 0x000080000
5901	5915	#define SQLITE_SUBTYPE 0x000100000
5902	5916	#define SQLITE_INNOCUOUS 0x000200000
	5917	+#define SQLITE_RESULT_SUBTYPE 0x001000000
5903	5918
5904	5919	/*
5905	5920	** CAPI3REF: Deprecated Functions
5906	5921	** DEPRECATED
5907	5922	**
		@@ -6094,10 +6109,16 @@
6094	6109	** The sqlite3_value_subtype(V) function returns the subtype for
6095	6110	** an [application-defined SQL function] argument V. The subtype
6096	6111	** information can be used to pass a limited amount of context from
6097	6112	** one SQL function to another. Use the [sqlite3_result_subtype()]
6098	6113	** routine to set the subtype for the return value of an SQL function.
	6114	+**
	6115	+** Every [application-defined SQL function] that invoke this interface
	6116	+** should include the [SQLITE_SUBTYPE] property in the text
	6117	+** encoding argument when the function is [sqlite3_create_function\|registered].
	6118	+** If the [SQLITE_SUBTYPE] property is omitted, then sqlite3_value_subtype()
	6119	+** might return zero instead of the upstream subtype in some corner cases.
6099	6120	*/
6100	6121	SQLITE_API unsigned int sqlite3_value_subtype(sqlite3_value*);
6101	6122
6102	6123	/*
6103	6124	** CAPI3REF: Copy And Free SQL Values
		@@ -6224,18 +6245,26 @@
6224	6245	** <li> ^(when [sqlite3_reset()] or [sqlite3_finalize()] is called for the
6225	6246	** SQL statement)^, or
6226	6247	** <li> ^(when sqlite3_set_auxdata() is invoked again on the same
6227	6248	** parameter)^, or
6228	6249	** <li> ^(during the original sqlite3_set_auxdata() call when a memory
6229		-** allocation error occurs.)^ </ul>
	6250	+** allocation error occurs.)^
	6251	+** <li> ^(during the original sqlite3_set_auxdata() call if the function
	6252	+** is evaluated during query planning instead of during query execution,
	6253	+** as sometimes happens with [SQLITE_ENABLE_STAT4].)^ </ul>
6230	6254	**
6231		-** Note the last bullet in particular. The destructor X in
	6255	+** Note the last two bullets in particular. The destructor X in
6232	6256	** sqlite3_set_auxdata(C,N,P,X) might be called immediately, before the
6233	6257	** sqlite3_set_auxdata() interface even returns. Hence sqlite3_set_auxdata()
6234	6258	** should be called near the end of the function implementation and the
6235	6259	** function implementation should not make any use of P after
6236		-** sqlite3_set_auxdata() has been called.
	6260	+** sqlite3_set_auxdata() has been called. Furthermore, a call to
	6261	+** sqlite3_get_auxdata() that occurs immediately after a corresponding call
	6262	+** to sqlite3_set_auxdata() might still return NULL if an out-of-memory
	6263	+** condition occurred during the sqlite3_set_auxdata() call or if the
	6264	+** function is being evaluated during query planning rather than during
	6265	+** query execution.
6237	6266	**
6238	6267	** ^(In practice, auxiliary data is preserved between function calls for
6239	6268	** function parameters that are compile-time constants, including literal
6240	6269	** values and [parameters] and expressions composed from the same.)^
6241	6270	**
		@@ -6505,10 +6534,24 @@
6505	6534	** [sqlite3_context] C to be the value T. Only the lower 8 bits
6506	6535	** of the subtype T are preserved in current versions of SQLite;
6507	6536	** higher order bits are discarded.
6508	6537	** The number of subtype bytes preserved by SQLite might increase
6509	6538	** in future releases of SQLite.
	6539	+**
	6540	+** Every [application-defined SQL function] that invokes this interface
	6541	+** should include the [SQLITE_RESULT_SUBTYPE] property in its
	6542	+** text encoding argument when the SQL function is
	6543	+** [sqlite3_create_function\|registered]. If the [SQLITE_RESULT_SUBTYPE]
	6544	+** property is omitted from the function that invokes sqlite3_result_subtype(),
	6545	+** then in some cases the sqlite3_result_subtype() might fail to set
	6546	+** the result subtype.
	6547	+**
	6548	+** If SQLite is compiled with -DSQLITE_STRICT_SUBTYPE=1, then any
	6549	+** SQL function that invokes the sqlite3_result_subtype() interface
	6550	+** and that does not have the SQLITE_RESULT_SUBTYPE property will raise
	6551	+** an error. Future versions of SQLite might enable -DSQLITE_STRICT_SUBTYPE=1
	6552	+** by default.
6510	6553	*/
6511	6554	SQLITE_API void sqlite3_result_subtype(sqlite3_context*,unsigned int);
6512	6555
6513	6556	/*
6514	6557	** CAPI3REF: Define New Collating Sequences
		@@ -17809,18 +17852,19 @@
17809	17852	#define SQLITE_FUNC_CONSTANT 0x0800 /* Constant inputs give a constant output */
17810	17853	#define SQLITE_FUNC_MINMAX 0x1000 /* True for min() and max() aggregates */
17811	17854	#define SQLITE_FUNC_SLOCHNG 0x2000 /* "Slow Change". Value constant during a
17812	17855	** single query - might change over time */
17813	17856	#define SQLITE_FUNC_TEST 0x4000 /* Built-in testing functions */
17814		-/* 0x8000 -- available for reuse */
	17857	+#define SQLITE_FUNC_RUNONLY 0x8000 /* Cannot be used by valueFromFunction */
17815	17858	#define SQLITE_FUNC_WINDOW 0x00010000 /* Built-in window-only function */
17816	17859	#define SQLITE_FUNC_INTERNAL 0x00040000 /* For use by NestedParse() only */
17817	17860	#define SQLITE_FUNC_DIRECT 0x00080000 /* Not for use in TRIGGERs or VIEWs */
17818		-#define SQLITE_FUNC_SUBTYPE 0x00100000 /* Result likely to have sub-type */
	17861	+/* SQLITE_SUBTYPE 0x00100000 // Consumer of subtypes */
17819	17862	#define SQLITE_FUNC_UNSAFE 0x00200000 /* Function has side effects */
17820	17863	#define SQLITE_FUNC_INLINE 0x00400000 /* Functions implemented in-line */
17821	17864	#define SQLITE_FUNC_BUILTIN 0x00800000 /* This is a built-in function */
	17865	+/* SQLITE_RESULT_SUBTYPE 0x01000000 // Generator of subtypes */
17822	17866	#define SQLITE_FUNC_ANYORDER 0x08000000 /* count/min/max aggregate */
17823	17867
17824	17868	/* Identifier numbers for each in-line function */
17825	17869	#define INLINEFUNC_coalesce 0
17826	17870	#define INLINEFUNC_implies_nonnull_row 1
		@@ -17908,13 +17952,14 @@
17908	17952	{nArg, SQLITE_FUNC_BUILTIN\|SQLITE_UTF8\|SQLITE_DIRECTONLY\|SQLITE_FUNC_UNSAFE, \
17909	17953	SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
17910	17954	#define MFUNCTION(zName, nArg, xPtr, xFunc) \
17911	17955	{nArg, SQLITE_FUNC_BUILTIN\|SQLITE_FUNC_CONSTANT\|SQLITE_UTF8, \
17912	17956	xPtr, 0, xFunc, 0, 0, 0, #zName, {0} }
17913		-#define JFUNCTION(zName, nArg, iArg, xFunc) \
17914		- {nArg, SQLITE_FUNC_BUILTIN\|SQLITE_DETERMINISTIC\|\
17915		- SQLITE_FUNC_CONSTANT\|SQLITE_UTF8, \
	17957	+#define JFUNCTION(zName, nArg, bUseCache, bWS, bRS, iArg, xFunc) \
	17958	+ {nArg, SQLITE_FUNC_BUILTIN\|SQLITE_DETERMINISTIC\|SQLITE_FUNC_CONSTANT\|\
	17959	+ SQLITE_UTF8\|((bUseCache)*SQLITE_FUNC_RUNONLY)\|\
	17960	+ ((bRS)SQLITE_SUBTYPE)\|((bWS)SQLITE_RESULT_SUBTYPE), \
17916	17961	SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
17917	17962	#define INLINE_FUNC(zName, nArg, iArg, mFlags) \
17918	17963	{nArg, SQLITE_FUNC_BUILTIN\|\
17919	17964	SQLITE_UTF8\|SQLITE_FUNC_INLINE\|SQLITE_FUNC_CONSTANT\|(mFlags), \
17920	17965	SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }
		@@ -29451,11 +29496,11 @@
29451	29496	SQLITE_PRIVATE void sqlite3MemoryBarrier(void){
29452	29497	#if defined(SQLITE_MEMORY_BARRIER)
29453	29498	SQLITE_MEMORY_BARRIER;
29454	29499	#elif defined(__GNUC__)
29455	29500	__sync_synchronize();
29456		-#elif MSVC_VERSION>=1300
	29501	+#elif MSVC_VERSION>=1400
29457	29502	_ReadWriteBarrier();
29458	29503	#elif defined(MemoryBarrier)
29459	29504	MemoryBarrier();
29460	29505	#endif
29461	29506	}
		@@ -61445,14 +61490,17 @@
61445	61490	** of the corresponding WAL or Journal name as passed into
61446	61491	** xOpen.
61447	61492	*/
61448	61493	SQLITE_API sqlite3_file sqlite3_database_file_object(const char zName){
61449	61494	Pager *pPager;
	61495	+ const char *p;
61450	61496	while( zName[-1]!=0 \|\| zName[-2]!=0 \|\| zName[-3]!=0 \|\| zName[-4]!=0 ){
61451	61497	zName--;
61452	61498	}
61453		- pPager = (Pager)(zName - 4 - sizeof(Pager));
	61499	+ p = zName - 4 - sizeof(Pager*);
	61500	+ assert( EIGHT_BYTE_ALIGNMENT(p) );
	61501	+ pPager = (Pager*)p;
61454	61502	return pPager->fd;
61455	61503	}
61456	61504
61457	61505
61458	61506	/*
		@@ -83409,11 +83457,11 @@
83409	83457	#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
83410	83458	if( pFunc==0 ) return SQLITE_OK;
83411	83459	#endif
83412	83460	assert( pFunc );
83413	83461	if( (pFunc->funcFlags & (SQLITE_FUNC_CONSTANT\|SQLITE_FUNC_SLOCHNG))==0
83414		- \|\| (pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL)
	83462	+ \|\| (pFunc->funcFlags & (SQLITE_FUNC_NEEDCOLL\|SQLITE_FUNC_RUNONLY))!=0
83415	83463	){
83416	83464	return SQLITE_OK;
83417	83465	}
83418	83466
83419	83467	if( pList ){
		@@ -84133,14 +84181,15 @@
84133	84181	** sqlite3CorruptError(lineno)
84134	84182	** sqlite3MisuseError(lineno)
84135	84183	** sqlite3CantopenError(lineno)
84136	84184	*/
84137	84185	static void test_addop_breakpoint(int pc, Op *pOp){
84138		- static int n = 0;
	84186	+ static u64 n = 0;
84139	84187	(void)pc;
84140	84188	(void)pOp;
84141	84189	n++;
	84190	+ if( n==LARGEST_UINT64 ) abort(); /* so that n is used, preventing a warning */
84142	84191	}
84143	84192	#endif
84144	84193
84145	84194	/*
84146	84195	** Slow paths for sqlite3VdbeAddOp3() and sqlite3VdbeAddOp4Int() for the
		@@ -89950,10 +89999,22 @@
89950	89999	SQLITE_API void sqlite3_result_subtype(sqlite3_context *pCtx, unsigned int eSubtype){
89951	90000	Mem *pOut;
89952	90001	#ifdef SQLITE_ENABLE_API_ARMOR
89953	90002	if( pCtx==0 ) return;
89954	90003	#endif
	90004	+#if defined(SQLITE_STRICT_SUBTYPE) && SQLITE_STRICT_SUBTYPE+0!=0
	90005	+ if( pCtx->pFunc!=0
	90006	+ && (pCtx->pFunc->funcFlags & SQLITE_RESULT_SUBTYPE)==0
	90007	+ ){
	90008	+ char zErr[200];
	90009	+ sqlite3_snprintf(sizeof(zErr), zErr,
	90010	+ "misuse of sqlite3_result_subtype() by %s()",
	90011	+ pCtx->pFunc->zName);
	90012	+ sqlite3_result_error(pCtx, zErr, -1);
	90013	+ return;
	90014	+ }
	90015	+#endif /* SQLITE_STRICT_SUBTYPE */
89955	90016	pOut = pCtx->pOut;
89956	90017	assert( sqlite3_mutex_held(pOut->db->mutex) );
89957	90018	pOut->eSubtype = eSubtype & 0xff;
89958	90019	pOut->flags \|= MEM_Subtype;
89959	90020	}
		@@ -92268,15 +92329,16 @@
92268	92329	** sqlite3CorruptError(lineno)
92269	92330	** sqlite3MisuseError(lineno)
92270	92331	** sqlite3CantopenError(lineno)
92271	92332	*/
92272	92333	static void test_trace_breakpoint(int pc, Op pOp, Vdbe v){
92273		- static int n = 0;
	92334	+ static u64 n = 0;
92274	92335	(void)pc;
92275	92336	(void)pOp;
92276	92337	(void)v;
92277	92338	n++;
	92339	+ if( n==LARGEST_UINT64 ) abort(); /* So that n is used, preventing a warning */
92278	92340	}
92279	92341	#endif
92280	92342
92281	92343	/*
92282	92344	** Invoke the VDBE coverage callback, if that callback is defined. This
		@@ -100319,11 +100381,11 @@
100319	100381	sqlite3VdbeMemSetNull(pOut); /* Innocent until proven guilty */
100320	100382	assert( pOp->p4type==P4_TABLE );
100321	100383	pTab = pOp->p4.pTab;
100322	100384	assert( pTab!=0 );
100323	100385	assert( IsVirtual(pTab) );
100324		- assert( pTab->u.vtab.p!=0 );
	100386	+ if( pTab->u.vtab.p==0 ) break;
100325	100387	pVtab = pTab->u.vtab.p->pVtab;
100326	100388	assert( pVtab!=0 );
100327	100389	pModule = pVtab->pModule;
100328	100390	assert( pModule!=0 );
100329	100391	assert( pModule->iVersion>=4 );
		@@ -113915,12 +113977,12 @@
113915	113977	** Like sqlite3ExprCompare() except COLLATE operators at the top-level
113916	113978	** are ignored.
113917	113979	*/
113918	113980	SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr pA,Expr pB, int iTab){
113919	113981	return sqlite3ExprCompare(0,
113920		- sqlite3ExprSkipCollateAndLikely(pA),
113921		- sqlite3ExprSkipCollateAndLikely(pB),
	113982	+ sqlite3ExprSkipCollate(pA),
	113983	+ sqlite3ExprSkipCollate(pB),
113922	113984	iTab);
113923	113985	}
113924	113986
113925	113987	/*
113926	113988	** Return non-zero if Expr p can only be true if pNN is not NULL.
		@@ -143550,11 +143612,12 @@
143550	143612	Expr *p;
143551	143613	struct ExprList_item *a;
143552	143614	NameContext sNC;
143553	143615
143554	143616	assert( pSelect!=0 );
143555		- assert( (pSelect->selFlags & SF_Resolved)!=0 );
	143617	+ testcase( (pSelect->selFlags & SF_Resolved)==0 );
	143618	+ assert( (pSelect->selFlags & SF_Resolved)!=0 \|\| IN_RENAME_OBJECT );
143556	143619	assert( pTab->nCol==pSelect->pEList->nExpr \|\| pParse->nErr>0 );
143557	143620	assert( aff==SQLITE_AFF_NONE \|\| aff==SQLITE_AFF_BLOB );
143558	143621	if( db->mallocFailed \|\| IN_RENAME_OBJECT ) return;
143559	143622	while( pSelect->pPrior ) pSelect = pSelect->pPrior;
143560	143623	a = pSelect->pEList->a;
		@@ -147603,14 +147666,15 @@
147603	147666	Parse *pParse;
147604	147667	int i;
147605	147668	SrcList *pTabList;
147606	147669	SrcItem *pFrom;
147607	147670
147608		- assert( p->selFlags & SF_Resolved );
147609	147671	if( p->selFlags & SF_HasTypeInfo ) return;
147610	147672	p->selFlags \|= SF_HasTypeInfo;
147611	147673	pParse = pWalker->pParse;
	147674	+ testcase( (p->selFlags & SF_Resolved)==0 );
	147675	+ assert( (p->selFlags & SF_Resolved) \|\| IN_RENAME_OBJECT );
147612	147676	pTabList = p->pSrc;
147613	147677	for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
147614	147678	Table *pTab = pFrom->pTab;
147615	147679	assert( pTab!=0 );
147616	147680	if( (pTab->tabFlags & TF_Ephemeral)!=0 ){
		@@ -148628,10 +148692,11 @@
148628	148692	pItem->fg.jointype &= ~JT_LEFT;
148629	148693	}else{
148630	148694	TREETRACE(0x1000,pParse,p,
148631	148695	("LEFT-JOIN simplifies to JOIN on term %d\n",i));
148632	148696	pItem->fg.jointype &= ~(JT_LEFT\|JT_OUTER);
	148697	+ unsetJoinExpr(p->pWhere, pItem->iCursor, 0);
148633	148698	}
148634	148699	}
148635	148700	if( pItem->fg.jointype & JT_LTORJ ){
148636	148701	for(j=i+1; j<pTabList->nSrc; j++){
148637	148702	SrcItem *pI2 = &pTabList->a[j];
		@@ -148642,21 +148707,19 @@
148642	148707	pI2->fg.jointype &= ~JT_RIGHT;
148643	148708	}else{
148644	148709	TREETRACE(0x1000,pParse,p,
148645	148710	("RIGHT-JOIN simplifies to JOIN on term %d\n",j));
148646	148711	pI2->fg.jointype &= ~(JT_RIGHT\|JT_OUTER);
	148712	+ unsetJoinExpr(p->pWhere, pI2->iCursor, 1);
148647	148713	}
148648	148714	}
148649	148715	}
148650		- for(j=pTabList->nSrc-1; j>=i; j--){
	148716	+ for(j=pTabList->nSrc-1; j>=0; j--){
148651	148717	pTabList->a[j].fg.jointype &= ~JT_LTORJ;
148652	148718	if( pTabList->a[j].fg.jointype & JT_RIGHT ) break;
148653	148719	}
148654	148720	}
148655		- assert( pItem->iCursor>=0 );
148656		- unsetJoinExpr(p->pWhere, pItem->iCursor,
148657		- pTabList->a[0].fg.jointype & JT_LTORJ);
148658	148721	}
148659	148722
148660	148723	/* No further action if this term of the FROM clause is not a subquery */
148661	148724	if( pSub==0 ) continue;
148662	148725
		@@ -166056,10 +166119,24 @@
166056	166119	bMaybeNullRow = 0;
166057	166120	}else{
166058	166121	continue;
166059	166122	}
166060	166123	if( sqlite3ExprIsConstant(pExpr) ) continue;
	166124	+ if( pExpr->op==TK_FUNCTION ){
	166125	+ /* Functions that might set a subtype should not be replaced by the
	166126	+ ** value taken from an expression index since the index omits the
	166127	+ ** subtype. https://sqlite.org/forum/forumpost/68d284c86b082c3e */
	166128	+ int n;
	166129	+ FuncDef *pDef;
	166130	+ sqlite3 *db = pParse->db;
	166131	+ assert( ExprUseXList(pExpr) );
	166132	+ n = pExpr->x.pList ? pExpr->x.pList->nExpr : 0;
	166133	+ pDef = sqlite3FindFunction(db, pExpr->u.zToken, n, ENC(db), 0);
	166134	+ if( pDef==0 \|\| (pDef->funcFlags & SQLITE_RESULT_SUBTYPE)!=0 ){
	166135	+ continue;
	166136	+ }
	166137	+ }
166061	166138	p = sqlite3DbMallocRaw(pParse->db, sizeof(IndexedExpr));
166062	166139	if( p==0 ) break;
166063	166140	p->pIENext = pParse->pIdxEpr;
166064	166141	#ifdef WHERETRACE_ENABLED
166065	166142	if( sqlite3WhereTrace & 0x200 ){
		@@ -168238,11 +168315,11 @@
168238	168315	for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
168239	168316	ExprList *pArgs;
168240	168317	assert( ExprUseXList(pWin->pOwner) );
168241	168318	assert( pWin->pWFunc!=0 );
168242	168319	pArgs = pWin->pOwner->x.pList;
168243		- if( pWin->pWFunc->funcFlags & SQLITE_FUNC_SUBTYPE ){
	168320	+ if( pWin->pWFunc->funcFlags & SQLITE_SUBTYPE ){
168244	168321	selectWindowRewriteEList(pParse, pMWin, pSrc, pArgs, pTab, &pSublist);
168245	168322	pWin->iArgCol = (pSublist ? pSublist->nExpr : 0);
168246	168323	pWin->bExprArgs = 1;
168247	168324	}else{
168248	168325	pWin->iArgCol = (pSublist ? pSublist->nExpr : 0);
		@@ -179412,11 +179489,11 @@
179412	179489	}
179413	179490
179414	179491	assert( SQLITE_FUNC_CONSTANT==SQLITE_DETERMINISTIC );
179415	179492	assert( SQLITE_FUNC_DIRECT==SQLITE_DIRECTONLY );
179416	179493	extraFlags = enc & (SQLITE_DETERMINISTIC\|SQLITE_DIRECTONLY\|
179417		- SQLITE_SUBTYPE\|SQLITE_INNOCUOUS);
	179494	+ SQLITE_SUBTYPE\|SQLITE_INNOCUOUS\|SQLITE_RESULT_SUBTYPE);
179418	179495	enc &= (SQLITE_FUNC_ENCMASK\|SQLITE_ANY);
179419	179496
179420	179497	/* The SQLITE_INNOCUOUS flag is the same bit as SQLITE_FUNC_UNSAFE. But
179421	179498	** the meaning is inverted. So flip the bit. */
179422	179499	assert( SQLITE_FUNC_UNSAFE==SQLITE_INNOCUOUS );
		@@ -202993,16 +203070,22 @@
202993	203070	u32 i;
202994	203071	jsonAppendChar(p, '"');
202995	203072	zIn++;
202996	203073	N -= 2;
202997	203074	while( N>0 ){
202998		- for(i=0; i<N && zIn[i]!='\\'; i++){}
	203075	+ for(i=0; i<N && zIn[i]!='\\' && zIn[i]!='"'; i++){}
202999	203076	if( i>0 ){
203000	203077	jsonAppendRawNZ(p, zIn, i);
203001	203078	zIn += i;
203002	203079	N -= i;
203003	203080	if( N==0 ) break;
	203081	+ }
	203082	+ if( zIn[0]=='"' ){
	203083	+ jsonAppendRawNZ(p, "\\\"", 2);
	203084	+ zIn++;
	203085	+ N--;
	203086	+ continue;
203004	203087	}
203005	203088	assert( zIn[0]=='\\' );
203006	203089	switch( (u8)zIn[1] ){
203007	203090	case '\'':
203008	203091	jsonAppendChar(p, '\'');
		@@ -203394,11 +203477,12 @@
203394	203477	*/
203395	203478	static void jsonReturnJson(
203396	203479	JsonParse pParse, / The complete JSON */
203397	203480	JsonNode pNode, / Node to return */
203398	203481	sqlite3_context pCtx, / Return value for this function */
203399		- int bGenerateAlt /* Also store the rendered text in zAlt */
	203482	+ int bGenerateAlt, /* Also store the rendered text in zAlt */
	203483	+ int omitSubtype /* Do not call sqlite3_result_subtype() */
203400	203484	){
203401	203485	JsonString s;
203402	203486	if( pParse->oom ){
203403	203487	sqlite3_result_error_nomem(pCtx);
203404	203488	return;
		@@ -203409,11 +203493,11 @@
203409	203493	if( bGenerateAlt && pParse->zAlt==0 && jsonForceRCStr(&s) ){
203410	203494	pParse->zAlt = sqlite3RCStrRef(s.zBuf);
203411	203495	pParse->nAlt = s.nUsed;
203412	203496	}
203413	203497	jsonResult(&s);
203414		- sqlite3_result_subtype(pCtx, JSON_SUBTYPE);
	203498	+ if( !omitSubtype ) sqlite3_result_subtype(pCtx, JSON_SUBTYPE);
203415	203499	}
203416	203500	}
203417	203501
203418	203502	/*
203419	203503	** Translate a single byte of Hex into an integer.
		@@ -203450,11 +203534,12 @@
203450	203534	** Make the JsonNode the return value of the function.
203451	203535	*/
203452	203536	static void jsonReturn(
203453	203537	JsonParse pParse, / Complete JSON parse tree */
203454	203538	JsonNode pNode, / Node to return */
203455		- sqlite3_context pCtx / Return value for this function */
	203539	+ sqlite3_context pCtx, / Return value for this function */
	203540	+ int omitSubtype /* Do not call sqlite3_result_subtype() */
203456	203541	){
203457	203542	switch( pNode->eType ){
203458	203543	default: {
203459	203544	assert( pNode->eType==JSON_NULL );
203460	203545	sqlite3_result_null(pCtx);
		@@ -203596,11 +203681,11 @@
203596	203681	}
203597	203682	break;
203598	203683	}
203599	203684	case JSON_ARRAY:
203600	203685	case JSON_OBJECT: {
203601		- jsonReturnJson(pParse, pNode, pCtx, 0);
	203686	+ jsonReturnJson(pParse, pNode, pCtx, 0, omitSubtype);
203602	203687	break;
203603	203688	}
203604	203689	}
203605	203690	}
203606	203691
		@@ -204948,11 +205033,11 @@
204948	205033	printf("hasMod = %u\n", p->hasMod);
204949	205034	printf("nJPRef = %u\n", p->nJPRef);
204950	205035	printf("iSubst = %u\n", p->iSubst);
204951	205036	printf("iHold = %u\n", p->iHold);
204952	205037	jsonDebugPrintNodeEntries(p->aNode, p->nNode);
204953		- jsonReturnJson(p, p->aNode, ctx, 1);
	205038	+ jsonReturnJson(p, p->aNode, ctx, 1, 0);
204954	205039	}
204955	205040
204956	205041	/*
204957	205042	** The json_test1(JSON) function return true (1) if the input is JSON
204958	205043	** text generated by another json function. It returns (0) if the input
		@@ -205134,19 +205219,18 @@
205134	205219	}else{
205135	205220	pNode = jsonLookup(p, zPath, 0, ctx);
205136	205221	}
205137	205222	if( pNode ){
205138	205223	if( flags & JSON_JSON ){
205139		- jsonReturnJson(p, pNode, ctx, 0);
	205224	+ jsonReturnJson(p, pNode, ctx, 0, 0);
205140	205225	}else{
205141		- jsonReturn(p, pNode, ctx);
205142		- sqlite3_result_subtype(ctx, 0);
	205226	+ jsonReturn(p, pNode, ctx, 1);
205143	205227	}
205144	205228	}
205145	205229	}else{
205146	205230	pNode = jsonLookup(p, zPath, 0, ctx);
205147		- if( p->nErr==0 && pNode ) jsonReturn(p, pNode, ctx);
	205231	+ if( p->nErr==0 && pNode ) jsonReturn(p, pNode, ctx, 0);
205148	205232	}
205149	205233	}else{
205150	205234	/* Two or more PATH arguments results in a JSON array with each
205151	205235	** element of the array being the value selected by one of the PATHs */
205152	205236	int i;
		@@ -205268,11 +205352,11 @@
205268	205352	pResult = jsonMergePatch(pX, 0, pY->aNode);
205269	205353	assert( pResult!=0 \|\| pX->oom );
205270	205354	if( pResult && pX->oom==0 ){
205271	205355	jsonDebugPrintParse(pX);
205272	205356	jsonDebugPrintNode(pResult);
205273		- jsonReturnJson(pX, pResult, ctx, 0);
	205357	+ jsonReturnJson(pX, pResult, ctx, 0, 0);
205274	205358	}else{
205275	205359	sqlite3_result_error_nomem(ctx);
205276	205360	}
205277	205361	}
205278	205362
		@@ -205347,11 +205431,11 @@
205347	205431	pParse->hasMod = 1;
205348	205432	pParse->useMod = 1;
205349	205433	}
205350	205434	}
205351	205435	if( (pParse->aNode[0].jnFlags & JNODE_REMOVE)==0 ){
205352		- jsonReturnJson(pParse, pParse->aNode, ctx, 1);
	205436	+ jsonReturnJson(pParse, pParse->aNode, ctx, 1, 0);
205353	205437	}
205354	205438	remove_done:
205355	205439	jsonDebugPrintParse(p);
205356	205440	}
205357	205441
		@@ -205476,11 +205560,11 @@
205476	205560	if( pParse->nErr ) goto replace_err;
205477	205561	if( pNode ){
205478	205562	jsonReplaceNode(ctx, pParse, (u32)(pNode - pParse->aNode), argv[i+1]);
205479	205563	}
205480	205564	}
205481		- jsonReturnJson(pParse, pParse->aNode, ctx, 1);
	205565	+ jsonReturnJson(pParse, pParse->aNode, ctx, 1, 0);
205482	205566	replace_err:
205483	205567	jsonDebugPrintParse(pParse);
205484	205568	jsonParseFree(pParse);
205485	205569	}
205486	205570
		@@ -205530,11 +205614,11 @@
205530	205614	}else if( pNode && (bApnd \|\| bIsSet) ){
205531	205615	jsonReplaceNode(ctx, pParse, (u32)(pNode - pParse->aNode), argv[i+1]);
205532	205616	}
205533	205617	}
205534	205618	jsonDebugPrintParse(pParse);
205535		- jsonReturnJson(pParse, pParse->aNode, ctx, 1);
	205619	+ jsonReturnJson(pParse, pParse->aNode, ctx, 1, 0);
205536	205620	jsonSetDone:
205537	205621	jsonParseFree(pParse);
205538	205622	}
205539	205623
205540	205624	/*
		@@ -206045,11 +206129,11 @@
206045	206129	JsonNode *pThis = &p->sParse.aNode[p->i];
206046	206130	switch( i ){
206047	206131	case JEACH_KEY: {
206048	206132	if( p->i==0 ) break;
206049	206133	if( p->eType==JSON_OBJECT ){
206050		- jsonReturn(&p->sParse, pThis, ctx);
	206134	+ jsonReturn(&p->sParse, pThis, ctx, 0);
206051	206135	}else if( p->eType==JSON_ARRAY ){
206052	206136	u32 iKey;
206053	206137	if( p->bRecursive ){
206054	206138	if( p->iRowid==0 ) break;
206055	206139	assert( p->sParse.aNode[p->sParse.aUp[p->i]].eU==3 );
		@@ -206061,11 +206145,11 @@
206061	206145	}
206062	206146	break;
206063	206147	}
206064	206148	case JEACH_VALUE: {
206065	206149	if( pThis->jnFlags & JNODE_LABEL ) pThis++;
206066		- jsonReturn(&p->sParse, pThis, ctx);
	206150	+ jsonReturn(&p->sParse, pThis, ctx, 0);
206067	206151	break;
206068	206152	}
206069	206153	case JEACH_TYPE: {
206070	206154	if( pThis->jnFlags & JNODE_LABEL ) pThis++;
206071	206155	sqlite3_result_text(ctx, jsonType[pThis->eType], -1, SQLITE_STATIC);
		@@ -206072,11 +206156,11 @@
206072	206156	break;
206073	206157	}
206074	206158	case JEACH_ATOM: {
206075	206159	if( pThis->jnFlags & JNODE_LABEL ) pThis++;
206076	206160	if( pThis->eType>=JSON_ARRAY ) break;
206077		- jsonReturn(&p->sParse, pThis, ctx);
	206161	+ jsonReturn(&p->sParse, pThis, ctx, 0);
206078	206162	break;
206079	206163	}
206080	206164	case JEACH_ID: {
206081	206165	sqlite3_result_int64(ctx,
206082	206166	(sqlite3_int64)p->i + ((pThis->jnFlags & JNODE_LABEL)!=0));
		@@ -206365,38 +206449,47 @@
206365	206449	** Register JSON functions.
206366	206450	*/
206367	206451	SQLITE_PRIVATE void sqlite3RegisterJsonFunctions(void){
206368	206452	#ifndef SQLITE_OMIT_JSON
206369	206453	static FuncDef aJsonFunc[] = {
206370		- JFUNCTION(json, 1, 0, jsonRemoveFunc),
206371		- JFUNCTION(json_array, -1, 0, jsonArrayFunc),
206372		- JFUNCTION(json_array_length, 1, 0, jsonArrayLengthFunc),
206373		- JFUNCTION(json_array_length, 2, 0, jsonArrayLengthFunc),
206374		- JFUNCTION(json_error_position,1, 0, jsonErrorFunc),
206375		- JFUNCTION(json_extract, -1, 0, jsonExtractFunc),
206376		- JFUNCTION(->, 2, JSON_JSON, jsonExtractFunc),
206377		- JFUNCTION(->>, 2, JSON_SQL, jsonExtractFunc),
206378		- JFUNCTION(json_insert, -1, 0, jsonSetFunc),
206379		- JFUNCTION(json_object, -1, 0, jsonObjectFunc),
206380		- JFUNCTION(json_patch, 2, 0, jsonPatchFunc),
206381		- JFUNCTION(json_quote, 1, 0, jsonQuoteFunc),
206382		- JFUNCTION(json_remove, -1, 0, jsonRemoveFunc),
206383		- JFUNCTION(json_replace, -1, 0, jsonReplaceFunc),
206384		- JFUNCTION(json_set, -1, JSON_ISSET, jsonSetFunc),
206385		- JFUNCTION(json_type, 1, 0, jsonTypeFunc),
206386		- JFUNCTION(json_type, 2, 0, jsonTypeFunc),
206387		- JFUNCTION(json_valid, 1, 0, jsonValidFunc),
206388		-#if SQLITE_DEBUG
206389		- JFUNCTION(json_parse, 1, 0, jsonParseFunc),
206390		- JFUNCTION(json_test1, 1, 0, jsonTest1Func),
	206454	+ /* calls sqlite3_result_subtype() */
	206455	+ /* \| */
	206456	+ /* Uses cache ______ \| __ calls sqlite3_value_subtype() */
	206457	+ /* \| \| \| */
	206458	+ /* Num args _________ \| \| \| ___ Flags */
	206459	+ /* \| \| \| \| \| */
	206460	+ /* \| \| \| \| \| */
	206461	+ JFUNCTION(json, 1, 1, 1, 0, 0, jsonRemoveFunc),
	206462	+ JFUNCTION(json_array, -1, 0, 1, 1, 0, jsonArrayFunc),
	206463	+ JFUNCTION(json_array_length, 1, 1, 0, 0, 0, jsonArrayLengthFunc),
	206464	+ JFUNCTION(json_array_length, 2, 1, 0, 0, 0, jsonArrayLengthFunc),
	206465	+ JFUNCTION(json_error_position,1, 1, 0, 0, 0, jsonErrorFunc),
	206466	+ JFUNCTION(json_extract, -1, 1, 1, 0, 0, jsonExtractFunc),
	206467	+ JFUNCTION(->, 2, 1, 1, 0, JSON_JSON, jsonExtractFunc),
	206468	+ JFUNCTION(->>, 2, 1, 0, 0, JSON_SQL, jsonExtractFunc),
	206469	+ JFUNCTION(json_insert, -1, 1, 1, 1, 0, jsonSetFunc),
	206470	+ JFUNCTION(json_object, -1, 0, 1, 1, 0, jsonObjectFunc),
	206471	+ JFUNCTION(json_patch, 2, 1, 1, 0, 0, jsonPatchFunc),
	206472	+ JFUNCTION(json_quote, 1, 0, 1, 1, 0, jsonQuoteFunc),
	206473	+ JFUNCTION(json_remove, -1, 1, 1, 0, 0, jsonRemoveFunc),
	206474	+ JFUNCTION(json_replace, -1, 1, 1, 1, 0, jsonReplaceFunc),
	206475	+ JFUNCTION(json_set, -1, 1, 1, 1, JSON_ISSET, jsonSetFunc),
	206476	+ JFUNCTION(json_type, 1, 1, 0, 0, 0, jsonTypeFunc),
	206477	+ JFUNCTION(json_type, 2, 1, 0, 0, 0, jsonTypeFunc),
	206478	+ JFUNCTION(json_valid, 1, 1, 0, 0, 0, jsonValidFunc),
	206479	+#ifdef SQLITE_DEBUG
	206480	+ JFUNCTION(json_parse, 1, 1, 1, 0, 0, jsonParseFunc),
	206481	+ JFUNCTION(json_test1, 1, 1, 0, 1, 0, jsonTest1Func),
206391	206482	#endif
206392	206483	WAGGREGATE(json_group_array, 1, 0, 0,
206393	206484	jsonArrayStep, jsonArrayFinal, jsonArrayValue, jsonGroupInverse,
206394		- SQLITE_SUBTYPE\|SQLITE_UTF8\|SQLITE_DETERMINISTIC),
	206485	+ SQLITE_SUBTYPE\|SQLITE_RESULT_SUBTYPE\|SQLITE_UTF8\|
	206486	+ SQLITE_DETERMINISTIC),
206395	206487	WAGGREGATE(json_group_object, 2, 0, 0,
206396	206488	jsonObjectStep, jsonObjectFinal, jsonObjectValue, jsonGroupInverse,
206397		- SQLITE_SUBTYPE\|SQLITE_UTF8\|SQLITE_DETERMINISTIC)
	206489	+ SQLITE_SUBTYPE\|SQLITE_RESULT_SUBTYPE\|SQLITE_UTF8\|
	206490	+ SQLITE_DETERMINISTIC)
206398	206491	};
206399	206492	sqlite3InsertBuiltinFuncs(aJsonFunc, ArraySize(aJsonFunc));
206400	206493	#endif
206401	206494	}
206402	206495
		@@ -236129,14 +236222,12 @@
236129	236222
236130	236223	return pRet;
236131	236224	}
236132	236225
236133	236226	/*
236134		-** Extract all tokens from hash table iHash and link them into a list
236135		-** in sorted order. The hash table is cleared before returning. It is
236136		-** the responsibility of the caller to free the elements of the returned
236137		-** list.
	236227	+** Link all tokens from hash table iHash into a list in sorted order. The
	236228	+** tokens are not removed from the hash table.
236138	236229	*/
236139	236230	static int fts5HashEntrySort(
236140	236231	Fts5Hash *pHash,
236141	236232	const char pTerm, int nTerm, / Query prefix, if any */
236142	236233	Fts5HashEntry **ppSorted
		@@ -238998,10 +239089,18 @@
238998	239089	pLeaf = fts5IdxMalloc(p, sizeof(Fts5Data));
238999	239090	if( pLeaf ){
239000	239091	pLeaf->p = (u8*)pList;
239001	239092	}
239002	239093	}
	239094	+
	239095	+ /* The call to sqlite3Fts5HashScanInit() causes the hash table to
	239096	+ ** fill the size field of all existing position lists. This means they
	239097	+ ** can no longer be appended to. Since the only scenario in which they
	239098	+ ** can be appended to is if the previous operation on this table was
	239099	+ ** a DELETE, by clearing the Fts5Index.bDelete flag we can avoid this
	239100	+ ** possibility altogether. */
	239101	+ p->bDelete = 0;
239003	239102	}else{
239004	239103	p->rc = sqlite3Fts5HashQuery(p->pHash, sizeof(Fts5Data),
239005	239104	(const char)pTerm, nTerm, (void*)&pLeaf, &nList
239006	239105	);
239007	239106	if( pLeaf ){
		@@ -240675,11 +240774,11 @@
240675	240774	){
240676	240775	Fts5PageWriter *pPage = &pWriter->writer;
240677	240776	const u8 *a = aData;
240678	240777	int n = nData;
240679	240778
240680		- assert( p->pConfig->pgsz>0 );
	240779	+ assert( p->pConfig->pgsz>0 \|\| p->rc!=SQLITE_OK );
240681	240780	while( p->rc==SQLITE_OK
240682	240781	&& (pPage->buf.n + pPage->pgidx.n + n)>=p->pConfig->pgsz
240683	240782	){
240684	240783	int nReq = p->pConfig->pgsz - pPage->buf.n - pPage->pgidx.n;
240685	240784	int nCopy = 0;
		@@ -241408,22 +241507,28 @@
241408	241507	}
241409	241508	}
241410	241509
241411	241510	iOff = iStart;
241412	241511
241413		- /* Set variable bLastInDoclist to true if this entry happens to be
241414		- ** the last rowid in the doclist for its term. */
	241512	+ /* If the position-list for the entry being removed flows over past
	241513	+ ** the end of this page, delete the portion of the position-list on the
	241514	+ ** next page and beyond.
	241515	+ **
	241516	+ ** Set variable bLastInDoclist to true if this entry happens
	241517	+ ** to be the last rowid in the doclist for its term. */
	241518	+ if( iNextOff>=iPgIdx ){
	241519	+ int pgno = pSeg->iLeafPgno+1;
	241520	+ fts5SecureDeleteOverflow(p, pSeg->pSeg, pgno, &bLastInDoclist);
	241521	+ iNextOff = iPgIdx;
	241522	+ }
	241523	+
241415	241524	if( pSeg->bDel==0 ){
241416		- if( iNextOff>=iPgIdx ){
241417		- int pgno = pSeg->iLeafPgno+1;
241418		- fts5SecureDeleteOverflow(p, pSeg->pSeg, pgno, &bLastInDoclist);
241419		- iNextOff = iPgIdx;
241420		- }else{
	241525	+ if( iNextOff!=iPgIdx ){
241421	241526	/* Loop through the page-footer. If iNextOff (offset of the
241422	241527	** entry following the one we are removing) is equal to the
241423	241528	** offset of a key on this page, then the entry is the last
241424		- ** in its doclist. */
	241529	+ ** in its doclist. */
241425	241530	int iKeyOff = 0;
241426	241531	for(iIdx=0; iIdx<nIdx; /* no-op */){
241427	241532	u32 iVal = 0;
241428	241533	iIdx += fts5GetVarint32(&aIdx[iIdx], iVal);
241429	241534	iKeyOff += iVal;
		@@ -241935,12 +242040,13 @@
241935	242040	Fts5Structure *pStruct;
241936	242041	Fts5Structure *pNew = 0;
241937	242042
241938	242043	assert( p->rc==SQLITE_OK );
241939	242044	fts5IndexFlush(p);
241940		- assert( p->nContentlessDelete==0 );
	242045	+ assert( p->rc!=SQLITE_OK \|\| p->nContentlessDelete==0 );
241941	242046	pStruct = fts5StructureRead(p);
	242047	+ assert( p->rc!=SQLITE_OK \|\| pStruct!=0 );
241942	242048	fts5StructureInvalidate(p);
241943	242049
241944	242050	if( pStruct ){
241945	242051	pNew = fts5IndexOptimizeStruct(p, pStruct);
241946	242052	}
		@@ -247513,11 +247619,11 @@
247513	247619	int nArg, /* Number of args */
247514	247620	sqlite3_value *apUnused / Function arguments */
247515	247621	){
247516	247622	assert( nArg==0 );
247517	247623	UNUSED_PARAM2(nArg, apUnused);
247518		- sqlite3_result_text(pCtx, "fts5: 2023-11-01 11:23:50 17129ba1ff7f0daf37100ee82d507aef7827cf38de1866e2633096ae6ad81301", -1, SQLITE_TRANSIENT);
	247624	+ sqlite3_result_text(pCtx, "fts5: 2023-11-24 11:41:44 ebead0e7230cd33bcec9f95d2183069565b9e709bf745c9b5db65cc0cbf92c0f", -1, SQLITE_TRANSIENT);
247519	247625	}
247520	247626
247521	247627	/*
247522	247628	** Return true if zName is the extension on one of the shadow tables used
247523	247629	** by this module.
247524	247630

	--- extsrc/sqlite3.c
	+++ extsrc/sqlite3.c
	@@ -1,8 +1,8 @@
1	/******************************************************************************
2	** This file is an amalgamation of many separate C source files from SQLite
3	** version 3.44.0. By combining all the individual C code files into this
4	** single large file, the entire code can be compiled as a single translation
5	** unit. This allows many compilers to do optimizations that would not be
6	** possible if the files were compiled separately. Performance improvements
7	** of 5% or more are commonly seen when SQLite is compiled as a single
8	** translation unit.
	@@ -16,11 +16,11 @@
16	** if you want a wrapper to interface SQLite with your choice of programming
17	** language. The code for the "sqlite3" command-line shell is also in a
18	** separate file. This file contains only code for the core SQLite library.
19	**
20	** The content in this amalgamation comes from Fossil check-in
21	** 17129ba1ff7f0daf37100ee82d507aef7827.
22	*/
23	#define SQLITE_CORE 1
24	#define SQLITE_AMALGAMATION 1
25	#ifndef SQLITE_PRIVATE
26	# define SQLITE_PRIVATE static
	@@ -457,13 +457,13 @@
457	**
458	** See also: [sqlite3_libversion()],
459	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
460	** [sqlite_version()] and [sqlite_source_id()].
461	*/
462	#define SQLITE_VERSION "3.44.0"
463	#define SQLITE_VERSION_NUMBER 3044000
464	#define SQLITE_SOURCE_ID "2023-11-01 11:23:50 17129ba1ff7f0daf37100ee82d507aef7827cf38de1866e2633096ae6ad81301"
465
466	/*
467	** CAPI3REF: Run-Time Library Version Numbers
468	** KEYWORDS: sqlite3_version sqlite3_sourceid
469	**
	@@ -5884,24 +5884,39 @@
5884	** function has been carefully audited and found to be free of potentially
5885	** security-adverse side-effects and information-leaks.
5886	** </dd>
5887	**
5888	** [[SQLITE_SUBTYPE]] <dt>SQLITE_SUBTYPE</dt><dd>
5889	** The SQLITE_SUBTYPE flag indicates to SQLite that a function may call
5890	** [sqlite3_value_subtype()] to inspect the sub-types of its arguments.
5891	** Specifying this flag makes no difference for scalar or aggregate user
5892	** functions. However, if it is not specified for a user-defined window
5893	** function, then any sub-types belonging to arguments passed to the window
5894	** function may be discarded before the window function is called (i.e.
5895	** sqlite3_value_subtype() will always return 0).














5896	** </dd>
5897	** </dl>
5898	*/
5899	#define SQLITE_DETERMINISTIC 0x000000800
5900	#define SQLITE_DIRECTONLY 0x000080000
5901	#define SQLITE_SUBTYPE 0x000100000
5902	#define SQLITE_INNOCUOUS 0x000200000

5903
5904	/*
5905	** CAPI3REF: Deprecated Functions
5906	** DEPRECATED
5907	**
	@@ -6094,10 +6109,16 @@
6094	** The sqlite3_value_subtype(V) function returns the subtype for
6095	** an [application-defined SQL function] argument V. The subtype
6096	** information can be used to pass a limited amount of context from
6097	** one SQL function to another. Use the [sqlite3_result_subtype()]
6098	** routine to set the subtype for the return value of an SQL function.






6099	*/
6100	SQLITE_API unsigned int sqlite3_value_subtype(sqlite3_value*);
6101
6102	/*
6103	** CAPI3REF: Copy And Free SQL Values
	@@ -6224,18 +6245,26 @@
6224	** <li> ^(when [sqlite3_reset()] or [sqlite3_finalize()] is called for the
6225	** SQL statement)^, or
6226	** <li> ^(when sqlite3_set_auxdata() is invoked again on the same
6227	** parameter)^, or
6228	** <li> ^(during the original sqlite3_set_auxdata() call when a memory
6229	** allocation error occurs.)^ </ul>



6230	**
6231	** Note the last bullet in particular. The destructor X in
6232	** sqlite3_set_auxdata(C,N,P,X) might be called immediately, before the
6233	** sqlite3_set_auxdata() interface even returns. Hence sqlite3_set_auxdata()
6234	** should be called near the end of the function implementation and the
6235	** function implementation should not make any use of P after
6236	** sqlite3_set_auxdata() has been called.





6237	**
6238	** ^(In practice, auxiliary data is preserved between function calls for
6239	** function parameters that are compile-time constants, including literal
6240	** values and [parameters] and expressions composed from the same.)^
6241	**
	@@ -6505,10 +6534,24 @@
6505	** [sqlite3_context] C to be the value T. Only the lower 8 bits
6506	** of the subtype T are preserved in current versions of SQLite;
6507	** higher order bits are discarded.
6508	** The number of subtype bytes preserved by SQLite might increase
6509	** in future releases of SQLite.














6510	*/
6511	SQLITE_API void sqlite3_result_subtype(sqlite3_context*,unsigned int);
6512
6513	/*
6514	** CAPI3REF: Define New Collating Sequences
	@@ -17809,18 +17852,19 @@
17809	#define SQLITE_FUNC_CONSTANT 0x0800 /* Constant inputs give a constant output */
17810	#define SQLITE_FUNC_MINMAX 0x1000 /* True for min() and max() aggregates */
17811	#define SQLITE_FUNC_SLOCHNG 0x2000 /* "Slow Change". Value constant during a
17812	** single query - might change over time */
17813	#define SQLITE_FUNC_TEST 0x4000 /* Built-in testing functions */
17814	/* 0x8000 -- available for reuse */
17815	#define SQLITE_FUNC_WINDOW 0x00010000 /* Built-in window-only function */
17816	#define SQLITE_FUNC_INTERNAL 0x00040000 /* For use by NestedParse() only */
17817	#define SQLITE_FUNC_DIRECT 0x00080000 /* Not for use in TRIGGERs or VIEWs */
17818	#define SQLITE_FUNC_SUBTYPE 0x00100000 /* Result likely to have sub-type */
17819	#define SQLITE_FUNC_UNSAFE 0x00200000 /* Function has side effects */
17820	#define SQLITE_FUNC_INLINE 0x00400000 /* Functions implemented in-line */
17821	#define SQLITE_FUNC_BUILTIN 0x00800000 /* This is a built-in function */

17822	#define SQLITE_FUNC_ANYORDER 0x08000000 /* count/min/max aggregate */
17823
17824	/* Identifier numbers for each in-line function */
17825	#define INLINEFUNC_coalesce 0
17826	#define INLINEFUNC_implies_nonnull_row 1
	@@ -17908,13 +17952,14 @@
17908	{nArg, SQLITE_FUNC_BUILTIN\|SQLITE_UTF8\|SQLITE_DIRECTONLY\|SQLITE_FUNC_UNSAFE, \
17909	SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
17910	#define MFUNCTION(zName, nArg, xPtr, xFunc) \
17911	{nArg, SQLITE_FUNC_BUILTIN\|SQLITE_FUNC_CONSTANT\|SQLITE_UTF8, \
17912	xPtr, 0, xFunc, 0, 0, 0, #zName, {0} }
17913	#define JFUNCTION(zName, nArg, iArg, xFunc) \
17914	{nArg, SQLITE_FUNC_BUILTIN\|SQLITE_DETERMINISTIC\|\
17915	SQLITE_FUNC_CONSTANT\|SQLITE_UTF8, \

17916	SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
17917	#define INLINE_FUNC(zName, nArg, iArg, mFlags) \
17918	{nArg, SQLITE_FUNC_BUILTIN\|\
17919	SQLITE_UTF8\|SQLITE_FUNC_INLINE\|SQLITE_FUNC_CONSTANT\|(mFlags), \
17920	SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }
	@@ -29451,11 +29496,11 @@
29451	SQLITE_PRIVATE void sqlite3MemoryBarrier(void){
29452	#if defined(SQLITE_MEMORY_BARRIER)
29453	SQLITE_MEMORY_BARRIER;
29454	#elif defined(__GNUC__)
29455	__sync_synchronize();
29456	#elif MSVC_VERSION>=1300
29457	_ReadWriteBarrier();
29458	#elif defined(MemoryBarrier)
29459	MemoryBarrier();
29460	#endif
29461	}
	@@ -61445,14 +61490,17 @@
61445	** of the corresponding WAL or Journal name as passed into
61446	** xOpen.
61447	*/
61448	SQLITE_API sqlite3_file sqlite3_database_file_object(const char zName){
61449	Pager *pPager;

61450	while( zName[-1]!=0 \|\| zName[-2]!=0 \|\| zName[-3]!=0 \|\| zName[-4]!=0 ){
61451	zName--;
61452	}
61453	pPager = (Pager)(zName - 4 - sizeof(Pager));


61454	return pPager->fd;
61455	}
61456
61457
61458	/*
	@@ -83409,11 +83457,11 @@
83409	#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
83410	if( pFunc==0 ) return SQLITE_OK;
83411	#endif
83412	assert( pFunc );
83413	if( (pFunc->funcFlags & (SQLITE_FUNC_CONSTANT\|SQLITE_FUNC_SLOCHNG))==0
83414	\|\| (pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL)
83415	){
83416	return SQLITE_OK;
83417	}
83418
83419	if( pList ){
	@@ -84133,14 +84181,15 @@
84133	** sqlite3CorruptError(lineno)
84134	** sqlite3MisuseError(lineno)
84135	** sqlite3CantopenError(lineno)
84136	*/
84137	static void test_addop_breakpoint(int pc, Op *pOp){
84138	static int n = 0;
84139	(void)pc;
84140	(void)pOp;
84141	n++;

84142	}
84143	#endif
84144
84145	/*
84146	** Slow paths for sqlite3VdbeAddOp3() and sqlite3VdbeAddOp4Int() for the
	@@ -89950,10 +89999,22 @@
89950	SQLITE_API void sqlite3_result_subtype(sqlite3_context *pCtx, unsigned int eSubtype){
89951	Mem *pOut;
89952	#ifdef SQLITE_ENABLE_API_ARMOR
89953	if( pCtx==0 ) return;
89954	#endif












89955	pOut = pCtx->pOut;
89956	assert( sqlite3_mutex_held(pOut->db->mutex) );
89957	pOut->eSubtype = eSubtype & 0xff;
89958	pOut->flags \|= MEM_Subtype;
89959	}
	@@ -92268,15 +92329,16 @@
92268	** sqlite3CorruptError(lineno)
92269	** sqlite3MisuseError(lineno)
92270	** sqlite3CantopenError(lineno)
92271	*/
92272	static void test_trace_breakpoint(int pc, Op pOp, Vdbe v){
92273	static int n = 0;
92274	(void)pc;
92275	(void)pOp;
92276	(void)v;
92277	n++;

92278	}
92279	#endif
92280
92281	/*
92282	** Invoke the VDBE coverage callback, if that callback is defined. This
	@@ -100319,11 +100381,11 @@
100319	sqlite3VdbeMemSetNull(pOut); /* Innocent until proven guilty */
100320	assert( pOp->p4type==P4_TABLE );
100321	pTab = pOp->p4.pTab;
100322	assert( pTab!=0 );
100323	assert( IsVirtual(pTab) );
100324	assert( pTab->u.vtab.p!=0 );
100325	pVtab = pTab->u.vtab.p->pVtab;
100326	assert( pVtab!=0 );
100327	pModule = pVtab->pModule;
100328	assert( pModule!=0 );
100329	assert( pModule->iVersion>=4 );
	@@ -113915,12 +113977,12 @@
113915	** Like sqlite3ExprCompare() except COLLATE operators at the top-level
113916	** are ignored.
113917	*/
113918	SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr pA,Expr pB, int iTab){
113919	return sqlite3ExprCompare(0,
113920	sqlite3ExprSkipCollateAndLikely(pA),
113921	sqlite3ExprSkipCollateAndLikely(pB),
113922	iTab);
113923	}
113924
113925	/*
113926	** Return non-zero if Expr p can only be true if pNN is not NULL.
	@@ -143550,11 +143612,12 @@
143550	Expr *p;
143551	struct ExprList_item *a;
143552	NameContext sNC;
143553
143554	assert( pSelect!=0 );
143555	assert( (pSelect->selFlags & SF_Resolved)!=0 );

143556	assert( pTab->nCol==pSelect->pEList->nExpr \|\| pParse->nErr>0 );
143557	assert( aff==SQLITE_AFF_NONE \|\| aff==SQLITE_AFF_BLOB );
143558	if( db->mallocFailed \|\| IN_RENAME_OBJECT ) return;
143559	while( pSelect->pPrior ) pSelect = pSelect->pPrior;
143560	a = pSelect->pEList->a;
	@@ -147603,14 +147666,15 @@
147603	Parse *pParse;
147604	int i;
147605	SrcList *pTabList;
147606	SrcItem *pFrom;
147607
147608	assert( p->selFlags & SF_Resolved );
147609	if( p->selFlags & SF_HasTypeInfo ) return;
147610	p->selFlags \|= SF_HasTypeInfo;
147611	pParse = pWalker->pParse;


147612	pTabList = p->pSrc;
147613	for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
147614	Table *pTab = pFrom->pTab;
147615	assert( pTab!=0 );
147616	if( (pTab->tabFlags & TF_Ephemeral)!=0 ){
	@@ -148628,10 +148692,11 @@
148628	pItem->fg.jointype &= ~JT_LEFT;
148629	}else{
148630	TREETRACE(0x1000,pParse,p,
148631	("LEFT-JOIN simplifies to JOIN on term %d\n",i));
148632	pItem->fg.jointype &= ~(JT_LEFT\|JT_OUTER);

148633	}
148634	}
148635	if( pItem->fg.jointype & JT_LTORJ ){
148636	for(j=i+1; j<pTabList->nSrc; j++){
148637	SrcItem *pI2 = &pTabList->a[j];
	@@ -148642,21 +148707,19 @@
148642	pI2->fg.jointype &= ~JT_RIGHT;
148643	}else{
148644	TREETRACE(0x1000,pParse,p,
148645	("RIGHT-JOIN simplifies to JOIN on term %d\n",j));
148646	pI2->fg.jointype &= ~(JT_RIGHT\|JT_OUTER);

148647	}
148648	}
148649	}
148650	for(j=pTabList->nSrc-1; j>=i; j--){
148651	pTabList->a[j].fg.jointype &= ~JT_LTORJ;
148652	if( pTabList->a[j].fg.jointype & JT_RIGHT ) break;
148653	}
148654	}
148655	assert( pItem->iCursor>=0 );
148656	unsetJoinExpr(p->pWhere, pItem->iCursor,
148657	pTabList->a[0].fg.jointype & JT_LTORJ);
148658	}
148659
148660	/* No further action if this term of the FROM clause is not a subquery */
148661	if( pSub==0 ) continue;
148662
	@@ -166056,10 +166119,24 @@
166056	bMaybeNullRow = 0;
166057	}else{
166058	continue;
166059	}
166060	if( sqlite3ExprIsConstant(pExpr) ) continue;














166061	p = sqlite3DbMallocRaw(pParse->db, sizeof(IndexedExpr));
166062	if( p==0 ) break;
166063	p->pIENext = pParse->pIdxEpr;
166064	#ifdef WHERETRACE_ENABLED
166065	if( sqlite3WhereTrace & 0x200 ){
	@@ -168238,11 +168315,11 @@
168238	for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
168239	ExprList *pArgs;
168240	assert( ExprUseXList(pWin->pOwner) );
168241	assert( pWin->pWFunc!=0 );
168242	pArgs = pWin->pOwner->x.pList;
168243	if( pWin->pWFunc->funcFlags & SQLITE_FUNC_SUBTYPE ){
168244	selectWindowRewriteEList(pParse, pMWin, pSrc, pArgs, pTab, &pSublist);
168245	pWin->iArgCol = (pSublist ? pSublist->nExpr : 0);
168246	pWin->bExprArgs = 1;
168247	}else{
168248	pWin->iArgCol = (pSublist ? pSublist->nExpr : 0);
	@@ -179412,11 +179489,11 @@
179412	}
179413
179414	assert( SQLITE_FUNC_CONSTANT==SQLITE_DETERMINISTIC );
179415	assert( SQLITE_FUNC_DIRECT==SQLITE_DIRECTONLY );
179416	extraFlags = enc & (SQLITE_DETERMINISTIC\|SQLITE_DIRECTONLY\|
179417	SQLITE_SUBTYPE\|SQLITE_INNOCUOUS);
179418	enc &= (SQLITE_FUNC_ENCMASK\|SQLITE_ANY);
179419
179420	/* The SQLITE_INNOCUOUS flag is the same bit as SQLITE_FUNC_UNSAFE. But
179421	** the meaning is inverted. So flip the bit. */
179422	assert( SQLITE_FUNC_UNSAFE==SQLITE_INNOCUOUS );
	@@ -202993,16 +203070,22 @@
202993	u32 i;
202994	jsonAppendChar(p, '"');
202995	zIn++;
202996	N -= 2;
202997	while( N>0 ){
202998	for(i=0; i<N && zIn[i]!='\\'; i++){}
202999	if( i>0 ){
203000	jsonAppendRawNZ(p, zIn, i);
203001	zIn += i;
203002	N -= i;
203003	if( N==0 ) break;






203004	}
203005	assert( zIn[0]=='\\' );
203006	switch( (u8)zIn[1] ){
203007	case '\'':
203008	jsonAppendChar(p, '\'');
	@@ -203394,11 +203477,12 @@
203394	*/
203395	static void jsonReturnJson(
203396	JsonParse pParse, / The complete JSON */
203397	JsonNode pNode, / Node to return */
203398	sqlite3_context pCtx, / Return value for this function */
203399	int bGenerateAlt /* Also store the rendered text in zAlt */

203400	){
203401	JsonString s;
203402	if( pParse->oom ){
203403	sqlite3_result_error_nomem(pCtx);
203404	return;
	@@ -203409,11 +203493,11 @@
203409	if( bGenerateAlt && pParse->zAlt==0 && jsonForceRCStr(&s) ){
203410	pParse->zAlt = sqlite3RCStrRef(s.zBuf);
203411	pParse->nAlt = s.nUsed;
203412	}
203413	jsonResult(&s);
203414	sqlite3_result_subtype(pCtx, JSON_SUBTYPE);
203415	}
203416	}
203417
203418	/*
203419	** Translate a single byte of Hex into an integer.
	@@ -203450,11 +203534,12 @@
203450	** Make the JsonNode the return value of the function.
203451	*/
203452	static void jsonReturn(
203453	JsonParse pParse, / Complete JSON parse tree */
203454	JsonNode pNode, / Node to return */
203455	sqlite3_context pCtx / Return value for this function */

203456	){
203457	switch( pNode->eType ){
203458	default: {
203459	assert( pNode->eType==JSON_NULL );
203460	sqlite3_result_null(pCtx);
	@@ -203596,11 +203681,11 @@
203596	}
203597	break;
203598	}
203599	case JSON_ARRAY:
203600	case JSON_OBJECT: {
203601	jsonReturnJson(pParse, pNode, pCtx, 0);
203602	break;
203603	}
203604	}
203605	}
203606
	@@ -204948,11 +205033,11 @@
204948	printf("hasMod = %u\n", p->hasMod);
204949	printf("nJPRef = %u\n", p->nJPRef);
204950	printf("iSubst = %u\n", p->iSubst);
204951	printf("iHold = %u\n", p->iHold);
204952	jsonDebugPrintNodeEntries(p->aNode, p->nNode);
204953	jsonReturnJson(p, p->aNode, ctx, 1);
204954	}
204955
204956	/*
204957	** The json_test1(JSON) function return true (1) if the input is JSON
204958	** text generated by another json function. It returns (0) if the input
	@@ -205134,19 +205219,18 @@
205134	}else{
205135	pNode = jsonLookup(p, zPath, 0, ctx);
205136	}
205137	if( pNode ){
205138	if( flags & JSON_JSON ){
205139	jsonReturnJson(p, pNode, ctx, 0);
205140	}else{
205141	jsonReturn(p, pNode, ctx);
205142	sqlite3_result_subtype(ctx, 0);
205143	}
205144	}
205145	}else{
205146	pNode = jsonLookup(p, zPath, 0, ctx);
205147	if( p->nErr==0 && pNode ) jsonReturn(p, pNode, ctx);
205148	}
205149	}else{
205150	/* Two or more PATH arguments results in a JSON array with each
205151	** element of the array being the value selected by one of the PATHs */
205152	int i;
	@@ -205268,11 +205352,11 @@
205268	pResult = jsonMergePatch(pX, 0, pY->aNode);
205269	assert( pResult!=0 \|\| pX->oom );
205270	if( pResult && pX->oom==0 ){
205271	jsonDebugPrintParse(pX);
205272	jsonDebugPrintNode(pResult);
205273	jsonReturnJson(pX, pResult, ctx, 0);
205274	}else{
205275	sqlite3_result_error_nomem(ctx);
205276	}
205277	}
205278
	@@ -205347,11 +205431,11 @@
205347	pParse->hasMod = 1;
205348	pParse->useMod = 1;
205349	}
205350	}
205351	if( (pParse->aNode[0].jnFlags & JNODE_REMOVE)==0 ){
205352	jsonReturnJson(pParse, pParse->aNode, ctx, 1);
205353	}
205354	remove_done:
205355	jsonDebugPrintParse(p);
205356	}
205357
	@@ -205476,11 +205560,11 @@
205476	if( pParse->nErr ) goto replace_err;
205477	if( pNode ){
205478	jsonReplaceNode(ctx, pParse, (u32)(pNode - pParse->aNode), argv[i+1]);
205479	}
205480	}
205481	jsonReturnJson(pParse, pParse->aNode, ctx, 1);
205482	replace_err:
205483	jsonDebugPrintParse(pParse);
205484	jsonParseFree(pParse);
205485	}
205486
	@@ -205530,11 +205614,11 @@
205530	}else if( pNode && (bApnd \|\| bIsSet) ){
205531	jsonReplaceNode(ctx, pParse, (u32)(pNode - pParse->aNode), argv[i+1]);
205532	}
205533	}
205534	jsonDebugPrintParse(pParse);
205535	jsonReturnJson(pParse, pParse->aNode, ctx, 1);
205536	jsonSetDone:
205537	jsonParseFree(pParse);
205538	}
205539
205540	/*
	@@ -206045,11 +206129,11 @@
206045	JsonNode *pThis = &p->sParse.aNode[p->i];
206046	switch( i ){
206047	case JEACH_KEY: {
206048	if( p->i==0 ) break;
206049	if( p->eType==JSON_OBJECT ){
206050	jsonReturn(&p->sParse, pThis, ctx);
206051	}else if( p->eType==JSON_ARRAY ){
206052	u32 iKey;
206053	if( p->bRecursive ){
206054	if( p->iRowid==0 ) break;
206055	assert( p->sParse.aNode[p->sParse.aUp[p->i]].eU==3 );
	@@ -206061,11 +206145,11 @@
206061	}
206062	break;
206063	}
206064	case JEACH_VALUE: {
206065	if( pThis->jnFlags & JNODE_LABEL ) pThis++;
206066	jsonReturn(&p->sParse, pThis, ctx);
206067	break;
206068	}
206069	case JEACH_TYPE: {
206070	if( pThis->jnFlags & JNODE_LABEL ) pThis++;
206071	sqlite3_result_text(ctx, jsonType[pThis->eType], -1, SQLITE_STATIC);
	@@ -206072,11 +206156,11 @@
206072	break;
206073	}
206074	case JEACH_ATOM: {
206075	if( pThis->jnFlags & JNODE_LABEL ) pThis++;
206076	if( pThis->eType>=JSON_ARRAY ) break;
206077	jsonReturn(&p->sParse, pThis, ctx);
206078	break;
206079	}
206080	case JEACH_ID: {
206081	sqlite3_result_int64(ctx,
206082	(sqlite3_int64)p->i + ((pThis->jnFlags & JNODE_LABEL)!=0));
	@@ -206365,38 +206449,47 @@
206365	** Register JSON functions.
206366	*/
206367	SQLITE_PRIVATE void sqlite3RegisterJsonFunctions(void){
206368	#ifndef SQLITE_OMIT_JSON
206369	static FuncDef aJsonFunc[] = {
206370	JFUNCTION(json, 1, 0, jsonRemoveFunc),
206371	JFUNCTION(json_array, -1, 0, jsonArrayFunc),
206372	JFUNCTION(json_array_length, 1, 0, jsonArrayLengthFunc),
206373	JFUNCTION(json_array_length, 2, 0, jsonArrayLengthFunc),
206374	JFUNCTION(json_error_position,1, 0, jsonErrorFunc),
206375	JFUNCTION(json_extract, -1, 0, jsonExtractFunc),
206376	JFUNCTION(->, 2, JSON_JSON, jsonExtractFunc),
206377	JFUNCTION(->>, 2, JSON_SQL, jsonExtractFunc),
206378	JFUNCTION(json_insert, -1, 0, jsonSetFunc),
206379	JFUNCTION(json_object, -1, 0, jsonObjectFunc),
206380	JFUNCTION(json_patch, 2, 0, jsonPatchFunc),
206381	JFUNCTION(json_quote, 1, 0, jsonQuoteFunc),
206382	JFUNCTION(json_remove, -1, 0, jsonRemoveFunc),
206383	JFUNCTION(json_replace, -1, 0, jsonReplaceFunc),
206384	JFUNCTION(json_set, -1, JSON_ISSET, jsonSetFunc),
206385	JFUNCTION(json_type, 1, 0, jsonTypeFunc),
206386	JFUNCTION(json_type, 2, 0, jsonTypeFunc),
206387	JFUNCTION(json_valid, 1, 0, jsonValidFunc),
206388	#if SQLITE_DEBUG
206389	JFUNCTION(json_parse, 1, 0, jsonParseFunc),
206390	JFUNCTION(json_test1, 1, 0, jsonTest1Func),







206391	#endif
206392	WAGGREGATE(json_group_array, 1, 0, 0,
206393	jsonArrayStep, jsonArrayFinal, jsonArrayValue, jsonGroupInverse,
206394	SQLITE_SUBTYPE\|SQLITE_UTF8\|SQLITE_DETERMINISTIC),

206395	WAGGREGATE(json_group_object, 2, 0, 0,
206396	jsonObjectStep, jsonObjectFinal, jsonObjectValue, jsonGroupInverse,
206397	SQLITE_SUBTYPE\|SQLITE_UTF8\|SQLITE_DETERMINISTIC)

206398	};
206399	sqlite3InsertBuiltinFuncs(aJsonFunc, ArraySize(aJsonFunc));
206400	#endif
206401	}
206402
	@@ -236129,14 +236222,12 @@
236129
236130	return pRet;
236131	}
236132
236133	/*
236134	** Extract all tokens from hash table iHash and link them into a list
236135	** in sorted order. The hash table is cleared before returning. It is
236136	** the responsibility of the caller to free the elements of the returned
236137	** list.
236138	*/
236139	static int fts5HashEntrySort(
236140	Fts5Hash *pHash,
236141	const char pTerm, int nTerm, / Query prefix, if any */
236142	Fts5HashEntry **ppSorted
	@@ -238998,10 +239089,18 @@
238998	pLeaf = fts5IdxMalloc(p, sizeof(Fts5Data));
238999	if( pLeaf ){
239000	pLeaf->p = (u8*)pList;
239001	}
239002	}








239003	}else{
239004	p->rc = sqlite3Fts5HashQuery(p->pHash, sizeof(Fts5Data),
239005	(const char)pTerm, nTerm, (void*)&pLeaf, &nList
239006	);
239007	if( pLeaf ){
	@@ -240675,11 +240774,11 @@
240675	){
240676	Fts5PageWriter *pPage = &pWriter->writer;
240677	const u8 *a = aData;
240678	int n = nData;
240679
240680	assert( p->pConfig->pgsz>0 );
240681	while( p->rc==SQLITE_OK
240682	&& (pPage->buf.n + pPage->pgidx.n + n)>=p->pConfig->pgsz
240683	){
240684	int nReq = p->pConfig->pgsz - pPage->buf.n - pPage->pgidx.n;
240685	int nCopy = 0;
	@@ -241408,22 +241507,28 @@
241408	}
241409	}
241410
241411	iOff = iStart;
241412
241413	/* Set variable bLastInDoclist to true if this entry happens to be
241414	** the last rowid in the doclist for its term. */










241415	if( pSeg->bDel==0 ){
241416	if( iNextOff>=iPgIdx ){
241417	int pgno = pSeg->iLeafPgno+1;
241418	fts5SecureDeleteOverflow(p, pSeg->pSeg, pgno, &bLastInDoclist);
241419	iNextOff = iPgIdx;
241420	}else{
241421	/* Loop through the page-footer. If iNextOff (offset of the
241422	** entry following the one we are removing) is equal to the
241423	** offset of a key on this page, then the entry is the last
241424	** in its doclist. */
241425	int iKeyOff = 0;
241426	for(iIdx=0; iIdx<nIdx; /* no-op */){
241427	u32 iVal = 0;
241428	iIdx += fts5GetVarint32(&aIdx[iIdx], iVal);
241429	iKeyOff += iVal;
	@@ -241935,12 +242040,13 @@
241935	Fts5Structure *pStruct;
241936	Fts5Structure *pNew = 0;
241937
241938	assert( p->rc==SQLITE_OK );
241939	fts5IndexFlush(p);
241940	assert( p->nContentlessDelete==0 );
241941	pStruct = fts5StructureRead(p);

241942	fts5StructureInvalidate(p);
241943
241944	if( pStruct ){
241945	pNew = fts5IndexOptimizeStruct(p, pStruct);
241946	}
	@@ -247513,11 +247619,11 @@
247513	int nArg, /* Number of args */
247514	sqlite3_value *apUnused / Function arguments */
247515	){
247516	assert( nArg==0 );
247517	UNUSED_PARAM2(nArg, apUnused);
247518	sqlite3_result_text(pCtx, "fts5: 2023-11-01 11:23:50 17129ba1ff7f0daf37100ee82d507aef7827cf38de1866e2633096ae6ad81301", -1, SQLITE_TRANSIENT);
247519	}
247520
247521	/*
247522	** Return true if zName is the extension on one of the shadow tables used
247523	** by this module.
247524

	--- extsrc/sqlite3.c
	+++ extsrc/sqlite3.c
	@@ -1,8 +1,8 @@
1	/******************************************************************************
2	** This file is an amalgamation of many separate C source files from SQLite
3	** version 3.44.2. By combining all the individual C code files into this
4	** single large file, the entire code can be compiled as a single translation
5	** unit. This allows many compilers to do optimizations that would not be
6	** possible if the files were compiled separately. Performance improvements
7	** of 5% or more are commonly seen when SQLite is compiled as a single
8	** translation unit.
	@@ -16,11 +16,11 @@
16	** if you want a wrapper to interface SQLite with your choice of programming
17	** language. The code for the "sqlite3" command-line shell is also in a
18	** separate file. This file contains only code for the core SQLite library.
19	**
20	** The content in this amalgamation comes from Fossil check-in
21	** ebead0e7230cd33bcec9f95d2183069565b9.
22	*/
23	#define SQLITE_CORE 1
24	#define SQLITE_AMALGAMATION 1
25	#ifndef SQLITE_PRIVATE
26	# define SQLITE_PRIVATE static
	@@ -457,13 +457,13 @@
457	**
458	** See also: [sqlite3_libversion()],
459	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
460	** [sqlite_version()] and [sqlite_source_id()].
461	*/
462	#define SQLITE_VERSION "3.44.2"
463	#define SQLITE_VERSION_NUMBER 3044002
464	#define SQLITE_SOURCE_ID "2023-11-24 11:41:44 ebead0e7230cd33bcec9f95d2183069565b9e709bf745c9b5db65cc0cbf92c0f"
465
466	/*
467	** CAPI3REF: Run-Time Library Version Numbers
468	** KEYWORDS: sqlite3_version sqlite3_sourceid
469	**
	@@ -5884,24 +5884,39 @@
5884	** function has been carefully audited and found to be free of potentially
5885	** security-adverse side-effects and information-leaks.
5886	** </dd>
5887	**
5888	** [[SQLITE_SUBTYPE]] <dt>SQLITE_SUBTYPE</dt><dd>
5889	** The SQLITE_SUBTYPE flag indicates to SQLite that a function might call
5890	** [sqlite3_value_subtype()] to inspect the sub-types of its arguments.
5891	** This flag instructs SQLite to omit some corner-case optimizations that
5892	** might disrupt the operation of the [sqlite3_value_subtype()] function,
5893	** causing it to return zero rather than the correct subtype().
5894	** SQL functions that invokes [sqlite3_value_subtype()] should have this
5895	** property. If the SQLITE_SUBTYPE property is omitted, then the return
5896	** value from [sqlite3_value_subtype()] might sometimes be zero even though
5897	** a non-zero subtype was specified by the function argument expression.
5898	**
5899	** [[SQLITE_RESULT_SUBTYPE]] <dt>SQLITE_RESULT_SUBTYPE</dt><dd>
5900	** The SQLITE_RESULT_SUBTYPE flag indicates to SQLite that a function might call
5901	** [sqlite3_result_subtype()] to cause a sub-type to be associated with its
5902	** result.
5903	** Every function that invokes [sqlite3_result_subtype()] should have this
5904	** property. If it does not, then the call to [sqlite3_result_subtype()]
5905	** might become a no-op if the function is used as term in an
5906	** [expression index]. On the other hand, SQL functions that never invoke
5907	** [sqlite3_result_subtype()] should avoid setting this property, as the
5908	** purpose of this property is to disable certain optimizations that are
5909	** incompatible with subtypes.
5910	** </dd>
5911	** </dl>
5912	*/
5913	#define SQLITE_DETERMINISTIC 0x000000800
5914	#define SQLITE_DIRECTONLY 0x000080000
5915	#define SQLITE_SUBTYPE 0x000100000
5916	#define SQLITE_INNOCUOUS 0x000200000
5917	#define SQLITE_RESULT_SUBTYPE 0x001000000
5918
5919	/*
5920	** CAPI3REF: Deprecated Functions
5921	** DEPRECATED
5922	**
	@@ -6094,10 +6109,16 @@
6109	** The sqlite3_value_subtype(V) function returns the subtype for
6110	** an [application-defined SQL function] argument V. The subtype
6111	** information can be used to pass a limited amount of context from
6112	** one SQL function to another. Use the [sqlite3_result_subtype()]
6113	** routine to set the subtype for the return value of an SQL function.
6114	**
6115	** Every [application-defined SQL function] that invoke this interface
6116	** should include the [SQLITE_SUBTYPE] property in the text
6117	** encoding argument when the function is [sqlite3_create_function\|registered].
6118	** If the [SQLITE_SUBTYPE] property is omitted, then sqlite3_value_subtype()
6119	** might return zero instead of the upstream subtype in some corner cases.
6120	*/
6121	SQLITE_API unsigned int sqlite3_value_subtype(sqlite3_value*);
6122
6123	/*
6124	** CAPI3REF: Copy And Free SQL Values
	@@ -6224,18 +6245,26 @@
6245	** <li> ^(when [sqlite3_reset()] or [sqlite3_finalize()] is called for the
6246	** SQL statement)^, or
6247	** <li> ^(when sqlite3_set_auxdata() is invoked again on the same
6248	** parameter)^, or
6249	** <li> ^(during the original sqlite3_set_auxdata() call when a memory
6250	** allocation error occurs.)^
6251	** <li> ^(during the original sqlite3_set_auxdata() call if the function
6252	** is evaluated during query planning instead of during query execution,
6253	** as sometimes happens with [SQLITE_ENABLE_STAT4].)^ </ul>
6254	**
6255	** Note the last two bullets in particular. The destructor X in
6256	** sqlite3_set_auxdata(C,N,P,X) might be called immediately, before the
6257	** sqlite3_set_auxdata() interface even returns. Hence sqlite3_set_auxdata()
6258	** should be called near the end of the function implementation and the
6259	** function implementation should not make any use of P after
6260	** sqlite3_set_auxdata() has been called. Furthermore, a call to
6261	** sqlite3_get_auxdata() that occurs immediately after a corresponding call
6262	** to sqlite3_set_auxdata() might still return NULL if an out-of-memory
6263	** condition occurred during the sqlite3_set_auxdata() call or if the
6264	** function is being evaluated during query planning rather than during
6265	** query execution.
6266	**
6267	** ^(In practice, auxiliary data is preserved between function calls for
6268	** function parameters that are compile-time constants, including literal
6269	** values and [parameters] and expressions composed from the same.)^
6270	**
	@@ -6505,10 +6534,24 @@
6534	** [sqlite3_context] C to be the value T. Only the lower 8 bits
6535	** of the subtype T are preserved in current versions of SQLite;
6536	** higher order bits are discarded.
6537	** The number of subtype bytes preserved by SQLite might increase
6538	** in future releases of SQLite.
6539	**
6540	** Every [application-defined SQL function] that invokes this interface
6541	** should include the [SQLITE_RESULT_SUBTYPE] property in its
6542	** text encoding argument when the SQL function is
6543	** [sqlite3_create_function\|registered]. If the [SQLITE_RESULT_SUBTYPE]
6544	** property is omitted from the function that invokes sqlite3_result_subtype(),
6545	** then in some cases the sqlite3_result_subtype() might fail to set
6546	** the result subtype.
6547	**
6548	** If SQLite is compiled with -DSQLITE_STRICT_SUBTYPE=1, then any
6549	** SQL function that invokes the sqlite3_result_subtype() interface
6550	** and that does not have the SQLITE_RESULT_SUBTYPE property will raise
6551	** an error. Future versions of SQLite might enable -DSQLITE_STRICT_SUBTYPE=1
6552	** by default.
6553	*/
6554	SQLITE_API void sqlite3_result_subtype(sqlite3_context*,unsigned int);
6555
6556	/*
6557	** CAPI3REF: Define New Collating Sequences
	@@ -17809,18 +17852,19 @@
17852	#define SQLITE_FUNC_CONSTANT 0x0800 /* Constant inputs give a constant output */
17853	#define SQLITE_FUNC_MINMAX 0x1000 /* True for min() and max() aggregates */
17854	#define SQLITE_FUNC_SLOCHNG 0x2000 /* "Slow Change". Value constant during a
17855	** single query - might change over time */
17856	#define SQLITE_FUNC_TEST 0x4000 /* Built-in testing functions */
17857	#define SQLITE_FUNC_RUNONLY 0x8000 /* Cannot be used by valueFromFunction */
17858	#define SQLITE_FUNC_WINDOW 0x00010000 /* Built-in window-only function */
17859	#define SQLITE_FUNC_INTERNAL 0x00040000 /* For use by NestedParse() only */
17860	#define SQLITE_FUNC_DIRECT 0x00080000 /* Not for use in TRIGGERs or VIEWs */
17861	/* SQLITE_SUBTYPE 0x00100000 // Consumer of subtypes */
17862	#define SQLITE_FUNC_UNSAFE 0x00200000 /* Function has side effects */
17863	#define SQLITE_FUNC_INLINE 0x00400000 /* Functions implemented in-line */
17864	#define SQLITE_FUNC_BUILTIN 0x00800000 /* This is a built-in function */
17865	/* SQLITE_RESULT_SUBTYPE 0x01000000 // Generator of subtypes */
17866	#define SQLITE_FUNC_ANYORDER 0x08000000 /* count/min/max aggregate */
17867
17868	/* Identifier numbers for each in-line function */
17869	#define INLINEFUNC_coalesce 0
17870	#define INLINEFUNC_implies_nonnull_row 1
	@@ -17908,13 +17952,14 @@
17952	{nArg, SQLITE_FUNC_BUILTIN\|SQLITE_UTF8\|SQLITE_DIRECTONLY\|SQLITE_FUNC_UNSAFE, \
17953	SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
17954	#define MFUNCTION(zName, nArg, xPtr, xFunc) \
17955	{nArg, SQLITE_FUNC_BUILTIN\|SQLITE_FUNC_CONSTANT\|SQLITE_UTF8, \
17956	xPtr, 0, xFunc, 0, 0, 0, #zName, {0} }
17957	#define JFUNCTION(zName, nArg, bUseCache, bWS, bRS, iArg, xFunc) \
17958	{nArg, SQLITE_FUNC_BUILTIN\|SQLITE_DETERMINISTIC\|SQLITE_FUNC_CONSTANT\|\
17959	SQLITE_UTF8\|((bUseCache)*SQLITE_FUNC_RUNONLY)\|\
17960	((bRS)SQLITE_SUBTYPE)\|((bWS)SQLITE_RESULT_SUBTYPE), \
17961	SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
17962	#define INLINE_FUNC(zName, nArg, iArg, mFlags) \
17963	{nArg, SQLITE_FUNC_BUILTIN\|\
17964	SQLITE_UTF8\|SQLITE_FUNC_INLINE\|SQLITE_FUNC_CONSTANT\|(mFlags), \
17965	SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }
	@@ -29451,11 +29496,11 @@
29496	SQLITE_PRIVATE void sqlite3MemoryBarrier(void){
29497	#if defined(SQLITE_MEMORY_BARRIER)
29498	SQLITE_MEMORY_BARRIER;
29499	#elif defined(__GNUC__)
29500	__sync_synchronize();
29501	#elif MSVC_VERSION>=1400
29502	_ReadWriteBarrier();
29503	#elif defined(MemoryBarrier)
29504	MemoryBarrier();
29505	#endif
29506	}
	@@ -61445,14 +61490,17 @@
61490	** of the corresponding WAL or Journal name as passed into
61491	** xOpen.
61492	*/
61493	SQLITE_API sqlite3_file sqlite3_database_file_object(const char zName){
61494	Pager *pPager;
61495	const char *p;
61496	while( zName[-1]!=0 \|\| zName[-2]!=0 \|\| zName[-3]!=0 \|\| zName[-4]!=0 ){
61497	zName--;
61498	}
61499	p = zName - 4 - sizeof(Pager*);
61500	assert( EIGHT_BYTE_ALIGNMENT(p) );
61501	pPager = (Pager*)p;
61502	return pPager->fd;
61503	}
61504
61505
61506	/*
	@@ -83409,11 +83457,11 @@
83457	#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
83458	if( pFunc==0 ) return SQLITE_OK;
83459	#endif
83460	assert( pFunc );
83461	if( (pFunc->funcFlags & (SQLITE_FUNC_CONSTANT\|SQLITE_FUNC_SLOCHNG))==0
83462	\|\| (pFunc->funcFlags & (SQLITE_FUNC_NEEDCOLL\|SQLITE_FUNC_RUNONLY))!=0
83463	){
83464	return SQLITE_OK;
83465	}
83466
83467	if( pList ){
	@@ -84133,14 +84181,15 @@
84181	** sqlite3CorruptError(lineno)
84182	** sqlite3MisuseError(lineno)
84183	** sqlite3CantopenError(lineno)
84184	*/
84185	static void test_addop_breakpoint(int pc, Op *pOp){
84186	static u64 n = 0;
84187	(void)pc;
84188	(void)pOp;
84189	n++;
84190	if( n==LARGEST_UINT64 ) abort(); /* so that n is used, preventing a warning */
84191	}
84192	#endif
84193
84194	/*
84195	** Slow paths for sqlite3VdbeAddOp3() and sqlite3VdbeAddOp4Int() for the
	@@ -89950,10 +89999,22 @@
89999	SQLITE_API void sqlite3_result_subtype(sqlite3_context *pCtx, unsigned int eSubtype){
90000	Mem *pOut;
90001	#ifdef SQLITE_ENABLE_API_ARMOR
90002	if( pCtx==0 ) return;
90003	#endif
90004	#if defined(SQLITE_STRICT_SUBTYPE) && SQLITE_STRICT_SUBTYPE+0!=0
90005	if( pCtx->pFunc!=0
90006	&& (pCtx->pFunc->funcFlags & SQLITE_RESULT_SUBTYPE)==0
90007	){
90008	char zErr[200];
90009	sqlite3_snprintf(sizeof(zErr), zErr,
90010	"misuse of sqlite3_result_subtype() by %s()",
90011	pCtx->pFunc->zName);
90012	sqlite3_result_error(pCtx, zErr, -1);
90013	return;
90014	}
90015	#endif /* SQLITE_STRICT_SUBTYPE */
90016	pOut = pCtx->pOut;
90017	assert( sqlite3_mutex_held(pOut->db->mutex) );
90018	pOut->eSubtype = eSubtype & 0xff;
90019	pOut->flags \|= MEM_Subtype;
90020	}
	@@ -92268,15 +92329,16 @@
92329	** sqlite3CorruptError(lineno)
92330	** sqlite3MisuseError(lineno)
92331	** sqlite3CantopenError(lineno)
92332	*/
92333	static void test_trace_breakpoint(int pc, Op pOp, Vdbe v){
92334	static u64 n = 0;
92335	(void)pc;
92336	(void)pOp;
92337	(void)v;
92338	n++;
92339	if( n==LARGEST_UINT64 ) abort(); /* So that n is used, preventing a warning */
92340	}
92341	#endif
92342
92343	/*
92344	** Invoke the VDBE coverage callback, if that callback is defined. This
	@@ -100319,11 +100381,11 @@
100381	sqlite3VdbeMemSetNull(pOut); /* Innocent until proven guilty */
100382	assert( pOp->p4type==P4_TABLE );
100383	pTab = pOp->p4.pTab;
100384	assert( pTab!=0 );
100385	assert( IsVirtual(pTab) );
100386	if( pTab->u.vtab.p==0 ) break;
100387	pVtab = pTab->u.vtab.p->pVtab;
100388	assert( pVtab!=0 );
100389	pModule = pVtab->pModule;
100390	assert( pModule!=0 );
100391	assert( pModule->iVersion>=4 );
	@@ -113915,12 +113977,12 @@
113977	** Like sqlite3ExprCompare() except COLLATE operators at the top-level
113978	** are ignored.
113979	*/
113980	SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr pA,Expr pB, int iTab){
113981	return sqlite3ExprCompare(0,
113982	sqlite3ExprSkipCollate(pA),
113983	sqlite3ExprSkipCollate(pB),
113984	iTab);
113985	}
113986
113987	/*
113988	** Return non-zero if Expr p can only be true if pNN is not NULL.
	@@ -143550,11 +143612,12 @@
143612	Expr *p;
143613	struct ExprList_item *a;
143614	NameContext sNC;
143615
143616	assert( pSelect!=0 );
143617	testcase( (pSelect->selFlags & SF_Resolved)==0 );
143618	assert( (pSelect->selFlags & SF_Resolved)!=0 \|\| IN_RENAME_OBJECT );
143619	assert( pTab->nCol==pSelect->pEList->nExpr \|\| pParse->nErr>0 );
143620	assert( aff==SQLITE_AFF_NONE \|\| aff==SQLITE_AFF_BLOB );
143621	if( db->mallocFailed \|\| IN_RENAME_OBJECT ) return;
143622	while( pSelect->pPrior ) pSelect = pSelect->pPrior;
143623	a = pSelect->pEList->a;
	@@ -147603,14 +147666,15 @@
147666	Parse *pParse;
147667	int i;
147668	SrcList *pTabList;
147669	SrcItem *pFrom;
147670

147671	if( p->selFlags & SF_HasTypeInfo ) return;
147672	p->selFlags \|= SF_HasTypeInfo;
147673	pParse = pWalker->pParse;
147674	testcase( (p->selFlags & SF_Resolved)==0 );
147675	assert( (p->selFlags & SF_Resolved) \|\| IN_RENAME_OBJECT );
147676	pTabList = p->pSrc;
147677	for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
147678	Table *pTab = pFrom->pTab;
147679	assert( pTab!=0 );
147680	if( (pTab->tabFlags & TF_Ephemeral)!=0 ){
	@@ -148628,10 +148692,11 @@
148692	pItem->fg.jointype &= ~JT_LEFT;
148693	}else{
148694	TREETRACE(0x1000,pParse,p,
148695	("LEFT-JOIN simplifies to JOIN on term %d\n",i));
148696	pItem->fg.jointype &= ~(JT_LEFT\|JT_OUTER);
148697	unsetJoinExpr(p->pWhere, pItem->iCursor, 0);
148698	}
148699	}
148700	if( pItem->fg.jointype & JT_LTORJ ){
148701	for(j=i+1; j<pTabList->nSrc; j++){
148702	SrcItem *pI2 = &pTabList->a[j];
	@@ -148642,21 +148707,19 @@
148707	pI2->fg.jointype &= ~JT_RIGHT;
148708	}else{
148709	TREETRACE(0x1000,pParse,p,
148710	("RIGHT-JOIN simplifies to JOIN on term %d\n",j));
148711	pI2->fg.jointype &= ~(JT_RIGHT\|JT_OUTER);
148712	unsetJoinExpr(p->pWhere, pI2->iCursor, 1);
148713	}
148714	}
148715	}
148716	for(j=pTabList->nSrc-1; j>=0; j--){
148717	pTabList->a[j].fg.jointype &= ~JT_LTORJ;
148718	if( pTabList->a[j].fg.jointype & JT_RIGHT ) break;
148719	}
148720	}



148721	}
148722
148723	/* No further action if this term of the FROM clause is not a subquery */
148724	if( pSub==0 ) continue;
148725
	@@ -166056,10 +166119,24 @@
166119	bMaybeNullRow = 0;
166120	}else{
166121	continue;
166122	}
166123	if( sqlite3ExprIsConstant(pExpr) ) continue;
166124	if( pExpr->op==TK_FUNCTION ){
166125	/* Functions that might set a subtype should not be replaced by the
166126	** value taken from an expression index since the index omits the
166127	** subtype. https://sqlite.org/forum/forumpost/68d284c86b082c3e */
166128	int n;
166129	FuncDef *pDef;
166130	sqlite3 *db = pParse->db;
166131	assert( ExprUseXList(pExpr) );
166132	n = pExpr->x.pList ? pExpr->x.pList->nExpr : 0;
166133	pDef = sqlite3FindFunction(db, pExpr->u.zToken, n, ENC(db), 0);
166134	if( pDef==0 \|\| (pDef->funcFlags & SQLITE_RESULT_SUBTYPE)!=0 ){
166135	continue;
166136	}
166137	}
166138	p = sqlite3DbMallocRaw(pParse->db, sizeof(IndexedExpr));
166139	if( p==0 ) break;
166140	p->pIENext = pParse->pIdxEpr;
166141	#ifdef WHERETRACE_ENABLED
166142	if( sqlite3WhereTrace & 0x200 ){
	@@ -168238,11 +168315,11 @@
168315	for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
168316	ExprList *pArgs;
168317	assert( ExprUseXList(pWin->pOwner) );
168318	assert( pWin->pWFunc!=0 );
168319	pArgs = pWin->pOwner->x.pList;
168320	if( pWin->pWFunc->funcFlags & SQLITE_SUBTYPE ){
168321	selectWindowRewriteEList(pParse, pMWin, pSrc, pArgs, pTab, &pSublist);
168322	pWin->iArgCol = (pSublist ? pSublist->nExpr : 0);
168323	pWin->bExprArgs = 1;
168324	}else{
168325	pWin->iArgCol = (pSublist ? pSublist->nExpr : 0);
	@@ -179412,11 +179489,11 @@
179489	}
179490
179491	assert( SQLITE_FUNC_CONSTANT==SQLITE_DETERMINISTIC );
179492	assert( SQLITE_FUNC_DIRECT==SQLITE_DIRECTONLY );
179493	extraFlags = enc & (SQLITE_DETERMINISTIC\|SQLITE_DIRECTONLY\|
179494	SQLITE_SUBTYPE\|SQLITE_INNOCUOUS\|SQLITE_RESULT_SUBTYPE);
179495	enc &= (SQLITE_FUNC_ENCMASK\|SQLITE_ANY);
179496
179497	/* The SQLITE_INNOCUOUS flag is the same bit as SQLITE_FUNC_UNSAFE. But
179498	** the meaning is inverted. So flip the bit. */
179499	assert( SQLITE_FUNC_UNSAFE==SQLITE_INNOCUOUS );
	@@ -202993,16 +203070,22 @@
203070	u32 i;
203071	jsonAppendChar(p, '"');
203072	zIn++;
203073	N -= 2;
203074	while( N>0 ){
203075	for(i=0; i<N && zIn[i]!='\\' && zIn[i]!='"'; i++){}
203076	if( i>0 ){
203077	jsonAppendRawNZ(p, zIn, i);
203078	zIn += i;
203079	N -= i;
203080	if( N==0 ) break;
203081	}
203082	if( zIn[0]=='"' ){
203083	jsonAppendRawNZ(p, "\\\"", 2);
203084	zIn++;
203085	N--;
203086	continue;
203087	}
203088	assert( zIn[0]=='\\' );
203089	switch( (u8)zIn[1] ){
203090	case '\'':
203091	jsonAppendChar(p, '\'');
	@@ -203394,11 +203477,12 @@
203477	*/
203478	static void jsonReturnJson(
203479	JsonParse pParse, / The complete JSON */
203480	JsonNode pNode, / Node to return */
203481	sqlite3_context pCtx, / Return value for this function */
203482	int bGenerateAlt, /* Also store the rendered text in zAlt */
203483	int omitSubtype /* Do not call sqlite3_result_subtype() */
203484	){
203485	JsonString s;
203486	if( pParse->oom ){
203487	sqlite3_result_error_nomem(pCtx);
203488	return;
	@@ -203409,11 +203493,11 @@
203493	if( bGenerateAlt && pParse->zAlt==0 && jsonForceRCStr(&s) ){
203494	pParse->zAlt = sqlite3RCStrRef(s.zBuf);
203495	pParse->nAlt = s.nUsed;
203496	}
203497	jsonResult(&s);
203498	if( !omitSubtype ) sqlite3_result_subtype(pCtx, JSON_SUBTYPE);
203499	}
203500	}
203501
203502	/*
203503	** Translate a single byte of Hex into an integer.
	@@ -203450,11 +203534,12 @@
203534	** Make the JsonNode the return value of the function.
203535	*/
203536	static void jsonReturn(
203537	JsonParse pParse, / Complete JSON parse tree */
203538	JsonNode pNode, / Node to return */
203539	sqlite3_context pCtx, / Return value for this function */
203540	int omitSubtype /* Do not call sqlite3_result_subtype() */
203541	){
203542	switch( pNode->eType ){
203543	default: {
203544	assert( pNode->eType==JSON_NULL );
203545	sqlite3_result_null(pCtx);
	@@ -203596,11 +203681,11 @@
203681	}
203682	break;
203683	}
203684	case JSON_ARRAY:
203685	case JSON_OBJECT: {
203686	jsonReturnJson(pParse, pNode, pCtx, 0, omitSubtype);
203687	break;
203688	}
203689	}
203690	}
203691
	@@ -204948,11 +205033,11 @@
205033	printf("hasMod = %u\n", p->hasMod);
205034	printf("nJPRef = %u\n", p->nJPRef);
205035	printf("iSubst = %u\n", p->iSubst);
205036	printf("iHold = %u\n", p->iHold);
205037	jsonDebugPrintNodeEntries(p->aNode, p->nNode);
205038	jsonReturnJson(p, p->aNode, ctx, 1, 0);
205039	}
205040
205041	/*
205042	** The json_test1(JSON) function return true (1) if the input is JSON
205043	** text generated by another json function. It returns (0) if the input
	@@ -205134,19 +205219,18 @@
205219	}else{
205220	pNode = jsonLookup(p, zPath, 0, ctx);
205221	}
205222	if( pNode ){
205223	if( flags & JSON_JSON ){
205224	jsonReturnJson(p, pNode, ctx, 0, 0);
205225	}else{
205226	jsonReturn(p, pNode, ctx, 1);

205227	}
205228	}
205229	}else{
205230	pNode = jsonLookup(p, zPath, 0, ctx);
205231	if( p->nErr==0 && pNode ) jsonReturn(p, pNode, ctx, 0);
205232	}
205233	}else{
205234	/* Two or more PATH arguments results in a JSON array with each
205235	** element of the array being the value selected by one of the PATHs */
205236	int i;
	@@ -205268,11 +205352,11 @@
205352	pResult = jsonMergePatch(pX, 0, pY->aNode);
205353	assert( pResult!=0 \|\| pX->oom );
205354	if( pResult && pX->oom==0 ){
205355	jsonDebugPrintParse(pX);
205356	jsonDebugPrintNode(pResult);
205357	jsonReturnJson(pX, pResult, ctx, 0, 0);
205358	}else{
205359	sqlite3_result_error_nomem(ctx);
205360	}
205361	}
205362
	@@ -205347,11 +205431,11 @@
205431	pParse->hasMod = 1;
205432	pParse->useMod = 1;
205433	}
205434	}
205435	if( (pParse->aNode[0].jnFlags & JNODE_REMOVE)==0 ){
205436	jsonReturnJson(pParse, pParse->aNode, ctx, 1, 0);
205437	}
205438	remove_done:
205439	jsonDebugPrintParse(p);
205440	}
205441
	@@ -205476,11 +205560,11 @@
205560	if( pParse->nErr ) goto replace_err;
205561	if( pNode ){
205562	jsonReplaceNode(ctx, pParse, (u32)(pNode - pParse->aNode), argv[i+1]);
205563	}
205564	}
205565	jsonReturnJson(pParse, pParse->aNode, ctx, 1, 0);
205566	replace_err:
205567	jsonDebugPrintParse(pParse);
205568	jsonParseFree(pParse);
205569	}
205570
	@@ -205530,11 +205614,11 @@
205614	}else if( pNode && (bApnd \|\| bIsSet) ){
205615	jsonReplaceNode(ctx, pParse, (u32)(pNode - pParse->aNode), argv[i+1]);
205616	}
205617	}
205618	jsonDebugPrintParse(pParse);
205619	jsonReturnJson(pParse, pParse->aNode, ctx, 1, 0);
205620	jsonSetDone:
205621	jsonParseFree(pParse);
205622	}
205623
205624	/*
	@@ -206045,11 +206129,11 @@
206129	JsonNode *pThis = &p->sParse.aNode[p->i];
206130	switch( i ){
206131	case JEACH_KEY: {
206132	if( p->i==0 ) break;
206133	if( p->eType==JSON_OBJECT ){
206134	jsonReturn(&p->sParse, pThis, ctx, 0);
206135	}else if( p->eType==JSON_ARRAY ){
206136	u32 iKey;
206137	if( p->bRecursive ){
206138	if( p->iRowid==0 ) break;
206139	assert( p->sParse.aNode[p->sParse.aUp[p->i]].eU==3 );
	@@ -206061,11 +206145,11 @@
206145	}
206146	break;
206147	}
206148	case JEACH_VALUE: {
206149	if( pThis->jnFlags & JNODE_LABEL ) pThis++;
206150	jsonReturn(&p->sParse, pThis, ctx, 0);
206151	break;
206152	}
206153	case JEACH_TYPE: {
206154	if( pThis->jnFlags & JNODE_LABEL ) pThis++;
206155	sqlite3_result_text(ctx, jsonType[pThis->eType], -1, SQLITE_STATIC);
	@@ -206072,11 +206156,11 @@
206156	break;
206157	}
206158	case JEACH_ATOM: {
206159	if( pThis->jnFlags & JNODE_LABEL ) pThis++;
206160	if( pThis->eType>=JSON_ARRAY ) break;
206161	jsonReturn(&p->sParse, pThis, ctx, 0);
206162	break;
206163	}
206164	case JEACH_ID: {
206165	sqlite3_result_int64(ctx,
206166	(sqlite3_int64)p->i + ((pThis->jnFlags & JNODE_LABEL)!=0));
	@@ -206365,38 +206449,47 @@
206449	** Register JSON functions.
206450	*/
206451	SQLITE_PRIVATE void sqlite3RegisterJsonFunctions(void){
206452	#ifndef SQLITE_OMIT_JSON
206453	static FuncDef aJsonFunc[] = {
206454	/* calls sqlite3_result_subtype() */
206455	/* \| */
206456	/* Uses cache ______ \| __ calls sqlite3_value_subtype() */
206457	/* \| \| \| */
206458	/* Num args _________ \| \| \| ___ Flags */
206459	/* \| \| \| \| \| */
206460	/* \| \| \| \| \| */
206461	JFUNCTION(json, 1, 1, 1, 0, 0, jsonRemoveFunc),
206462	JFUNCTION(json_array, -1, 0, 1, 1, 0, jsonArrayFunc),
206463	JFUNCTION(json_array_length, 1, 1, 0, 0, 0, jsonArrayLengthFunc),
206464	JFUNCTION(json_array_length, 2, 1, 0, 0, 0, jsonArrayLengthFunc),
206465	JFUNCTION(json_error_position,1, 1, 0, 0, 0, jsonErrorFunc),
206466	JFUNCTION(json_extract, -1, 1, 1, 0, 0, jsonExtractFunc),
206467	JFUNCTION(->, 2, 1, 1, 0, JSON_JSON, jsonExtractFunc),
206468	JFUNCTION(->>, 2, 1, 0, 0, JSON_SQL, jsonExtractFunc),
206469	JFUNCTION(json_insert, -1, 1, 1, 1, 0, jsonSetFunc),
206470	JFUNCTION(json_object, -1, 0, 1, 1, 0, jsonObjectFunc),
206471	JFUNCTION(json_patch, 2, 1, 1, 0, 0, jsonPatchFunc),
206472	JFUNCTION(json_quote, 1, 0, 1, 1, 0, jsonQuoteFunc),
206473	JFUNCTION(json_remove, -1, 1, 1, 0, 0, jsonRemoveFunc),
206474	JFUNCTION(json_replace, -1, 1, 1, 1, 0, jsonReplaceFunc),
206475	JFUNCTION(json_set, -1, 1, 1, 1, JSON_ISSET, jsonSetFunc),
206476	JFUNCTION(json_type, 1, 1, 0, 0, 0, jsonTypeFunc),
206477	JFUNCTION(json_type, 2, 1, 0, 0, 0, jsonTypeFunc),
206478	JFUNCTION(json_valid, 1, 1, 0, 0, 0, jsonValidFunc),
206479	#ifdef SQLITE_DEBUG
206480	JFUNCTION(json_parse, 1, 1, 1, 0, 0, jsonParseFunc),
206481	JFUNCTION(json_test1, 1, 1, 0, 1, 0, jsonTest1Func),
206482	#endif
206483	WAGGREGATE(json_group_array, 1, 0, 0,
206484	jsonArrayStep, jsonArrayFinal, jsonArrayValue, jsonGroupInverse,
206485	SQLITE_SUBTYPE\|SQLITE_RESULT_SUBTYPE\|SQLITE_UTF8\|
206486	SQLITE_DETERMINISTIC),
206487	WAGGREGATE(json_group_object, 2, 0, 0,
206488	jsonObjectStep, jsonObjectFinal, jsonObjectValue, jsonGroupInverse,
206489	SQLITE_SUBTYPE\|SQLITE_RESULT_SUBTYPE\|SQLITE_UTF8\|
206490	SQLITE_DETERMINISTIC)
206491	};
206492	sqlite3InsertBuiltinFuncs(aJsonFunc, ArraySize(aJsonFunc));
206493	#endif
206494	}
206495
	@@ -236129,14 +236222,12 @@
236222
236223	return pRet;
236224	}
236225
236226	/*
236227	** Link all tokens from hash table iHash into a list in sorted order. The
236228	** tokens are not removed from the hash table.


236229	*/
236230	static int fts5HashEntrySort(
236231	Fts5Hash *pHash,
236232	const char pTerm, int nTerm, / Query prefix, if any */
236233	Fts5HashEntry **ppSorted
	@@ -238998,10 +239089,18 @@
239089	pLeaf = fts5IdxMalloc(p, sizeof(Fts5Data));
239090	if( pLeaf ){
239091	pLeaf->p = (u8*)pList;
239092	}
239093	}
239094
239095	/* The call to sqlite3Fts5HashScanInit() causes the hash table to
239096	** fill the size field of all existing position lists. This means they
239097	** can no longer be appended to. Since the only scenario in which they
239098	** can be appended to is if the previous operation on this table was
239099	** a DELETE, by clearing the Fts5Index.bDelete flag we can avoid this
239100	** possibility altogether. */
239101	p->bDelete = 0;
239102	}else{
239103	p->rc = sqlite3Fts5HashQuery(p->pHash, sizeof(Fts5Data),
239104	(const char)pTerm, nTerm, (void*)&pLeaf, &nList
239105	);
239106	if( pLeaf ){
	@@ -240675,11 +240774,11 @@
240774	){
240775	Fts5PageWriter *pPage = &pWriter->writer;
240776	const u8 *a = aData;
240777	int n = nData;
240778
240779	assert( p->pConfig->pgsz>0 \|\| p->rc!=SQLITE_OK );
240780	while( p->rc==SQLITE_OK
240781	&& (pPage->buf.n + pPage->pgidx.n + n)>=p->pConfig->pgsz
240782	){
240783	int nReq = p->pConfig->pgsz - pPage->buf.n - pPage->pgidx.n;
240784	int nCopy = 0;
	@@ -241408,22 +241507,28 @@
241507	}
241508	}
241509
241510	iOff = iStart;
241511
241512	/* If the position-list for the entry being removed flows over past
241513	** the end of this page, delete the portion of the position-list on the
241514	** next page and beyond.
241515	**
241516	** Set variable bLastInDoclist to true if this entry happens
241517	** to be the last rowid in the doclist for its term. */
241518	if( iNextOff>=iPgIdx ){
241519	int pgno = pSeg->iLeafPgno+1;
241520	fts5SecureDeleteOverflow(p, pSeg->pSeg, pgno, &bLastInDoclist);
241521	iNextOff = iPgIdx;
241522	}
241523
241524	if( pSeg->bDel==0 ){
241525	if( iNextOff!=iPgIdx ){




241526	/* Loop through the page-footer. If iNextOff (offset of the
241527	** entry following the one we are removing) is equal to the
241528	** offset of a key on this page, then the entry is the last
241529	** in its doclist. */
241530	int iKeyOff = 0;
241531	for(iIdx=0; iIdx<nIdx; /* no-op */){
241532	u32 iVal = 0;
241533	iIdx += fts5GetVarint32(&aIdx[iIdx], iVal);
241534	iKeyOff += iVal;
	@@ -241935,12 +242040,13 @@
242040	Fts5Structure *pStruct;
242041	Fts5Structure *pNew = 0;
242042
242043	assert( p->rc==SQLITE_OK );
242044	fts5IndexFlush(p);
242045	assert( p->rc!=SQLITE_OK \|\| p->nContentlessDelete==0 );
242046	pStruct = fts5StructureRead(p);
242047	assert( p->rc!=SQLITE_OK \|\| pStruct!=0 );
242048	fts5StructureInvalidate(p);
242049
242050	if( pStruct ){
242051	pNew = fts5IndexOptimizeStruct(p, pStruct);
242052	}
	@@ -247513,11 +247619,11 @@
247619	int nArg, /* Number of args */
247620	sqlite3_value *apUnused / Function arguments */
247621	){
247622	assert( nArg==0 );
247623	UNUSED_PARAM2(nArg, apUnused);
247624	sqlite3_result_text(pCtx, "fts5: 2023-11-24 11:41:44 ebead0e7230cd33bcec9f95d2183069565b9e709bf745c9b5db65cc0cbf92c0f", -1, SQLITE_TRANSIENT);
247625	}
247626
247627	/*
247628	** Return true if zName is the extension on one of the shadow tables used
247629	** by this module.
247630

M extsrc/sqlite3.h

+55 -12

		--- extsrc/sqlite3.h
		+++ extsrc/sqlite3.h
		@@ -144,13 +144,13 @@
144	144	**
145	145	** See also: [sqlite3_libversion()],
146	146	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
147	147	** [sqlite_version()] and [sqlite_source_id()].
148	148	*/
149		-#define SQLITE_VERSION "3.44.0"
150		-#define SQLITE_VERSION_NUMBER 3044000
151		-#define SQLITE_SOURCE_ID "2023-11-01 11:23:50 17129ba1ff7f0daf37100ee82d507aef7827cf38de1866e2633096ae6ad81301"
	149	+#define SQLITE_VERSION "3.44.2"
	150	+#define SQLITE_VERSION_NUMBER 3044002
	151	+#define SQLITE_SOURCE_ID "2023-11-24 11:41:44 ebead0e7230cd33bcec9f95d2183069565b9e709bf745c9b5db65cc0cbf92c0f"
152	152
153	153	/*
154	154	** CAPI3REF: Run-Time Library Version Numbers
155	155	** KEYWORDS: sqlite3_version sqlite3_sourceid
156	156	**
		@@ -5571,24 +5571,39 @@
5571	5571	** function has been carefully audited and found to be free of potentially
5572	5572	** security-adverse side-effects and information-leaks.
5573	5573	** </dd>
5574	5574	**
5575	5575	** [[SQLITE_SUBTYPE]] <dt>SQLITE_SUBTYPE</dt><dd>
5576		-** The SQLITE_SUBTYPE flag indicates to SQLite that a function may call
	5576	+** The SQLITE_SUBTYPE flag indicates to SQLite that a function might call
5577	5577	** [sqlite3_value_subtype()] to inspect the sub-types of its arguments.
5578		-** Specifying this flag makes no difference for scalar or aggregate user
5579		-** functions. However, if it is not specified for a user-defined window
5580		-** function, then any sub-types belonging to arguments passed to the window
5581		-** function may be discarded before the window function is called (i.e.
5582		-** sqlite3_value_subtype() will always return 0).
	5578	+** This flag instructs SQLite to omit some corner-case optimizations that
	5579	+** might disrupt the operation of the [sqlite3_value_subtype()] function,
	5580	+** causing it to return zero rather than the correct subtype().
	5581	+** SQL functions that invokes [sqlite3_value_subtype()] should have this
	5582	+** property. If the SQLITE_SUBTYPE property is omitted, then the return
	5583	+** value from [sqlite3_value_subtype()] might sometimes be zero even though
	5584	+** a non-zero subtype was specified by the function argument expression.
	5585	+**
	5586	+** [[SQLITE_RESULT_SUBTYPE]] <dt>SQLITE_RESULT_SUBTYPE</dt><dd>
	5587	+** The SQLITE_RESULT_SUBTYPE flag indicates to SQLite that a function might call
	5588	+** [sqlite3_result_subtype()] to cause a sub-type to be associated with its
	5589	+** result.
	5590	+** Every function that invokes [sqlite3_result_subtype()] should have this
	5591	+** property. If it does not, then the call to [sqlite3_result_subtype()]
	5592	+** might become a no-op if the function is used as term in an
	5593	+** [expression index]. On the other hand, SQL functions that never invoke
	5594	+** [sqlite3_result_subtype()] should avoid setting this property, as the
	5595	+** purpose of this property is to disable certain optimizations that are
	5596	+** incompatible with subtypes.
5583	5597	** </dd>
5584	5598	** </dl>
5585	5599	*/
5586	5600	#define SQLITE_DETERMINISTIC 0x000000800
5587	5601	#define SQLITE_DIRECTONLY 0x000080000
5588	5602	#define SQLITE_SUBTYPE 0x000100000
5589	5603	#define SQLITE_INNOCUOUS 0x000200000
	5604	+#define SQLITE_RESULT_SUBTYPE 0x001000000
5590	5605
5591	5606	/*
5592	5607	** CAPI3REF: Deprecated Functions
5593	5608	** DEPRECATED
5594	5609	**
		@@ -5781,10 +5796,16 @@
5781	5796	** The sqlite3_value_subtype(V) function returns the subtype for
5782	5797	** an [application-defined SQL function] argument V. The subtype
5783	5798	** information can be used to pass a limited amount of context from
5784	5799	** one SQL function to another. Use the [sqlite3_result_subtype()]
5785	5800	** routine to set the subtype for the return value of an SQL function.
	5801	+**
	5802	+** Every [application-defined SQL function] that invoke this interface
	5803	+** should include the [SQLITE_SUBTYPE] property in the text
	5804	+** encoding argument when the function is [sqlite3_create_function\|registered].
	5805	+** If the [SQLITE_SUBTYPE] property is omitted, then sqlite3_value_subtype()
	5806	+** might return zero instead of the upstream subtype in some corner cases.
5786	5807	*/
5787	5808	SQLITE_API unsigned int sqlite3_value_subtype(sqlite3_value*);
5788	5809
5789	5810	/*
5790	5811	** CAPI3REF: Copy And Free SQL Values
		@@ -5911,18 +5932,26 @@
5911	5932	** <li> ^(when [sqlite3_reset()] or [sqlite3_finalize()] is called for the
5912	5933	** SQL statement)^, or
5913	5934	** <li> ^(when sqlite3_set_auxdata() is invoked again on the same
5914	5935	** parameter)^, or
5915	5936	** <li> ^(during the original sqlite3_set_auxdata() call when a memory
5916		-** allocation error occurs.)^ </ul>
	5937	+** allocation error occurs.)^
	5938	+** <li> ^(during the original sqlite3_set_auxdata() call if the function
	5939	+** is evaluated during query planning instead of during query execution,
	5940	+** as sometimes happens with [SQLITE_ENABLE_STAT4].)^ </ul>
5917	5941	**
5918		-** Note the last bullet in particular. The destructor X in
	5942	+** Note the last two bullets in particular. The destructor X in
5919	5943	** sqlite3_set_auxdata(C,N,P,X) might be called immediately, before the
5920	5944	** sqlite3_set_auxdata() interface even returns. Hence sqlite3_set_auxdata()
5921	5945	** should be called near the end of the function implementation and the
5922	5946	** function implementation should not make any use of P after
5923		-** sqlite3_set_auxdata() has been called.
	5947	+** sqlite3_set_auxdata() has been called. Furthermore, a call to
	5948	+** sqlite3_get_auxdata() that occurs immediately after a corresponding call
	5949	+** to sqlite3_set_auxdata() might still return NULL if an out-of-memory
	5950	+** condition occurred during the sqlite3_set_auxdata() call or if the
	5951	+** function is being evaluated during query planning rather than during
	5952	+** query execution.
5924	5953	**
5925	5954	** ^(In practice, auxiliary data is preserved between function calls for
5926	5955	** function parameters that are compile-time constants, including literal
5927	5956	** values and [parameters] and expressions composed from the same.)^
5928	5957	**
		@@ -6192,10 +6221,24 @@
6192	6221	** [sqlite3_context] C to be the value T. Only the lower 8 bits
6193	6222	** of the subtype T are preserved in current versions of SQLite;
6194	6223	** higher order bits are discarded.
6195	6224	** The number of subtype bytes preserved by SQLite might increase
6196	6225	** in future releases of SQLite.
	6226	+**
	6227	+** Every [application-defined SQL function] that invokes this interface
	6228	+** should include the [SQLITE_RESULT_SUBTYPE] property in its
	6229	+** text encoding argument when the SQL function is
	6230	+** [sqlite3_create_function\|registered]. If the [SQLITE_RESULT_SUBTYPE]
	6231	+** property is omitted from the function that invokes sqlite3_result_subtype(),
	6232	+** then in some cases the sqlite3_result_subtype() might fail to set
	6233	+** the result subtype.
	6234	+**
	6235	+** If SQLite is compiled with -DSQLITE_STRICT_SUBTYPE=1, then any
	6236	+** SQL function that invokes the sqlite3_result_subtype() interface
	6237	+** and that does not have the SQLITE_RESULT_SUBTYPE property will raise
	6238	+** an error. Future versions of SQLite might enable -DSQLITE_STRICT_SUBTYPE=1
	6239	+** by default.
6197	6240	*/
6198	6241	SQLITE_API void sqlite3_result_subtype(sqlite3_context*,unsigned int);
6199	6242
6200	6243	/*
6201	6244	** CAPI3REF: Define New Collating Sequences
6202	6245

	--- extsrc/sqlite3.h
	+++ extsrc/sqlite3.h
	@@ -144,13 +144,13 @@
144	**
145	** See also: [sqlite3_libversion()],
146	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
147	** [sqlite_version()] and [sqlite_source_id()].
148	*/
149	#define SQLITE_VERSION "3.44.0"
150	#define SQLITE_VERSION_NUMBER 3044000
151	#define SQLITE_SOURCE_ID "2023-11-01 11:23:50 17129ba1ff7f0daf37100ee82d507aef7827cf38de1866e2633096ae6ad81301"
152
153	/*
154	** CAPI3REF: Run-Time Library Version Numbers
155	** KEYWORDS: sqlite3_version sqlite3_sourceid
156	**
	@@ -5571,24 +5571,39 @@
5571	** function has been carefully audited and found to be free of potentially
5572	** security-adverse side-effects and information-leaks.
5573	** </dd>
5574	**
5575	** [[SQLITE_SUBTYPE]] <dt>SQLITE_SUBTYPE</dt><dd>
5576	** The SQLITE_SUBTYPE flag indicates to SQLite that a function may call
5577	** [sqlite3_value_subtype()] to inspect the sub-types of its arguments.
5578	** Specifying this flag makes no difference for scalar or aggregate user
5579	** functions. However, if it is not specified for a user-defined window
5580	** function, then any sub-types belonging to arguments passed to the window
5581	** function may be discarded before the window function is called (i.e.
5582	** sqlite3_value_subtype() will always return 0).














5583	** </dd>
5584	** </dl>
5585	*/
5586	#define SQLITE_DETERMINISTIC 0x000000800
5587	#define SQLITE_DIRECTONLY 0x000080000
5588	#define SQLITE_SUBTYPE 0x000100000
5589	#define SQLITE_INNOCUOUS 0x000200000

5590
5591	/*
5592	** CAPI3REF: Deprecated Functions
5593	** DEPRECATED
5594	**
	@@ -5781,10 +5796,16 @@
5781	** The sqlite3_value_subtype(V) function returns the subtype for
5782	** an [application-defined SQL function] argument V. The subtype
5783	** information can be used to pass a limited amount of context from
5784	** one SQL function to another. Use the [sqlite3_result_subtype()]
5785	** routine to set the subtype for the return value of an SQL function.






5786	*/
5787	SQLITE_API unsigned int sqlite3_value_subtype(sqlite3_value*);
5788
5789	/*
5790	** CAPI3REF: Copy And Free SQL Values
	@@ -5911,18 +5932,26 @@
5911	** <li> ^(when [sqlite3_reset()] or [sqlite3_finalize()] is called for the
5912	** SQL statement)^, or
5913	** <li> ^(when sqlite3_set_auxdata() is invoked again on the same
5914	** parameter)^, or
5915	** <li> ^(during the original sqlite3_set_auxdata() call when a memory
5916	** allocation error occurs.)^ </ul>



5917	**
5918	** Note the last bullet in particular. The destructor X in
5919	** sqlite3_set_auxdata(C,N,P,X) might be called immediately, before the
5920	** sqlite3_set_auxdata() interface even returns. Hence sqlite3_set_auxdata()
5921	** should be called near the end of the function implementation and the
5922	** function implementation should not make any use of P after
5923	** sqlite3_set_auxdata() has been called.





5924	**
5925	** ^(In practice, auxiliary data is preserved between function calls for
5926	** function parameters that are compile-time constants, including literal
5927	** values and [parameters] and expressions composed from the same.)^
5928	**
	@@ -6192,10 +6221,24 @@
6192	** [sqlite3_context] C to be the value T. Only the lower 8 bits
6193	** of the subtype T are preserved in current versions of SQLite;
6194	** higher order bits are discarded.
6195	** The number of subtype bytes preserved by SQLite might increase
6196	** in future releases of SQLite.














6197	*/
6198	SQLITE_API void sqlite3_result_subtype(sqlite3_context*,unsigned int);
6199
6200	/*
6201	** CAPI3REF: Define New Collating Sequences
6202

	--- extsrc/sqlite3.h
	+++ extsrc/sqlite3.h
	@@ -144,13 +144,13 @@
144	**
145	** See also: [sqlite3_libversion()],
146	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
147	** [sqlite_version()] and [sqlite_source_id()].
148	*/
149	#define SQLITE_VERSION "3.44.2"
150	#define SQLITE_VERSION_NUMBER 3044002
151	#define SQLITE_SOURCE_ID "2023-11-24 11:41:44 ebead0e7230cd33bcec9f95d2183069565b9e709bf745c9b5db65cc0cbf92c0f"
152
153	/*
154	** CAPI3REF: Run-Time Library Version Numbers
155	** KEYWORDS: sqlite3_version sqlite3_sourceid
156	**
	@@ -5571,24 +5571,39 @@
5571	** function has been carefully audited and found to be free of potentially
5572	** security-adverse side-effects and information-leaks.
5573	** </dd>
5574	**
5575	** [[SQLITE_SUBTYPE]] <dt>SQLITE_SUBTYPE</dt><dd>
5576	** The SQLITE_SUBTYPE flag indicates to SQLite that a function might call
5577	** [sqlite3_value_subtype()] to inspect the sub-types of its arguments.
5578	** This flag instructs SQLite to omit some corner-case optimizations that
5579	** might disrupt the operation of the [sqlite3_value_subtype()] function,
5580	** causing it to return zero rather than the correct subtype().
5581	** SQL functions that invokes [sqlite3_value_subtype()] should have this
5582	** property. If the SQLITE_SUBTYPE property is omitted, then the return
5583	** value from [sqlite3_value_subtype()] might sometimes be zero even though
5584	** a non-zero subtype was specified by the function argument expression.
5585	**
5586	** [[SQLITE_RESULT_SUBTYPE]] <dt>SQLITE_RESULT_SUBTYPE</dt><dd>
5587	** The SQLITE_RESULT_SUBTYPE flag indicates to SQLite that a function might call
5588	** [sqlite3_result_subtype()] to cause a sub-type to be associated with its
5589	** result.
5590	** Every function that invokes [sqlite3_result_subtype()] should have this
5591	** property. If it does not, then the call to [sqlite3_result_subtype()]
5592	** might become a no-op if the function is used as term in an
5593	** [expression index]. On the other hand, SQL functions that never invoke
5594	** [sqlite3_result_subtype()] should avoid setting this property, as the
5595	** purpose of this property is to disable certain optimizations that are
5596	** incompatible with subtypes.
5597	** </dd>
5598	** </dl>
5599	*/
5600	#define SQLITE_DETERMINISTIC 0x000000800
5601	#define SQLITE_DIRECTONLY 0x000080000
5602	#define SQLITE_SUBTYPE 0x000100000
5603	#define SQLITE_INNOCUOUS 0x000200000
5604	#define SQLITE_RESULT_SUBTYPE 0x001000000
5605
5606	/*
5607	** CAPI3REF: Deprecated Functions
5608	** DEPRECATED
5609	**
	@@ -5781,10 +5796,16 @@
5796	** The sqlite3_value_subtype(V) function returns the subtype for
5797	** an [application-defined SQL function] argument V. The subtype
5798	** information can be used to pass a limited amount of context from
5799	** one SQL function to another. Use the [sqlite3_result_subtype()]
5800	** routine to set the subtype for the return value of an SQL function.
5801	**
5802	** Every [application-defined SQL function] that invoke this interface
5803	** should include the [SQLITE_SUBTYPE] property in the text
5804	** encoding argument when the function is [sqlite3_create_function\|registered].
5805	** If the [SQLITE_SUBTYPE] property is omitted, then sqlite3_value_subtype()
5806	** might return zero instead of the upstream subtype in some corner cases.
5807	*/
5808	SQLITE_API unsigned int sqlite3_value_subtype(sqlite3_value*);
5809
5810	/*
5811	** CAPI3REF: Copy And Free SQL Values
	@@ -5911,18 +5932,26 @@
5932	** <li> ^(when [sqlite3_reset()] or [sqlite3_finalize()] is called for the
5933	** SQL statement)^, or
5934	** <li> ^(when sqlite3_set_auxdata() is invoked again on the same
5935	** parameter)^, or
5936	** <li> ^(during the original sqlite3_set_auxdata() call when a memory
5937	** allocation error occurs.)^
5938	** <li> ^(during the original sqlite3_set_auxdata() call if the function
5939	** is evaluated during query planning instead of during query execution,
5940	** as sometimes happens with [SQLITE_ENABLE_STAT4].)^ </ul>
5941	**
5942	** Note the last two bullets in particular. The destructor X in
5943	** sqlite3_set_auxdata(C,N,P,X) might be called immediately, before the
5944	** sqlite3_set_auxdata() interface even returns. Hence sqlite3_set_auxdata()
5945	** should be called near the end of the function implementation and the
5946	** function implementation should not make any use of P after
5947	** sqlite3_set_auxdata() has been called. Furthermore, a call to
5948	** sqlite3_get_auxdata() that occurs immediately after a corresponding call
5949	** to sqlite3_set_auxdata() might still return NULL if an out-of-memory
5950	** condition occurred during the sqlite3_set_auxdata() call or if the
5951	** function is being evaluated during query planning rather than during
5952	** query execution.
5953	**
5954	** ^(In practice, auxiliary data is preserved between function calls for
5955	** function parameters that are compile-time constants, including literal
5956	** values and [parameters] and expressions composed from the same.)^
5957	**
	@@ -6192,10 +6221,24 @@
6221	** [sqlite3_context] C to be the value T. Only the lower 8 bits
6222	** of the subtype T are preserved in current versions of SQLite;
6223	** higher order bits are discarded.
6224	** The number of subtype bytes preserved by SQLite might increase
6225	** in future releases of SQLite.
6226	**
6227	** Every [application-defined SQL function] that invokes this interface
6228	** should include the [SQLITE_RESULT_SUBTYPE] property in its
6229	** text encoding argument when the SQL function is
6230	** [sqlite3_create_function\|registered]. If the [SQLITE_RESULT_SUBTYPE]
6231	** property is omitted from the function that invokes sqlite3_result_subtype(),
6232	** then in some cases the sqlite3_result_subtype() might fail to set
6233	** the result subtype.
6234	**
6235	** If SQLite is compiled with -DSQLITE_STRICT_SUBTYPE=1, then any
6236	** SQL function that invokes the sqlite3_result_subtype() interface
6237	** and that does not have the SQLITE_RESULT_SUBTYPE property will raise
6238	** an error. Future versions of SQLite might enable -DSQLITE_STRICT_SUBTYPE=1
6239	** by default.
6240	*/
6241	SQLITE_API void sqlite3_result_subtype(sqlite3_context*,unsigned int);
6242
6243	/*
6244	** CAPI3REF: Define New Collating Sequences
6245

M src/allrepo.c

+2 -2

		--- src/allrepo.c
		+++ src/allrepo.c
		@@ -106,12 +106,12 @@
106	106	** push Run a "push" on all repositories. Only the --verbose
107	107	** option is supported.
108	108	**
109	109	** rebuild Rebuild on all repositories. The command line options
110	110	** supported by the rebuild command itself, if any are
111		-** present, are passed along verbatim. The --force and
112		-** --randomize options are not supported.
	111	+** present, are passed along verbatim. The --force option
	112	+** is not supported.
113	113	**
114	114	** remote Show remote hosts for all repositories.
115	115	**
116	116	** repack Look for extra compression in all repositories.
117	117	**
118	118

	--- src/allrepo.c
	+++ src/allrepo.c
	@@ -106,12 +106,12 @@
106	** push Run a "push" on all repositories. Only the --verbose
107	** option is supported.
108	**
109	** rebuild Rebuild on all repositories. The command line options
110	** supported by the rebuild command itself, if any are
111	** present, are passed along verbatim. The --force and
112	** --randomize options are not supported.
113	**
114	** remote Show remote hosts for all repositories.
115	**
116	** repack Look for extra compression in all repositories.
117	**
118

	--- src/allrepo.c
	+++ src/allrepo.c
	@@ -106,12 +106,12 @@
106	** push Run a "push" on all repositories. Only the --verbose
107	** option is supported.
108	**
109	** rebuild Rebuild on all repositories. The command line options
110	** supported by the rebuild command itself, if any are
111	** present, are passed along verbatim. The --force option
112	** is not supported.
113	**
114	** remote Show remote hosts for all repositories.
115	**
116	** repack Look for extra compression in all repositories.
117	**
118

M src/hook.c

+1 -1

		--- src/hook.c
		+++ src/hook.c
		@@ -232,11 +232,11 @@
232	232	**
233	233	** Run the hook script given by ID for testing purposes.
234	234	** Options:
235	235	**
236	236	** --dry-run Print the script on stdout rather than run it
237		-** --base-rcvid N Pretend that the hook-last-rcvid value is N
	237	+** --base-rcvid N Pretend that the hook-last-rcvid value is N
238	238	** --new-rcvid M Pretend that the last rcvid valud is M
239	239	** --aux-file NAME NAME is substituted for %A in the script
240	240	**
241	241	** The --base-rcvid and --new-rcvid options are silently ignored if
242	242	** the hook type is not "after-receive". The default values for
243	243

	--- src/hook.c
	+++ src/hook.c
	@@ -232,11 +232,11 @@
232	**
233	** Run the hook script given by ID for testing purposes.
234	** Options:
235	**
236	** --dry-run Print the script on stdout rather than run it
237	** --base-rcvid N Pretend that the hook-last-rcvid value is N
238	** --new-rcvid M Pretend that the last rcvid valud is M
239	** --aux-file NAME NAME is substituted for %A in the script
240	**
241	** The --base-rcvid and --new-rcvid options are silently ignored if
242	** the hook type is not "after-receive". The default values for
243

	--- src/hook.c
	+++ src/hook.c
	@@ -232,11 +232,11 @@
232	**
233	** Run the hook script given by ID for testing purposes.
234	** Options:
235	**
236	** --dry-run Print the script on stdout rather than run it
237	** --base-rcvid N Pretend that the hook-last-rcvid value is N
238	** --new-rcvid M Pretend that the last rcvid valud is M
239	** --aux-file NAME NAME is substituted for %A in the script
240	**
241	** The --base-rcvid and --new-rcvid options are silently ignored if
242	** the hook type is not "after-receive". The default values for
243

M www/unvers.wiki

+2 -2

		--- www/unvers.wiki
		+++ www/unvers.wiki
		@@ -5,11 +5,11 @@
5	5	files stored in a Fossil repository without history, meaning
6	6	it retains the newest version of each such file, and that alone.
7	7
8	8	Though it omits history, Fossil does sync unversioned content between
9	9	repositories. In the event of a conflict during a sync, it retains
10		-the most recent version of each unversioned file, discrding
	10	+the most recent version of each unversioned file, discarding
11	11	older versions.
12	12
13	13	Unversioned files are useful for storing ephemeral content such as builds
14	14	or frequently changing web pages. We store
15	15	the [https://fossil-scm.org/home/uv/download.html\|download] page of
		@@ -100,15 +100,15 @@
100	100	Lacking history for unversioned files, Fossil does not attempt delta
101	101	compression on them.
102	102
103	103	Fossil servers exchange unversioned content whole; it does not attempt
104	104	to "diff" your local version against the remote and send only the
105		-changes. We point tihs out because one use-case for unversioned content
	105	+changes. We point this out because one use-case for unversioned content
106	106	is to send large, frequently-changing files. Appreciate the consequences
107	107	before making each change.
108	108
109	109	There are two bandwidth-saving measures in "<tt>fossil uv sync</tt>".
110	110	The first is the regular HTTP payload compression step, done on all
111	111	syncs. The second is that Fossil sends SHA1 hash exchanges to determine
112	112	when it can avoid sending duplicate content over the wire unnecessarily.
113	113	See the [./sync.wiki\|synchronization protocol documentation] for further
114	114	information.
115	115

	--- www/unvers.wiki
	+++ www/unvers.wiki
	@@ -5,11 +5,11 @@
5	files stored in a Fossil repository without history, meaning
6	it retains the newest version of each such file, and that alone.
7
8	Though it omits history, Fossil does sync unversioned content between
9	repositories. In the event of a conflict during a sync, it retains
10	the most recent version of each unversioned file, discrding
11	older versions.
12
13	Unversioned files are useful for storing ephemeral content such as builds
14	or frequently changing web pages. We store
15	the [https://fossil-scm.org/home/uv/download.html\|download] page of
	@@ -100,15 +100,15 @@
100	Lacking history for unversioned files, Fossil does not attempt delta
101	compression on them.
102
103	Fossil servers exchange unversioned content whole; it does not attempt
104	to "diff" your local version against the remote and send only the
105	changes. We point tihs out because one use-case for unversioned content
106	is to send large, frequently-changing files. Appreciate the consequences
107	before making each change.
108
109	There are two bandwidth-saving measures in "<tt>fossil uv sync</tt>".
110	The first is the regular HTTP payload compression step, done on all
111	syncs. The second is that Fossil sends SHA1 hash exchanges to determine
112	when it can avoid sending duplicate content over the wire unnecessarily.
113	See the [./sync.wiki\|synchronization protocol documentation] for further
114	information.
115

	--- www/unvers.wiki
	+++ www/unvers.wiki
	@@ -5,11 +5,11 @@
5	files stored in a Fossil repository without history, meaning
6	it retains the newest version of each such file, and that alone.
7
8	Though it omits history, Fossil does sync unversioned content between
9	repositories. In the event of a conflict during a sync, it retains
10	the most recent version of each unversioned file, discarding
11	older versions.
12
13	Unversioned files are useful for storing ephemeral content such as builds
14	or frequently changing web pages. We store
15	the [https://fossil-scm.org/home/uv/download.html\|download] page of
	@@ -100,15 +100,15 @@
100	Lacking history for unversioned files, Fossil does not attempt delta
101	compression on them.
102
103	Fossil servers exchange unversioned content whole; it does not attempt
104	to "diff" your local version against the remote and send only the
105	changes. We point this out because one use-case for unversioned content
106	is to send large, frequently-changing files. Appreciate the consequences
107	before making each change.
108
109	There are two bandwidth-saving measures in "<tt>fossil uv sync</tt>".
110	The first is the regular HTTP payload compression step, done on all
111	syncs. The second is that Fossil sends SHA1 hash exchanges to determine
112	when it can avoid sending duplicate content over the wire unnecessarily.
113	See the [./sync.wiki\|synchronization protocol documentation] for further
114	information.
115

Fossil SCM

Keyboard Shortcuts