Fossil SCM

Merged from trunk for testing before pushing back to trunk.

rberteig 2017-03-13 22:24 rkb-2.0-tests merge

Commit f955c632c427c2115d725ea9a3e4a4a25abdf65f754779ae435b4a98e7eed342

Parent 4077357a38ddb2f…

12 files changed +4 -2 +3 -2 +1 -1 +1411 -230 +1515 -987 +36 -16 +64 -2 +7 -12 +1 -1 +2 -2 +5 -4 +2 -2

~ src/checkin.c ~ src/db.c ~ src/hname.c ~ src/shell.c ~ src/sqlite3.c ~ src/sqlite3.h ~ src/stat.c ~ www/build.wiki ~ www/changes.wiki ~ www/fossil-v-git.wiki ~ www/selfcheck.wiki ~ www/tech_overview.wiki

M src/checkin.c

+4 -2

		--- src/checkin.c
		+++ src/checkin.c
		@@ -464,11 +464,12 @@
464	464	{"no-merge", C_MERGE }, {"no-classify", C_CLASSIFY },
465	465	};
466	466
467	467	Blob report = BLOB_INITIALIZER;
468	468	enum {CHANGES, STATUS} command = *g.argv[1]=='s' ? STATUS : CHANGES;
469		- int useHash = find_option("hash", 0, 0)!=0;
	469	+ /* --sha1sum is an undocumented alias for --hash for backwards compatiblity */
	470	+ int useHash = find_option("hash",0,0)!=0 \|\| find_option("sha1sum",0,0)!=0;
470	471	int showHdr = command==CHANGES && find_option("header", 0, 0);
471	472	int verboseFlag = command==CHANGES && find_option("verbose", "v", 0);
472	473	const char *zIgnoreFlag = find_option("ignore", 0, 1);
473	474	unsigned scanFlags = 0;
474	475	unsigned flags = 0;
		@@ -2068,11 +2069,12 @@
2068	2069	Blob ans;
2069	2070	char cReply;
2070	2071
2071	2072	memset(&sCiInfo, 0, sizeof(sCiInfo));
2072	2073	url_proxy_options();
2073		- useHash = find_option("hash", 0, 0)!=0;
	2074	+ /* --sha1sum is an undocumented alias for --hash for backwards compatiblity */
	2075	+ useHash = find_option("hash",0,0)!=0 \|\| find_option("sha1sum",0,0)!=0;
2074	2076	noSign = find_option("nosign",0,0)!=0;
2075	2077	forceDelta = find_option("delta",0,0)!=0;
2076	2078	forceBaseline = find_option("baseline",0,0)!=0;
2077	2079	if( forceDelta && forceBaseline ){
2078	2080	fossil_fatal("cannot use --delta and --baseline together");
2079	2081

	--- src/checkin.c
	+++ src/checkin.c
	@@ -464,11 +464,12 @@
464	{"no-merge", C_MERGE }, {"no-classify", C_CLASSIFY },
465	};
466
467	Blob report = BLOB_INITIALIZER;
468	enum {CHANGES, STATUS} command = *g.argv[1]=='s' ? STATUS : CHANGES;
469	int useHash = find_option("hash", 0, 0)!=0;

470	int showHdr = command==CHANGES && find_option("header", 0, 0);
471	int verboseFlag = command==CHANGES && find_option("verbose", "v", 0);
472	const char *zIgnoreFlag = find_option("ignore", 0, 1);
473	unsigned scanFlags = 0;
474	unsigned flags = 0;
	@@ -2068,11 +2069,12 @@
2068	Blob ans;
2069	char cReply;
2070
2071	memset(&sCiInfo, 0, sizeof(sCiInfo));
2072	url_proxy_options();
2073	useHash = find_option("hash", 0, 0)!=0;

2074	noSign = find_option("nosign",0,0)!=0;
2075	forceDelta = find_option("delta",0,0)!=0;
2076	forceBaseline = find_option("baseline",0,0)!=0;
2077	if( forceDelta && forceBaseline ){
2078	fossil_fatal("cannot use --delta and --baseline together");
2079

	--- src/checkin.c
	+++ src/checkin.c
	@@ -464,11 +464,12 @@
464	{"no-merge", C_MERGE }, {"no-classify", C_CLASSIFY },
465	};
466
467	Blob report = BLOB_INITIALIZER;
468	enum {CHANGES, STATUS} command = *g.argv[1]=='s' ? STATUS : CHANGES;
469	/* --sha1sum is an undocumented alias for --hash for backwards compatiblity */
470	int useHash = find_option("hash",0,0)!=0 \|\| find_option("sha1sum",0,0)!=0;
471	int showHdr = command==CHANGES && find_option("header", 0, 0);
472	int verboseFlag = command==CHANGES && find_option("verbose", "v", 0);
473	const char *zIgnoreFlag = find_option("ignore", 0, 1);
474	unsigned scanFlags = 0;
475	unsigned flags = 0;
	@@ -2068,11 +2069,12 @@
2069	Blob ans;
2070	char cReply;
2071
2072	memset(&sCiInfo, 0, sizeof(sCiInfo));
2073	url_proxy_options();
2074	/* --sha1sum is an undocumented alias for --hash for backwards compatiblity */
2075	useHash = find_option("hash",0,0)!=0 \|\| find_option("sha1sum",0,0)!=0;
2076	noSign = find_option("nosign",0,0)!=0;
2077	forceDelta = find_option("delta",0,0)!=0;
2078	forceBaseline = find_option("baseline",0,0)!=0;
2079	if( forceDelta && forceBaseline ){
2080	fossil_fatal("cannot use --delta and --baseline together");
2081

M src/db.c

+3 -2

		--- src/db.c
		+++ src/db.c
		@@ -1491,12 +1491,12 @@
1491	1491	if( g.eHashPolicy<0 ){
1492	1492	g.eHashPolicy = hname_default_policy();
1493	1493	db_set_int("hash-policy", g.eHashPolicy, 0);
1494	1494	}
1495	1495
1496		- /* If the ALIAS table is not present, then some on-the-fly schema
1497		- ** updates might be required.
	1496	+ /* Make a change to the CHECK constraint on the BLOB table for
	1497	+ ** version 2.0 and later.
1498	1498	*/
1499	1499	rebuild_schema_update_2_0(); /* Do the Fossil-2.0 schema updates */
1500	1500	}
1501	1501
1502	1502	/*
		@@ -1662,10 +1662,11 @@
1662	1662	while( db.pAllStmt ){
1663	1663	db_finalize(db.pAllStmt);
1664	1664	}
1665	1665	db_end_transaction(1);
1666	1666	pStmt = 0;
	1667	+ sqlite3_exec(g.db, "PRAGMA optimize", 0, 0, 0);
1667	1668	db_close_config();
1668	1669
1669	1670	/* If the localdb has a lot of unused free space,
1670	1671	** then VACUUM it as we shut down.
1671	1672	*/
1672	1673

	--- src/db.c
	+++ src/db.c
	@@ -1491,12 +1491,12 @@
1491	if( g.eHashPolicy<0 ){
1492	g.eHashPolicy = hname_default_policy();
1493	db_set_int("hash-policy", g.eHashPolicy, 0);
1494	}
1495
1496	/* If the ALIAS table is not present, then some on-the-fly schema
1497	** updates might be required.
1498	*/
1499	rebuild_schema_update_2_0(); /* Do the Fossil-2.0 schema updates */
1500	}
1501
1502	/*
	@@ -1662,10 +1662,11 @@
1662	while( db.pAllStmt ){
1663	db_finalize(db.pAllStmt);
1664	}
1665	db_end_transaction(1);
1666	pStmt = 0;

1667	db_close_config();
1668
1669	/* If the localdb has a lot of unused free space,
1670	** then VACUUM it as we shut down.
1671	*/
1672

	--- src/db.c
	+++ src/db.c
	@@ -1491,12 +1491,12 @@
1491	if( g.eHashPolicy<0 ){
1492	g.eHashPolicy = hname_default_policy();
1493	db_set_int("hash-policy", g.eHashPolicy, 0);
1494	}
1495
1496	/* Make a change to the CHECK constraint on the BLOB table for
1497	** version 2.0 and later.
1498	*/
1499	rebuild_schema_update_2_0(); /* Do the Fossil-2.0 schema updates */
1500	}
1501
1502	/*
	@@ -1662,10 +1662,11 @@
1662	while( db.pAllStmt ){
1663	db_finalize(db.pAllStmt);
1664	}
1665	db_end_transaction(1);
1666	pStmt = 0;
1667	sqlite3_exec(g.db, "PRAGMA optimize", 0, 0, 0);
1668	db_close_config();
1669
1670	/* If the localdb has a lot of unused free space,
1671	** then VACUUM it as we shut down.
1672	*/
1673

M src/hname.c

+1 -1

		--- src/hname.c
		+++ src/hname.c
		@@ -249,11 +249,11 @@
249	249	** sha3-only Use only SHA3 artifact names. Do not reuse legacy
250	250	** SHA1 names.
251	251	**
252	252	** shun-sha1 Shun any SHA1 artifacts received by sync operations
253	253	** other than clones. Older legacy SHA1 artifacts are
254		-** are allowed during a clone.
	254	+** allowed during a clone.
255	255	**
256	256	** The default hash policy for existing repositories is "auto", which will
257	257	** immediately promote to "sha3" if the repository contains one or more
258	258	** artifacts with SHA3 names. The default hash policy for new repositories
259	259	** is "shun-sha1".
260	260

	--- src/hname.c
	+++ src/hname.c
	@@ -249,11 +249,11 @@
249	** sha3-only Use only SHA3 artifact names. Do not reuse legacy
250	** SHA1 names.
251	**
252	** shun-sha1 Shun any SHA1 artifacts received by sync operations
253	** other than clones. Older legacy SHA1 artifacts are
254	** are allowed during a clone.
255	**
256	** The default hash policy for existing repositories is "auto", which will
257	** immediately promote to "sha3" if the repository contains one or more
258	** artifacts with SHA3 names. The default hash policy for new repositories
259	** is "shun-sha1".
260

	--- src/hname.c
	+++ src/hname.c
	@@ -249,11 +249,11 @@
249	** sha3-only Use only SHA3 artifact names. Do not reuse legacy
250	** SHA1 names.
251	**
252	** shun-sha1 Shun any SHA1 artifacts received by sync operations
253	** other than clones. Older legacy SHA1 artifacts are
254	** allowed during a clone.
255	**
256	** The default hash policy for existing repositories is "auto", which will
257	** immediately promote to "sha3" if the repository contains one or more
258	** artifacts with SHA3 names. The default hash policy for new repositories
259	** is "shun-sha1".
260

M src/shell.c

+1411 -230

		--- src/shell.c
		+++ src/shell.c
		@@ -452,32 +452,10 @@
452	452	while( IsDigit(*z) ){ z++; }
453	453	if( realnum ) *realnum = 1;
454	454	}
455	455	return *z==0;
456	456	}
457		-
458		-/*
459		-** A global char* and an SQL function to access its current value
460		-** from within an SQL statement. This program used to use the
461		-** sqlite_exec_printf() API to substitue a string into an SQL statement.
462		-** The correct way to do this with sqlite3 is to use the bind API, but
463		-** since the shell is built around the callback paradigm it would be a lot
464		-** of work. Instead just use this hack, which is quite harmless.
465		-*/
466		-static const char *zShellStatic = 0;
467		-static void shellstaticFunc(
468		- sqlite3_context *context,
469		- int argc,
470		- sqlite3_value **argv
471		-){
472		- assert( 0==argc );
473		- assert( zShellStatic );
474		- UNUSED_PARAMETER(argc);
475		- UNUSED_PARAMETER(argv);
476		- sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC);
477		-}
478		-
479	457
480	458	/*
481	459	** Compute a string length that is limited to what can be stored in
482	460	** lower 30 bits of a 32-bit signed integer.
483	461	*/
		@@ -575,10 +553,783 @@
575	553	if( zResult && *zResult ) shell_add_history(zResult);
576	554	#endif
577	555	}
578	556	return zResult;
579	557	}
	558	+/*
	559	+** A variable length string to which one can append text.
	560	+*/
	561	+typedef struct ShellText ShellText;
	562	+struct ShellText {
	563	+ char *z;
	564	+ int n;
	565	+ int nAlloc;
	566	+};
	567	+
	568	+/*
	569	+** Initialize and destroy a ShellText object
	570	+*/
	571	+static void initText(ShellText *p){
	572	+ memset(p, 0, sizeof(*p));
	573	+}
	574	+static void freeText(ShellText *p){
	575	+ free(p->z);
	576	+ initText(p);
	577	+}
	578	+
	579	+/* zIn is either a pointer to a NULL-terminated string in memory obtained
	580	+** from malloc(), or a NULL pointer. The string pointed to by zAppend is
	581	+** added to zIn, and the result returned in memory obtained from malloc().
	582	+** zIn, if it was not NULL, is freed.
	583	+**
	584	+** If the third argument, quote, is not '\0', then it is used as a
	585	+** quote character for zAppend.
	586	+*/
	587	+static void appendText(ShellText p, char const zAppend, char quote){
	588	+ int len;
	589	+ int i;
	590	+ int nAppend = strlen30(zAppend);
	591	+
	592	+ len = nAppend+p->n+1;
	593	+ if( quote ){
	594	+ len += 2;
	595	+ for(i=0; i<nAppend; i++){
	596	+ if( zAppend[i]==quote ) len++;
	597	+ }
	598	+ }
	599	+
	600	+ if( p->n+len>=p->nAlloc ){
	601	+ p->nAlloc = p->nAlloc*2 + len + 20;
	602	+ p->z = realloc(p->z, p->nAlloc);
	603	+ if( p->z==0 ){
	604	+ memset(p, 0, sizeof(*p));
	605	+ return;
	606	+ }
	607	+ }
	608	+
	609	+ if( quote ){
	610	+ char *zCsr = p->z+p->n;
	611	+ *zCsr++ = quote;
	612	+ for(i=0; i<nAppend; i++){
	613	+ *zCsr++ = zAppend[i];
	614	+ if( zAppend[i]==quote ) *zCsr++ = quote;
	615	+ }
	616	+ *zCsr++ = quote;
	617	+ p->n = (int)(zCsr - p->z);
	618	+ *zCsr = '\0';
	619	+ }else{
	620	+ memcpy(p->z+p->n, zAppend, nAppend);
	621	+ p->n += nAppend;
	622	+ p->z[p->n] = '\0';
	623	+ }
	624	+}
	625	+
	626	+/*
	627	+** Attempt to determine if identifier zName needs to be quoted, either
	628	+** because it contains non-alphanumeric characters, or because it is an
	629	+** SQLite keyword. Be conservative in this estimate: When in doubt assume
	630	+** that quoting is required.
	631	+**
	632	+** Return '"' if quoting is required. Return 0 if no quoting is required.
	633	+*/
	634	+static char quoteChar(const char *zName){
	635	+ /* All SQLite keywords, in alphabetical order */
	636	+ static const char *azKeywords[] = {
	637	+ "ABORT", "ACTION", "ADD", "AFTER", "ALL", "ALTER", "ANALYZE", "AND", "AS",
	638	+ "ASC", "ATTACH", "AUTOINCREMENT", "BEFORE", "BEGIN", "BETWEEN", "BY",
	639	+ "CASCADE", "CASE", "CAST", "CHECK", "COLLATE", "COLUMN", "COMMIT",
	640	+ "CONFLICT", "CONSTRAINT", "CREATE", "CROSS", "CURRENT_DATE",
	641	+ "CURRENT_TIME", "CURRENT_TIMESTAMP", "DATABASE", "DEFAULT", "DEFERRABLE",
	642	+ "DEFERRED", "DELETE", "DESC", "DETACH", "DISTINCT", "DROP", "EACH",
	643	+ "ELSE", "END", "ESCAPE", "EXCEPT", "EXCLUSIVE", "EXISTS", "EXPLAIN",
	644	+ "FAIL", "FOR", "FOREIGN", "FROM", "FULL", "GLOB", "GROUP", "HAVING", "IF",
	645	+ "IGNORE", "IMMEDIATE", "IN", "INDEX", "INDEXED", "INITIALLY", "INNER",
	646	+ "INSERT", "INSTEAD", "INTERSECT", "INTO", "IS", "ISNULL", "JOIN", "KEY",
	647	+ "LEFT", "LIKE", "LIMIT", "MATCH", "NATURAL", "NO", "NOT", "NOTNULL",
	648	+ "NULL", "OF", "OFFSET", "ON", "OR", "ORDER", "OUTER", "PLAN", "PRAGMA",
	649	+ "PRIMARY", "QUERY", "RAISE", "RECURSIVE", "REFERENCES", "REGEXP",
	650	+ "REINDEX", "RELEASE", "RENAME", "REPLACE", "RESTRICT", "RIGHT",
	651	+ "ROLLBACK", "ROW", "SAVEPOINT", "SELECT", "SET", "TABLE", "TEMP",
	652	+ "TEMPORARY", "THEN", "TO", "TRANSACTION", "TRIGGER", "UNION", "UNIQUE",
	653	+ "UPDATE", "USING", "VACUUM", "VALUES", "VIEW", "VIRTUAL", "WHEN", "WHERE",
	654	+ "WITH", "WITHOUT",
	655	+ };
	656	+ int i, lwr, upr, mid, c;
	657	+ if( !isalpha((unsigned char)zName[0]) && zName[0]!='_' ) return '"';
	658	+ for(i=0; zName[i]; i++){
	659	+ if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ) return '"';
	660	+ }
	661	+ lwr = 0;
	662	+ upr = sizeof(azKeywords)/sizeof(azKeywords[0]) - 1;
	663	+ while( lwr<=upr ){
	664	+ mid = (lwr+upr)/2;
	665	+ c = sqlite3_stricmp(azKeywords[mid], zName);
	666	+ if( c==0 ) return '"';
	667	+ if( c<0 ){
	668	+ lwr = mid+1;
	669	+ }else{
	670	+ upr = mid-1;
	671	+ }
	672	+ }
	673	+ return 0;
	674	+}
	675	+
	676	+/******************************************************************************
	677	+** SHA3 hash implementation copied from ../ext/misc/shathree.c
	678	+*/
	679	+typedef sqlite3_uint64 u64;
	680	+/*
	681	+** Macros to determine whether the machine is big or little endian,
	682	+** and whether or not that determination is run-time or compile-time.
	683	+**
	684	+** For best performance, an attempt is made to guess at the byte-order
	685	+** using C-preprocessor macros. If that is unsuccessful, or if
	686	+** -DSHA3_BYTEORDER=0 is set, then byte-order is determined
	687	+** at run-time.
	688	+*/
	689	+#ifndef SHA3_BYTEORDER
	690	+# if defined(i386) \|\| defined(__i386__) \|\| defined(_M_IX86) \|\| \
	691	+ defined(__x86_64) \|\| defined(__x86_64__) \|\| defined(_M_X64) \|\| \
	692	+ defined(_M_AMD64) \|\| defined(_M_ARM) \|\| defined(__x86) \|\| \
	693	+ defined(__arm__)
	694	+# define SHA3_BYTEORDER 1234
	695	+# elif defined(sparc) \|\| defined(__ppc__)
	696	+# define SHA3_BYTEORDER 4321
	697	+# else
	698	+# define SHA3_BYTEORDER 0
	699	+# endif
	700	+#endif
	701	+
	702	+
	703	+/*
	704	+** State structure for a SHA3 hash in progress
	705	+*/
	706	+typedef struct SHA3Context SHA3Context;
	707	+struct SHA3Context {
	708	+ union {
	709	+ u64 s[25]; /* Keccak state. 5x5 lines of 64 bits each */
	710	+ unsigned char x[1600]; /* ... or 1600 bytes */
	711	+ } u;
	712	+ unsigned nRate; /* Bytes of input accepted per Keccak iteration */
	713	+ unsigned nLoaded; /* Input bytes loaded into u.x[] so far this cycle */
	714	+ unsigned ixMask; /* Insert next input into u.x[nLoaded^ixMask]. */
	715	+};
	716	+
	717	+/*
	718	+** A single step of the Keccak mixing function for a 1600-bit state
	719	+*/
	720	+static void KeccakF1600Step(SHA3Context *p){
	721	+ int i;
	722	+ u64 B0, B1, B2, B3, B4;
	723	+ u64 C0, C1, C2, C3, C4;
	724	+ u64 D0, D1, D2, D3, D4;
	725	+ static const u64 RC[] = {
	726	+ 0x0000000000000001ULL, 0x0000000000008082ULL,
	727	+ 0x800000000000808aULL, 0x8000000080008000ULL,
	728	+ 0x000000000000808bULL, 0x0000000080000001ULL,
	729	+ 0x8000000080008081ULL, 0x8000000000008009ULL,
	730	+ 0x000000000000008aULL, 0x0000000000000088ULL,
	731	+ 0x0000000080008009ULL, 0x000000008000000aULL,
	732	+ 0x000000008000808bULL, 0x800000000000008bULL,
	733	+ 0x8000000000008089ULL, 0x8000000000008003ULL,
	734	+ 0x8000000000008002ULL, 0x8000000000000080ULL,
	735	+ 0x000000000000800aULL, 0x800000008000000aULL,
	736	+ 0x8000000080008081ULL, 0x8000000000008080ULL,
	737	+ 0x0000000080000001ULL, 0x8000000080008008ULL
	738	+ };
	739	+# define A00 (p->u.s[0])
	740	+# define A01 (p->u.s[1])
	741	+# define A02 (p->u.s[2])
	742	+# define A03 (p->u.s[3])
	743	+# define A04 (p->u.s[4])
	744	+# define A10 (p->u.s[5])
	745	+# define A11 (p->u.s[6])
	746	+# define A12 (p->u.s[7])
	747	+# define A13 (p->u.s[8])
	748	+# define A14 (p->u.s[9])
	749	+# define A20 (p->u.s[10])
	750	+# define A21 (p->u.s[11])
	751	+# define A22 (p->u.s[12])
	752	+# define A23 (p->u.s[13])
	753	+# define A24 (p->u.s[14])
	754	+# define A30 (p->u.s[15])
	755	+# define A31 (p->u.s[16])
	756	+# define A32 (p->u.s[17])
	757	+# define A33 (p->u.s[18])
	758	+# define A34 (p->u.s[19])
	759	+# define A40 (p->u.s[20])
	760	+# define A41 (p->u.s[21])
	761	+# define A42 (p->u.s[22])
	762	+# define A43 (p->u.s[23])
	763	+# define A44 (p->u.s[24])
	764	+# define ROL64(a,x) ((a<<x)\|(a>>(64-x)))
	765	+
	766	+ for(i=0; i<24; i+=4){
	767	+ C0 = A00^A10^A20^A30^A40;
	768	+ C1 = A01^A11^A21^A31^A41;
	769	+ C2 = A02^A12^A22^A32^A42;
	770	+ C3 = A03^A13^A23^A33^A43;
	771	+ C4 = A04^A14^A24^A34^A44;
	772	+ D0 = C4^ROL64(C1, 1);
	773	+ D1 = C0^ROL64(C2, 1);
	774	+ D2 = C1^ROL64(C3, 1);
	775	+ D3 = C2^ROL64(C4, 1);
	776	+ D4 = C3^ROL64(C0, 1);
	777	+
	778	+ B0 = (A00^D0);
	779	+ B1 = ROL64((A11^D1), 44);
	780	+ B2 = ROL64((A22^D2), 43);
	781	+ B3 = ROL64((A33^D3), 21);
	782	+ B4 = ROL64((A44^D4), 14);
	783	+ A00 = B0 ^((~B1)& B2 );
	784	+ A00 ^= RC[i];
	785	+ A11 = B1 ^((~B2)& B3 );
	786	+ A22 = B2 ^((~B3)& B4 );
	787	+ A33 = B3 ^((~B4)& B0 );
	788	+ A44 = B4 ^((~B0)& B1 );
	789	+
	790	+ B2 = ROL64((A20^D0), 3);
	791	+ B3 = ROL64((A31^D1), 45);
	792	+ B4 = ROL64((A42^D2), 61);
	793	+ B0 = ROL64((A03^D3), 28);
	794	+ B1 = ROL64((A14^D4), 20);
	795	+ A20 = B0 ^((~B1)& B2 );
	796	+ A31 = B1 ^((~B2)& B3 );
	797	+ A42 = B2 ^((~B3)& B4 );
	798	+ A03 = B3 ^((~B4)& B0 );
	799	+ A14 = B4 ^((~B0)& B1 );
	800	+
	801	+ B4 = ROL64((A40^D0), 18);
	802	+ B0 = ROL64((A01^D1), 1);
	803	+ B1 = ROL64((A12^D2), 6);
	804	+ B2 = ROL64((A23^D3), 25);
	805	+ B3 = ROL64((A34^D4), 8);
	806	+ A40 = B0 ^((~B1)& B2 );
	807	+ A01 = B1 ^((~B2)& B3 );
	808	+ A12 = B2 ^((~B3)& B4 );
	809	+ A23 = B3 ^((~B4)& B0 );
	810	+ A34 = B4 ^((~B0)& B1 );
	811	+
	812	+ B1 = ROL64((A10^D0), 36);
	813	+ B2 = ROL64((A21^D1), 10);
	814	+ B3 = ROL64((A32^D2), 15);
	815	+ B4 = ROL64((A43^D3), 56);
	816	+ B0 = ROL64((A04^D4), 27);
	817	+ A10 = B0 ^((~B1)& B2 );
	818	+ A21 = B1 ^((~B2)& B3 );
	819	+ A32 = B2 ^((~B3)& B4 );
	820	+ A43 = B3 ^((~B4)& B0 );
	821	+ A04 = B4 ^((~B0)& B1 );
	822	+
	823	+ B3 = ROL64((A30^D0), 41);
	824	+ B4 = ROL64((A41^D1), 2);
	825	+ B0 = ROL64((A02^D2), 62);
	826	+ B1 = ROL64((A13^D3), 55);
	827	+ B2 = ROL64((A24^D4), 39);
	828	+ A30 = B0 ^((~B1)& B2 );
	829	+ A41 = B1 ^((~B2)& B3 );
	830	+ A02 = B2 ^((~B3)& B4 );
	831	+ A13 = B3 ^((~B4)& B0 );
	832	+ A24 = B4 ^((~B0)& B1 );
	833	+
	834	+ C0 = A00^A20^A40^A10^A30;
	835	+ C1 = A11^A31^A01^A21^A41;
	836	+ C2 = A22^A42^A12^A32^A02;
	837	+ C3 = A33^A03^A23^A43^A13;
	838	+ C4 = A44^A14^A34^A04^A24;
	839	+ D0 = C4^ROL64(C1, 1);
	840	+ D1 = C0^ROL64(C2, 1);
	841	+ D2 = C1^ROL64(C3, 1);
	842	+ D3 = C2^ROL64(C4, 1);
	843	+ D4 = C3^ROL64(C0, 1);
	844	+
	845	+ B0 = (A00^D0);
	846	+ B1 = ROL64((A31^D1), 44);
	847	+ B2 = ROL64((A12^D2), 43);
	848	+ B3 = ROL64((A43^D3), 21);
	849	+ B4 = ROL64((A24^D4), 14);
	850	+ A00 = B0 ^((~B1)& B2 );
	851	+ A00 ^= RC[i+1];
	852	+ A31 = B1 ^((~B2)& B3 );
	853	+ A12 = B2 ^((~B3)& B4 );
	854	+ A43 = B3 ^((~B4)& B0 );
	855	+ A24 = B4 ^((~B0)& B1 );
	856	+
	857	+ B2 = ROL64((A40^D0), 3);
	858	+ B3 = ROL64((A21^D1), 45);
	859	+ B4 = ROL64((A02^D2), 61);
	860	+ B0 = ROL64((A33^D3), 28);
	861	+ B1 = ROL64((A14^D4), 20);
	862	+ A40 = B0 ^((~B1)& B2 );
	863	+ A21 = B1 ^((~B2)& B3 );
	864	+ A02 = B2 ^((~B3)& B4 );
	865	+ A33 = B3 ^((~B4)& B0 );
	866	+ A14 = B4 ^((~B0)& B1 );
	867	+
	868	+ B4 = ROL64((A30^D0), 18);
	869	+ B0 = ROL64((A11^D1), 1);
	870	+ B1 = ROL64((A42^D2), 6);
	871	+ B2 = ROL64((A23^D3), 25);
	872	+ B3 = ROL64((A04^D4), 8);
	873	+ A30 = B0 ^((~B1)& B2 );
	874	+ A11 = B1 ^((~B2)& B3 );
	875	+ A42 = B2 ^((~B3)& B4 );
	876	+ A23 = B3 ^((~B4)& B0 );
	877	+ A04 = B4 ^((~B0)& B1 );
	878	+
	879	+ B1 = ROL64((A20^D0), 36);
	880	+ B2 = ROL64((A01^D1), 10);
	881	+ B3 = ROL64((A32^D2), 15);
	882	+ B4 = ROL64((A13^D3), 56);
	883	+ B0 = ROL64((A44^D4), 27);
	884	+ A20 = B0 ^((~B1)& B2 );
	885	+ A01 = B1 ^((~B2)& B3 );
	886	+ A32 = B2 ^((~B3)& B4 );
	887	+ A13 = B3 ^((~B4)& B0 );
	888	+ A44 = B4 ^((~B0)& B1 );
	889	+
	890	+ B3 = ROL64((A10^D0), 41);
	891	+ B4 = ROL64((A41^D1), 2);
	892	+ B0 = ROL64((A22^D2), 62);
	893	+ B1 = ROL64((A03^D3), 55);
	894	+ B2 = ROL64((A34^D4), 39);
	895	+ A10 = B0 ^((~B1)& B2 );
	896	+ A41 = B1 ^((~B2)& B3 );
	897	+ A22 = B2 ^((~B3)& B4 );
	898	+ A03 = B3 ^((~B4)& B0 );
	899	+ A34 = B4 ^((~B0)& B1 );
	900	+
	901	+ C0 = A00^A40^A30^A20^A10;
	902	+ C1 = A31^A21^A11^A01^A41;
	903	+ C2 = A12^A02^A42^A32^A22;
	904	+ C3 = A43^A33^A23^A13^A03;
	905	+ C4 = A24^A14^A04^A44^A34;
	906	+ D0 = C4^ROL64(C1, 1);
	907	+ D1 = C0^ROL64(C2, 1);
	908	+ D2 = C1^ROL64(C3, 1);
	909	+ D3 = C2^ROL64(C4, 1);
	910	+ D4 = C3^ROL64(C0, 1);
	911	+
	912	+ B0 = (A00^D0);
	913	+ B1 = ROL64((A21^D1), 44);
	914	+ B2 = ROL64((A42^D2), 43);
	915	+ B3 = ROL64((A13^D3), 21);
	916	+ B4 = ROL64((A34^D4), 14);
	917	+ A00 = B0 ^((~B1)& B2 );
	918	+ A00 ^= RC[i+2];
	919	+ A21 = B1 ^((~B2)& B3 );
	920	+ A42 = B2 ^((~B3)& B4 );
	921	+ A13 = B3 ^((~B4)& B0 );
	922	+ A34 = B4 ^((~B0)& B1 );
	923	+
	924	+ B2 = ROL64((A30^D0), 3);
	925	+ B3 = ROL64((A01^D1), 45);
	926	+ B4 = ROL64((A22^D2), 61);
	927	+ B0 = ROL64((A43^D3), 28);
	928	+ B1 = ROL64((A14^D4), 20);
	929	+ A30 = B0 ^((~B1)& B2 );
	930	+ A01 = B1 ^((~B2)& B3 );
	931	+ A22 = B2 ^((~B3)& B4 );
	932	+ A43 = B3 ^((~B4)& B0 );
	933	+ A14 = B4 ^((~B0)& B1 );
	934	+
	935	+ B4 = ROL64((A10^D0), 18);
	936	+ B0 = ROL64((A31^D1), 1);
	937	+ B1 = ROL64((A02^D2), 6);
	938	+ B2 = ROL64((A23^D3), 25);
	939	+ B3 = ROL64((A44^D4), 8);
	940	+ A10 = B0 ^((~B1)& B2 );
	941	+ A31 = B1 ^((~B2)& B3 );
	942	+ A02 = B2 ^((~B3)& B4 );
	943	+ A23 = B3 ^((~B4)& B0 );
	944	+ A44 = B4 ^((~B0)& B1 );
	945	+
	946	+ B1 = ROL64((A40^D0), 36);
	947	+ B2 = ROL64((A11^D1), 10);
	948	+ B3 = ROL64((A32^D2), 15);
	949	+ B4 = ROL64((A03^D3), 56);
	950	+ B0 = ROL64((A24^D4), 27);
	951	+ A40 = B0 ^((~B1)& B2 );
	952	+ A11 = B1 ^((~B2)& B3 );
	953	+ A32 = B2 ^((~B3)& B4 );
	954	+ A03 = B3 ^((~B4)& B0 );
	955	+ A24 = B4 ^((~B0)& B1 );
	956	+
	957	+ B3 = ROL64((A20^D0), 41);
	958	+ B4 = ROL64((A41^D1), 2);
	959	+ B0 = ROL64((A12^D2), 62);
	960	+ B1 = ROL64((A33^D3), 55);
	961	+ B2 = ROL64((A04^D4), 39);
	962	+ A20 = B0 ^((~B1)& B2 );
	963	+ A41 = B1 ^((~B2)& B3 );
	964	+ A12 = B2 ^((~B3)& B4 );
	965	+ A33 = B3 ^((~B4)& B0 );
	966	+ A04 = B4 ^((~B0)& B1 );
	967	+
	968	+ C0 = A00^A30^A10^A40^A20;
	969	+ C1 = A21^A01^A31^A11^A41;
	970	+ C2 = A42^A22^A02^A32^A12;
	971	+ C3 = A13^A43^A23^A03^A33;
	972	+ C4 = A34^A14^A44^A24^A04;
	973	+ D0 = C4^ROL64(C1, 1);
	974	+ D1 = C0^ROL64(C2, 1);
	975	+ D2 = C1^ROL64(C3, 1);
	976	+ D3 = C2^ROL64(C4, 1);
	977	+ D4 = C3^ROL64(C0, 1);
	978	+
	979	+ B0 = (A00^D0);
	980	+ B1 = ROL64((A01^D1), 44);
	981	+ B2 = ROL64((A02^D2), 43);
	982	+ B3 = ROL64((A03^D3), 21);
	983	+ B4 = ROL64((A04^D4), 14);
	984	+ A00 = B0 ^((~B1)& B2 );
	985	+ A00 ^= RC[i+3];
	986	+ A01 = B1 ^((~B2)& B3 );
	987	+ A02 = B2 ^((~B3)& B4 );
	988	+ A03 = B3 ^((~B4)& B0 );
	989	+ A04 = B4 ^((~B0)& B1 );
	990	+
	991	+ B2 = ROL64((A10^D0), 3);
	992	+ B3 = ROL64((A11^D1), 45);
	993	+ B4 = ROL64((A12^D2), 61);
	994	+ B0 = ROL64((A13^D3), 28);
	995	+ B1 = ROL64((A14^D4), 20);
	996	+ A10 = B0 ^((~B1)& B2 );
	997	+ A11 = B1 ^((~B2)& B3 );
	998	+ A12 = B2 ^((~B3)& B4 );
	999	+ A13 = B3 ^((~B4)& B0 );
	1000	+ A14 = B4 ^((~B0)& B1 );
	1001	+
	1002	+ B4 = ROL64((A20^D0), 18);
	1003	+ B0 = ROL64((A21^D1), 1);
	1004	+ B1 = ROL64((A22^D2), 6);
	1005	+ B2 = ROL64((A23^D3), 25);
	1006	+ B3 = ROL64((A24^D4), 8);
	1007	+ A20 = B0 ^((~B1)& B2 );
	1008	+ A21 = B1 ^((~B2)& B3 );
	1009	+ A22 = B2 ^((~B3)& B4 );
	1010	+ A23 = B3 ^((~B4)& B0 );
	1011	+ A24 = B4 ^((~B0)& B1 );
	1012	+
	1013	+ B1 = ROL64((A30^D0), 36);
	1014	+ B2 = ROL64((A31^D1), 10);
	1015	+ B3 = ROL64((A32^D2), 15);
	1016	+ B4 = ROL64((A33^D3), 56);
	1017	+ B0 = ROL64((A34^D4), 27);
	1018	+ A30 = B0 ^((~B1)& B2 );
	1019	+ A31 = B1 ^((~B2)& B3 );
	1020	+ A32 = B2 ^((~B3)& B4 );
	1021	+ A33 = B3 ^((~B4)& B0 );
	1022	+ A34 = B4 ^((~B0)& B1 );
	1023	+
	1024	+ B3 = ROL64((A40^D0), 41);
	1025	+ B4 = ROL64((A41^D1), 2);
	1026	+ B0 = ROL64((A42^D2), 62);
	1027	+ B1 = ROL64((A43^D3), 55);
	1028	+ B2 = ROL64((A44^D4), 39);
	1029	+ A40 = B0 ^((~B1)& B2 );
	1030	+ A41 = B1 ^((~B2)& B3 );
	1031	+ A42 = B2 ^((~B3)& B4 );
	1032	+ A43 = B3 ^((~B4)& B0 );
	1033	+ A44 = B4 ^((~B0)& B1 );
	1034	+ }
	1035	+}
	1036	+
	1037	+/*
	1038	+** Initialize a new hash. iSize determines the size of the hash
	1039	+** in bits and should be one of 224, 256, 384, or 512. Or iSize
	1040	+** can be zero to use the default hash size of 256 bits.
	1041	+*/
	1042	+static void SHA3Init(SHA3Context *p, int iSize){
	1043	+ memset(p, 0, sizeof(*p));
	1044	+ if( iSize>=128 && iSize<=512 ){
	1045	+ p->nRate = (1600 - ((iSize + 31)&~31)*2)/8;
	1046	+ }else{
	1047	+ p->nRate = (1600 - 2*256)/8;
	1048	+ }
	1049	+#if SHA3_BYTEORDER==1234
	1050	+ /* Known to be little-endian at compile-time. No-op */
	1051	+#elif SHA3_BYTEORDER==4321
	1052	+ p->ixMask = 7; /* Big-endian */
	1053	+#else
	1054	+ {
	1055	+ static unsigned int one = 1;
	1056	+ if( 1==(unsigned char)&one ){
	1057	+ /* Little endian. No byte swapping. */
	1058	+ p->ixMask = 0;
	1059	+ }else{
	1060	+ /* Big endian. Byte swap. */
	1061	+ p->ixMask = 7;
	1062	+ }
	1063	+ }
	1064	+#endif
	1065	+}
	1066	+
	1067	+/*
	1068	+** Make consecutive calls to the SHA3Update function to add new content
	1069	+** to the hash
	1070	+*/
	1071	+static void SHA3Update(
	1072	+ SHA3Context *p,
	1073	+ const unsigned char *aData,
	1074	+ unsigned int nData
	1075	+){
	1076	+ unsigned int i = 0;
	1077	+#if SHA3_BYTEORDER==1234
	1078	+ if( (p->nLoaded % 8)==0 && ((aData - (const unsigned char*)0)&7)==0 ){
	1079	+ for(; i+7<nData; i+=8){
	1080	+ p->u.s[p->nLoaded/8] ^= (u64)&aData[i];
	1081	+ p->nLoaded += 8;
	1082	+ if( p->nLoaded>=p->nRate ){
	1083	+ KeccakF1600Step(p);
	1084	+ p->nLoaded = 0;
	1085	+ }
	1086	+ }
	1087	+ }
	1088	+#endif
	1089	+ for(; i<nData; i++){
	1090	+#if SHA3_BYTEORDER==1234
	1091	+ p->u.x[p->nLoaded] ^= aData[i];
	1092	+#elif SHA3_BYTEORDER==4321
	1093	+ p->u.x[p->nLoaded^0x07] ^= aData[i];
	1094	+#else
	1095	+ p->u.x[p->nLoaded^p->ixMask] ^= aData[i];
	1096	+#endif
	1097	+ p->nLoaded++;
	1098	+ if( p->nLoaded==p->nRate ){
	1099	+ KeccakF1600Step(p);
	1100	+ p->nLoaded = 0;
	1101	+ }
	1102	+ }
	1103	+}
	1104	+
	1105	+/*
	1106	+** After all content has been added, invoke SHA3Final() to compute
	1107	+** the final hash. The function returns a pointer to the binary
	1108	+** hash value.
	1109	+*/
	1110	+static unsigned char SHA3Final(SHA3Context p){
	1111	+ unsigned int i;
	1112	+ if( p->nLoaded==p->nRate-1 ){
	1113	+ const unsigned char c1 = 0x86;
	1114	+ SHA3Update(p, &c1, 1);
	1115	+ }else{
	1116	+ const unsigned char c2 = 0x06;
	1117	+ const unsigned char c3 = 0x80;
	1118	+ SHA3Update(p, &c2, 1);
	1119	+ p->nLoaded = p->nRate - 1;
	1120	+ SHA3Update(p, &c3, 1);
	1121	+ }
	1122	+ for(i=0; i<p->nRate; i++){
	1123	+ p->u.x[i+p->nRate] = p->u.x[i^p->ixMask];
	1124	+ }
	1125	+ return &p->u.x[p->nRate];
	1126	+}
	1127	+
	1128	+/*
	1129	+** Implementation of the sha3(X,SIZE) function.
	1130	+**
	1131	+** Return a BLOB which is the SIZE-bit SHA3 hash of X. The default
	1132	+** size is 256. If X is a BLOB, it is hashed as is.
	1133	+** For all other non-NULL types of input, X is converted into a UTF-8 string
	1134	+** and the string is hashed without the trailing 0x00 terminator. The hash
	1135	+** of a NULL value is NULL.
	1136	+*/
	1137	+static void sha3Func(
	1138	+ sqlite3_context *context,
	1139	+ int argc,
	1140	+ sqlite3_value **argv
	1141	+){
	1142	+ SHA3Context cx;
	1143	+ int eType = sqlite3_value_type(argv[0]);
	1144	+ int nByte = sqlite3_value_bytes(argv[0]);
	1145	+ int iSize;
	1146	+ if( argc==1 ){
	1147	+ iSize = 256;
	1148	+ }else{
	1149	+ iSize = sqlite3_value_int(argv[1]);
	1150	+ if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){
	1151	+ sqlite3_result_error(context, "SHA3 size should be one of: 224 256 "
	1152	+ "384 512", -1);
	1153	+ return;
	1154	+ }
	1155	+ }
	1156	+ if( eType==SQLITE_NULL ) return;
	1157	+ SHA3Init(&cx, iSize);
	1158	+ if( eType==SQLITE_BLOB ){
	1159	+ SHA3Update(&cx, sqlite3_value_blob(argv[0]), nByte);
	1160	+ }else{
	1161	+ SHA3Update(&cx, sqlite3_value_text(argv[0]), nByte);
	1162	+ }
	1163	+ sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT);
	1164	+}
	1165	+
	1166	+/* Compute a string using sqlite3_vsnprintf() with a maximum length
	1167	+** of 50 bytes and add it to the hash.
	1168	+*/
	1169	+static void hash_step_vformat(
	1170	+ SHA3Context p, / Add content to this context */
	1171	+ const char *zFormat,
	1172	+ ...
	1173	+){
	1174	+ va_list ap;
	1175	+ int n;
	1176	+ char zBuf[50];
	1177	+ va_start(ap, zFormat);
	1178	+ sqlite3_vsnprintf(sizeof(zBuf),zBuf,zFormat,ap);
	1179	+ va_end(ap);
	1180	+ n = (int)strlen(zBuf);
	1181	+ SHA3Update(p, (unsigned char*)zBuf, n);
	1182	+}
	1183	+
	1184	+/*
	1185	+** Implementation of the sha3_query(SQL,SIZE) function.
	1186	+**
	1187	+** This function compiles and runs the SQL statement(s) given in the
	1188	+** argument. The results are hashed using a SIZE-bit SHA3. The default
	1189	+** size is 256.
	1190	+**
	1191	+** The format of the byte stream that is hashed is summarized as follows:
	1192	+**
	1193	+** S<n>:<sql>
	1194	+** R
	1195	+** N
	1196	+** I<int>
	1197	+** F<ieee-float>
	1198	+** B<size>:<bytes>
	1199	+** T<size>:<text>
	1200	+**
	1201	+** <sql> is the original SQL text for each statement run and <n> is
	1202	+** the size of that text. The SQL text is UTF-8. A single R character
	1203	+** occurs before the start of each row. N means a NULL value.
	1204	+** I mean an 8-byte little-endian integer <int>. F is a floating point
	1205	+** number with an 8-byte little-endian IEEE floating point value <ieee-float>.
	1206	+** B means blobs of <size> bytes. T means text rendered as <size>
	1207	+** bytes of UTF-8. The <n> and <size> values are expressed as an ASCII
	1208	+** text integers.
	1209	+**
	1210	+** For each SQL statement in the X input, there is one S segment. Each
	1211	+** S segment is followed by zero or more R segments, one for each row in the
	1212	+** result set. After each R, there are one or more N, I, F, B, or T segments,
	1213	+** one for each column in the result set. Segments are concatentated directly
	1214	+** with no delimiters of any kind.
	1215	+*/
	1216	+static void sha3QueryFunc(
	1217	+ sqlite3_context *context,
	1218	+ int argc,
	1219	+ sqlite3_value **argv
	1220	+){
	1221	+ sqlite3 *db = sqlite3_context_db_handle(context);
	1222	+ const char zSql = (const char)sqlite3_value_text(argv[0]);
	1223	+ sqlite3_stmt *pStmt = 0;
	1224	+ int nCol; /* Number of columns in the result set */
	1225	+ int i; /* Loop counter */
	1226	+ int rc;
	1227	+ int n;
	1228	+ const char *z;
	1229	+ SHA3Context cx;
	1230	+ int iSize;
	1231	+
	1232	+ if( argc==1 ){
	1233	+ iSize = 256;
	1234	+ }else{
	1235	+ iSize = sqlite3_value_int(argv[1]);
	1236	+ if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){
	1237	+ sqlite3_result_error(context, "SHA3 size should be one of: 224 256 "
	1238	+ "384 512", -1);
	1239	+ return;
	1240	+ }
	1241	+ }
	1242	+ if( zSql==0 ) return;
	1243	+ SHA3Init(&cx, iSize);
	1244	+ while( zSql[0] ){
	1245	+ rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zSql);
	1246	+ if( rc ){
	1247	+ char *zMsg = sqlite3_mprintf("error SQL statement [%s]: %s",
	1248	+ zSql, sqlite3_errmsg(db));
	1249	+ sqlite3_finalize(pStmt);
	1250	+ sqlite3_result_error(context, zMsg, -1);
	1251	+ sqlite3_free(zMsg);
	1252	+ return;
	1253	+ }
	1254	+ if( !sqlite3_stmt_readonly(pStmt) ){
	1255	+ char *zMsg = sqlite3_mprintf("non-query: [%s]", sqlite3_sql(pStmt));
	1256	+ sqlite3_finalize(pStmt);
	1257	+ sqlite3_result_error(context, zMsg, -1);
	1258	+ sqlite3_free(zMsg);
	1259	+ return;
	1260	+ }
	1261	+ nCol = sqlite3_column_count(pStmt);
	1262	+ z = sqlite3_sql(pStmt);
	1263	+ if( z==0 ){
	1264	+ sqlite3_finalize(pStmt);
	1265	+ continue;
	1266	+ }
	1267	+ n = (int)strlen(z);
	1268	+ hash_step_vformat(&cx,"S%d:",n);
	1269	+ SHA3Update(&cx,(unsigned char*)z,n);
	1270	+
	1271	+ /* Compute a hash over the result of the query */
	1272	+ while( SQLITE_ROW==sqlite3_step(pStmt) ){
	1273	+ SHA3Update(&cx,(const unsigned char*)"R",1);
	1274	+ for(i=0; i<nCol; i++){
	1275	+ switch( sqlite3_column_type(pStmt,i) ){
	1276	+ case SQLITE_NULL: {
	1277	+ SHA3Update(&cx, (const unsigned char*)"N",1);
	1278	+ break;
	1279	+ }
	1280	+ case SQLITE_INTEGER: {
	1281	+ sqlite3_uint64 u;
	1282	+ int j;
	1283	+ unsigned char x[9];
	1284	+ sqlite3_int64 v = sqlite3_column_int64(pStmt,i);
	1285	+ memcpy(&u, &v, 8);
	1286	+ for(j=8; j>=1; j--){
	1287	+ x[j] = u & 0xff;
	1288	+ u >>= 8;
	1289	+ }
	1290	+ x[0] = 'I';
	1291	+ SHA3Update(&cx, x, 9);
	1292	+ break;
	1293	+ }
	1294	+ case SQLITE_FLOAT: {
	1295	+ sqlite3_uint64 u;
	1296	+ int j;
	1297	+ unsigned char x[9];
	1298	+ double r = sqlite3_column_double(pStmt,i);
	1299	+ memcpy(&u, &r, 8);
	1300	+ for(j=8; j>=1; j--){
	1301	+ x[j] = u & 0xff;
	1302	+ u >>= 8;
	1303	+ }
	1304	+ x[0] = 'F';
	1305	+ SHA3Update(&cx,x,9);
	1306	+ break;
	1307	+ }
	1308	+ case SQLITE_TEXT: {
	1309	+ int n2 = sqlite3_column_bytes(pStmt, i);
	1310	+ const unsigned char *z2 = sqlite3_column_text(pStmt, i);
	1311	+ hash_step_vformat(&cx,"T%d:",n2);
	1312	+ SHA3Update(&cx, z2, n2);
	1313	+ break;
	1314	+ }
	1315	+ case SQLITE_BLOB: {
	1316	+ int n2 = sqlite3_column_bytes(pStmt, i);
	1317	+ const unsigned char *z2 = sqlite3_column_blob(pStmt, i);
	1318	+ hash_step_vformat(&cx,"B%d:",n2);
	1319	+ SHA3Update(&cx, z2, n2);
	1320	+ break;
	1321	+ }
	1322	+ }
	1323	+ }
	1324	+ }
	1325	+ sqlite3_finalize(pStmt);
	1326	+ }
	1327	+ sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT);
	1328	+}
	1329	+/* End of SHA3 hashing logic copy/pasted from ../ext/misc/shathree.c
	1330	+********************************************************************************/
580	1331
581	1332	#if defined(SQLITE_ENABLE_SESSION)
582	1333	/*
583	1334	** State information for a single open session
584	1335	*/
		@@ -608,17 +1359,14 @@
608	1359	** instance of the following structure.
609	1360	*/
610	1361	typedef struct ShellState ShellState;
611	1362	struct ShellState {
612	1363	sqlite3 db; / The database */
613		- int echoOn; /* True to echo input commands */
614	1364	int autoExplain; /* Automatically turn on .explain mode */
615	1365	int autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
616	1366	int statsOn; /* True to display memory stats before each finalize */
617	1367	int scanstatsOn; /* True to display scan stats before each finalize */
618		- int countChanges; /* True to display change counts */
619		- int backslashOn; /* Resolve C-style \x escapes in SQL input text */
620	1368	int outCount; /* Revert to stdout when reaching zero */
621	1369	int cnt; /* Number of records displayed so far */
622	1370	FILE out; / Write results here */
623	1371	FILE traceOut; / Output for sqlite3_trace() */
624	1372	int nErr; /* Number of errors seen */
		@@ -653,13 +1401,24 @@
653	1401	};
654	1402
655	1403	/*
656	1404	** These are the allowed shellFlgs values
657	1405	*/
658		-#define SHFLG_Scratch 0x00001 /* The --scratch option is used */
659		-#define SHFLG_Pagecache 0x00002 /* The --pagecache option is used */
660		-#define SHFLG_Lookaside 0x00004 /* Lookaside memory is used */
	1406	+#define SHFLG_Scratch 0x00000001 /* The --scratch option is used */
	1407	+#define SHFLG_Pagecache 0x00000002 /* The --pagecache option is used */
	1408	+#define SHFLG_Lookaside 0x00000004 /* Lookaside memory is used */
	1409	+#define SHFLG_Backslash 0x00000008 /* The --backslash option is used */
	1410	+#define SHFLG_PreserveRowid 0x00000010 /* .dump preserves rowid values */
	1411	+#define SHFLG_CountChanges 0x00000020 /* .changes setting */
	1412	+#define SHFLG_Echo 0x00000040 /* .echo or --echo setting */
	1413	+
	1414	+/*
	1415	+** Macros for testing and setting shellFlgs
	1416	+*/
	1417	+#define ShellHasFlag(P,X) (((P)->shellFlgs & (X))!=0)
	1418	+#define ShellSetFlag(P,X) ((P)->shellFlgs\|=(X))
	1419	+#define ShellClearFlag(P,X) ((P)->shellFlgs&=(~(X)))
661	1420
662	1421	/*
663	1422	** These are the allowed modes.
664	1423	*/
665	1424	#define MODE_Line 0 /* One column per line. Blank line between records */
		@@ -1292,92 +2051,106 @@
1292	2051	*/
1293	2052	static int callback(void pArg, int nArg, char azArg, char *azCol){
1294	2053	/* since we don't have type info, call the shell_callback with a NULL value */
1295	2054	return shell_callback(pArg, nArg, azArg, azCol, NULL);
1296	2055	}
	2056	+
	2057	+/*
	2058	+** This is the callback routine from sqlite3_exec() that appends all
	2059	+** output onto the end of a ShellText object.
	2060	+*/
	2061	+static int captureOutputCallback(void pArg, int nArg, char azArg, char *az){
	2062	+ ShellText p = (ShellText)pArg;
	2063	+ int i;
	2064	+ if( p->n ) appendText(p, "\|", 0);
	2065	+ for(i=0; i<nArg; i++){
	2066	+ if( i ) appendText(p, ",", 0);
	2067	+ if( azArg[i] ) appendText(p, azArg[i], 0);
	2068	+ }
	2069	+ return 0;
	2070	+}
	2071	+
	2072	+/*
	2073	+** Generate an appropriate SELFTEST table in the main database.
	2074	+*/
	2075	+static void createSelftestTable(ShellState *p){
	2076	+ char *zErrMsg = 0;
	2077	+ sqlite3_exec(p->db,
	2078	+ "SAVEPOINT selftest_init;\n"
	2079	+ "CREATE TABLE IF NOT EXISTS selftest(\n"
	2080	+ " tno INTEGER PRIMARY KEY,\n" /* Test number */
	2081	+ " op TEXT,\n" /* Operator: memo run */
	2082	+ " cmd TEXT,\n" /* Command text */
	2083	+ " ans TEXT\n" /* Desired answer */
	2084	+ ");"
	2085	+ "CREATE TEMP TABLE [_shell$self](op,cmd,ans);\n"
	2086	+ "INSERT INTO [_shell$self](rowid,op,cmd)\n"
	2087	+ " VALUES(coalesce((SELECT (max(tno)+100)/10 FROM selftest),10),\n"
	2088	+ " 'memo','Tests generated by --init');\n"
	2089	+ "INSERT INTO [_shell$self]\n"
	2090	+ " SELECT 'run',\n"
	2091	+ " 'SELECT hex(sha3_query(''SELECT type,name,tbl_name,sql "
	2092	+ "FROM sqlite_master ORDER BY 2'',224))',\n"
	2093	+ " hex(sha3_query('SELECT type,name,tbl_name,sql "
	2094	+ "FROM sqlite_master ORDER BY 2',224));\n"
	2095	+ "INSERT INTO [_shell$self]\n"
	2096	+ " SELECT 'run',"
	2097	+ " 'SELECT hex(sha3_query(''SELECT * FROM \"' \|\|"
	2098	+ " printf('%w',name) \|\| '\" NOT INDEXED'',224))',\n"
	2099	+ " hex(sha3_query(printf('SELECT * FROM \"%w\" NOT INDEXED',name),224))\n"
	2100	+ " FROM (\n"
	2101	+ " SELECT name FROM sqlite_master\n"
	2102	+ " WHERE type='table'\n"
	2103	+ " AND name<>'selftest'\n"
	2104	+ " AND coalesce(rootpage,0)>0\n"
	2105	+ " )\n"
	2106	+ " ORDER BY name;\n"
	2107	+ "INSERT INTO [_shell$self]\n"
	2108	+ " VALUES('run','PRAGMA integrity_check','ok');\n"
	2109	+ "INSERT INTO selftest(tno,op,cmd,ans)"
	2110	+ " SELECT rowid*10,op,cmd,ans FROM [_shell$self];\n"
	2111	+ "DROP TABLE [_shell$self];"
	2112	+ ,0,0,&zErrMsg);
	2113	+ if( zErrMsg ){
	2114	+ utf8_printf(stderr, "SELFTEST initialization failure: %s\n", zErrMsg);
	2115	+ sqlite3_free(zErrMsg);
	2116	+ }
	2117	+ sqlite3_exec(p->db, "RELEASE selftest_init",0,0,0);
	2118	+}
	2119	+
1297	2120
1298	2121	/*
1299	2122	** Set the destination table field of the ShellState structure to
1300	2123	** the name of the table given. Escape any quote characters in the
1301	2124	** table name.
1302	2125	*/
1303	2126	static void set_table_name(ShellState p, const char zName){
1304	2127	int i, n;
1305		- int needQuote;
	2128	+ int cQuote;
1306	2129	char *z;
1307	2130
1308	2131	if( p->zDestTable ){
1309	2132	free(p->zDestTable);
1310	2133	p->zDestTable = 0;
1311	2134	}
1312	2135	if( zName==0 ) return;
1313		- needQuote = !isalpha((unsigned char)zName) && zName!='_';
1314		- for(i=n=0; zName[i]; i++, n++){
1315		- if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){
1316		- needQuote = 1;
1317		- if( zName[i]=='\'' ) n++;
1318		- }
1319		- }
1320		- if( needQuote ) n += 2;
	2136	+ cQuote = quoteChar(zName);
	2137	+ n = strlen30(zName);
	2138	+ if( cQuote ) n += 2;
1321	2139	z = p->zDestTable = malloc( n+1 );
1322	2140	if( z==0 ){
1323	2141	raw_printf(stderr,"Error: out of memory\n");
1324	2142	exit(1);
1325	2143	}
1326	2144	n = 0;
1327		- if( needQuote ) z[n++] = '\'';
	2145	+ if( cQuote ) z[n++] = cQuote;
1328	2146	for(i=0; zName[i]; i++){
1329	2147	z[n++] = zName[i];
1330		- if( zName[i]=='\'' ) z[n++] = '\'';
1331		- }
1332		- if( needQuote ) z[n++] = '\'';
1333		- z[n] = 0;
1334		-}
1335		-
1336		-/* zIn is either a pointer to a NULL-terminated string in memory obtained
1337		-** from malloc(), or a NULL pointer. The string pointed to by zAppend is
1338		-** added to zIn, and the result returned in memory obtained from malloc().
1339		-** zIn, if it was not NULL, is freed.
1340		-**
1341		-** If the third argument, quote, is not '\0', then it is used as a
1342		-** quote character for zAppend.
1343		-*/
1344		-static char appendText(char zIn, char const *zAppend, char quote){
1345		- int len;
1346		- int i;
1347		- int nAppend = strlen30(zAppend);
1348		- int nIn = (zIn?strlen30(zIn):0);
1349		-
1350		- len = nAppend+nIn+1;
1351		- if( quote ){
1352		- len += 2;
1353		- for(i=0; i<nAppend; i++){
1354		- if( zAppend[i]==quote ) len++;
1355		- }
1356		- }
1357		-
1358		- zIn = (char *)realloc(zIn, len);
1359		- if( !zIn ){
1360		- return 0;
1361		- }
1362		-
1363		- if( quote ){
1364		- char *zCsr = &zIn[nIn];
1365		- *zCsr++ = quote;
1366		- for(i=0; i<nAppend; i++){
1367		- *zCsr++ = zAppend[i];
1368		- if( zAppend[i]==quote ) *zCsr++ = quote;
1369		- }
1370		- *zCsr++ = quote;
1371		- *zCsr++ = '\0';
1372		- assert( (zCsr-zIn)==len );
1373		- }else{
1374		- memcpy(&zIn[nIn], zAppend, nAppend);
1375		- zIn[len-1] = '\0';
1376		- }
1377		-
1378		- return zIn;
	2148	+ if( zName[i]==cQuote ) z[n++] = cQuote;
	2149	+ }
	2150	+ if( cQuote ) z[n++] = cQuote;
	2151	+ z[n] = 0;
1379	2152	}
1380	2153
1381	2154
1382	2155	/*
1383	2156	** Execute a query statement that will generate SQL output. Print
		@@ -1484,10 +2257,35 @@
1484	2257	}
1485	2258	fclose(in);
1486	2259	}
1487	2260	#endif
1488	2261
	2262	+/*
	2263	+** Display a single line of status using 64-bit values.
	2264	+*/
	2265	+static void displayStatLine(
	2266	+ ShellState p, / The shell context */
	2267	+ char zLabel, / Label for this one line */
	2268	+ char zFormat, / Format for the result */
	2269	+ int iStatusCtrl, /* Which status to display */
	2270	+ int bReset /* True to reset the stats */
	2271	+){
	2272	+ sqlite3_int64 iCur = -1;
	2273	+ sqlite3_int64 iHiwtr = -1;
	2274	+ int i, nPercent;
	2275	+ char zLine[200];
	2276	+ sqlite3_status64(iStatusCtrl, &iCur, &iHiwtr, bReset);
	2277	+ for(i=0, nPercent=0; zFormat[i]; i++){
	2278	+ if( zFormat[i]=='%' ) nPercent++;
	2279	+ }
	2280	+ if( nPercent>1 ){
	2281	+ sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iCur, iHiwtr);
	2282	+ }else{
	2283	+ sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iHiwtr);
	2284	+ }
	2285	+ raw_printf(p->out, "%-36s %s\n", zLabel, zLine);
	2286	+}
1489	2287
1490	2288	/*
1491	2289	** Display memory stats.
1492	2290	*/
1493	2291	static int display_stats(
		@@ -1497,61 +2295,35 @@
1497	2295	){
1498	2296	int iCur;
1499	2297	int iHiwtr;
1500	2298
1501	2299	if( pArg && pArg->out ){
1502		-
1503		- iHiwtr = iCur = -1;
1504		- sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, bReset);
1505		- raw_printf(pArg->out,
1506		- "Memory Used: %d (max %d) bytes\n",
1507		- iCur, iHiwtr);
1508		- iHiwtr = iCur = -1;
1509		- sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset);
1510		- raw_printf(pArg->out, "Number of Outstanding Allocations: %d (max %d)\n",
1511		- iCur, iHiwtr);
	2300	+ displayStatLine(pArg, "Memory Used:",
	2301	+ "%lld (max %lld) bytes", SQLITE_STATUS_MEMORY_USED, bReset);
	2302	+ displayStatLine(pArg, "Number of Outstanding Allocations:",
	2303	+ "%lld (max %lld)", SQLITE_STATUS_MALLOC_COUNT, bReset);
1512	2304	if( pArg->shellFlgs & SHFLG_Pagecache ){
1513		- iHiwtr = iCur = -1;
1514		- sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset);
1515		- raw_printf(pArg->out,
1516		- "Number of Pcache Pages Used: %d (max %d) pages\n",
1517		- iCur, iHiwtr);
1518		- }
1519		- iHiwtr = iCur = -1;
1520		- sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset);
1521		- raw_printf(pArg->out,
1522		- "Number of Pcache Overflow Bytes: %d (max %d) bytes\n",
1523		- iCur, iHiwtr);
	2305	+ displayStatLine(pArg, "Number of Pcache Pages Used:",
	2306	+ "%lld (max %lld) pages", SQLITE_STATUS_PAGECACHE_USED, bReset);
	2307	+ }
	2308	+ displayStatLine(pArg, "Number of Pcache Overflow Bytes:",
	2309	+ "%lld (max %lld) bytes", SQLITE_STATUS_PAGECACHE_OVERFLOW, bReset);
1524	2310	if( pArg->shellFlgs & SHFLG_Scratch ){
1525		- iHiwtr = iCur = -1;
1526		- sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset);
1527		- raw_printf(pArg->out,
1528		- "Number of Scratch Allocations Used: %d (max %d)\n",
1529		- iCur, iHiwtr);
1530		- }
1531		- iHiwtr = iCur = -1;
1532		- sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset);
1533		- raw_printf(pArg->out,
1534		- "Number of Scratch Overflow Bytes: %d (max %d) bytes\n",
1535		- iCur, iHiwtr);
1536		- iHiwtr = iCur = -1;
1537		- sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, bReset);
1538		- raw_printf(pArg->out, "Largest Allocation: %d bytes\n",
1539		- iHiwtr);
1540		- iHiwtr = iCur = -1;
1541		- sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, bReset);
1542		- raw_printf(pArg->out, "Largest Pcache Allocation: %d bytes\n",
1543		- iHiwtr);
1544		- iHiwtr = iCur = -1;
1545		- sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHiwtr, bReset);
1546		- raw_printf(pArg->out, "Largest Scratch Allocation: %d bytes\n",
1547		- iHiwtr);
	2311	+ displayStatLine(pArg, "Number of Scratch Allocations Used:",
	2312	+ "%lld (max %lld)", SQLITE_STATUS_SCRATCH_USED, bReset);
	2313	+ }
	2314	+ displayStatLine(pArg, "Number of Scratch Overflow Bytes:",
	2315	+ "%lld (max %lld) bytes", SQLITE_STATUS_SCRATCH_OVERFLOW, bReset);
	2316	+ displayStatLine(pArg, "Largest Allocation:",
	2317	+ "%lld bytes", SQLITE_STATUS_MALLOC_SIZE, bReset);
	2318	+ displayStatLine(pArg, "Largest Pcache Allocation:",
	2319	+ "%lld bytes", SQLITE_STATUS_PAGECACHE_SIZE, bReset);
	2320	+ displayStatLine(pArg, "Largest Scratch Allocation:",
	2321	+ "%lld bytes", SQLITE_STATUS_SCRATCH_SIZE, bReset);
1548	2322	#ifdef YYTRACKMAXSTACKDEPTH
1549		- iHiwtr = iCur = -1;
1550		- sqlite3_status(SQLITE_STATUS_PARSER_STACK, &iCur, &iHiwtr, bReset);
1551		- raw_printf(pArg->out, "Deepest Parser Stack: %d (max %d)\n",
1552		- iCur, iHiwtr);
	2323	+ displayStatLine(pArg, "Deepest Parser Stack:",
	2324	+ "%lld (max %lld)", SQLITE_STATUS_PARSER_STACK, bReset);
1553	2325	#endif
1554	2326	}
1555	2327
1556	2328	if( pArg && pArg->out && db ){
1557	2329	if( pArg->shellFlgs & SHFLG_Lookaside ){
		@@ -1934,11 +2706,11 @@
1934	2706	pArg->pStmt = pStmt;
1935	2707	pArg->cnt = 0;
1936	2708	}
1937	2709
1938	2710	/* echo the sql statement if echo on */
1939		- if( pArg && pArg->echoOn ){
	2711	+ if( pArg && ShellHasFlag(pArg, SHFLG_Echo) ){
1940	2712	utf8_printf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
1941	2713	}
1942	2714
1943	2715	/* Show the EXPLAIN QUERY PLAN if .eqp is on */
1944	2716	if( pArg && pArg->autoEQP && sqlite3_strlike("EXPLAIN%",zStmtSql,0)!=0 ){
		@@ -2022,10 +2794,142 @@
2022	2794	} /* end while */
2023	2795
2024	2796	return rc;
2025	2797	}
2026	2798
	2799	+/*
	2800	+** Release memory previously allocated by tableColumnList().
	2801	+*/
	2802	+static void freeColumnList(char **azCol){
	2803	+ int i;
	2804	+ for(i=1; azCol[i]; i++){
	2805	+ sqlite3_free(azCol[i]);
	2806	+ }
	2807	+ /* azCol[0] is a static string */
	2808	+ sqlite3_free(azCol);
	2809	+}
	2810	+
	2811	+/*
	2812	+** Return a list of pointers to strings which are the names of all
	2813	+** columns in table zTab. The memory to hold the names is dynamically
	2814	+** allocated and must be released by the caller using a subsequent call
	2815	+** to freeColumnList().
	2816	+**
	2817	+** The azCol[0] entry is usually NULL. However, if zTab contains a rowid
	2818	+** value that needs to be preserved, then azCol[0] is filled in with the
	2819	+** name of the rowid column.
	2820	+**
	2821	+** The first regular column in the table is azCol[1]. The list is terminated
	2822	+** by an entry with azCol[i]==0.
	2823	+*/
	2824	+static char *tableColumnList(ShellState p, const char *zTab){
	2825	+ char **azCol = 0;
	2826	+ sqlite3_stmt *pStmt;
	2827	+ char *zSql;
	2828	+ int nCol = 0;
	2829	+ int nAlloc = 0;
	2830	+ int nPK = 0; /* Number of PRIMARY KEY columns seen */
	2831	+ int isIPK = 0; /* True if one PRIMARY KEY column of type INTEGER */
	2832	+ int preserveRowid = ShellHasFlag(p, SHFLG_PreserveRowid);
	2833	+ int rc;
	2834	+
	2835	+ zSql = sqlite3_mprintf("PRAGMA table_info=%Q", zTab);
	2836	+ rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
	2837	+ sqlite3_free(zSql);
	2838	+ if( rc ) return 0;
	2839	+ while( sqlite3_step(pStmt)==SQLITE_ROW ){
	2840	+ if( nCol>=nAlloc-2 ){
	2841	+ nAlloc = nAlloc*2 + nCol + 10;
	2842	+ azCol = sqlite3_realloc(azCol, nAlloc*sizeof(azCol[0]));
	2843	+ if( azCol==0 ){
	2844	+ raw_printf(stderr, "Error: out of memory\n");
	2845	+ exit(1);
	2846	+ }
	2847	+ }
	2848	+ azCol[++nCol] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 1));
	2849	+ if( sqlite3_column_int(pStmt, 5) ){
	2850	+ nPK++;
	2851	+ if( nPK==1
	2852	+ && sqlite3_stricmp((const char*)sqlite3_column_text(pStmt,2),
	2853	+ "INTEGER")==0
	2854	+ ){
	2855	+ isIPK = 1;
	2856	+ }else{
	2857	+ isIPK = 0;
	2858	+ }
	2859	+ }
	2860	+ }
	2861	+ sqlite3_finalize(pStmt);
	2862	+ azCol[0] = 0;
	2863	+ azCol[nCol+1] = 0;
	2864	+
	2865	+ /* The decision of whether or not a rowid really needs to be preserved
	2866	+ ** is tricky. We never need to preserve a rowid for a WITHOUT ROWID table
	2867	+ ** or a table with an INTEGER PRIMARY KEY. We are unable to preserve
	2868	+ ** rowids on tables where the rowid is inaccessible because there are other
	2869	+ ** columns in the table named "rowid", "_rowid_", and "oid".
	2870	+ */
	2871	+ if( preserveRowid && isIPK ){
	2872	+ /* If a single PRIMARY KEY column with type INTEGER was seen, then it
	2873	+ ** might be an alise for the ROWID. But it might also be a WITHOUT ROWID
	2874	+ ** table or a INTEGER PRIMARY KEY DESC column, neither of which are
	2875	+ ** ROWID aliases. To distinguish these cases, check to see if
	2876	+ ** there is a "pk" entry in "PRAGMA index_list". There will be
	2877	+ ** no "pk" index if the PRIMARY KEY really is an alias for the ROWID.
	2878	+ */
	2879	+ zSql = sqlite3_mprintf("SELECT 1 FROM pragma_index_list(%Q)"
	2880	+ " WHERE origin='pk'", zTab);
	2881	+ rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
	2882	+ sqlite3_free(zSql);
	2883	+ if( rc ){
	2884	+ freeColumnList(azCol);
	2885	+ return 0;
	2886	+ }
	2887	+ rc = sqlite3_step(pStmt);
	2888	+ sqlite3_finalize(pStmt);
	2889	+ preserveRowid = rc==SQLITE_ROW;
	2890	+ }
	2891	+ if( preserveRowid ){
	2892	+ /* Only preserve the rowid if we can find a name to use for the
	2893	+ ** rowid */
	2894	+ static char *azRowid[] = { "rowid", "_rowid_", "oid" };
	2895	+ int i, j;
	2896	+ for(j=0; j<3; j++){
	2897	+ for(i=1; i<=nCol; i++){
	2898	+ if( sqlite3_stricmp(azRowid[j],azCol[i])==0 ) break;
	2899	+ }
	2900	+ if( i>nCol ){
	2901	+ /* At this point, we know that azRowid[j] is not the name of any
	2902	+ ** ordinary column in the table. Verify that azRowid[j] is a valid
	2903	+ ** name for the rowid before adding it to azCol[0]. WITHOUT ROWID
	2904	+ ** tables will fail this last check */
	2905	+ int rc;
	2906	+ rc = sqlite3_table_column_metadata(p->db,0,zTab,azRowid[j],0,0,0,0,0);
	2907	+ if( rc==SQLITE_OK ) azCol[0] = azRowid[j];
	2908	+ break;
	2909	+ }
	2910	+ }
	2911	+ }
	2912	+ return azCol;
	2913	+}
	2914	+
	2915	+/*
	2916	+** Toggle the reverse_unordered_selects setting.
	2917	+*/
	2918	+static void toggleSelectOrder(sqlite3 *db){
	2919	+ sqlite3_stmt *pStmt = 0;
	2920	+ int iSetting = 0;
	2921	+ char zStmt[100];
	2922	+ sqlite3_prepare_v2(db, "PRAGMA reverse_unordered_selects", -1, &pStmt, 0);
	2923	+ if( sqlite3_step(pStmt)==SQLITE_ROW ){
	2924	+ iSetting = sqlite3_column_int(pStmt, 0);
	2925	+ }
	2926	+ sqlite3_finalize(pStmt);
	2927	+ sqlite3_snprintf(sizeof(zStmt), zStmt,
	2928	+ "PRAGMA reverse_unordered_selects(%d)", !iSetting);
	2929	+ sqlite3_exec(db, zStmt, 0, 0, 0);
	2930	+}
2027	2931
2028	2932	/*
2029	2933	** This is a different callback routine used for dumping the database.
2030	2934	** Each row received by this callback consists of a table name,
2031	2935	** the table type ("index" or "table") and SQL to create the table.
		@@ -2034,21 +2938,20 @@
2034	2938	static int dump_callback(void pArg, int nArg, char azArg, char *azCol){
2035	2939	int rc;
2036	2940	const char *zTable;
2037	2941	const char *zType;
2038	2942	const char *zSql;
2039		- const char *zPrepStmt = 0;
2040	2943	ShellState p = (ShellState )pArg;
2041	2944
2042	2945	UNUSED_PARAMETER(azCol);
2043	2946	if( nArg!=3 ) return 1;
2044	2947	zTable = azArg[0];
2045	2948	zType = azArg[1];
2046	2949	zSql = azArg[2];
2047	2950
2048	2951	if( strcmp(zTable, "sqlite_sequence")==0 ){
2049		- zPrepStmt = "DELETE FROM sqlite_sequence;\n";
	2952	+ raw_printf(p->out, "DELETE FROM sqlite_sequence;\n");
2050	2953	}else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
2051	2954	raw_printf(p->out, "ANALYZE sqlite_master;\n");
2052	2955	}else if( strncmp(zTable, "sqlite_", 7)==0 ){
2053	2956	return 0;
2054	2957	}else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
		@@ -2067,62 +2970,74 @@
2067	2970	}else{
2068	2971	printSchemaLine(p->out, zSql, ";\n");
2069	2972	}
2070	2973
2071	2974	if( strcmp(zType, "table")==0 ){
2072		- sqlite3_stmt *pTableInfo = 0;
2073		- char *zSelect = 0;
2074		- char *zTableInfo = 0;
2075		- char *zTmp = 0;
2076		- int nRow = 0;
2077		-
2078		- zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);
2079		- zTableInfo = appendText(zTableInfo, zTable, '"');
2080		- zTableInfo = appendText(zTableInfo, ");", 0);
2081		-
2082		- rc = sqlite3_prepare_v2(p->db, zTableInfo, -1, &pTableInfo, 0);
2083		- free(zTableInfo);
2084		- if( rc!=SQLITE_OK \|\| !pTableInfo ){
2085		- return 1;
2086		- }
2087		-
2088		- zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' \|\| ", 0);
	2975	+ ShellText sSelect;
	2976	+ ShellText sTable;
	2977	+ char **azCol;
	2978	+ int i;
	2979	+ char *savedDestTable;
	2980	+ int savedMode;
	2981	+
	2982	+ azCol = tableColumnList(p, zTable);
	2983	+ if( azCol==0 ){
	2984	+ p->nErr++;
	2985	+ return 0;
	2986	+ }
	2987	+
2089	2988	/* Always quote the table name, even if it appears to be pure ascii,
2090	2989	** in case it is a keyword. Ex: INSERT INTO "table" ... */
2091		- zTmp = appendText(zTmp, zTable, '"');
2092		- if( zTmp ){
2093		- zSelect = appendText(zSelect, zTmp, '\'');
2094		- free(zTmp);
2095		- }
2096		- zSelect = appendText(zSelect, " \|\| ' VALUES(' \|\| ", 0);
2097		- rc = sqlite3_step(pTableInfo);
2098		- while( rc==SQLITE_ROW ){
2099		- const char zText = (const char )sqlite3_column_text(pTableInfo, 1);
2100		- zSelect = appendText(zSelect, "quote(", 0);
2101		- zSelect = appendText(zSelect, zText, '"');
2102		- rc = sqlite3_step(pTableInfo);
2103		- if( rc==SQLITE_ROW ){
2104		- zSelect = appendText(zSelect, "), ", 0);
2105		- }else{
2106		- zSelect = appendText(zSelect, ") ", 0);
2107		- }
2108		- nRow++;
2109		- }
2110		- rc = sqlite3_finalize(pTableInfo);
2111		- if( rc!=SQLITE_OK \|\| nRow==0 ){
2112		- free(zSelect);
2113		- return 1;
2114		- }
2115		- zSelect = appendText(zSelect, "\|\| ')' FROM ", 0);
2116		- zSelect = appendText(zSelect, zTable, '"');
2117		-
2118		- rc = run_table_dump_query(p, zSelect, zPrepStmt);
2119		- if( rc==SQLITE_CORRUPT ){
2120		- zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);
2121		- run_table_dump_query(p, zSelect, 0);
2122		- }
2123		- free(zSelect);
	2990	+ initText(&sTable);
	2991	+ appendText(&sTable, zTable, quoteChar(zTable));
	2992	+ /* If preserving the rowid, add a column list after the table name.
	2993	+ ** In other words: "INSERT INTO tab(rowid,a,b,c,...) VALUES(...)"
	2994	+ ** instead of the usual "INSERT INTO tab VALUES(...)".
	2995	+ */
	2996	+ if( azCol[0] ){
	2997	+ appendText(&sTable, "(", 0);
	2998	+ appendText(&sTable, azCol[0], 0);
	2999	+ for(i=1; azCol[i]; i++){
	3000	+ appendText(&sTable, ",", 0);
	3001	+ appendText(&sTable, azCol[i], quoteChar(azCol[i]));
	3002	+ }
	3003	+ appendText(&sTable, ")", 0);
	3004	+ }
	3005	+
	3006	+ /* Build an appropriate SELECT statement */
	3007	+ initText(&sSelect);
	3008	+ appendText(&sSelect, "SELECT ", 0);
	3009	+ if( azCol[0] ){
	3010	+ appendText(&sSelect, azCol[0], 0);
	3011	+ appendText(&sSelect, ",", 0);
	3012	+ }
	3013	+ for(i=1; azCol[i]; i++){
	3014	+ appendText(&sSelect, azCol[i], quoteChar(azCol[i]));
	3015	+ if( azCol[i+1] ){
	3016	+ appendText(&sSelect, ",", 0);
	3017	+ }
	3018	+ }
	3019	+ freeColumnList(azCol);
	3020	+ appendText(&sSelect, " FROM ", 0);
	3021	+ appendText(&sSelect, zTable, quoteChar(zTable));
	3022	+
	3023	+ savedDestTable = p->zDestTable;
	3024	+ savedMode = p->mode;
	3025	+ p->zDestTable = sTable.z;
	3026	+ p->mode = p->cMode = MODE_Insert;
	3027	+ rc = shell_exec(p->db, sSelect.z, shell_callback, p, 0);
	3028	+ if( (rc&0xff)==SQLITE_CORRUPT ){
	3029	+ raw_printf(p->out, "/**** CORRUPTION ERROR *****/\n");
	3030	+ toggleSelectOrder(p->db);
	3031	+ shell_exec(p->db, sSelect.z, shell_callback, p, 0);
	3032	+ toggleSelectOrder(p->db);
	3033	+ }
	3034	+ p->zDestTable = savedDestTable;
	3035	+ p->mode = savedMode;
	3036	+ freeText(&sTable);
	3037	+ freeText(&sSelect);
	3038	+ if( rc ) p->nErr++;
2124	3039	}
2125	3040	return 0;
2126	3041	}
2127	3042
2128	3043	/*
		@@ -2233,10 +3148,11 @@
2233	3148	".separator COL ?ROW? Change the column separator and optionally the row\n"
2234	3149	" separator for both the output mode and .import\n"
2235	3150	#if defined(SQLITE_ENABLE_SESSION)
2236	3151	".session CMD ... Create or control sessions\n"
2237	3152	#endif
	3153	+ ".sha3sum ?OPTIONS...? Compute a SHA3 hash of database content\n"
2238	3154	".shell CMD ARGS... Run CMD ARGS... in a system shell\n"
2239	3155	".show Show the current values for various settings\n"
2240	3156	".stats ?on\|off? Show stats or turn stats on or off\n"
2241	3157	".system CMD ARGS... Run CMD ARGS... in a system shell\n"
2242	3158	".tables ?TABLE? List names of tables\n"
		@@ -2423,14 +3339,10 @@
2423	3339	static void open_db(ShellState *p, int keepAlive){
2424	3340	if( p->db==0 ){
2425	3341	sqlite3_initialize();
2426	3342	sqlite3_open(p->zDbFilename, &p->db);
2427	3343	globalDb = p->db;
2428		- if( p->db && sqlite3_errcode(p->db)==SQLITE_OK ){
2429		- sqlite3_create_function(p->db, "shellstatic", 0, SQLITE_UTF8, 0,
2430		- shellstaticFunc, 0, 0);
2431		- }
2432	3344	if( p->db==0 \|\| SQLITE_OK!=sqlite3_errcode(p->db) ){
2433	3345	utf8_printf(stderr,"Error: unable to open database \"%s\": %s\n",
2434	3346	p->zDbFilename, sqlite3_errmsg(p->db));
2435	3347	if( keepAlive ) return;
2436	3348	exit(1);
		@@ -2440,10 +3352,18 @@
2440	3352	#endif
2441	3353	sqlite3_create_function(p->db, "readfile", 1, SQLITE_UTF8, 0,
2442	3354	readfileFunc, 0, 0);
2443	3355	sqlite3_create_function(p->db, "writefile", 2, SQLITE_UTF8, 0,
2444	3356	writefileFunc, 0, 0);
	3357	+ sqlite3_create_function(p->db, "sha3", 1, SQLITE_UTF8, 0,
	3358	+ sha3Func, 0, 0);
	3359	+ sqlite3_create_function(p->db, "sha3", 2, SQLITE_UTF8, 0,
	3360	+ sha3Func, 0, 0);
	3361	+ sqlite3_create_function(p->db, "sha3_query", 1, SQLITE_UTF8, 0,
	3362	+ sha3QueryFunc, 0, 0);
	3363	+ sqlite3_create_function(p->db, "sha3_query", 2, SQLITE_UTF8, 0,
	3364	+ sha3QueryFunc, 0, 0);
2445	3365	}
2446	3366	}
2447	3367
2448	3368	/*
2449	3369	** Do C-language style dequoting.
		@@ -2564,11 +3484,11 @@
2564	3484
2565	3485	/*
2566	3486	** Interpret zArg as either an integer or a boolean value. Return 1 or 0
2567	3487	** for TRUE and FALSE. Return the integer value if appropriate.
2568	3488	*/
2569		-static int booleanValue(char *zArg){
	3489	+static int booleanValue(const char *zArg){
2570	3490	int i;
2571	3491	if( zArg[0]=='0' && zArg[1]=='x' ){
2572	3492	for(i=2; hexDigitValue(zArg[i])>=0; i++){}
2573	3493	}else{
2574	3494	for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
		@@ -2582,10 +3502,21 @@
2582	3502	}
2583	3503	utf8_printf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
2584	3504	zArg);
2585	3505	return 0;
2586	3506	}
	3507	+
	3508	+/*
	3509	+** Set or clear a shell flag according to a boolean value.
	3510	+*/
	3511	+static void setOrClearFlag(ShellState p, unsigned mFlag, const char zArg){
	3512	+ if( booleanValue(zArg) ){
	3513	+ ShellSetFlag(p, mFlag);
	3514	+ }else{
	3515	+ ShellClearFlag(p, mFlag);
	3516	+ }
	3517	+}
2587	3518
2588	3519	/*
2589	3520	** Close an output file, assuming it is not stderr or stdout
2590	3521	*/
2591	3522	static void output_file_close(FILE *f){
		@@ -3656,11 +4587,11 @@
3656	4587	test_breakpoint();
3657	4588	}else
3658	4589
3659	4590	if( c=='c' && n>=3 && strncmp(azArg[0], "changes", n)==0 ){
3660	4591	if( nArg==2 ){
3661		- p->countChanges = booleanValue(azArg[1]);
	4592	+ setOrClearFlag(p, SHFLG_CountChanges, azArg[1]);
3662	4593	}else{
3663	4594	raw_printf(stderr, "Usage: .changes on\|off\n");
3664	4595	rc = 1;
3665	4596	}
3666	4597	}else
		@@ -3720,25 +4651,46 @@
3720	4651	if( c=='d' && strncmp(azArg[0], "dbinfo", n)==0 ){
3721	4652	rc = shell_dbinfo_command(p, nArg, azArg);
3722	4653	}else
3723	4654
3724	4655	if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
	4656	+ const char *zLike = 0;
	4657	+ int i;
	4658	+ ShellClearFlag(p, SHFLG_PreserveRowid);
	4659	+ for(i=1; i<nArg; i++){
	4660	+ if( azArg[i][0]=='-' ){
	4661	+ const char *z = azArg[i]+1;
	4662	+ if( z[0]=='-' ) z++;
	4663	+ if( strcmp(z,"preserve-rowids")==0 ){
	4664	+ ShellSetFlag(p, SHFLG_PreserveRowid);
	4665	+ }else
	4666	+ {
	4667	+ raw_printf(stderr, "Unknown option \"%s\" on \".dump\"\n", azArg[i]);
	4668	+ rc = 1;
	4669	+ goto meta_command_exit;
	4670	+ }
	4671	+ }else if( zLike ){
	4672	+ raw_printf(stderr, "Usage: .dump ?--preserve-rowids? ?LIKE-PATTERN?\n");
	4673	+ rc = 1;
	4674	+ goto meta_command_exit;
	4675	+ }else{
	4676	+ zLike = azArg[i];
	4677	+ }
	4678	+ }
3725	4679	open_db(p, 0);
3726	4680	/* When playing back a "dump", the content might appear in an order
3727	4681	** which causes immediate foreign key constraints to be violated.
3728	4682	** So disable foreign-key constraint enforcement to prevent problems. */
3729		- if( nArg!=1 && nArg!=2 ){
3730		- raw_printf(stderr, "Usage: .dump ?LIKE-PATTERN?\n");
3731		- rc = 1;
3732		- goto meta_command_exit;
3733		- }
3734	4683	raw_printf(p->out, "PRAGMA foreign_keys=OFF;\n");
3735	4684	raw_printf(p->out, "BEGIN TRANSACTION;\n");
3736	4685	p->writableSchema = 0;
	4686	+ /* Set writable_schema=ON since doing so forces SQLite to initialize
	4687	+ ** as much of the schema as it can even if the sqlite_master table is
	4688	+ ** corrupt. */
3737	4689	sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
3738	4690	p->nErr = 0;
3739		- if( nArg==1 ){
	4691	+ if( zLike==0 ){
3740	4692	run_schema_dump_query(p,
3741	4693	"SELECT name, type, sql FROM sqlite_master "
3742	4694	"WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
3743	4695	);
3744	4696	run_schema_dump_query(p,
		@@ -3748,25 +4700,24 @@
3748	4700	run_table_dump_query(p,
3749	4701	"SELECT sql FROM sqlite_master "
3750	4702	"WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
3751	4703	);
3752	4704	}else{
3753		- int i;
3754		- for(i=1; i<nArg; i++){
3755		- zShellStatic = azArg[i];
3756		- run_schema_dump_query(p,
3757		- "SELECT name, type, sql FROM sqlite_master "
3758		- "WHERE tbl_name LIKE shellstatic() AND type=='table'"
3759		- " AND sql NOT NULL");
3760		- run_table_dump_query(p,
3761		- "SELECT sql FROM sqlite_master "
3762		- "WHERE sql NOT NULL"
3763		- " AND type IN ('index','trigger','view')"
3764		- " AND tbl_name LIKE shellstatic()", 0
3765		- );
3766		- zShellStatic = 0;
3767		- }
	4705	+ char *zSql;
	4706	+ zSql = sqlite3_mprintf(
	4707	+ "SELECT name, type, sql FROM sqlite_master "
	4708	+ "WHERE tbl_name LIKE %Q AND type=='table'"
	4709	+ " AND sql NOT NULL", zLike);
	4710	+ run_schema_dump_query(p,zSql);
	4711	+ sqlite3_free(zSql);
	4712	+ zSql = sqlite3_mprintf(
	4713	+ "SELECT sql FROM sqlite_master "
	4714	+ "WHERE sql NOT NULL"
	4715	+ " AND type IN ('index','trigger','view')"
	4716	+ " AND tbl_name LIKE %Q", zLike);
	4717	+ run_table_dump_query(p, zSql, 0);
	4718	+ sqlite3_free(zSql);
3768	4719	}
3769	4720	if( p->writableSchema ){
3770	4721	raw_printf(p->out, "PRAGMA writable_schema=OFF;\n");
3771	4722	p->writableSchema = 0;
3772	4723	}
		@@ -3775,11 +4726,11 @@
3775	4726	raw_printf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
3776	4727	}else
3777	4728
3778	4729	if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){
3779	4730	if( nArg==2 ){
3780		- p->echoOn = booleanValue(azArg[1]);
	4731	+ setOrClearFlag(p, SHFLG_Echo, azArg[1]);
3781	4732	}else{
3782	4733	raw_printf(stderr, "Usage: .echo on\|off\n");
3783	4734	rc = 1;
3784	4735	}
3785	4736	}else
		@@ -4572,21 +5523,21 @@
4572	5523	new_colv[0] = "sql";
4573	5524	new_colv[1] = 0;
4574	5525	callback(&data, 1, new_argv, new_colv);
4575	5526	rc = SQLITE_OK;
4576	5527	}else{
4577		- zShellStatic = azArg[1];
4578		- rc = sqlite3_exec(p->db,
	5528	+ char *zSql;
	5529	+ zSql = sqlite3_mprintf(
4579	5530	"SELECT sql FROM "
4580	5531	" (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
4581	5532	" FROM sqlite_master UNION ALL"
4582	5533	" SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
4583		- "WHERE lower(tbl_name) LIKE shellstatic()"
	5534	+ "WHERE lower(tbl_name) LIKE %Q"
4584	5535	" AND type!='meta' AND sql NOTNULL "
4585		- "ORDER BY rowid",
4586		- callback, &data, &zErrMsg);
4587		- zShellStatic = 0;
	5536	+ "ORDER BY rowid", azArg[1]);
	5537	+ rc = sqlite3_exec(p->db, zSql, callback, &data, &zErrMsg);
	5538	+ sqlite3_free(zSql);
4588	5539	}
4589	5540	}else if( nArg==1 ){
4590	5541	rc = sqlite3_exec(p->db,
4591	5542	"SELECT sql FROM "
4592	5543	" (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
		@@ -4835,10 +5786,123 @@
4835	5786	utf8_printf(p->out, "%s", zBuf);
4836	5787	}
4837	5788	}
4838	5789	}else
4839	5790	#endif
	5791	+
	5792	+ if( c=='s' && n>=4 && strncmp(azArg[0],"selftest",n)==0 ){
	5793	+ int bIsInit = 0; /* True to initialize the SELFTEST table */
	5794	+ int bVerbose = 0; /* Verbose output */
	5795	+ int bSelftestExists; /* True if SELFTEST already exists */
	5796	+ char *azTest = 0; / Content of the SELFTEST table */
	5797	+ int nRow = 0; /* Number of rows in the SELFTEST table */
	5798	+ int nCol = 4; /* Number of columns in the SELFTEST table */
	5799	+ int i; /* Loop counter */
	5800	+ int nTest = 0; /* Number of tests runs */
	5801	+ int nErr = 0; /* Number of errors seen */
	5802	+ ShellText str; /* Answer for a query */
	5803	+ static char *azDefaultTest[] = {
	5804	+ 0, 0, 0, 0,
	5805	+ "0", "memo", "Missing SELFTEST table - default checks only", "",
	5806	+ "1", "run", "PRAGMA integrity_check", "ok"
	5807	+ };
	5808	+ static const int nDefaultRow = 2;
	5809	+
	5810	+ open_db(p,0);
	5811	+ for(i=1; i<nArg; i++){
	5812	+ const char *z = azArg[i];
	5813	+ if( z[0]=='-' && z[1]=='-' ) z++;
	5814	+ if( strcmp(z,"-init")==0 ){
	5815	+ bIsInit = 1;
	5816	+ }else
	5817	+ if( strcmp(z,"-v")==0 ){
	5818	+ bVerbose++;
	5819	+ }else
	5820	+ {
	5821	+ utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
	5822	+ azArg[i], azArg[0]);
	5823	+ raw_printf(stderr, "Should be one of: --init -v\n");
	5824	+ rc = 1;
	5825	+ goto meta_command_exit;
	5826	+ }
	5827	+ }
	5828	+ if( sqlite3_table_column_metadata(p->db,"main","selftest",0,0,0,0,0,0)
	5829	+ != SQLITE_OK ){
	5830	+ bSelftestExists = 0;
	5831	+ }else{
	5832	+ bSelftestExists = 1;
	5833	+ }
	5834	+ if( bIsInit ){
	5835	+ createSelftestTable(p);
	5836	+ bSelftestExists = 1;
	5837	+ }
	5838	+ if( bSelftestExists ){
	5839	+ rc = sqlite3_get_table(p->db,
	5840	+ "SELECT tno,op,cmd,ans FROM selftest ORDER BY tno",
	5841	+ &azTest, &nRow, &nCol, 0);
	5842	+ if( rc ){
	5843	+ raw_printf(stderr, "Error querying the selftest table\n");
	5844	+ rc = 1;
	5845	+ sqlite3_free_table(azTest);
	5846	+ goto meta_command_exit;
	5847	+ }else if( nRow==0 ){
	5848	+ sqlite3_free_table(azTest);
	5849	+ azTest = azDefaultTest;
	5850	+ nRow = nDefaultRow;
	5851	+ }
	5852	+ }else{
	5853	+ azTest = azDefaultTest;
	5854	+ nRow = nDefaultRow;
	5855	+ }
	5856	+ initText(&str);
	5857	+ appendText(&str, "x", 0);
	5858	+ for(i=1; i<=nRow; i++){
	5859	+ int tno = atoi(azTest[i*nCol]);
	5860	+ const char zOp = azTest[inCol+1];
	5861	+ const char zSql = azTest[inCol+2];
	5862	+ const char zAns = azTest[inCol+3];
	5863	+
	5864	+ if( bVerbose>0 ){
	5865	+ char *zQuote = sqlite3_mprintf("%q", zSql);
	5866	+ printf("%d: %s %s\n", tno, zOp, zSql);
	5867	+ sqlite3_free(zQuote);
	5868	+ }
	5869	+ if( strcmp(zOp,"memo")==0 ){
	5870	+ utf8_printf(p->out, "%s\n", zSql);
	5871	+ }else
	5872	+ if( strcmp(zOp,"run")==0 ){
	5873	+ char *zErrMsg = 0;
	5874	+ str.n = 0;
	5875	+ str.z[0] = 0;
	5876	+ rc = sqlite3_exec(p->db, zSql, captureOutputCallback, &str, &zErrMsg);
	5877	+ nTest++;
	5878	+ if( bVerbose ){
	5879	+ utf8_printf(p->out, "Result: %s\n", str.z);
	5880	+ }
	5881	+ if( rc \|\| zErrMsg ){
	5882	+ nErr++;
	5883	+ rc = 1;
	5884	+ utf8_printf(p->out, "%d: error-code-%d: %s\n", tno, rc, zErrMsg);
	5885	+ sqlite3_free(zErrMsg);
	5886	+ }else if( strcmp(zAns,str.z)!=0 ){
	5887	+ nErr++;
	5888	+ rc = 1;
	5889	+ utf8_printf(p->out, "%d: Expected: [%s]\n", tno, zAns);
	5890	+ utf8_printf(p->out, "%d: Got: [%s]\n", tno, str.z);
	5891	+ }
	5892	+ }else
	5893	+ {
	5894	+ utf8_printf(stderr,
	5895	+ "Unknown operation \"%s\" on selftest line %d\n", zOp, tno);
	5896	+ rc = 1;
	5897	+ break;
	5898	+ }
	5899	+ }
	5900	+ freeText(&str);
	5901	+ if( azTest!=azDefaultTest ) sqlite3_free_table(azTest);
	5902	+ utf8_printf(p->out, "%d errors out of %d tests\n", nErr, nTest);
	5903	+ }else
4840	5904
4841	5905	if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){
4842	5906	if( nArg<2 \|\| nArg>3 ){
4843	5907	raw_printf(stderr, "Usage: .separator COL ?ROW?\n");
4844	5908	rc = 1;
		@@ -4850,10 +5914,126 @@
4850	5914	if( nArg>=3 ){
4851	5915	sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator,
4852	5916	"%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]);
4853	5917	}
4854	5918	}else
	5919	+
	5920	+ if( c=='s' && n>=4 && strncmp(azArg[0],"sha3sum",n)==0 ){
	5921	+ const char zLike = 0; / Which table to checksum. 0 means everything */
	5922	+ int i; /* Loop counter */
	5923	+ int bSchema = 0; /* Also hash the schema */
	5924	+ int bSeparate = 0; /* Hash each table separately */
	5925	+ int iSize = 224; /* Hash algorithm to use */
	5926	+ int bDebug = 0; /* Only show the query that would have run */
	5927	+ sqlite3_stmt pStmt; / For querying tables names */
	5928	+ char zSql; / SQL to be run */
	5929	+ char zSep; / Separator */
	5930	+ ShellText sSql; /* Complete SQL for the query to run the hash */
	5931	+ ShellText sQuery; /* Set of queries used to read all content */
	5932	+ open_db(p, 0);
	5933	+ for(i=1; i<nArg; i++){
	5934	+ const char *z = azArg[i];
	5935	+ if( z[0]=='-' ){
	5936	+ z++;
	5937	+ if( z[0]=='-' ) z++;
	5938	+ if( strcmp(z,"schema")==0 ){
	5939	+ bSchema = 1;
	5940	+ }else
	5941	+ if( strcmp(z,"sha3-224")==0 \|\| strcmp(z,"sha3-256")==0
	5942	+ \|\| strcmp(z,"sha3-384")==0 \|\| strcmp(z,"sha3-512")==0
	5943	+ ){
	5944	+ iSize = atoi(&z[5]);
	5945	+ }else
	5946	+ if( strcmp(z,"debug")==0 ){
	5947	+ bDebug = 1;
	5948	+ }else
	5949	+ {
	5950	+ utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
	5951	+ azArg[i], azArg[0]);
	5952	+ raw_printf(stderr, "Should be one of: --schema"
	5953	+ " --sha3-224 --sha3-255 --sha3-384 --sha3-512\n");
	5954	+ rc = 1;
	5955	+ goto meta_command_exit;
	5956	+ }
	5957	+ }else if( zLike ){
	5958	+ raw_printf(stderr, "Usage: .sha3sum ?OPTIONS? ?LIKE-PATTERN?\n");
	5959	+ rc = 1;
	5960	+ goto meta_command_exit;
	5961	+ }else{
	5962	+ zLike = z;
	5963	+ bSeparate = 1;
	5964	+ if( sqlite3_strlike("sqlite_%", zLike, 0)==0 ) bSchema = 1;
	5965	+ }
	5966	+ }
	5967	+ if( bSchema ){
	5968	+ zSql = "SELECT lower(name) FROM sqlite_master"
	5969	+ " WHERE type='table' AND coalesce(rootpage,0)>1"
	5970	+ " UNION ALL SELECT 'sqlite_master'"
	5971	+ " ORDER BY 1 collate nocase";
	5972	+ }else{
	5973	+ zSql = "SELECT lower(name) FROM sqlite_master"
	5974	+ " WHERE type='table' AND coalesce(rootpage,0)>1"
	5975	+ " AND name NOT LIKE 'sqlite_%'"
	5976	+ " ORDER BY 1 collate nocase";
	5977	+ }
	5978	+ sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
	5979	+ initText(&sQuery);
	5980	+ initText(&sSql);
	5981	+ appendText(&sSql, "WITH [sha3sum$query](a,b) AS(",0);
	5982	+ zSep = "VALUES(";
	5983	+ while( SQLITE_ROW==sqlite3_step(pStmt) ){
	5984	+ const char zTab = (const char)sqlite3_column_text(pStmt,0);
	5985	+ if( zLike && sqlite3_strlike(zLike, zTab, 0)!=0 ) continue;
	5986	+ if( strncmp(zTab, "sqlite_",7)!=0 ){
	5987	+ appendText(&sQuery,"SELECT * FROM ", 0);
	5988	+ appendText(&sQuery,zTab,'"');
	5989	+ appendText(&sQuery," NOT INDEXED;", 0);
	5990	+ }else if( strcmp(zTab, "sqlite_master")==0 ){
	5991	+ appendText(&sQuery,"SELECT type,name,tbl_name,sql FROM sqlite_master"
	5992	+ " ORDER BY name;", 0);
	5993	+ }else if( strcmp(zTab, "sqlite_sequence")==0 ){
	5994	+ appendText(&sQuery,"SELECT name,seq FROM sqlite_sequence"
	5995	+ " ORDER BY name;", 0);
	5996	+ }else if( strcmp(zTab, "sqlite_stat1")==0 ){
	5997	+ appendText(&sQuery,"SELECT tbl,idx,stat FROM sqlite_stat1"
	5998	+ " ORDER BY tbl,idx;", 0);
	5999	+ }else if( strcmp(zTab, "sqlite_stat3")==0
	6000	+ \|\| strcmp(zTab, "sqlite_stat4")==0 ){
	6001	+ appendText(&sQuery, "SELECT * FROM ", 0);
	6002	+ appendText(&sQuery, zTab, 0);
	6003	+ appendText(&sQuery, " ORDER BY tbl, idx, rowid;\n", 0);
	6004	+ }
	6005	+ appendText(&sSql, zSep, 0);
	6006	+ appendText(&sSql, sQuery.z, '\'');
	6007	+ sQuery.n = 0;
	6008	+ appendText(&sSql, ",", 0);
	6009	+ appendText(&sSql, zTab, '\'');
	6010	+ zSep = "),(";
	6011	+ }
	6012	+ sqlite3_finalize(pStmt);
	6013	+ if( bSeparate ){
	6014	+ zSql = sqlite3_mprintf(
	6015	+ "%s))"
	6016	+ " SELECT lower(hex(sha3_query(a,%d))) AS hash, b AS label"
	6017	+ " FROM [sha3sum$query]",
	6018	+ sSql.z, iSize);
	6019	+ }else{
	6020	+ zSql = sqlite3_mprintf(
	6021	+ "%s))"
	6022	+ " SELECT lower(hex(sha3_query(group_concat(a,''),%d))) AS hash"
	6023	+ " FROM [sha3sum$query]",
	6024	+ sSql.z, iSize);
	6025	+ }
	6026	+ freeText(&sQuery);
	6027	+ freeText(&sSql);
	6028	+ if( bDebug ){
	6029	+ utf8_printf(p->out, "%s\n", zSql);
	6030	+ }else{
	6031	+ shell_exec(p->db, zSql, shell_callback, p, 0);
	6032	+ }
	6033	+ sqlite3_free(zSql);
	6034	+ }else
4855	6035
4856	6036	if( c=='s'
4857	6037	&& (strncmp(azArg[0], "shell", n)==0 \|\| strncmp(azArg[0],"system",n)==0)
4858	6038	){
4859	6039	char *zCmd;
		@@ -4879,11 +6059,12 @@
4879	6059	if( nArg!=1 ){
4880	6060	raw_printf(stderr, "Usage: .show\n");
4881	6061	rc = 1;
4882	6062	goto meta_command_exit;
4883	6063	}
4884		- utf8_printf(p->out, "%12.12s: %s\n","echo", azBool[p->echoOn!=0]);
	6064	+ utf8_printf(p->out, "%12.12s: %s\n","echo",
	6065	+ azBool[ShellHasFlag(p, SHFLG_Echo)]);
4885	6066	utf8_printf(p->out, "%12.12s: %s\n","eqp", azBool[p->autoEQP&3]);
4886	6067	utf8_printf(p->out, "%12.12s: %s\n","explain",
4887	6068	p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off");
4888	6069	utf8_printf(p->out,"%12.12s: %s\n","headers", azBool[p->showHeader!=0]);
4889	6070	utf8_printf(p->out, "%12.12s: %s\n","mode", modeDescr[p->mode]);
		@@ -5444,11 +6625,11 @@
5444	6625	static int runOneSqlLine(ShellState p, char zSql, FILE *in, int startline){
5445	6626	int rc;
5446	6627	char *zErrMsg = 0;
5447	6628
5448	6629	open_db(p, 0);
5449		- if( p->backslashOn ) resolve_backslashes(zSql);
	6630	+ if( ShellHasFlag(p,SHFLG_Backslash) ) resolve_backslashes(zSql);
5450	6631	BEGIN_TIMER;
5451	6632	rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
5452	6633	END_TIMER;
5453	6634	if( rc \|\| zErrMsg ){
5454	6635	char zPrefix[100];
		@@ -5464,11 +6645,11 @@
5464	6645	zErrMsg = 0;
5465	6646	}else{
5466	6647	utf8_printf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
5467	6648	}
5468	6649	return 1;
5469		- }else if( p->countChanges ){
	6650	+ }else if( ShellHasFlag(p, SHFLG_CountChanges) ){
5470	6651	raw_printf(p->out, "changes: %3d total_changes: %d\n",
5471	6652	sqlite3_changes(p->db), sqlite3_total_changes(p->db));
5472	6653	}
5473	6654	return 0;
5474	6655	}
		@@ -5507,15 +6688,15 @@
5507	6688	if( in!=0 ) break;
5508	6689	seenInterrupt = 0;
5509	6690	}
5510	6691	lineno++;
5511	6692	if( nSql==0 && _all_whitespace(zLine) ){
5512		- if( p->echoOn ) printf("%s\n", zLine);
	6693	+ if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
5513	6694	continue;
5514	6695	}
5515	6696	if( zLine && zLine[0]=='.' && nSql==0 ){
5516		- if( p->echoOn ) printf("%s\n", zLine);
	6697	+ if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
5517	6698	rc = do_meta_command(zLine, p);
5518	6699	if( rc==2 ){ /* exit requested */
5519	6700	break;
5520	6701	}else if( rc ){
5521	6702	errCnt++;
		@@ -5554,11 +6735,11 @@
5554	6735	if( p->outCount ){
5555	6736	output_reset(p);
5556	6737	p->outCount = 0;
5557	6738	}
5558	6739	}else if( nSql && _all_whitespace(zSql) ){
5559		- if( p->echoOn ) printf("%s\n", zSql);
	6740	+ if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zSql);
5560	6741	nSql = 0;
5561	6742	}
5562	6743	}
5563	6744	if( nSql && !_all_whitespace(zSql) ){
5564	6745	runOneSqlLine(p, zSql, in, startline);
		@@ -6023,11 +7204,11 @@
6023	7204	}else if( strcmp(z,"-header")==0 ){
6024	7205	data.showHeader = 1;
6025	7206	}else if( strcmp(z,"-noheader")==0 ){
6026	7207	data.showHeader = 0;
6027	7208	}else if( strcmp(z,"-echo")==0 ){
6028		- data.echoOn = 1;
	7209	+ ShellSetFlag(&data, SHFLG_Echo);
6029	7210	}else if( strcmp(z,"-eqp")==0 ){
6030	7211	data.autoEQP = 1;
6031	7212	}else if( strcmp(z,"-eqpfull")==0 ){
6032	7213	data.autoEQP = 2;
6033	7214	}else if( strcmp(z,"-stats")==0 ){
		@@ -6038,11 +7219,11 @@
6038	7219	/* Undocumented command-line option: -backslash
6039	7220	** Causes C-style backslash escapes to be evaluated in SQL statements
6040	7221	** prior to sending the SQL into SQLite. Useful for injecting
6041	7222	** crazy bytes in the middle of SQL statements for testing and debugging.
6042	7223	*/
6043		- data.backslashOn = 1;
	7224	+ ShellSetFlag(&data, SHFLG_Backslash);
6044	7225	}else if( strcmp(z,"-bail")==0 ){
6045	7226	bail_on_error = 1;
6046	7227	}else if( strcmp(z,"-version")==0 ){
6047	7228	printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
6048	7229	return 0;
6049	7230

	--- src/shell.c
	+++ src/shell.c
	@@ -452,32 +452,10 @@
452	while( IsDigit(*z) ){ z++; }
453	if( realnum ) *realnum = 1;
454	}
455	return *z==0;
456	}
457
458	/*
459	** A global char* and an SQL function to access its current value
460	** from within an SQL statement. This program used to use the
461	** sqlite_exec_printf() API to substitue a string into an SQL statement.
462	** The correct way to do this with sqlite3 is to use the bind API, but
463	** since the shell is built around the callback paradigm it would be a lot
464	** of work. Instead just use this hack, which is quite harmless.
465	*/
466	static const char *zShellStatic = 0;
467	static void shellstaticFunc(
468	sqlite3_context *context,
469	int argc,
470	sqlite3_value **argv
471	){
472	assert( 0==argc );
473	assert( zShellStatic );
474	UNUSED_PARAMETER(argc);
475	UNUSED_PARAMETER(argv);
476	sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC);
477	}
478
479
480	/*
481	** Compute a string length that is limited to what can be stored in
482	** lower 30 bits of a 32-bit signed integer.
483	*/
	@@ -575,10 +553,783 @@
575	if( zResult && *zResult ) shell_add_history(zResult);
576	#endif
577	}
578	return zResult;
579	}





































































































































































































































































































































































































































































































































































































































































































































































































580
581	#if defined(SQLITE_ENABLE_SESSION)
582	/*
583	** State information for a single open session
584	*/
	@@ -608,17 +1359,14 @@
608	** instance of the following structure.
609	*/
610	typedef struct ShellState ShellState;
611	struct ShellState {
612	sqlite3 db; / The database */
613	int echoOn; /* True to echo input commands */
614	int autoExplain; /* Automatically turn on .explain mode */
615	int autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
616	int statsOn; /* True to display memory stats before each finalize */
617	int scanstatsOn; /* True to display scan stats before each finalize */
618	int countChanges; /* True to display change counts */
619	int backslashOn; /* Resolve C-style \x escapes in SQL input text */
620	int outCount; /* Revert to stdout when reaching zero */
621	int cnt; /* Number of records displayed so far */
622	FILE out; / Write results here */
623	FILE traceOut; / Output for sqlite3_trace() */
624	int nErr; /* Number of errors seen */
	@@ -653,13 +1401,24 @@
653	};
654
655	/*
656	** These are the allowed shellFlgs values
657	*/
658	#define SHFLG_Scratch 0x00001 /* The --scratch option is used */
659	#define SHFLG_Pagecache 0x00002 /* The --pagecache option is used */
660	#define SHFLG_Lookaside 0x00004 /* Lookaside memory is used */











661
662	/*
663	** These are the allowed modes.
664	*/
665	#define MODE_Line 0 /* One column per line. Blank line between records */
	@@ -1292,92 +2051,106 @@
1292	*/
1293	static int callback(void pArg, int nArg, char azArg, char *azCol){
1294	/* since we don't have type info, call the shell_callback with a NULL value */
1295	return shell_callback(pArg, nArg, azArg, azCol, NULL);
1296	}
































































1297
1298	/*
1299	** Set the destination table field of the ShellState structure to
1300	** the name of the table given. Escape any quote characters in the
1301	** table name.
1302	*/
1303	static void set_table_name(ShellState p, const char zName){
1304	int i, n;
1305	int needQuote;
1306	char *z;
1307
1308	if( p->zDestTable ){
1309	free(p->zDestTable);
1310	p->zDestTable = 0;
1311	}
1312	if( zName==0 ) return;
1313	needQuote = !isalpha((unsigned char)zName) && zName!='_';
1314	for(i=n=0; zName[i]; i++, n++){
1315	if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){
1316	needQuote = 1;
1317	if( zName[i]=='\'' ) n++;
1318	}
1319	}
1320	if( needQuote ) n += 2;
1321	z = p->zDestTable = malloc( n+1 );
1322	if( z==0 ){
1323	raw_printf(stderr,"Error: out of memory\n");
1324	exit(1);
1325	}
1326	n = 0;
1327	if( needQuote ) z[n++] = '\'';
1328	for(i=0; zName[i]; i++){
1329	z[n++] = zName[i];
1330	if( zName[i]=='\'' ) z[n++] = '\'';
1331	}
1332	if( needQuote ) z[n++] = '\'';
1333	z[n] = 0;
1334	}
1335
1336	/* zIn is either a pointer to a NULL-terminated string in memory obtained
1337	** from malloc(), or a NULL pointer. The string pointed to by zAppend is
1338	** added to zIn, and the result returned in memory obtained from malloc().
1339	** zIn, if it was not NULL, is freed.
1340	**
1341	** If the third argument, quote, is not '\0', then it is used as a
1342	** quote character for zAppend.
1343	*/
1344	static char appendText(char zIn, char const *zAppend, char quote){
1345	int len;
1346	int i;
1347	int nAppend = strlen30(zAppend);
1348	int nIn = (zIn?strlen30(zIn):0);
1349
1350	len = nAppend+nIn+1;
1351	if( quote ){
1352	len += 2;
1353	for(i=0; i<nAppend; i++){
1354	if( zAppend[i]==quote ) len++;
1355	}
1356	}
1357
1358	zIn = (char *)realloc(zIn, len);
1359	if( !zIn ){
1360	return 0;
1361	}
1362
1363	if( quote ){
1364	char *zCsr = &zIn[nIn];
1365	*zCsr++ = quote;
1366	for(i=0; i<nAppend; i++){
1367	*zCsr++ = zAppend[i];
1368	if( zAppend[i]==quote ) *zCsr++ = quote;
1369	}
1370	*zCsr++ = quote;
1371	*zCsr++ = '\0';
1372	assert( (zCsr-zIn)==len );
1373	}else{
1374	memcpy(&zIn[nIn], zAppend, nAppend);
1375	zIn[len-1] = '\0';
1376	}
1377
1378	return zIn;
1379	}
1380
1381
1382	/*
1383	** Execute a query statement that will generate SQL output. Print
	@@ -1484,10 +2257,35 @@
1484	}
1485	fclose(in);
1486	}
1487	#endif
1488

























1489
1490	/*
1491	** Display memory stats.
1492	*/
1493	static int display_stats(
	@@ -1497,61 +2295,35 @@
1497	){
1498	int iCur;
1499	int iHiwtr;
1500
1501	if( pArg && pArg->out ){
1502
1503	iHiwtr = iCur = -1;
1504	sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, bReset);
1505	raw_printf(pArg->out,
1506	"Memory Used: %d (max %d) bytes\n",
1507	iCur, iHiwtr);
1508	iHiwtr = iCur = -1;
1509	sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset);
1510	raw_printf(pArg->out, "Number of Outstanding Allocations: %d (max %d)\n",
1511	iCur, iHiwtr);
1512	if( pArg->shellFlgs & SHFLG_Pagecache ){
1513	iHiwtr = iCur = -1;
1514	sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset);
1515	raw_printf(pArg->out,
1516	"Number of Pcache Pages Used: %d (max %d) pages\n",
1517	iCur, iHiwtr);
1518	}
1519	iHiwtr = iCur = -1;
1520	sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset);
1521	raw_printf(pArg->out,
1522	"Number of Pcache Overflow Bytes: %d (max %d) bytes\n",
1523	iCur, iHiwtr);
1524	if( pArg->shellFlgs & SHFLG_Scratch ){
1525	iHiwtr = iCur = -1;
1526	sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset);
1527	raw_printf(pArg->out,
1528	"Number of Scratch Allocations Used: %d (max %d)\n",
1529	iCur, iHiwtr);
1530	}
1531	iHiwtr = iCur = -1;
1532	sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset);
1533	raw_printf(pArg->out,
1534	"Number of Scratch Overflow Bytes: %d (max %d) bytes\n",
1535	iCur, iHiwtr);
1536	iHiwtr = iCur = -1;
1537	sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, bReset);
1538	raw_printf(pArg->out, "Largest Allocation: %d bytes\n",
1539	iHiwtr);
1540	iHiwtr = iCur = -1;
1541	sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, bReset);
1542	raw_printf(pArg->out, "Largest Pcache Allocation: %d bytes\n",
1543	iHiwtr);
1544	iHiwtr = iCur = -1;
1545	sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHiwtr, bReset);
1546	raw_printf(pArg->out, "Largest Scratch Allocation: %d bytes\n",
1547	iHiwtr);
1548	#ifdef YYTRACKMAXSTACKDEPTH
1549	iHiwtr = iCur = -1;
1550	sqlite3_status(SQLITE_STATUS_PARSER_STACK, &iCur, &iHiwtr, bReset);
1551	raw_printf(pArg->out, "Deepest Parser Stack: %d (max %d)\n",
1552	iCur, iHiwtr);
1553	#endif
1554	}
1555
1556	if( pArg && pArg->out && db ){
1557	if( pArg->shellFlgs & SHFLG_Lookaside ){
	@@ -1934,11 +2706,11 @@
1934	pArg->pStmt = pStmt;
1935	pArg->cnt = 0;
1936	}
1937
1938	/* echo the sql statement if echo on */
1939	if( pArg && pArg->echoOn ){
1940	utf8_printf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
1941	}
1942
1943	/* Show the EXPLAIN QUERY PLAN if .eqp is on */
1944	if( pArg && pArg->autoEQP && sqlite3_strlike("EXPLAIN%",zStmtSql,0)!=0 ){
	@@ -2022,10 +2794,142 @@
2022	} /* end while */
2023
2024	return rc;
2025	}
2026




































































































































2027
2028	/*
2029	** This is a different callback routine used for dumping the database.
2030	** Each row received by this callback consists of a table name,
2031	** the table type ("index" or "table") and SQL to create the table.
	@@ -2034,21 +2938,20 @@
2034	static int dump_callback(void pArg, int nArg, char azArg, char *azCol){
2035	int rc;
2036	const char *zTable;
2037	const char *zType;
2038	const char *zSql;
2039	const char *zPrepStmt = 0;
2040	ShellState p = (ShellState )pArg;
2041
2042	UNUSED_PARAMETER(azCol);
2043	if( nArg!=3 ) return 1;
2044	zTable = azArg[0];
2045	zType = azArg[1];
2046	zSql = azArg[2];
2047
2048	if( strcmp(zTable, "sqlite_sequence")==0 ){
2049	zPrepStmt = "DELETE FROM sqlite_sequence;\n";
2050	}else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
2051	raw_printf(p->out, "ANALYZE sqlite_master;\n");
2052	}else if( strncmp(zTable, "sqlite_", 7)==0 ){
2053	return 0;
2054	}else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
	@@ -2067,62 +2970,74 @@
2067	}else{
2068	printSchemaLine(p->out, zSql, ";\n");
2069	}
2070
2071	if( strcmp(zType, "table")==0 ){
2072	sqlite3_stmt *pTableInfo = 0;
2073	char *zSelect = 0;
2074	char *zTableInfo = 0;
2075	char *zTmp = 0;
2076	int nRow = 0;
2077
2078	zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);
2079	zTableInfo = appendText(zTableInfo, zTable, '"');
2080	zTableInfo = appendText(zTableInfo, ");", 0);
2081
2082	rc = sqlite3_prepare_v2(p->db, zTableInfo, -1, &pTableInfo, 0);
2083	free(zTableInfo);
2084	if( rc!=SQLITE_OK \|\| !pTableInfo ){
2085	return 1;
2086	}
2087
2088	zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' \|\| ", 0);
2089	/* Always quote the table name, even if it appears to be pure ascii,
2090	** in case it is a keyword. Ex: INSERT INTO "table" ... */
2091	zTmp = appendText(zTmp, zTable, '"');
2092	if( zTmp ){
2093	zSelect = appendText(zSelect, zTmp, '\'');
2094	free(zTmp);
2095	}
2096	zSelect = appendText(zSelect, " \|\| ' VALUES(' \|\| ", 0);
2097	rc = sqlite3_step(pTableInfo);
2098	while( rc==SQLITE_ROW ){
2099	const char zText = (const char )sqlite3_column_text(pTableInfo, 1);
2100	zSelect = appendText(zSelect, "quote(", 0);
2101	zSelect = appendText(zSelect, zText, '"');
2102	rc = sqlite3_step(pTableInfo);
2103	if( rc==SQLITE_ROW ){
2104	zSelect = appendText(zSelect, "), ", 0);
2105	}else{
2106	zSelect = appendText(zSelect, ") ", 0);
2107	}
2108	nRow++;
2109	}
2110	rc = sqlite3_finalize(pTableInfo);
2111	if( rc!=SQLITE_OK \|\| nRow==0 ){
2112	free(zSelect);
2113	return 1;
2114	}
2115	zSelect = appendText(zSelect, "\|\| ')' FROM ", 0);
2116	zSelect = appendText(zSelect, zTable, '"');
2117
2118	rc = run_table_dump_query(p, zSelect, zPrepStmt);
2119	if( rc==SQLITE_CORRUPT ){
2120	zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);
2121	run_table_dump_query(p, zSelect, 0);
2122	}
2123	free(zSelect);
















2124	}
2125	return 0;
2126	}
2127
2128	/*
	@@ -2233,10 +3148,11 @@
2233	".separator COL ?ROW? Change the column separator and optionally the row\n"
2234	" separator for both the output mode and .import\n"
2235	#if defined(SQLITE_ENABLE_SESSION)
2236	".session CMD ... Create or control sessions\n"
2237	#endif

2238	".shell CMD ARGS... Run CMD ARGS... in a system shell\n"
2239	".show Show the current values for various settings\n"
2240	".stats ?on\|off? Show stats or turn stats on or off\n"
2241	".system CMD ARGS... Run CMD ARGS... in a system shell\n"
2242	".tables ?TABLE? List names of tables\n"
	@@ -2423,14 +3339,10 @@
2423	static void open_db(ShellState *p, int keepAlive){
2424	if( p->db==0 ){
2425	sqlite3_initialize();
2426	sqlite3_open(p->zDbFilename, &p->db);
2427	globalDb = p->db;
2428	if( p->db && sqlite3_errcode(p->db)==SQLITE_OK ){
2429	sqlite3_create_function(p->db, "shellstatic", 0, SQLITE_UTF8, 0,
2430	shellstaticFunc, 0, 0);
2431	}
2432	if( p->db==0 \|\| SQLITE_OK!=sqlite3_errcode(p->db) ){
2433	utf8_printf(stderr,"Error: unable to open database \"%s\": %s\n",
2434	p->zDbFilename, sqlite3_errmsg(p->db));
2435	if( keepAlive ) return;
2436	exit(1);
	@@ -2440,10 +3352,18 @@
2440	#endif
2441	sqlite3_create_function(p->db, "readfile", 1, SQLITE_UTF8, 0,
2442	readfileFunc, 0, 0);
2443	sqlite3_create_function(p->db, "writefile", 2, SQLITE_UTF8, 0,
2444	writefileFunc, 0, 0);








2445	}
2446	}
2447
2448	/*
2449	** Do C-language style dequoting.
	@@ -2564,11 +3484,11 @@
2564
2565	/*
2566	** Interpret zArg as either an integer or a boolean value. Return 1 or 0
2567	** for TRUE and FALSE. Return the integer value if appropriate.
2568	*/
2569	static int booleanValue(char *zArg){
2570	int i;
2571	if( zArg[0]=='0' && zArg[1]=='x' ){
2572	for(i=2; hexDigitValue(zArg[i])>=0; i++){}
2573	}else{
2574	for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
	@@ -2582,10 +3502,21 @@
2582	}
2583	utf8_printf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
2584	zArg);
2585	return 0;
2586	}











2587
2588	/*
2589	** Close an output file, assuming it is not stderr or stdout
2590	*/
2591	static void output_file_close(FILE *f){
	@@ -3656,11 +4587,11 @@
3656	test_breakpoint();
3657	}else
3658
3659	if( c=='c' && n>=3 && strncmp(azArg[0], "changes", n)==0 ){
3660	if( nArg==2 ){
3661	p->countChanges = booleanValue(azArg[1]);
3662	}else{
3663	raw_printf(stderr, "Usage: .changes on\|off\n");
3664	rc = 1;
3665	}
3666	}else
	@@ -3720,25 +4651,46 @@
3720	if( c=='d' && strncmp(azArg[0], "dbinfo", n)==0 ){
3721	rc = shell_dbinfo_command(p, nArg, azArg);
3722	}else
3723
3724	if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){























3725	open_db(p, 0);
3726	/* When playing back a "dump", the content might appear in an order
3727	** which causes immediate foreign key constraints to be violated.
3728	** So disable foreign-key constraint enforcement to prevent problems. */
3729	if( nArg!=1 && nArg!=2 ){
3730	raw_printf(stderr, "Usage: .dump ?LIKE-PATTERN?\n");
3731	rc = 1;
3732	goto meta_command_exit;
3733	}
3734	raw_printf(p->out, "PRAGMA foreign_keys=OFF;\n");
3735	raw_printf(p->out, "BEGIN TRANSACTION;\n");
3736	p->writableSchema = 0;



3737	sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
3738	p->nErr = 0;
3739	if( nArg==1 ){
3740	run_schema_dump_query(p,
3741	"SELECT name, type, sql FROM sqlite_master "
3742	"WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
3743	);
3744	run_schema_dump_query(p,
	@@ -3748,25 +4700,24 @@
3748	run_table_dump_query(p,
3749	"SELECT sql FROM sqlite_master "
3750	"WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
3751	);
3752	}else{
3753	int i;
3754	for(i=1; i<nArg; i++){
3755	zShellStatic = azArg[i];
3756	run_schema_dump_query(p,
3757	"SELECT name, type, sql FROM sqlite_master "
3758	"WHERE tbl_name LIKE shellstatic() AND type=='table'"
3759	" AND sql NOT NULL");
3760	run_table_dump_query(p,
3761	"SELECT sql FROM sqlite_master "
3762	"WHERE sql NOT NULL"
3763	" AND type IN ('index','trigger','view')"
3764	" AND tbl_name LIKE shellstatic()", 0
3765	);
3766	zShellStatic = 0;
3767	}
3768	}
3769	if( p->writableSchema ){
3770	raw_printf(p->out, "PRAGMA writable_schema=OFF;\n");
3771	p->writableSchema = 0;
3772	}
	@@ -3775,11 +4726,11 @@
3775	raw_printf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
3776	}else
3777
3778	if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){
3779	if( nArg==2 ){
3780	p->echoOn = booleanValue(azArg[1]);
3781	}else{
3782	raw_printf(stderr, "Usage: .echo on\|off\n");
3783	rc = 1;
3784	}
3785	}else
	@@ -4572,21 +5523,21 @@
4572	new_colv[0] = "sql";
4573	new_colv[1] = 0;
4574	callback(&data, 1, new_argv, new_colv);
4575	rc = SQLITE_OK;
4576	}else{
4577	zShellStatic = azArg[1];
4578	rc = sqlite3_exec(p->db,
4579	"SELECT sql FROM "
4580	" (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
4581	" FROM sqlite_master UNION ALL"
4582	" SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
4583	"WHERE lower(tbl_name) LIKE shellstatic()"
4584	" AND type!='meta' AND sql NOTNULL "
4585	"ORDER BY rowid",
4586	callback, &data, &zErrMsg);
4587	zShellStatic = 0;
4588	}
4589	}else if( nArg==1 ){
4590	rc = sqlite3_exec(p->db,
4591	"SELECT sql FROM "
4592	" (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
	@@ -4835,10 +5786,123 @@
4835	utf8_printf(p->out, "%s", zBuf);
4836	}
4837	}
4838	}else
4839	#endif

















































































































4840
4841	if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){
4842	if( nArg<2 \|\| nArg>3 ){
4843	raw_printf(stderr, "Usage: .separator COL ?ROW?\n");
4844	rc = 1;
	@@ -4850,10 +5914,126 @@
4850	if( nArg>=3 ){
4851	sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator,
4852	"%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]);
4853	}
4854	}else




















































































































4855
4856	if( c=='s'
4857	&& (strncmp(azArg[0], "shell", n)==0 \|\| strncmp(azArg[0],"system",n)==0)
4858	){
4859	char *zCmd;
	@@ -4879,11 +6059,12 @@
4879	if( nArg!=1 ){
4880	raw_printf(stderr, "Usage: .show\n");
4881	rc = 1;
4882	goto meta_command_exit;
4883	}
4884	utf8_printf(p->out, "%12.12s: %s\n","echo", azBool[p->echoOn!=0]);

4885	utf8_printf(p->out, "%12.12s: %s\n","eqp", azBool[p->autoEQP&3]);
4886	utf8_printf(p->out, "%12.12s: %s\n","explain",
4887	p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off");
4888	utf8_printf(p->out,"%12.12s: %s\n","headers", azBool[p->showHeader!=0]);
4889	utf8_printf(p->out, "%12.12s: %s\n","mode", modeDescr[p->mode]);
	@@ -5444,11 +6625,11 @@
5444	static int runOneSqlLine(ShellState p, char zSql, FILE *in, int startline){
5445	int rc;
5446	char *zErrMsg = 0;
5447
5448	open_db(p, 0);
5449	if( p->backslashOn ) resolve_backslashes(zSql);
5450	BEGIN_TIMER;
5451	rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
5452	END_TIMER;
5453	if( rc \|\| zErrMsg ){
5454	char zPrefix[100];
	@@ -5464,11 +6645,11 @@
5464	zErrMsg = 0;
5465	}else{
5466	utf8_printf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
5467	}
5468	return 1;
5469	}else if( p->countChanges ){
5470	raw_printf(p->out, "changes: %3d total_changes: %d\n",
5471	sqlite3_changes(p->db), sqlite3_total_changes(p->db));
5472	}
5473	return 0;
5474	}
	@@ -5507,15 +6688,15 @@
5507	if( in!=0 ) break;
5508	seenInterrupt = 0;
5509	}
5510	lineno++;
5511	if( nSql==0 && _all_whitespace(zLine) ){
5512	if( p->echoOn ) printf("%s\n", zLine);
5513	continue;
5514	}
5515	if( zLine && zLine[0]=='.' && nSql==0 ){
5516	if( p->echoOn ) printf("%s\n", zLine);
5517	rc = do_meta_command(zLine, p);
5518	if( rc==2 ){ /* exit requested */
5519	break;
5520	}else if( rc ){
5521	errCnt++;
	@@ -5554,11 +6735,11 @@
5554	if( p->outCount ){
5555	output_reset(p);
5556	p->outCount = 0;
5557	}
5558	}else if( nSql && _all_whitespace(zSql) ){
5559	if( p->echoOn ) printf("%s\n", zSql);
5560	nSql = 0;
5561	}
5562	}
5563	if( nSql && !_all_whitespace(zSql) ){
5564	runOneSqlLine(p, zSql, in, startline);
	@@ -6023,11 +7204,11 @@
6023	}else if( strcmp(z,"-header")==0 ){
6024	data.showHeader = 1;
6025	}else if( strcmp(z,"-noheader")==0 ){
6026	data.showHeader = 0;
6027	}else if( strcmp(z,"-echo")==0 ){
6028	data.echoOn = 1;
6029	}else if( strcmp(z,"-eqp")==0 ){
6030	data.autoEQP = 1;
6031	}else if( strcmp(z,"-eqpfull")==0 ){
6032	data.autoEQP = 2;
6033	}else if( strcmp(z,"-stats")==0 ){
	@@ -6038,11 +7219,11 @@
6038	/* Undocumented command-line option: -backslash
6039	** Causes C-style backslash escapes to be evaluated in SQL statements
6040	** prior to sending the SQL into SQLite. Useful for injecting
6041	** crazy bytes in the middle of SQL statements for testing and debugging.
6042	*/
6043	data.backslashOn = 1;
6044	}else if( strcmp(z,"-bail")==0 ){
6045	bail_on_error = 1;
6046	}else if( strcmp(z,"-version")==0 ){
6047	printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
6048	return 0;
6049

	--- src/shell.c
	+++ src/shell.c
	@@ -452,32 +452,10 @@
452	while( IsDigit(*z) ){ z++; }
453	if( realnum ) *realnum = 1;
454	}
455	return *z==0;
456	}






















457
458	/*
459	** Compute a string length that is limited to what can be stored in
460	** lower 30 bits of a 32-bit signed integer.
461	*/
	@@ -575,10 +553,783 @@
553	if( zResult && *zResult ) shell_add_history(zResult);
554	#endif
555	}
556	return zResult;
557	}
558	/*
559	** A variable length string to which one can append text.
560	*/
561	typedef struct ShellText ShellText;
562	struct ShellText {
563	char *z;
564	int n;
565	int nAlloc;
566	};
567
568	/*
569	** Initialize and destroy a ShellText object
570	*/
571	static void initText(ShellText *p){
572	memset(p, 0, sizeof(*p));
573	}
574	static void freeText(ShellText *p){
575	free(p->z);
576	initText(p);
577	}
578
579	/* zIn is either a pointer to a NULL-terminated string in memory obtained
580	** from malloc(), or a NULL pointer. The string pointed to by zAppend is
581	** added to zIn, and the result returned in memory obtained from malloc().
582	** zIn, if it was not NULL, is freed.
583	**
584	** If the third argument, quote, is not '\0', then it is used as a
585	** quote character for zAppend.
586	*/
587	static void appendText(ShellText p, char const zAppend, char quote){
588	int len;
589	int i;
590	int nAppend = strlen30(zAppend);
591
592	len = nAppend+p->n+1;
593	if( quote ){
594	len += 2;
595	for(i=0; i<nAppend; i++){
596	if( zAppend[i]==quote ) len++;
597	}
598	}
599
600	if( p->n+len>=p->nAlloc ){
601	p->nAlloc = p->nAlloc*2 + len + 20;
602	p->z = realloc(p->z, p->nAlloc);
603	if( p->z==0 ){
604	memset(p, 0, sizeof(*p));
605	return;
606	}
607	}
608
609	if( quote ){
610	char *zCsr = p->z+p->n;
611	*zCsr++ = quote;
612	for(i=0; i<nAppend; i++){
613	*zCsr++ = zAppend[i];
614	if( zAppend[i]==quote ) *zCsr++ = quote;
615	}
616	*zCsr++ = quote;
617	p->n = (int)(zCsr - p->z);
618	*zCsr = '\0';
619	}else{
620	memcpy(p->z+p->n, zAppend, nAppend);
621	p->n += nAppend;
622	p->z[p->n] = '\0';
623	}
624	}
625
626	/*
627	** Attempt to determine if identifier zName needs to be quoted, either
628	** because it contains non-alphanumeric characters, or because it is an
629	** SQLite keyword. Be conservative in this estimate: When in doubt assume
630	** that quoting is required.
631	**
632	** Return '"' if quoting is required. Return 0 if no quoting is required.
633	*/
634	static char quoteChar(const char *zName){
635	/* All SQLite keywords, in alphabetical order */
636	static const char *azKeywords[] = {
637	"ABORT", "ACTION", "ADD", "AFTER", "ALL", "ALTER", "ANALYZE", "AND", "AS",
638	"ASC", "ATTACH", "AUTOINCREMENT", "BEFORE", "BEGIN", "BETWEEN", "BY",
639	"CASCADE", "CASE", "CAST", "CHECK", "COLLATE", "COLUMN", "COMMIT",
640	"CONFLICT", "CONSTRAINT", "CREATE", "CROSS", "CURRENT_DATE",
641	"CURRENT_TIME", "CURRENT_TIMESTAMP", "DATABASE", "DEFAULT", "DEFERRABLE",
642	"DEFERRED", "DELETE", "DESC", "DETACH", "DISTINCT", "DROP", "EACH",
643	"ELSE", "END", "ESCAPE", "EXCEPT", "EXCLUSIVE", "EXISTS", "EXPLAIN",
644	"FAIL", "FOR", "FOREIGN", "FROM", "FULL", "GLOB", "GROUP", "HAVING", "IF",
645	"IGNORE", "IMMEDIATE", "IN", "INDEX", "INDEXED", "INITIALLY", "INNER",
646	"INSERT", "INSTEAD", "INTERSECT", "INTO", "IS", "ISNULL", "JOIN", "KEY",
647	"LEFT", "LIKE", "LIMIT", "MATCH", "NATURAL", "NO", "NOT", "NOTNULL",
648	"NULL", "OF", "OFFSET", "ON", "OR", "ORDER", "OUTER", "PLAN", "PRAGMA",
649	"PRIMARY", "QUERY", "RAISE", "RECURSIVE", "REFERENCES", "REGEXP",
650	"REINDEX", "RELEASE", "RENAME", "REPLACE", "RESTRICT", "RIGHT",
651	"ROLLBACK", "ROW", "SAVEPOINT", "SELECT", "SET", "TABLE", "TEMP",
652	"TEMPORARY", "THEN", "TO", "TRANSACTION", "TRIGGER", "UNION", "UNIQUE",
653	"UPDATE", "USING", "VACUUM", "VALUES", "VIEW", "VIRTUAL", "WHEN", "WHERE",
654	"WITH", "WITHOUT",
655	};
656	int i, lwr, upr, mid, c;
657	if( !isalpha((unsigned char)zName[0]) && zName[0]!='_' ) return '"';
658	for(i=0; zName[i]; i++){
659	if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ) return '"';
660	}
661	lwr = 0;
662	upr = sizeof(azKeywords)/sizeof(azKeywords[0]) - 1;
663	while( lwr<=upr ){
664	mid = (lwr+upr)/2;
665	c = sqlite3_stricmp(azKeywords[mid], zName);
666	if( c==0 ) return '"';
667	if( c<0 ){
668	lwr = mid+1;
669	}else{
670	upr = mid-1;
671	}
672	}
673	return 0;
674	}
675
676	/******************************************************************************
677	** SHA3 hash implementation copied from ../ext/misc/shathree.c
678	*/
679	typedef sqlite3_uint64 u64;
680	/*
681	** Macros to determine whether the machine is big or little endian,
682	** and whether or not that determination is run-time or compile-time.
683	**
684	** For best performance, an attempt is made to guess at the byte-order
685	** using C-preprocessor macros. If that is unsuccessful, or if
686	** -DSHA3_BYTEORDER=0 is set, then byte-order is determined
687	** at run-time.
688	*/
689	#ifndef SHA3_BYTEORDER
690	# if defined(i386) \|\| defined(__i386__) \|\| defined(_M_IX86) \|\| \
691	defined(__x86_64) \|\| defined(__x86_64__) \|\| defined(_M_X64) \|\| \
692	defined(_M_AMD64) \|\| defined(_M_ARM) \|\| defined(__x86) \|\| \
693	defined(__arm__)
694	# define SHA3_BYTEORDER 1234
695	# elif defined(sparc) \|\| defined(__ppc__)
696	# define SHA3_BYTEORDER 4321
697	# else
698	# define SHA3_BYTEORDER 0
699	# endif
700	#endif
701
702
703	/*
704	** State structure for a SHA3 hash in progress
705	*/
706	typedef struct SHA3Context SHA3Context;
707	struct SHA3Context {
708	union {
709	u64 s[25]; /* Keccak state. 5x5 lines of 64 bits each */
710	unsigned char x[1600]; /* ... or 1600 bytes */
711	} u;
712	unsigned nRate; /* Bytes of input accepted per Keccak iteration */
713	unsigned nLoaded; /* Input bytes loaded into u.x[] so far this cycle */
714	unsigned ixMask; /* Insert next input into u.x[nLoaded^ixMask]. */
715	};
716
717	/*
718	** A single step of the Keccak mixing function for a 1600-bit state
719	*/
720	static void KeccakF1600Step(SHA3Context *p){
721	int i;
722	u64 B0, B1, B2, B3, B4;
723	u64 C0, C1, C2, C3, C4;
724	u64 D0, D1, D2, D3, D4;
725	static const u64 RC[] = {
726	0x0000000000000001ULL, 0x0000000000008082ULL,
727	0x800000000000808aULL, 0x8000000080008000ULL,
728	0x000000000000808bULL, 0x0000000080000001ULL,
729	0x8000000080008081ULL, 0x8000000000008009ULL,
730	0x000000000000008aULL, 0x0000000000000088ULL,
731	0x0000000080008009ULL, 0x000000008000000aULL,
732	0x000000008000808bULL, 0x800000000000008bULL,
733	0x8000000000008089ULL, 0x8000000000008003ULL,
734	0x8000000000008002ULL, 0x8000000000000080ULL,
735	0x000000000000800aULL, 0x800000008000000aULL,
736	0x8000000080008081ULL, 0x8000000000008080ULL,
737	0x0000000080000001ULL, 0x8000000080008008ULL
738	};
739	# define A00 (p->u.s[0])
740	# define A01 (p->u.s[1])
741	# define A02 (p->u.s[2])
742	# define A03 (p->u.s[3])
743	# define A04 (p->u.s[4])
744	# define A10 (p->u.s[5])
745	# define A11 (p->u.s[6])
746	# define A12 (p->u.s[7])
747	# define A13 (p->u.s[8])
748	# define A14 (p->u.s[9])
749	# define A20 (p->u.s[10])
750	# define A21 (p->u.s[11])
751	# define A22 (p->u.s[12])
752	# define A23 (p->u.s[13])
753	# define A24 (p->u.s[14])
754	# define A30 (p->u.s[15])
755	# define A31 (p->u.s[16])
756	# define A32 (p->u.s[17])
757	# define A33 (p->u.s[18])
758	# define A34 (p->u.s[19])
759	# define A40 (p->u.s[20])
760	# define A41 (p->u.s[21])
761	# define A42 (p->u.s[22])
762	# define A43 (p->u.s[23])
763	# define A44 (p->u.s[24])
764	# define ROL64(a,x) ((a<<x)\|(a>>(64-x)))
765
766	for(i=0; i<24; i+=4){
767	C0 = A00^A10^A20^A30^A40;
768	C1 = A01^A11^A21^A31^A41;
769	C2 = A02^A12^A22^A32^A42;
770	C3 = A03^A13^A23^A33^A43;
771	C4 = A04^A14^A24^A34^A44;
772	D0 = C4^ROL64(C1, 1);
773	D1 = C0^ROL64(C2, 1);
774	D2 = C1^ROL64(C3, 1);
775	D3 = C2^ROL64(C4, 1);
776	D4 = C3^ROL64(C0, 1);
777
778	B0 = (A00^D0);
779	B1 = ROL64((A11^D1), 44);
780	B2 = ROL64((A22^D2), 43);
781	B3 = ROL64((A33^D3), 21);
782	B4 = ROL64((A44^D4), 14);
783	A00 = B0 ^((~B1)& B2 );
784	A00 ^= RC[i];
785	A11 = B1 ^((~B2)& B3 );
786	A22 = B2 ^((~B3)& B4 );
787	A33 = B3 ^((~B4)& B0 );
788	A44 = B4 ^((~B0)& B1 );
789
790	B2 = ROL64((A20^D0), 3);
791	B3 = ROL64((A31^D1), 45);
792	B4 = ROL64((A42^D2), 61);
793	B0 = ROL64((A03^D3), 28);
794	B1 = ROL64((A14^D4), 20);
795	A20 = B0 ^((~B1)& B2 );
796	A31 = B1 ^((~B2)& B3 );
797	A42 = B2 ^((~B3)& B4 );
798	A03 = B3 ^((~B4)& B0 );
799	A14 = B4 ^((~B0)& B1 );
800
801	B4 = ROL64((A40^D0), 18);
802	B0 = ROL64((A01^D1), 1);
803	B1 = ROL64((A12^D2), 6);
804	B2 = ROL64((A23^D3), 25);
805	B3 = ROL64((A34^D4), 8);
806	A40 = B0 ^((~B1)& B2 );
807	A01 = B1 ^((~B2)& B3 );
808	A12 = B2 ^((~B3)& B4 );
809	A23 = B3 ^((~B4)& B0 );
810	A34 = B4 ^((~B0)& B1 );
811
812	B1 = ROL64((A10^D0), 36);
813	B2 = ROL64((A21^D1), 10);
814	B3 = ROL64((A32^D2), 15);
815	B4 = ROL64((A43^D3), 56);
816	B0 = ROL64((A04^D4), 27);
817	A10 = B0 ^((~B1)& B2 );
818	A21 = B1 ^((~B2)& B3 );
819	A32 = B2 ^((~B3)& B4 );
820	A43 = B3 ^((~B4)& B0 );
821	A04 = B4 ^((~B0)& B1 );
822
823	B3 = ROL64((A30^D0), 41);
824	B4 = ROL64((A41^D1), 2);
825	B0 = ROL64((A02^D2), 62);
826	B1 = ROL64((A13^D3), 55);
827	B2 = ROL64((A24^D4), 39);
828	A30 = B0 ^((~B1)& B2 );
829	A41 = B1 ^((~B2)& B3 );
830	A02 = B2 ^((~B3)& B4 );
831	A13 = B3 ^((~B4)& B0 );
832	A24 = B4 ^((~B0)& B1 );
833
834	C0 = A00^A20^A40^A10^A30;
835	C1 = A11^A31^A01^A21^A41;
836	C2 = A22^A42^A12^A32^A02;
837	C3 = A33^A03^A23^A43^A13;
838	C4 = A44^A14^A34^A04^A24;
839	D0 = C4^ROL64(C1, 1);
840	D1 = C0^ROL64(C2, 1);
841	D2 = C1^ROL64(C3, 1);
842	D3 = C2^ROL64(C4, 1);
843	D4 = C3^ROL64(C0, 1);
844
845	B0 = (A00^D0);
846	B1 = ROL64((A31^D1), 44);
847	B2 = ROL64((A12^D2), 43);
848	B3 = ROL64((A43^D3), 21);
849	B4 = ROL64((A24^D4), 14);
850	A00 = B0 ^((~B1)& B2 );
851	A00 ^= RC[i+1];
852	A31 = B1 ^((~B2)& B3 );
853	A12 = B2 ^((~B3)& B4 );
854	A43 = B3 ^((~B4)& B0 );
855	A24 = B4 ^((~B0)& B1 );
856
857	B2 = ROL64((A40^D0), 3);
858	B3 = ROL64((A21^D1), 45);
859	B4 = ROL64((A02^D2), 61);
860	B0 = ROL64((A33^D3), 28);
861	B1 = ROL64((A14^D4), 20);
862	A40 = B0 ^((~B1)& B2 );
863	A21 = B1 ^((~B2)& B3 );
864	A02 = B2 ^((~B3)& B4 );
865	A33 = B3 ^((~B4)& B0 );
866	A14 = B4 ^((~B0)& B1 );
867
868	B4 = ROL64((A30^D0), 18);
869	B0 = ROL64((A11^D1), 1);
870	B1 = ROL64((A42^D2), 6);
871	B2 = ROL64((A23^D3), 25);
872	B3 = ROL64((A04^D4), 8);
873	A30 = B0 ^((~B1)& B2 );
874	A11 = B1 ^((~B2)& B3 );
875	A42 = B2 ^((~B3)& B4 );
876	A23 = B3 ^((~B4)& B0 );
877	A04 = B4 ^((~B0)& B1 );
878
879	B1 = ROL64((A20^D0), 36);
880	B2 = ROL64((A01^D1), 10);
881	B3 = ROL64((A32^D2), 15);
882	B4 = ROL64((A13^D3), 56);
883	B0 = ROL64((A44^D4), 27);
884	A20 = B0 ^((~B1)& B2 );
885	A01 = B1 ^((~B2)& B3 );
886	A32 = B2 ^((~B3)& B4 );
887	A13 = B3 ^((~B4)& B0 );
888	A44 = B4 ^((~B0)& B1 );
889
890	B3 = ROL64((A10^D0), 41);
891	B4 = ROL64((A41^D1), 2);
892	B0 = ROL64((A22^D2), 62);
893	B1 = ROL64((A03^D3), 55);
894	B2 = ROL64((A34^D4), 39);
895	A10 = B0 ^((~B1)& B2 );
896	A41 = B1 ^((~B2)& B3 );
897	A22 = B2 ^((~B3)& B4 );
898	A03 = B3 ^((~B4)& B0 );
899	A34 = B4 ^((~B0)& B1 );
900
901	C0 = A00^A40^A30^A20^A10;
902	C1 = A31^A21^A11^A01^A41;
903	C2 = A12^A02^A42^A32^A22;
904	C3 = A43^A33^A23^A13^A03;
905	C4 = A24^A14^A04^A44^A34;
906	D0 = C4^ROL64(C1, 1);
907	D1 = C0^ROL64(C2, 1);
908	D2 = C1^ROL64(C3, 1);
909	D3 = C2^ROL64(C4, 1);
910	D4 = C3^ROL64(C0, 1);
911
912	B0 = (A00^D0);
913	B1 = ROL64((A21^D1), 44);
914	B2 = ROL64((A42^D2), 43);
915	B3 = ROL64((A13^D3), 21);
916	B4 = ROL64((A34^D4), 14);
917	A00 = B0 ^((~B1)& B2 );
918	A00 ^= RC[i+2];
919	A21 = B1 ^((~B2)& B3 );
920	A42 = B2 ^((~B3)& B4 );
921	A13 = B3 ^((~B4)& B0 );
922	A34 = B4 ^((~B0)& B1 );
923
924	B2 = ROL64((A30^D0), 3);
925	B3 = ROL64((A01^D1), 45);
926	B4 = ROL64((A22^D2), 61);
927	B0 = ROL64((A43^D3), 28);
928	B1 = ROL64((A14^D4), 20);
929	A30 = B0 ^((~B1)& B2 );
930	A01 = B1 ^((~B2)& B3 );
931	A22 = B2 ^((~B3)& B4 );
932	A43 = B3 ^((~B4)& B0 );
933	A14 = B4 ^((~B0)& B1 );
934
935	B4 = ROL64((A10^D0), 18);
936	B0 = ROL64((A31^D1), 1);
937	B1 = ROL64((A02^D2), 6);
938	B2 = ROL64((A23^D3), 25);
939	B3 = ROL64((A44^D4), 8);
940	A10 = B0 ^((~B1)& B2 );
941	A31 = B1 ^((~B2)& B3 );
942	A02 = B2 ^((~B3)& B4 );
943	A23 = B3 ^((~B4)& B0 );
944	A44 = B4 ^((~B0)& B1 );
945
946	B1 = ROL64((A40^D0), 36);
947	B2 = ROL64((A11^D1), 10);
948	B3 = ROL64((A32^D2), 15);
949	B4 = ROL64((A03^D3), 56);
950	B0 = ROL64((A24^D4), 27);
951	A40 = B0 ^((~B1)& B2 );
952	A11 = B1 ^((~B2)& B3 );
953	A32 = B2 ^((~B3)& B4 );
954	A03 = B3 ^((~B4)& B0 );
955	A24 = B4 ^((~B0)& B1 );
956
957	B3 = ROL64((A20^D0), 41);
958	B4 = ROL64((A41^D1), 2);
959	B0 = ROL64((A12^D2), 62);
960	B1 = ROL64((A33^D3), 55);
961	B2 = ROL64((A04^D4), 39);
962	A20 = B0 ^((~B1)& B2 );
963	A41 = B1 ^((~B2)& B3 );
964	A12 = B2 ^((~B3)& B4 );
965	A33 = B3 ^((~B4)& B0 );
966	A04 = B4 ^((~B0)& B1 );
967
968	C0 = A00^A30^A10^A40^A20;
969	C1 = A21^A01^A31^A11^A41;
970	C2 = A42^A22^A02^A32^A12;
971	C3 = A13^A43^A23^A03^A33;
972	C4 = A34^A14^A44^A24^A04;
973	D0 = C4^ROL64(C1, 1);
974	D1 = C0^ROL64(C2, 1);
975	D2 = C1^ROL64(C3, 1);
976	D3 = C2^ROL64(C4, 1);
977	D4 = C3^ROL64(C0, 1);
978
979	B0 = (A00^D0);
980	B1 = ROL64((A01^D1), 44);
981	B2 = ROL64((A02^D2), 43);
982	B3 = ROL64((A03^D3), 21);
983	B4 = ROL64((A04^D4), 14);
984	A00 = B0 ^((~B1)& B2 );
985	A00 ^= RC[i+3];
986	A01 = B1 ^((~B2)& B3 );
987	A02 = B2 ^((~B3)& B4 );
988	A03 = B3 ^((~B4)& B0 );
989	A04 = B4 ^((~B0)& B1 );
990
991	B2 = ROL64((A10^D0), 3);
992	B3 = ROL64((A11^D1), 45);
993	B4 = ROL64((A12^D2), 61);
994	B0 = ROL64((A13^D3), 28);
995	B1 = ROL64((A14^D4), 20);
996	A10 = B0 ^((~B1)& B2 );
997	A11 = B1 ^((~B2)& B3 );
998	A12 = B2 ^((~B3)& B4 );
999	A13 = B3 ^((~B4)& B0 );
1000	A14 = B4 ^((~B0)& B1 );
1001
1002	B4 = ROL64((A20^D0), 18);
1003	B0 = ROL64((A21^D1), 1);
1004	B1 = ROL64((A22^D2), 6);
1005	B2 = ROL64((A23^D3), 25);
1006	B3 = ROL64((A24^D4), 8);
1007	A20 = B0 ^((~B1)& B2 );
1008	A21 = B1 ^((~B2)& B3 );
1009	A22 = B2 ^((~B3)& B4 );
1010	A23 = B3 ^((~B4)& B0 );
1011	A24 = B4 ^((~B0)& B1 );
1012
1013	B1 = ROL64((A30^D0), 36);
1014	B2 = ROL64((A31^D1), 10);
1015	B3 = ROL64((A32^D2), 15);
1016	B4 = ROL64((A33^D3), 56);
1017	B0 = ROL64((A34^D4), 27);
1018	A30 = B0 ^((~B1)& B2 );
1019	A31 = B1 ^((~B2)& B3 );
1020	A32 = B2 ^((~B3)& B4 );
1021	A33 = B3 ^((~B4)& B0 );
1022	A34 = B4 ^((~B0)& B1 );
1023
1024	B3 = ROL64((A40^D0), 41);
1025	B4 = ROL64((A41^D1), 2);
1026	B0 = ROL64((A42^D2), 62);
1027	B1 = ROL64((A43^D3), 55);
1028	B2 = ROL64((A44^D4), 39);
1029	A40 = B0 ^((~B1)& B2 );
1030	A41 = B1 ^((~B2)& B3 );
1031	A42 = B2 ^((~B3)& B4 );
1032	A43 = B3 ^((~B4)& B0 );
1033	A44 = B4 ^((~B0)& B1 );
1034	}
1035	}
1036
1037	/*
1038	** Initialize a new hash. iSize determines the size of the hash
1039	** in bits and should be one of 224, 256, 384, or 512. Or iSize
1040	** can be zero to use the default hash size of 256 bits.
1041	*/
1042	static void SHA3Init(SHA3Context *p, int iSize){
1043	memset(p, 0, sizeof(*p));
1044	if( iSize>=128 && iSize<=512 ){
1045	p->nRate = (1600 - ((iSize + 31)&~31)*2)/8;
1046	}else{
1047	p->nRate = (1600 - 2*256)/8;
1048	}
1049	#if SHA3_BYTEORDER==1234
1050	/* Known to be little-endian at compile-time. No-op */
1051	#elif SHA3_BYTEORDER==4321
1052	p->ixMask = 7; /* Big-endian */
1053	#else
1054	{
1055	static unsigned int one = 1;
1056	if( 1==(unsigned char)&one ){
1057	/* Little endian. No byte swapping. */
1058	p->ixMask = 0;
1059	}else{
1060	/* Big endian. Byte swap. */
1061	p->ixMask = 7;
1062	}
1063	}
1064	#endif
1065	}
1066
1067	/*
1068	** Make consecutive calls to the SHA3Update function to add new content
1069	** to the hash
1070	*/
1071	static void SHA3Update(
1072	SHA3Context *p,
1073	const unsigned char *aData,
1074	unsigned int nData
1075	){
1076	unsigned int i = 0;
1077	#if SHA3_BYTEORDER==1234
1078	if( (p->nLoaded % 8)==0 && ((aData - (const unsigned char*)0)&7)==0 ){
1079	for(; i+7<nData; i+=8){
1080	p->u.s[p->nLoaded/8] ^= (u64)&aData[i];
1081	p->nLoaded += 8;
1082	if( p->nLoaded>=p->nRate ){
1083	KeccakF1600Step(p);
1084	p->nLoaded = 0;
1085	}
1086	}
1087	}
1088	#endif
1089	for(; i<nData; i++){
1090	#if SHA3_BYTEORDER==1234
1091	p->u.x[p->nLoaded] ^= aData[i];
1092	#elif SHA3_BYTEORDER==4321
1093	p->u.x[p->nLoaded^0x07] ^= aData[i];
1094	#else
1095	p->u.x[p->nLoaded^p->ixMask] ^= aData[i];
1096	#endif
1097	p->nLoaded++;
1098	if( p->nLoaded==p->nRate ){
1099	KeccakF1600Step(p);
1100	p->nLoaded = 0;
1101	}
1102	}
1103	}
1104
1105	/*
1106	** After all content has been added, invoke SHA3Final() to compute
1107	** the final hash. The function returns a pointer to the binary
1108	** hash value.
1109	*/
1110	static unsigned char SHA3Final(SHA3Context p){
1111	unsigned int i;
1112	if( p->nLoaded==p->nRate-1 ){
1113	const unsigned char c1 = 0x86;
1114	SHA3Update(p, &c1, 1);
1115	}else{
1116	const unsigned char c2 = 0x06;
1117	const unsigned char c3 = 0x80;
1118	SHA3Update(p, &c2, 1);
1119	p->nLoaded = p->nRate - 1;
1120	SHA3Update(p, &c3, 1);
1121	}
1122	for(i=0; i<p->nRate; i++){
1123	p->u.x[i+p->nRate] = p->u.x[i^p->ixMask];
1124	}
1125	return &p->u.x[p->nRate];
1126	}
1127
1128	/*
1129	** Implementation of the sha3(X,SIZE) function.
1130	**
1131	** Return a BLOB which is the SIZE-bit SHA3 hash of X. The default
1132	** size is 256. If X is a BLOB, it is hashed as is.
1133	** For all other non-NULL types of input, X is converted into a UTF-8 string
1134	** and the string is hashed without the trailing 0x00 terminator. The hash
1135	** of a NULL value is NULL.
1136	*/
1137	static void sha3Func(
1138	sqlite3_context *context,
1139	int argc,
1140	sqlite3_value **argv
1141	){
1142	SHA3Context cx;
1143	int eType = sqlite3_value_type(argv[0]);
1144	int nByte = sqlite3_value_bytes(argv[0]);
1145	int iSize;
1146	if( argc==1 ){
1147	iSize = 256;
1148	}else{
1149	iSize = sqlite3_value_int(argv[1]);
1150	if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){
1151	sqlite3_result_error(context, "SHA3 size should be one of: 224 256 "
1152	"384 512", -1);
1153	return;
1154	}
1155	}
1156	if( eType==SQLITE_NULL ) return;
1157	SHA3Init(&cx, iSize);
1158	if( eType==SQLITE_BLOB ){
1159	SHA3Update(&cx, sqlite3_value_blob(argv[0]), nByte);
1160	}else{
1161	SHA3Update(&cx, sqlite3_value_text(argv[0]), nByte);
1162	}
1163	sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT);
1164	}
1165
1166	/* Compute a string using sqlite3_vsnprintf() with a maximum length
1167	** of 50 bytes and add it to the hash.
1168	*/
1169	static void hash_step_vformat(
1170	SHA3Context p, / Add content to this context */
1171	const char *zFormat,
1172	...
1173	){
1174	va_list ap;
1175	int n;
1176	char zBuf[50];
1177	va_start(ap, zFormat);
1178	sqlite3_vsnprintf(sizeof(zBuf),zBuf,zFormat,ap);
1179	va_end(ap);
1180	n = (int)strlen(zBuf);
1181	SHA3Update(p, (unsigned char*)zBuf, n);
1182	}
1183
1184	/*
1185	** Implementation of the sha3_query(SQL,SIZE) function.
1186	**
1187	** This function compiles and runs the SQL statement(s) given in the
1188	** argument. The results are hashed using a SIZE-bit SHA3. The default
1189	** size is 256.
1190	**
1191	** The format of the byte stream that is hashed is summarized as follows:
1192	**
1193	** S<n>:<sql>
1194	** R
1195	** N
1196	** I<int>
1197	** F<ieee-float>
1198	** B<size>:<bytes>
1199	** T<size>:<text>
1200	**
1201	** <sql> is the original SQL text for each statement run and <n> is
1202	** the size of that text. The SQL text is UTF-8. A single R character
1203	** occurs before the start of each row. N means a NULL value.
1204	** I mean an 8-byte little-endian integer <int>. F is a floating point
1205	** number with an 8-byte little-endian IEEE floating point value <ieee-float>.
1206	** B means blobs of <size> bytes. T means text rendered as <size>
1207	** bytes of UTF-8. The <n> and <size> values are expressed as an ASCII
1208	** text integers.
1209	**
1210	** For each SQL statement in the X input, there is one S segment. Each
1211	** S segment is followed by zero or more R segments, one for each row in the
1212	** result set. After each R, there are one or more N, I, F, B, or T segments,
1213	** one for each column in the result set. Segments are concatentated directly
1214	** with no delimiters of any kind.
1215	*/
1216	static void sha3QueryFunc(
1217	sqlite3_context *context,
1218	int argc,
1219	sqlite3_value **argv
1220	){
1221	sqlite3 *db = sqlite3_context_db_handle(context);
1222	const char zSql = (const char)sqlite3_value_text(argv[0]);
1223	sqlite3_stmt *pStmt = 0;
1224	int nCol; /* Number of columns in the result set */
1225	int i; /* Loop counter */
1226	int rc;
1227	int n;
1228	const char *z;
1229	SHA3Context cx;
1230	int iSize;
1231
1232	if( argc==1 ){
1233	iSize = 256;
1234	}else{
1235	iSize = sqlite3_value_int(argv[1]);
1236	if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){
1237	sqlite3_result_error(context, "SHA3 size should be one of: 224 256 "
1238	"384 512", -1);
1239	return;
1240	}
1241	}
1242	if( zSql==0 ) return;
1243	SHA3Init(&cx, iSize);
1244	while( zSql[0] ){
1245	rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zSql);
1246	if( rc ){
1247	char *zMsg = sqlite3_mprintf("error SQL statement [%s]: %s",
1248	zSql, sqlite3_errmsg(db));
1249	sqlite3_finalize(pStmt);
1250	sqlite3_result_error(context, zMsg, -1);
1251	sqlite3_free(zMsg);
1252	return;
1253	}
1254	if( !sqlite3_stmt_readonly(pStmt) ){
1255	char *zMsg = sqlite3_mprintf("non-query: [%s]", sqlite3_sql(pStmt));
1256	sqlite3_finalize(pStmt);
1257	sqlite3_result_error(context, zMsg, -1);
1258	sqlite3_free(zMsg);
1259	return;
1260	}
1261	nCol = sqlite3_column_count(pStmt);
1262	z = sqlite3_sql(pStmt);
1263	if( z==0 ){
1264	sqlite3_finalize(pStmt);
1265	continue;
1266	}
1267	n = (int)strlen(z);
1268	hash_step_vformat(&cx,"S%d:",n);
1269	SHA3Update(&cx,(unsigned char*)z,n);
1270
1271	/* Compute a hash over the result of the query */
1272	while( SQLITE_ROW==sqlite3_step(pStmt) ){
1273	SHA3Update(&cx,(const unsigned char*)"R",1);
1274	for(i=0; i<nCol; i++){
1275	switch( sqlite3_column_type(pStmt,i) ){
1276	case SQLITE_NULL: {
1277	SHA3Update(&cx, (const unsigned char*)"N",1);
1278	break;
1279	}
1280	case SQLITE_INTEGER: {
1281	sqlite3_uint64 u;
1282	int j;
1283	unsigned char x[9];
1284	sqlite3_int64 v = sqlite3_column_int64(pStmt,i);
1285	memcpy(&u, &v, 8);
1286	for(j=8; j>=1; j--){
1287	x[j] = u & 0xff;
1288	u >>= 8;
1289	}
1290	x[0] = 'I';
1291	SHA3Update(&cx, x, 9);
1292	break;
1293	}
1294	case SQLITE_FLOAT: {
1295	sqlite3_uint64 u;
1296	int j;
1297	unsigned char x[9];
1298	double r = sqlite3_column_double(pStmt,i);
1299	memcpy(&u, &r, 8);
1300	for(j=8; j>=1; j--){
1301	x[j] = u & 0xff;
1302	u >>= 8;
1303	}
1304	x[0] = 'F';
1305	SHA3Update(&cx,x,9);
1306	break;
1307	}
1308	case SQLITE_TEXT: {
1309	int n2 = sqlite3_column_bytes(pStmt, i);
1310	const unsigned char *z2 = sqlite3_column_text(pStmt, i);
1311	hash_step_vformat(&cx,"T%d:",n2);
1312	SHA3Update(&cx, z2, n2);
1313	break;
1314	}
1315	case SQLITE_BLOB: {
1316	int n2 = sqlite3_column_bytes(pStmt, i);
1317	const unsigned char *z2 = sqlite3_column_blob(pStmt, i);
1318	hash_step_vformat(&cx,"B%d:",n2);
1319	SHA3Update(&cx, z2, n2);
1320	break;
1321	}
1322	}
1323	}
1324	}
1325	sqlite3_finalize(pStmt);
1326	}
1327	sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT);
1328	}
1329	/* End of SHA3 hashing logic copy/pasted from ../ext/misc/shathree.c
1330	********************************************************************************/
1331
1332	#if defined(SQLITE_ENABLE_SESSION)
1333	/*
1334	** State information for a single open session
1335	*/
	@@ -608,17 +1359,14 @@
1359	** instance of the following structure.
1360	*/
1361	typedef struct ShellState ShellState;
1362	struct ShellState {
1363	sqlite3 db; / The database */

1364	int autoExplain; /* Automatically turn on .explain mode */
1365	int autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
1366	int statsOn; /* True to display memory stats before each finalize */
1367	int scanstatsOn; /* True to display scan stats before each finalize */


1368	int outCount; /* Revert to stdout when reaching zero */
1369	int cnt; /* Number of records displayed so far */
1370	FILE out; / Write results here */
1371	FILE traceOut; / Output for sqlite3_trace() */
1372	int nErr; /* Number of errors seen */
	@@ -653,13 +1401,24 @@
1401	};
1402
1403	/*
1404	** These are the allowed shellFlgs values
1405	*/
1406	#define SHFLG_Scratch 0x00000001 /* The --scratch option is used */
1407	#define SHFLG_Pagecache 0x00000002 /* The --pagecache option is used */
1408	#define SHFLG_Lookaside 0x00000004 /* Lookaside memory is used */
1409	#define SHFLG_Backslash 0x00000008 /* The --backslash option is used */
1410	#define SHFLG_PreserveRowid 0x00000010 /* .dump preserves rowid values */
1411	#define SHFLG_CountChanges 0x00000020 /* .changes setting */
1412	#define SHFLG_Echo 0x00000040 /* .echo or --echo setting */
1413
1414	/*
1415	** Macros for testing and setting shellFlgs
1416	*/
1417	#define ShellHasFlag(P,X) (((P)->shellFlgs & (X))!=0)
1418	#define ShellSetFlag(P,X) ((P)->shellFlgs\|=(X))
1419	#define ShellClearFlag(P,X) ((P)->shellFlgs&=(~(X)))
1420
1421	/*
1422	** These are the allowed modes.
1423	*/
1424	#define MODE_Line 0 /* One column per line. Blank line between records */
	@@ -1292,92 +2051,106 @@
2051	*/
2052	static int callback(void pArg, int nArg, char azArg, char *azCol){
2053	/* since we don't have type info, call the shell_callback with a NULL value */
2054	return shell_callback(pArg, nArg, azArg, azCol, NULL);
2055	}
2056
2057	/*
2058	** This is the callback routine from sqlite3_exec() that appends all
2059	** output onto the end of a ShellText object.
2060	*/
2061	static int captureOutputCallback(void pArg, int nArg, char azArg, char *az){
2062	ShellText p = (ShellText)pArg;
2063	int i;
2064	if( p->n ) appendText(p, "\|", 0);
2065	for(i=0; i<nArg; i++){
2066	if( i ) appendText(p, ",", 0);
2067	if( azArg[i] ) appendText(p, azArg[i], 0);
2068	}
2069	return 0;
2070	}
2071
2072	/*
2073	** Generate an appropriate SELFTEST table in the main database.
2074	*/
2075	static void createSelftestTable(ShellState *p){
2076	char *zErrMsg = 0;
2077	sqlite3_exec(p->db,
2078	"SAVEPOINT selftest_init;\n"
2079	"CREATE TABLE IF NOT EXISTS selftest(\n"
2080	" tno INTEGER PRIMARY KEY,\n" /* Test number */
2081	" op TEXT,\n" /* Operator: memo run */
2082	" cmd TEXT,\n" /* Command text */
2083	" ans TEXT\n" /* Desired answer */
2084	");"
2085	"CREATE TEMP TABLE [_shell$self](op,cmd,ans);\n"
2086	"INSERT INTO [_shell$self](rowid,op,cmd)\n"
2087	" VALUES(coalesce((SELECT (max(tno)+100)/10 FROM selftest),10),\n"
2088	" 'memo','Tests generated by --init');\n"
2089	"INSERT INTO [_shell$self]\n"
2090	" SELECT 'run',\n"
2091	" 'SELECT hex(sha3_query(''SELECT type,name,tbl_name,sql "
2092	"FROM sqlite_master ORDER BY 2'',224))',\n"
2093	" hex(sha3_query('SELECT type,name,tbl_name,sql "
2094	"FROM sqlite_master ORDER BY 2',224));\n"
2095	"INSERT INTO [_shell$self]\n"
2096	" SELECT 'run',"
2097	" 'SELECT hex(sha3_query(''SELECT * FROM \"' \|\|"
2098	" printf('%w',name) \|\| '\" NOT INDEXED'',224))',\n"
2099	" hex(sha3_query(printf('SELECT * FROM \"%w\" NOT INDEXED',name),224))\n"
2100	" FROM (\n"
2101	" SELECT name FROM sqlite_master\n"
2102	" WHERE type='table'\n"
2103	" AND name<>'selftest'\n"
2104	" AND coalesce(rootpage,0)>0\n"
2105	" )\n"
2106	" ORDER BY name;\n"
2107	"INSERT INTO [_shell$self]\n"
2108	" VALUES('run','PRAGMA integrity_check','ok');\n"
2109	"INSERT INTO selftest(tno,op,cmd,ans)"
2110	" SELECT rowid*10,op,cmd,ans FROM [_shell$self];\n"
2111	"DROP TABLE [_shell$self];"
2112	,0,0,&zErrMsg);
2113	if( zErrMsg ){
2114	utf8_printf(stderr, "SELFTEST initialization failure: %s\n", zErrMsg);
2115	sqlite3_free(zErrMsg);
2116	}
2117	sqlite3_exec(p->db, "RELEASE selftest_init",0,0,0);
2118	}
2119
2120
2121	/*
2122	** Set the destination table field of the ShellState structure to
2123	** the name of the table given. Escape any quote characters in the
2124	** table name.
2125	*/
2126	static void set_table_name(ShellState p, const char zName){
2127	int i, n;
2128	int cQuote;
2129	char *z;
2130
2131	if( p->zDestTable ){
2132	free(p->zDestTable);
2133	p->zDestTable = 0;
2134	}
2135	if( zName==0 ) return;
2136	cQuote = quoteChar(zName);
2137	n = strlen30(zName);
2138	if( cQuote ) n += 2;





2139	z = p->zDestTable = malloc( n+1 );
2140	if( z==0 ){
2141	raw_printf(stderr,"Error: out of memory\n");
2142	exit(1);
2143	}
2144	n = 0;
2145	if( cQuote ) z[n++] = cQuote;
2146	for(i=0; zName[i]; i++){
2147	z[n++] = zName[i];
2148	if( zName[i]==cQuote ) z[n++] = cQuote;
2149	}
2150	if( cQuote ) z[n++] = cQuote;
2151	z[n] = 0;













































2152	}
2153
2154
2155	/*
2156	** Execute a query statement that will generate SQL output. Print
	@@ -1484,10 +2257,35 @@
2257	}
2258	fclose(in);
2259	}
2260	#endif
2261
2262	/*
2263	** Display a single line of status using 64-bit values.
2264	*/
2265	static void displayStatLine(
2266	ShellState p, / The shell context */
2267	char zLabel, / Label for this one line */
2268	char zFormat, / Format for the result */
2269	int iStatusCtrl, /* Which status to display */
2270	int bReset /* True to reset the stats */
2271	){
2272	sqlite3_int64 iCur = -1;
2273	sqlite3_int64 iHiwtr = -1;
2274	int i, nPercent;
2275	char zLine[200];
2276	sqlite3_status64(iStatusCtrl, &iCur, &iHiwtr, bReset);
2277	for(i=0, nPercent=0; zFormat[i]; i++){
2278	if( zFormat[i]=='%' ) nPercent++;
2279	}
2280	if( nPercent>1 ){
2281	sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iCur, iHiwtr);
2282	}else{
2283	sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iHiwtr);
2284	}
2285	raw_printf(p->out, "%-36s %s\n", zLabel, zLine);
2286	}
2287
2288	/*
2289	** Display memory stats.
2290	*/
2291	static int display_stats(
	@@ -1497,61 +2295,35 @@
2295	){
2296	int iCur;
2297	int iHiwtr;
2298
2299	if( pArg && pArg->out ){
2300	displayStatLine(pArg, "Memory Used:",
2301	"%lld (max %lld) bytes", SQLITE_STATUS_MEMORY_USED, bReset);
2302	displayStatLine(pArg, "Number of Outstanding Allocations:",
2303	"%lld (max %lld)", SQLITE_STATUS_MALLOC_COUNT, bReset);






2304	if( pArg->shellFlgs & SHFLG_Pagecache ){
2305	displayStatLine(pArg, "Number of Pcache Pages Used:",
2306	"%lld (max %lld) pages", SQLITE_STATUS_PAGECACHE_USED, bReset);
2307	}
2308	displayStatLine(pArg, "Number of Pcache Overflow Bytes:",
2309	"%lld (max %lld) bytes", SQLITE_STATUS_PAGECACHE_OVERFLOW, bReset);






2310	if( pArg->shellFlgs & SHFLG_Scratch ){
2311	displayStatLine(pArg, "Number of Scratch Allocations Used:",
2312	"%lld (max %lld)", SQLITE_STATUS_SCRATCH_USED, bReset);
2313	}
2314	displayStatLine(pArg, "Number of Scratch Overflow Bytes:",
2315	"%lld (max %lld) bytes", SQLITE_STATUS_SCRATCH_OVERFLOW, bReset);
2316	displayStatLine(pArg, "Largest Allocation:",
2317	"%lld bytes", SQLITE_STATUS_MALLOC_SIZE, bReset);
2318	displayStatLine(pArg, "Largest Pcache Allocation:",
2319	"%lld bytes", SQLITE_STATUS_PAGECACHE_SIZE, bReset);
2320	displayStatLine(pArg, "Largest Scratch Allocation:",
2321	"%lld bytes", SQLITE_STATUS_SCRATCH_SIZE, bReset);












2322	#ifdef YYTRACKMAXSTACKDEPTH
2323	displayStatLine(pArg, "Deepest Parser Stack:",
2324	"%lld (max %lld)", SQLITE_STATUS_PARSER_STACK, bReset);


2325	#endif
2326	}
2327
2328	if( pArg && pArg->out && db ){
2329	if( pArg->shellFlgs & SHFLG_Lookaside ){
	@@ -1934,11 +2706,11 @@
2706	pArg->pStmt = pStmt;
2707	pArg->cnt = 0;
2708	}
2709
2710	/* echo the sql statement if echo on */
2711	if( pArg && ShellHasFlag(pArg, SHFLG_Echo) ){
2712	utf8_printf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
2713	}
2714
2715	/* Show the EXPLAIN QUERY PLAN if .eqp is on */
2716	if( pArg && pArg->autoEQP && sqlite3_strlike("EXPLAIN%",zStmtSql,0)!=0 ){
	@@ -2022,10 +2794,142 @@
2794	} /* end while */
2795
2796	return rc;
2797	}
2798
2799	/*
2800	** Release memory previously allocated by tableColumnList().
2801	*/
2802	static void freeColumnList(char **azCol){
2803	int i;
2804	for(i=1; azCol[i]; i++){
2805	sqlite3_free(azCol[i]);
2806	}
2807	/* azCol[0] is a static string */
2808	sqlite3_free(azCol);
2809	}
2810
2811	/*
2812	** Return a list of pointers to strings which are the names of all
2813	** columns in table zTab. The memory to hold the names is dynamically
2814	** allocated and must be released by the caller using a subsequent call
2815	** to freeColumnList().
2816	**
2817	** The azCol[0] entry is usually NULL. However, if zTab contains a rowid
2818	** value that needs to be preserved, then azCol[0] is filled in with the
2819	** name of the rowid column.
2820	**
2821	** The first regular column in the table is azCol[1]. The list is terminated
2822	** by an entry with azCol[i]==0.
2823	*/
2824	static char *tableColumnList(ShellState p, const char *zTab){
2825	char **azCol = 0;
2826	sqlite3_stmt *pStmt;
2827	char *zSql;
2828	int nCol = 0;
2829	int nAlloc = 0;
2830	int nPK = 0; /* Number of PRIMARY KEY columns seen */
2831	int isIPK = 0; /* True if one PRIMARY KEY column of type INTEGER */
2832	int preserveRowid = ShellHasFlag(p, SHFLG_PreserveRowid);
2833	int rc;
2834
2835	zSql = sqlite3_mprintf("PRAGMA table_info=%Q", zTab);
2836	rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2837	sqlite3_free(zSql);
2838	if( rc ) return 0;
2839	while( sqlite3_step(pStmt)==SQLITE_ROW ){
2840	if( nCol>=nAlloc-2 ){
2841	nAlloc = nAlloc*2 + nCol + 10;
2842	azCol = sqlite3_realloc(azCol, nAlloc*sizeof(azCol[0]));
2843	if( azCol==0 ){
2844	raw_printf(stderr, "Error: out of memory\n");
2845	exit(1);
2846	}
2847	}
2848	azCol[++nCol] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 1));
2849	if( sqlite3_column_int(pStmt, 5) ){
2850	nPK++;
2851	if( nPK==1
2852	&& sqlite3_stricmp((const char*)sqlite3_column_text(pStmt,2),
2853	"INTEGER")==0
2854	){
2855	isIPK = 1;
2856	}else{
2857	isIPK = 0;
2858	}
2859	}
2860	}
2861	sqlite3_finalize(pStmt);
2862	azCol[0] = 0;
2863	azCol[nCol+1] = 0;
2864
2865	/* The decision of whether or not a rowid really needs to be preserved
2866	** is tricky. We never need to preserve a rowid for a WITHOUT ROWID table
2867	** or a table with an INTEGER PRIMARY KEY. We are unable to preserve
2868	** rowids on tables where the rowid is inaccessible because there are other
2869	** columns in the table named "rowid", "_rowid_", and "oid".
2870	*/
2871	if( preserveRowid && isIPK ){
2872	/* If a single PRIMARY KEY column with type INTEGER was seen, then it
2873	** might be an alise for the ROWID. But it might also be a WITHOUT ROWID
2874	** table or a INTEGER PRIMARY KEY DESC column, neither of which are
2875	** ROWID aliases. To distinguish these cases, check to see if
2876	** there is a "pk" entry in "PRAGMA index_list". There will be
2877	** no "pk" index if the PRIMARY KEY really is an alias for the ROWID.
2878	*/
2879	zSql = sqlite3_mprintf("SELECT 1 FROM pragma_index_list(%Q)"
2880	" WHERE origin='pk'", zTab);
2881	rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
2882	sqlite3_free(zSql);
2883	if( rc ){
2884	freeColumnList(azCol);
2885	return 0;
2886	}
2887	rc = sqlite3_step(pStmt);
2888	sqlite3_finalize(pStmt);
2889	preserveRowid = rc==SQLITE_ROW;
2890	}
2891	if( preserveRowid ){
2892	/* Only preserve the rowid if we can find a name to use for the
2893	** rowid */
2894	static char *azRowid[] = { "rowid", "_rowid_", "oid" };
2895	int i, j;
2896	for(j=0; j<3; j++){
2897	for(i=1; i<=nCol; i++){
2898	if( sqlite3_stricmp(azRowid[j],azCol[i])==0 ) break;
2899	}
2900	if( i>nCol ){
2901	/* At this point, we know that azRowid[j] is not the name of any
2902	** ordinary column in the table. Verify that azRowid[j] is a valid
2903	** name for the rowid before adding it to azCol[0]. WITHOUT ROWID
2904	** tables will fail this last check */
2905	int rc;
2906	rc = sqlite3_table_column_metadata(p->db,0,zTab,azRowid[j],0,0,0,0,0);
2907	if( rc==SQLITE_OK ) azCol[0] = azRowid[j];
2908	break;
2909	}
2910	}
2911	}
2912	return azCol;
2913	}
2914
2915	/*
2916	** Toggle the reverse_unordered_selects setting.
2917	*/
2918	static void toggleSelectOrder(sqlite3 *db){
2919	sqlite3_stmt *pStmt = 0;
2920	int iSetting = 0;
2921	char zStmt[100];
2922	sqlite3_prepare_v2(db, "PRAGMA reverse_unordered_selects", -1, &pStmt, 0);
2923	if( sqlite3_step(pStmt)==SQLITE_ROW ){
2924	iSetting = sqlite3_column_int(pStmt, 0);
2925	}
2926	sqlite3_finalize(pStmt);
2927	sqlite3_snprintf(sizeof(zStmt), zStmt,
2928	"PRAGMA reverse_unordered_selects(%d)", !iSetting);
2929	sqlite3_exec(db, zStmt, 0, 0, 0);
2930	}
2931
2932	/*
2933	** This is a different callback routine used for dumping the database.
2934	** Each row received by this callback consists of a table name,
2935	** the table type ("index" or "table") and SQL to create the table.
	@@ -2034,21 +2938,20 @@
2938	static int dump_callback(void pArg, int nArg, char azArg, char *azCol){
2939	int rc;
2940	const char *zTable;
2941	const char *zType;
2942	const char *zSql;

2943	ShellState p = (ShellState )pArg;
2944
2945	UNUSED_PARAMETER(azCol);
2946	if( nArg!=3 ) return 1;
2947	zTable = azArg[0];
2948	zType = azArg[1];
2949	zSql = azArg[2];
2950
2951	if( strcmp(zTable, "sqlite_sequence")==0 ){
2952	raw_printf(p->out, "DELETE FROM sqlite_sequence;\n");
2953	}else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
2954	raw_printf(p->out, "ANALYZE sqlite_master;\n");
2955	}else if( strncmp(zTable, "sqlite_", 7)==0 ){
2956	return 0;
2957	}else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
	@@ -2067,62 +2970,74 @@
2970	}else{
2971	printSchemaLine(p->out, zSql, ";\n");
2972	}
2973
2974	if( strcmp(zType, "table")==0 ){
2975	ShellText sSelect;
2976	ShellText sTable;
2977	char **azCol;
2978	int i;
2979	char *savedDestTable;
2980	int savedMode;
2981
2982	azCol = tableColumnList(p, zTable);
2983	if( azCol==0 ){
2984	p->nErr++;
2985	return 0;
2986	}
2987




2988	/* Always quote the table name, even if it appears to be pure ascii,
2989	** in case it is a keyword. Ex: INSERT INTO "table" ... */
2990	initText(&sTable);
2991	appendText(&sTable, zTable, quoteChar(zTable));
2992	/* If preserving the rowid, add a column list after the table name.
2993	** In other words: "INSERT INTO tab(rowid,a,b,c,...) VALUES(...)"
2994	** instead of the usual "INSERT INTO tab VALUES(...)".
2995	*/
2996	if( azCol[0] ){
2997	appendText(&sTable, "(", 0);
2998	appendText(&sTable, azCol[0], 0);
2999	for(i=1; azCol[i]; i++){
3000	appendText(&sTable, ",", 0);
3001	appendText(&sTable, azCol[i], quoteChar(azCol[i]));
3002	}
3003	appendText(&sTable, ")", 0);
3004	}
3005
3006	/* Build an appropriate SELECT statement */
3007	initText(&sSelect);
3008	appendText(&sSelect, "SELECT ", 0);
3009	if( azCol[0] ){
3010	appendText(&sSelect, azCol[0], 0);
3011	appendText(&sSelect, ",", 0);
3012	}
3013	for(i=1; azCol[i]; i++){
3014	appendText(&sSelect, azCol[i], quoteChar(azCol[i]));
3015	if( azCol[i+1] ){
3016	appendText(&sSelect, ",", 0);
3017	}
3018	}
3019	freeColumnList(azCol);
3020	appendText(&sSelect, " FROM ", 0);
3021	appendText(&sSelect, zTable, quoteChar(zTable));
3022
3023	savedDestTable = p->zDestTable;
3024	savedMode = p->mode;
3025	p->zDestTable = sTable.z;
3026	p->mode = p->cMode = MODE_Insert;
3027	rc = shell_exec(p->db, sSelect.z, shell_callback, p, 0);
3028	if( (rc&0xff)==SQLITE_CORRUPT ){
3029	raw_printf(p->out, "/**** CORRUPTION ERROR *****/\n");
3030	toggleSelectOrder(p->db);
3031	shell_exec(p->db, sSelect.z, shell_callback, p, 0);
3032	toggleSelectOrder(p->db);
3033	}
3034	p->zDestTable = savedDestTable;
3035	p->mode = savedMode;
3036	freeText(&sTable);
3037	freeText(&sSelect);
3038	if( rc ) p->nErr++;
3039	}
3040	return 0;
3041	}
3042
3043	/*
	@@ -2233,10 +3148,11 @@
3148	".separator COL ?ROW? Change the column separator and optionally the row\n"
3149	" separator for both the output mode and .import\n"
3150	#if defined(SQLITE_ENABLE_SESSION)
3151	".session CMD ... Create or control sessions\n"
3152	#endif
3153	".sha3sum ?OPTIONS...? Compute a SHA3 hash of database content\n"
3154	".shell CMD ARGS... Run CMD ARGS... in a system shell\n"
3155	".show Show the current values for various settings\n"
3156	".stats ?on\|off? Show stats or turn stats on or off\n"
3157	".system CMD ARGS... Run CMD ARGS... in a system shell\n"
3158	".tables ?TABLE? List names of tables\n"
	@@ -2423,14 +3339,10 @@
3339	static void open_db(ShellState *p, int keepAlive){
3340	if( p->db==0 ){
3341	sqlite3_initialize();
3342	sqlite3_open(p->zDbFilename, &p->db);
3343	globalDb = p->db;




3344	if( p->db==0 \|\| SQLITE_OK!=sqlite3_errcode(p->db) ){
3345	utf8_printf(stderr,"Error: unable to open database \"%s\": %s\n",
3346	p->zDbFilename, sqlite3_errmsg(p->db));
3347	if( keepAlive ) return;
3348	exit(1);
	@@ -2440,10 +3352,18 @@
3352	#endif
3353	sqlite3_create_function(p->db, "readfile", 1, SQLITE_UTF8, 0,
3354	readfileFunc, 0, 0);
3355	sqlite3_create_function(p->db, "writefile", 2, SQLITE_UTF8, 0,
3356	writefileFunc, 0, 0);
3357	sqlite3_create_function(p->db, "sha3", 1, SQLITE_UTF8, 0,
3358	sha3Func, 0, 0);
3359	sqlite3_create_function(p->db, "sha3", 2, SQLITE_UTF8, 0,
3360	sha3Func, 0, 0);
3361	sqlite3_create_function(p->db, "sha3_query", 1, SQLITE_UTF8, 0,
3362	sha3QueryFunc, 0, 0);
3363	sqlite3_create_function(p->db, "sha3_query", 2, SQLITE_UTF8, 0,
3364	sha3QueryFunc, 0, 0);
3365	}
3366	}
3367
3368	/*
3369	** Do C-language style dequoting.
	@@ -2564,11 +3484,11 @@
3484
3485	/*
3486	** Interpret zArg as either an integer or a boolean value. Return 1 or 0
3487	** for TRUE and FALSE. Return the integer value if appropriate.
3488	*/
3489	static int booleanValue(const char *zArg){
3490	int i;
3491	if( zArg[0]=='0' && zArg[1]=='x' ){
3492	for(i=2; hexDigitValue(zArg[i])>=0; i++){}
3493	}else{
3494	for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
	@@ -2582,10 +3502,21 @@
3502	}
3503	utf8_printf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
3504	zArg);
3505	return 0;
3506	}
3507
3508	/*
3509	** Set or clear a shell flag according to a boolean value.
3510	*/
3511	static void setOrClearFlag(ShellState p, unsigned mFlag, const char zArg){
3512	if( booleanValue(zArg) ){
3513	ShellSetFlag(p, mFlag);
3514	}else{
3515	ShellClearFlag(p, mFlag);
3516	}
3517	}
3518
3519	/*
3520	** Close an output file, assuming it is not stderr or stdout
3521	*/
3522	static void output_file_close(FILE *f){
	@@ -3656,11 +4587,11 @@
4587	test_breakpoint();
4588	}else
4589
4590	if( c=='c' && n>=3 && strncmp(azArg[0], "changes", n)==0 ){
4591	if( nArg==2 ){
4592	setOrClearFlag(p, SHFLG_CountChanges, azArg[1]);
4593	}else{
4594	raw_printf(stderr, "Usage: .changes on\|off\n");
4595	rc = 1;
4596	}
4597	}else
	@@ -3720,25 +4651,46 @@
4651	if( c=='d' && strncmp(azArg[0], "dbinfo", n)==0 ){
4652	rc = shell_dbinfo_command(p, nArg, azArg);
4653	}else
4654
4655	if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
4656	const char *zLike = 0;
4657	int i;
4658	ShellClearFlag(p, SHFLG_PreserveRowid);
4659	for(i=1; i<nArg; i++){
4660	if( azArg[i][0]=='-' ){
4661	const char *z = azArg[i]+1;
4662	if( z[0]=='-' ) z++;
4663	if( strcmp(z,"preserve-rowids")==0 ){
4664	ShellSetFlag(p, SHFLG_PreserveRowid);
4665	}else
4666	{
4667	raw_printf(stderr, "Unknown option \"%s\" on \".dump\"\n", azArg[i]);
4668	rc = 1;
4669	goto meta_command_exit;
4670	}
4671	}else if( zLike ){
4672	raw_printf(stderr, "Usage: .dump ?--preserve-rowids? ?LIKE-PATTERN?\n");
4673	rc = 1;
4674	goto meta_command_exit;
4675	}else{
4676	zLike = azArg[i];
4677	}
4678	}
4679	open_db(p, 0);
4680	/* When playing back a "dump", the content might appear in an order
4681	** which causes immediate foreign key constraints to be violated.
4682	** So disable foreign-key constraint enforcement to prevent problems. */





4683	raw_printf(p->out, "PRAGMA foreign_keys=OFF;\n");
4684	raw_printf(p->out, "BEGIN TRANSACTION;\n");
4685	p->writableSchema = 0;
4686	/* Set writable_schema=ON since doing so forces SQLite to initialize
4687	** as much of the schema as it can even if the sqlite_master table is
4688	** corrupt. */
4689	sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
4690	p->nErr = 0;
4691	if( zLike==0 ){
4692	run_schema_dump_query(p,
4693	"SELECT name, type, sql FROM sqlite_master "
4694	"WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
4695	);
4696	run_schema_dump_query(p,
	@@ -3748,25 +4700,24 @@
4700	run_table_dump_query(p,
4701	"SELECT sql FROM sqlite_master "
4702	"WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
4703	);
4704	}else{
4705	char *zSql;
4706	zSql = sqlite3_mprintf(
4707	"SELECT name, type, sql FROM sqlite_master "
4708	"WHERE tbl_name LIKE %Q AND type=='table'"
4709	" AND sql NOT NULL", zLike);
4710	run_schema_dump_query(p,zSql);
4711	sqlite3_free(zSql);
4712	zSql = sqlite3_mprintf(
4713	"SELECT sql FROM sqlite_master "
4714	"WHERE sql NOT NULL"
4715	" AND type IN ('index','trigger','view')"
4716	" AND tbl_name LIKE %Q", zLike);
4717	run_table_dump_query(p, zSql, 0);
4718	sqlite3_free(zSql);

4719	}
4720	if( p->writableSchema ){
4721	raw_printf(p->out, "PRAGMA writable_schema=OFF;\n");
4722	p->writableSchema = 0;
4723	}
	@@ -3775,11 +4726,11 @@
4726	raw_printf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
4727	}else
4728
4729	if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){
4730	if( nArg==2 ){
4731	setOrClearFlag(p, SHFLG_Echo, azArg[1]);
4732	}else{
4733	raw_printf(stderr, "Usage: .echo on\|off\n");
4734	rc = 1;
4735	}
4736	}else
	@@ -4572,21 +5523,21 @@
5523	new_colv[0] = "sql";
5524	new_colv[1] = 0;
5525	callback(&data, 1, new_argv, new_colv);
5526	rc = SQLITE_OK;
5527	}else{
5528	char *zSql;
5529	zSql = sqlite3_mprintf(
5530	"SELECT sql FROM "
5531	" (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
5532	" FROM sqlite_master UNION ALL"
5533	" SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
5534	"WHERE lower(tbl_name) LIKE %Q"
5535	" AND type!='meta' AND sql NOTNULL "
5536	"ORDER BY rowid", azArg[1]);
5537	rc = sqlite3_exec(p->db, zSql, callback, &data, &zErrMsg);
5538	sqlite3_free(zSql);
5539	}
5540	}else if( nArg==1 ){
5541	rc = sqlite3_exec(p->db,
5542	"SELECT sql FROM "
5543	" (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
	@@ -4835,10 +5786,123 @@
5786	utf8_printf(p->out, "%s", zBuf);
5787	}
5788	}
5789	}else
5790	#endif
5791
5792	if( c=='s' && n>=4 && strncmp(azArg[0],"selftest",n)==0 ){
5793	int bIsInit = 0; /* True to initialize the SELFTEST table */
5794	int bVerbose = 0; /* Verbose output */
5795	int bSelftestExists; /* True if SELFTEST already exists */
5796	char *azTest = 0; / Content of the SELFTEST table */
5797	int nRow = 0; /* Number of rows in the SELFTEST table */
5798	int nCol = 4; /* Number of columns in the SELFTEST table */
5799	int i; /* Loop counter */
5800	int nTest = 0; /* Number of tests runs */
5801	int nErr = 0; /* Number of errors seen */
5802	ShellText str; /* Answer for a query */
5803	static char *azDefaultTest[] = {
5804	0, 0, 0, 0,
5805	"0", "memo", "Missing SELFTEST table - default checks only", "",
5806	"1", "run", "PRAGMA integrity_check", "ok"
5807	};
5808	static const int nDefaultRow = 2;
5809
5810	open_db(p,0);
5811	for(i=1; i<nArg; i++){
5812	const char *z = azArg[i];
5813	if( z[0]=='-' && z[1]=='-' ) z++;
5814	if( strcmp(z,"-init")==0 ){
5815	bIsInit = 1;
5816	}else
5817	if( strcmp(z,"-v")==0 ){
5818	bVerbose++;
5819	}else
5820	{
5821	utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
5822	azArg[i], azArg[0]);
5823	raw_printf(stderr, "Should be one of: --init -v\n");
5824	rc = 1;
5825	goto meta_command_exit;
5826	}
5827	}
5828	if( sqlite3_table_column_metadata(p->db,"main","selftest",0,0,0,0,0,0)
5829	!= SQLITE_OK ){
5830	bSelftestExists = 0;
5831	}else{
5832	bSelftestExists = 1;
5833	}
5834	if( bIsInit ){
5835	createSelftestTable(p);
5836	bSelftestExists = 1;
5837	}
5838	if( bSelftestExists ){
5839	rc = sqlite3_get_table(p->db,
5840	"SELECT tno,op,cmd,ans FROM selftest ORDER BY tno",
5841	&azTest, &nRow, &nCol, 0);
5842	if( rc ){
5843	raw_printf(stderr, "Error querying the selftest table\n");
5844	rc = 1;
5845	sqlite3_free_table(azTest);
5846	goto meta_command_exit;
5847	}else if( nRow==0 ){
5848	sqlite3_free_table(azTest);
5849	azTest = azDefaultTest;
5850	nRow = nDefaultRow;
5851	}
5852	}else{
5853	azTest = azDefaultTest;
5854	nRow = nDefaultRow;
5855	}
5856	initText(&str);
5857	appendText(&str, "x", 0);
5858	for(i=1; i<=nRow; i++){
5859	int tno = atoi(azTest[i*nCol]);
5860	const char zOp = azTest[inCol+1];
5861	const char zSql = azTest[inCol+2];
5862	const char zAns = azTest[inCol+3];
5863
5864	if( bVerbose>0 ){
5865	char *zQuote = sqlite3_mprintf("%q", zSql);
5866	printf("%d: %s %s\n", tno, zOp, zSql);
5867	sqlite3_free(zQuote);
5868	}
5869	if( strcmp(zOp,"memo")==0 ){
5870	utf8_printf(p->out, "%s\n", zSql);
5871	}else
5872	if( strcmp(zOp,"run")==0 ){
5873	char *zErrMsg = 0;
5874	str.n = 0;
5875	str.z[0] = 0;
5876	rc = sqlite3_exec(p->db, zSql, captureOutputCallback, &str, &zErrMsg);
5877	nTest++;
5878	if( bVerbose ){
5879	utf8_printf(p->out, "Result: %s\n", str.z);
5880	}
5881	if( rc \|\| zErrMsg ){
5882	nErr++;
5883	rc = 1;
5884	utf8_printf(p->out, "%d: error-code-%d: %s\n", tno, rc, zErrMsg);
5885	sqlite3_free(zErrMsg);
5886	}else if( strcmp(zAns,str.z)!=0 ){
5887	nErr++;
5888	rc = 1;
5889	utf8_printf(p->out, "%d: Expected: [%s]\n", tno, zAns);
5890	utf8_printf(p->out, "%d: Got: [%s]\n", tno, str.z);
5891	}
5892	}else
5893	{
5894	utf8_printf(stderr,
5895	"Unknown operation \"%s\" on selftest line %d\n", zOp, tno);
5896	rc = 1;
5897	break;
5898	}
5899	}
5900	freeText(&str);
5901	if( azTest!=azDefaultTest ) sqlite3_free_table(azTest);
5902	utf8_printf(p->out, "%d errors out of %d tests\n", nErr, nTest);
5903	}else
5904
5905	if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){
5906	if( nArg<2 \|\| nArg>3 ){
5907	raw_printf(stderr, "Usage: .separator COL ?ROW?\n");
5908	rc = 1;
	@@ -4850,10 +5914,126 @@
5914	if( nArg>=3 ){
5915	sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator,
5916	"%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]);
5917	}
5918	}else
5919
5920	if( c=='s' && n>=4 && strncmp(azArg[0],"sha3sum",n)==0 ){
5921	const char zLike = 0; / Which table to checksum. 0 means everything */
5922	int i; /* Loop counter */
5923	int bSchema = 0; /* Also hash the schema */
5924	int bSeparate = 0; /* Hash each table separately */
5925	int iSize = 224; /* Hash algorithm to use */
5926	int bDebug = 0; /* Only show the query that would have run */
5927	sqlite3_stmt pStmt; / For querying tables names */
5928	char zSql; / SQL to be run */
5929	char zSep; / Separator */
5930	ShellText sSql; /* Complete SQL for the query to run the hash */
5931	ShellText sQuery; /* Set of queries used to read all content */
5932	open_db(p, 0);
5933	for(i=1; i<nArg; i++){
5934	const char *z = azArg[i];
5935	if( z[0]=='-' ){
5936	z++;
5937	if( z[0]=='-' ) z++;
5938	if( strcmp(z,"schema")==0 ){
5939	bSchema = 1;
5940	}else
5941	if( strcmp(z,"sha3-224")==0 \|\| strcmp(z,"sha3-256")==0
5942	\|\| strcmp(z,"sha3-384")==0 \|\| strcmp(z,"sha3-512")==0
5943	){
5944	iSize = atoi(&z[5]);
5945	}else
5946	if( strcmp(z,"debug")==0 ){
5947	bDebug = 1;
5948	}else
5949	{
5950	utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
5951	azArg[i], azArg[0]);
5952	raw_printf(stderr, "Should be one of: --schema"
5953	" --sha3-224 --sha3-255 --sha3-384 --sha3-512\n");
5954	rc = 1;
5955	goto meta_command_exit;
5956	}
5957	}else if( zLike ){
5958	raw_printf(stderr, "Usage: .sha3sum ?OPTIONS? ?LIKE-PATTERN?\n");
5959	rc = 1;
5960	goto meta_command_exit;
5961	}else{
5962	zLike = z;
5963	bSeparate = 1;
5964	if( sqlite3_strlike("sqlite_%", zLike, 0)==0 ) bSchema = 1;
5965	}
5966	}
5967	if( bSchema ){
5968	zSql = "SELECT lower(name) FROM sqlite_master"
5969	" WHERE type='table' AND coalesce(rootpage,0)>1"
5970	" UNION ALL SELECT 'sqlite_master'"
5971	" ORDER BY 1 collate nocase";
5972	}else{
5973	zSql = "SELECT lower(name) FROM sqlite_master"
5974	" WHERE type='table' AND coalesce(rootpage,0)>1"
5975	" AND name NOT LIKE 'sqlite_%'"
5976	" ORDER BY 1 collate nocase";
5977	}
5978	sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
5979	initText(&sQuery);
5980	initText(&sSql);
5981	appendText(&sSql, "WITH [sha3sum$query](a,b) AS(",0);
5982	zSep = "VALUES(";
5983	while( SQLITE_ROW==sqlite3_step(pStmt) ){
5984	const char zTab = (const char)sqlite3_column_text(pStmt,0);
5985	if( zLike && sqlite3_strlike(zLike, zTab, 0)!=0 ) continue;
5986	if( strncmp(zTab, "sqlite_",7)!=0 ){
5987	appendText(&sQuery,"SELECT * FROM ", 0);
5988	appendText(&sQuery,zTab,'"');
5989	appendText(&sQuery," NOT INDEXED;", 0);
5990	}else if( strcmp(zTab, "sqlite_master")==0 ){
5991	appendText(&sQuery,"SELECT type,name,tbl_name,sql FROM sqlite_master"
5992	" ORDER BY name;", 0);
5993	}else if( strcmp(zTab, "sqlite_sequence")==0 ){
5994	appendText(&sQuery,"SELECT name,seq FROM sqlite_sequence"
5995	" ORDER BY name;", 0);
5996	}else if( strcmp(zTab, "sqlite_stat1")==0 ){
5997	appendText(&sQuery,"SELECT tbl,idx,stat FROM sqlite_stat1"
5998	" ORDER BY tbl,idx;", 0);
5999	}else if( strcmp(zTab, "sqlite_stat3")==0
6000	\|\| strcmp(zTab, "sqlite_stat4")==0 ){
6001	appendText(&sQuery, "SELECT * FROM ", 0);
6002	appendText(&sQuery, zTab, 0);
6003	appendText(&sQuery, " ORDER BY tbl, idx, rowid;\n", 0);
6004	}
6005	appendText(&sSql, zSep, 0);
6006	appendText(&sSql, sQuery.z, '\'');
6007	sQuery.n = 0;
6008	appendText(&sSql, ",", 0);
6009	appendText(&sSql, zTab, '\'');
6010	zSep = "),(";
6011	}
6012	sqlite3_finalize(pStmt);
6013	if( bSeparate ){
6014	zSql = sqlite3_mprintf(
6015	"%s))"
6016	" SELECT lower(hex(sha3_query(a,%d))) AS hash, b AS label"
6017	" FROM [sha3sum$query]",
6018	sSql.z, iSize);
6019	}else{
6020	zSql = sqlite3_mprintf(
6021	"%s))"
6022	" SELECT lower(hex(sha3_query(group_concat(a,''),%d))) AS hash"
6023	" FROM [sha3sum$query]",
6024	sSql.z, iSize);
6025	}
6026	freeText(&sQuery);
6027	freeText(&sSql);
6028	if( bDebug ){
6029	utf8_printf(p->out, "%s\n", zSql);
6030	}else{
6031	shell_exec(p->db, zSql, shell_callback, p, 0);
6032	}
6033	sqlite3_free(zSql);
6034	}else
6035
6036	if( c=='s'
6037	&& (strncmp(azArg[0], "shell", n)==0 \|\| strncmp(azArg[0],"system",n)==0)
6038	){
6039	char *zCmd;
	@@ -4879,11 +6059,12 @@
6059	if( nArg!=1 ){
6060	raw_printf(stderr, "Usage: .show\n");
6061	rc = 1;
6062	goto meta_command_exit;
6063	}
6064	utf8_printf(p->out, "%12.12s: %s\n","echo",
6065	azBool[ShellHasFlag(p, SHFLG_Echo)]);
6066	utf8_printf(p->out, "%12.12s: %s\n","eqp", azBool[p->autoEQP&3]);
6067	utf8_printf(p->out, "%12.12s: %s\n","explain",
6068	p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off");
6069	utf8_printf(p->out,"%12.12s: %s\n","headers", azBool[p->showHeader!=0]);
6070	utf8_printf(p->out, "%12.12s: %s\n","mode", modeDescr[p->mode]);
	@@ -5444,11 +6625,11 @@
6625	static int runOneSqlLine(ShellState p, char zSql, FILE *in, int startline){
6626	int rc;
6627	char *zErrMsg = 0;
6628
6629	open_db(p, 0);
6630	if( ShellHasFlag(p,SHFLG_Backslash) ) resolve_backslashes(zSql);
6631	BEGIN_TIMER;
6632	rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
6633	END_TIMER;
6634	if( rc \|\| zErrMsg ){
6635	char zPrefix[100];
	@@ -5464,11 +6645,11 @@
6645	zErrMsg = 0;
6646	}else{
6647	utf8_printf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
6648	}
6649	return 1;
6650	}else if( ShellHasFlag(p, SHFLG_CountChanges) ){
6651	raw_printf(p->out, "changes: %3d total_changes: %d\n",
6652	sqlite3_changes(p->db), sqlite3_total_changes(p->db));
6653	}
6654	return 0;
6655	}
	@@ -5507,15 +6688,15 @@
6688	if( in!=0 ) break;
6689	seenInterrupt = 0;
6690	}
6691	lineno++;
6692	if( nSql==0 && _all_whitespace(zLine) ){
6693	if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
6694	continue;
6695	}
6696	if( zLine && zLine[0]=='.' && nSql==0 ){
6697	if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
6698	rc = do_meta_command(zLine, p);
6699	if( rc==2 ){ /* exit requested */
6700	break;
6701	}else if( rc ){
6702	errCnt++;
	@@ -5554,11 +6735,11 @@
6735	if( p->outCount ){
6736	output_reset(p);
6737	p->outCount = 0;
6738	}
6739	}else if( nSql && _all_whitespace(zSql) ){
6740	if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zSql);
6741	nSql = 0;
6742	}
6743	}
6744	if( nSql && !_all_whitespace(zSql) ){
6745	runOneSqlLine(p, zSql, in, startline);
	@@ -6023,11 +7204,11 @@
7204	}else if( strcmp(z,"-header")==0 ){
7205	data.showHeader = 1;
7206	}else if( strcmp(z,"-noheader")==0 ){
7207	data.showHeader = 0;
7208	}else if( strcmp(z,"-echo")==0 ){
7209	ShellSetFlag(&data, SHFLG_Echo);
7210	}else if( strcmp(z,"-eqp")==0 ){
7211	data.autoEQP = 1;
7212	}else if( strcmp(z,"-eqpfull")==0 ){
7213	data.autoEQP = 2;
7214	}else if( strcmp(z,"-stats")==0 ){
	@@ -6038,11 +7219,11 @@
7219	/* Undocumented command-line option: -backslash
7220	** Causes C-style backslash escapes to be evaluated in SQL statements
7221	** prior to sending the SQL into SQLite. Useful for injecting
7222	** crazy bytes in the middle of SQL statements for testing and debugging.
7223	*/
7224	ShellSetFlag(&data, SHFLG_Backslash);
7225	}else if( strcmp(z,"-bail")==0 ){
7226	bail_on_error = 1;
7227	}else if( strcmp(z,"-version")==0 ){
7228	printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
7229	return 0;
7230

M src/sqlite3.c

+1515 -987

		--- src/sqlite3.c
		+++ src/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.17.0. By combining all the individual C code files into this
	3	+** version 3.18.0. 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.
		@@ -396,13 +396,13 @@
396	396	**
397	397	** See also: [sqlite3_libversion()],
398	398	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
399	399	** [sqlite_version()] and [sqlite_source_id()].
400	400	*/
401		-#define SQLITE_VERSION "3.17.0"
402		-#define SQLITE_VERSION_NUMBER 3017000
403		-#define SQLITE_SOURCE_ID "2017-02-13 16:02:40 ada05cfa86ad7f5645450ac7a2a21c9aa6e57d2c"
	401	+#define SQLITE_VERSION "3.18.0"
	402	+#define SQLITE_VERSION_NUMBER 3018000
	403	+#define SQLITE_SOURCE_ID "2017-03-10 17:03:11 f8560c60d10c0365b33342ab05b5a953987b0471"
404	404
405	405	/*
406	406	** CAPI3REF: Run-Time Library Version Numbers
407	407	** KEYWORDS: sqlite3_version sqlite3_sourceid
408	408	**
		@@ -2315,24 +2315,34 @@
2315	2315	** as an undeclared column named ROWID, OID, or _ROWID_ as long as those
2316	2316	** names are not also used by explicitly declared columns. ^If
2317	2317	** the table has a column of type [INTEGER PRIMARY KEY] then that column
2318	2318	** is another alias for the rowid.
2319	2319	**
2320		-** ^The sqlite3_last_insert_rowid(D) interface returns the [rowid] of the
2321		-** most recent successful [INSERT] into a rowid table or [virtual table]
2322		-** on database connection D.
2323		-** ^Inserts into [WITHOUT ROWID] tables are not recorded.
2324		-** ^If no successful [INSERT]s into rowid tables
2325		-** have ever occurred on the database connection D,
2326		-** then sqlite3_last_insert_rowid(D) returns zero.
	2320	+** ^The sqlite3_last_insert_rowid(D) interface usually returns the [rowid] of
	2321	+** the most recent successful [INSERT] into a rowid table or [virtual table]
	2322	+** on database connection D. ^Inserts into [WITHOUT ROWID] tables are not
	2323	+** recorded. ^If no successful [INSERT]s into rowid tables have ever occurred
	2324	+** on the database connection D, then sqlite3_last_insert_rowid(D) returns
	2325	+** zero.
2327	2326	**
2328		-** ^(If an [INSERT] occurs within a trigger or within a [virtual table]
2329		-** method, then this routine will return the [rowid] of the inserted
2330		-** row as long as the trigger or virtual table method is running.
2331		-** But once the trigger or virtual table method ends, the value returned
2332		-** by this routine reverts to what it was before the trigger or virtual
2333		-** table method began.)^
	2327	+** As well as being set automatically as rows are inserted into database
	2328	+** tables, the value returned by this function may be set explicitly by
	2329	+** [sqlite3_set_last_insert_rowid()]
	2330	+**
	2331	+** Some virtual table implementations may INSERT rows into rowid tables as
	2332	+** part of committing a transaction (e.g. to flush data accumulated in memory
	2333	+** to disk). In this case subsequent calls to this function return the rowid
	2334	+** associated with these internal INSERT operations, which leads to
	2335	+** unintuitive results. Virtual table implementations that do write to rowid
	2336	+** tables in this way can avoid this problem by restoring the original
	2337	+** rowid value using [sqlite3_set_last_insert_rowid()] before returning
	2338	+** control to the user.
	2339	+**
	2340	+** ^(If an [INSERT] occurs within a trigger then this routine will
	2341	+** return the [rowid] of the inserted row as long as the trigger is
	2342	+** running. Once the trigger program ends, the value returned
	2343	+** by this routine reverts to what it was before the trigger was fired.)^
2334	2344	**
2335	2345	** ^An [INSERT] that fails due to a constraint violation is not a
2336	2346	** successful [INSERT] and does not change the value returned by this
2337	2347	** routine. ^Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK,
2338	2348	** and INSERT OR ABORT make no changes to the return value of this
		@@ -2355,10 +2365,20 @@
2355	2365	** unpredictable and might not equal either the old or the new
2356	2366	** last insert [rowid].
2357	2367	*/
2358	2368	SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);
2359	2369
	2370	+/*
	2371	+** CAPI3REF: Set the Last Insert Rowid value.
	2372	+** METHOD: sqlite3
	2373	+**
	2374	+** The sqlite3_set_last_insert_rowid(D, R) method allows the application to
	2375	+** set the value returned by calling sqlite3_last_insert_rowid(D) to R
	2376	+** without inserting a row into the database.
	2377	+*/
	2378	+SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3*,sqlite3_int64);
	2379	+
2360	2380	/*
2361	2381	** CAPI3REF: Count The Number Of Rows Modified
2362	2382	** METHOD: sqlite3
2363	2383	**
2364	2384	** ^This function returns the number of rows modified, inserted or
		@@ -12457,10 +12477,11 @@
12457	12477	SQLITE_PRIVATE const void sqlite3BtreePayloadFetch(BtCursor, u32 *pAmt);
12458	12478	SQLITE_PRIVATE u32 sqlite3BtreePayloadSize(BtCursor*);
12459	12479
12460	12480	SQLITE_PRIVATE char sqlite3BtreeIntegrityCheck(Btree, int aRoot, int nRoot, int, int);
12461	12481	SQLITE_PRIVATE struct Pager sqlite3BtreePager(Btree);
	12482	+SQLITE_PRIVATE i64 sqlite3BtreeRowCountEst(BtCursor*);
12462	12483
12463	12484	#ifndef SQLITE_OMIT_INCRBLOB
12464	12485	SQLITE_PRIVATE int sqlite3BtreePayloadChecked(BtCursor, u32 offset, u32 amt, void);
12465	12486	SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor, u32 offset, u32 amt, void);
12466	12487	SQLITE_PRIVATE void sqlite3BtreeIncrblobCursor(BtCursor *);
		@@ -12757,117 +12778,119 @@
12757	12778	#define OP_Divide 50 /* same as TK_SLASH, synopsis: r[P3]=r[P2]/r[P1] */
12758	12779	#define OP_Remainder 51 /* same as TK_REM, synopsis: r[P3]=r[P2]%r[P1] */
12759	12780	#define OP_Concat 52 /* same as TK_CONCAT, synopsis: r[P3]=r[P2]+r[P1] */
12760	12781	#define OP_Last 53
12761	12782	#define OP_BitNot 54 /* same as TK_BITNOT, synopsis: r[P1]= ~r[P1] */
12762		-#define OP_SorterSort 55
12763		-#define OP_Sort 56
12764		-#define OP_Rewind 57
12765		-#define OP_IdxLE 58 /* synopsis: key=r[P3@P4] */
12766		-#define OP_IdxGT 59 /* synopsis: key=r[P3@P4] */
12767		-#define OP_IdxLT 60 /* synopsis: key=r[P3@P4] */
12768		-#define OP_IdxGE 61 /* synopsis: key=r[P3@P4] */
12769		-#define OP_RowSetRead 62 /* synopsis: r[P3]=rowset(P1) */
12770		-#define OP_RowSetTest 63 /* synopsis: if r[P3] in rowset(P1) goto P2 */
12771		-#define OP_Program 64
12772		-#define OP_FkIfZero 65 /* synopsis: if fkctr[P1]==0 goto P2 */
12773		-#define OP_IfPos 66 /* synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 */
12774		-#define OP_IfNotZero 67 /* synopsis: if r[P1]!=0 then r[P1]--, goto P2 */
12775		-#define OP_DecrJumpZero 68 /* synopsis: if (--r[P1])==0 goto P2 */
12776		-#define OP_IncrVacuum 69
12777		-#define OP_VNext 70
12778		-#define OP_Init 71 /* synopsis: Start at P2 */
12779		-#define OP_Return 72
12780		-#define OP_EndCoroutine 73
12781		-#define OP_HaltIfNull 74 /* synopsis: if r[P3]=null halt */
12782		-#define OP_Halt 75
12783		-#define OP_Integer 76 /* synopsis: r[P2]=P1 */
12784		-#define OP_Int64 77 /* synopsis: r[P2]=P4 */
12785		-#define OP_String 78 /* synopsis: r[P2]='P4' (len=P1) */
12786		-#define OP_Null 79 /* synopsis: r[P2..P3]=NULL */
12787		-#define OP_SoftNull 80 /* synopsis: r[P1]=NULL */
12788		-#define OP_Blob 81 /* synopsis: r[P2]=P4 (len=P1) */
12789		-#define OP_Variable 82 /* synopsis: r[P2]=parameter(P1,P4) */
12790		-#define OP_Move 83 /* synopsis: r[P2@P3]=r[P1@P3] */
12791		-#define OP_Copy 84 /* synopsis: r[P2@P3+1]=r[P1@P3+1] */
12792		-#define OP_SCopy 85 /* synopsis: r[P2]=r[P1] */
12793		-#define OP_IntCopy 86 /* synopsis: r[P2]=r[P1] */
12794		-#define OP_ResultRow 87 /* synopsis: output=r[P1@P2] */
12795		-#define OP_CollSeq 88
12796		-#define OP_Function0 89 /* synopsis: r[P3]=func(r[P2@P5]) */
12797		-#define OP_Function 90 /* synopsis: r[P3]=func(r[P2@P5]) */
12798		-#define OP_AddImm 91 /* synopsis: r[P1]=r[P1]+P2 */
12799		-#define OP_RealAffinity 92
12800		-#define OP_Cast 93 /* synopsis: affinity(r[P1]) */
12801		-#define OP_Permutation 94
12802		-#define OP_Compare 95 /* synopsis: r[P1@P3] <-> r[P2@P3] */
12803		-#define OP_Column 96 /* synopsis: r[P3]=PX */
	12783	+#define OP_IfSmaller 55
	12784	+#define OP_SorterSort 56
	12785	+#define OP_Sort 57
	12786	+#define OP_Rewind 58
	12787	+#define OP_IdxLE 59 /* synopsis: key=r[P3@P4] */
	12788	+#define OP_IdxGT 60 /* synopsis: key=r[P3@P4] */
	12789	+#define OP_IdxLT 61 /* synopsis: key=r[P3@P4] */
	12790	+#define OP_IdxGE 62 /* synopsis: key=r[P3@P4] */
	12791	+#define OP_RowSetRead 63 /* synopsis: r[P3]=rowset(P1) */
	12792	+#define OP_RowSetTest 64 /* synopsis: if r[P3] in rowset(P1) goto P2 */
	12793	+#define OP_Program 65
	12794	+#define OP_FkIfZero 66 /* synopsis: if fkctr[P1]==0 goto P2 */
	12795	+#define OP_IfPos 67 /* synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 */
	12796	+#define OP_IfNotZero 68 /* synopsis: if r[P1]!=0 then r[P1]--, goto P2 */
	12797	+#define OP_DecrJumpZero 69 /* synopsis: if (--r[P1])==0 goto P2 */
	12798	+#define OP_IncrVacuum 70
	12799	+#define OP_VNext 71
	12800	+#define OP_Init 72 /* synopsis: Start at P2 */
	12801	+#define OP_Return 73
	12802	+#define OP_EndCoroutine 74
	12803	+#define OP_HaltIfNull 75 /* synopsis: if r[P3]=null halt */
	12804	+#define OP_Halt 76
	12805	+#define OP_Integer 77 /* synopsis: r[P2]=P1 */
	12806	+#define OP_Int64 78 /* synopsis: r[P2]=P4 */
	12807	+#define OP_String 79 /* synopsis: r[P2]='P4' (len=P1) */
	12808	+#define OP_Null 80 /* synopsis: r[P2..P3]=NULL */
	12809	+#define OP_SoftNull 81 /* synopsis: r[P1]=NULL */
	12810	+#define OP_Blob 82 /* synopsis: r[P2]=P4 (len=P1) */
	12811	+#define OP_Variable 83 /* synopsis: r[P2]=parameter(P1,P4) */
	12812	+#define OP_Move 84 /* synopsis: r[P2@P3]=r[P1@P3] */
	12813	+#define OP_Copy 85 /* synopsis: r[P2@P3+1]=r[P1@P3+1] */
	12814	+#define OP_SCopy 86 /* synopsis: r[P2]=r[P1] */
	12815	+#define OP_IntCopy 87 /* synopsis: r[P2]=r[P1] */
	12816	+#define OP_ResultRow 88 /* synopsis: output=r[P1@P2] */
	12817	+#define OP_CollSeq 89
	12818	+#define OP_Function0 90 /* synopsis: r[P3]=func(r[P2@P5]) */
	12819	+#define OP_Function 91 /* synopsis: r[P3]=func(r[P2@P5]) */
	12820	+#define OP_AddImm 92 /* synopsis: r[P1]=r[P1]+P2 */
	12821	+#define OP_RealAffinity 93
	12822	+#define OP_Cast 94 /* synopsis: affinity(r[P1]) */
	12823	+#define OP_Permutation 95
	12824	+#define OP_Compare 96 /* synopsis: r[P1@P3] <-> r[P2@P3] */
12804	12825	#define OP_String8 97 /* same as TK_STRING, synopsis: r[P2]='P4' */
12805		-#define OP_Affinity 98 /* synopsis: affinity(r[P1@P2]) */
12806		-#define OP_MakeRecord 99 /* synopsis: r[P3]=mkrec(r[P1@P2]) */
12807		-#define OP_Count 100 /* synopsis: r[P2]=count() */
12808		-#define OP_ReadCookie 101
12809		-#define OP_SetCookie 102
12810		-#define OP_ReopenIdx 103 /* synopsis: root=P2 iDb=P3 */
12811		-#define OP_OpenRead 104 /* synopsis: root=P2 iDb=P3 */
12812		-#define OP_OpenWrite 105 /* synopsis: root=P2 iDb=P3 */
12813		-#define OP_OpenAutoindex 106 /* synopsis: nColumn=P2 */
12814		-#define OP_OpenEphemeral 107 /* synopsis: nColumn=P2 */
12815		-#define OP_SorterOpen 108
12816		-#define OP_SequenceTest 109 /* synopsis: if( cursor[P1].ctr++ ) pc = P2 */
12817		-#define OP_OpenPseudo 110 /* synopsis: P3 columns in r[P2] */
12818		-#define OP_Close 111
12819		-#define OP_ColumnsUsed 112
12820		-#define OP_Sequence 113 /* synopsis: r[P2]=cursor[P1].ctr++ */
12821		-#define OP_NewRowid 114 /* synopsis: r[P2]=rowid */
12822		-#define OP_Insert 115 /* synopsis: intkey=r[P3] data=r[P2] */
12823		-#define OP_InsertInt 116 /* synopsis: intkey=P3 data=r[P2] */
12824		-#define OP_Delete 117
12825		-#define OP_ResetCount 118
12826		-#define OP_SorterCompare 119 /* synopsis: if key(P1)!=trim(r[P3],P4) goto P2 */
12827		-#define OP_SorterData 120 /* synopsis: r[P2]=data */
12828		-#define OP_RowData 121 /* synopsis: r[P2]=data */
12829		-#define OP_Rowid 122 /* synopsis: r[P2]=rowid */
12830		-#define OP_NullRow 123
12831		-#define OP_SorterInsert 124 /* synopsis: key=r[P2] */
12832		-#define OP_IdxInsert 125 /* synopsis: key=r[P2] */
12833		-#define OP_IdxDelete 126 /* synopsis: key=r[P2@P3] */
12834		-#define OP_Seek 127 /* synopsis: Move P3 to P1.rowid */
12835		-#define OP_IdxRowid 128 /* synopsis: r[P2]=rowid */
12836		-#define OP_Destroy 129
12837		-#define OP_Clear 130
12838		-#define OP_ResetSorter 131
	12826	+#define OP_Column 98 /* synopsis: r[P3]=PX */
	12827	+#define OP_Affinity 99 /* synopsis: affinity(r[P1@P2]) */
	12828	+#define OP_MakeRecord 100 /* synopsis: r[P3]=mkrec(r[P1@P2]) */
	12829	+#define OP_Count 101 /* synopsis: r[P2]=count() */
	12830	+#define OP_ReadCookie 102
	12831	+#define OP_SetCookie 103
	12832	+#define OP_ReopenIdx 104 /* synopsis: root=P2 iDb=P3 */
	12833	+#define OP_OpenRead 105 /* synopsis: root=P2 iDb=P3 */
	12834	+#define OP_OpenWrite 106 /* synopsis: root=P2 iDb=P3 */
	12835	+#define OP_OpenAutoindex 107 /* synopsis: nColumn=P2 */
	12836	+#define OP_OpenEphemeral 108 /* synopsis: nColumn=P2 */
	12837	+#define OP_SorterOpen 109
	12838	+#define OP_SequenceTest 110 /* synopsis: if( cursor[P1].ctr++ ) pc = P2 */
	12839	+#define OP_OpenPseudo 111 /* synopsis: P3 columns in r[P2] */
	12840	+#define OP_Close 112
	12841	+#define OP_ColumnsUsed 113
	12842	+#define OP_Sequence 114 /* synopsis: r[P2]=cursor[P1].ctr++ */
	12843	+#define OP_NewRowid 115 /* synopsis: r[P2]=rowid */
	12844	+#define OP_Insert 116 /* synopsis: intkey=r[P3] data=r[P2] */
	12845	+#define OP_InsertInt 117 /* synopsis: intkey=P3 data=r[P2] */
	12846	+#define OP_Delete 118
	12847	+#define OP_ResetCount 119
	12848	+#define OP_SorterCompare 120 /* synopsis: if key(P1)!=trim(r[P3],P4) goto P2 */
	12849	+#define OP_SorterData 121 /* synopsis: r[P2]=data */
	12850	+#define OP_RowData 122 /* synopsis: r[P2]=data */
	12851	+#define OP_Rowid 123 /* synopsis: r[P2]=rowid */
	12852	+#define OP_NullRow 124
	12853	+#define OP_SorterInsert 125 /* synopsis: key=r[P2] */
	12854	+#define OP_IdxInsert 126 /* synopsis: key=r[P2] */
	12855	+#define OP_IdxDelete 127 /* synopsis: key=r[P2@P3] */
	12856	+#define OP_Seek 128 /* synopsis: Move P3 to P1.rowid */
	12857	+#define OP_IdxRowid 129 /* synopsis: r[P2]=rowid */
	12858	+#define OP_Destroy 130
	12859	+#define OP_Clear 131
12839	12860	#define OP_Real 132 /* same as TK_FLOAT, synopsis: r[P2]=P4 */
12840		-#define OP_CreateIndex 133 /* synopsis: r[P2]=root iDb=P1 */
12841		-#define OP_CreateTable 134 /* synopsis: r[P2]=root iDb=P1 */
12842		-#define OP_ParseSchema 135
12843		-#define OP_LoadAnalysis 136
12844		-#define OP_DropTable 137
12845		-#define OP_DropIndex 138
12846		-#define OP_DropTrigger 139
12847		-#define OP_IntegrityCk 140
12848		-#define OP_RowSetAdd 141 /* synopsis: rowset(P1)=r[P2] */
12849		-#define OP_Param 142
12850		-#define OP_FkCounter 143 /* synopsis: fkctr[P1]+=P2 */
12851		-#define OP_MemMax 144 /* synopsis: r[P1]=max(r[P1],r[P2]) */
12852		-#define OP_OffsetLimit 145 /* synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1) */
12853		-#define OP_AggStep0 146 /* synopsis: accum=r[P3] step(r[P2@P5]) */
12854		-#define OP_AggStep 147 /* synopsis: accum=r[P3] step(r[P2@P5]) */
12855		-#define OP_AggFinal 148 /* synopsis: accum=r[P1] N=P2 */
12856		-#define OP_Expire 149
12857		-#define OP_TableLock 150 /* synopsis: iDb=P1 root=P2 write=P3 */
12858		-#define OP_VBegin 151
12859		-#define OP_VCreate 152
12860		-#define OP_VDestroy 153
12861		-#define OP_VOpen 154
12862		-#define OP_VColumn 155 /* synopsis: r[P3]=vcolumn(P2) */
12863		-#define OP_VRename 156
12864		-#define OP_Pagecount 157
12865		-#define OP_MaxPgcnt 158
12866		-#define OP_CursorHint 159
12867		-#define OP_Noop 160
12868		-#define OP_Explain 161
	12861	+#define OP_ResetSorter 133
	12862	+#define OP_CreateIndex 134 /* synopsis: r[P2]=root iDb=P1 */
	12863	+#define OP_CreateTable 135 /* synopsis: r[P2]=root iDb=P1 */
	12864	+#define OP_SqlExec 136
	12865	+#define OP_ParseSchema 137
	12866	+#define OP_LoadAnalysis 138
	12867	+#define OP_DropTable 139
	12868	+#define OP_DropIndex 140
	12869	+#define OP_DropTrigger 141
	12870	+#define OP_IntegrityCk 142
	12871	+#define OP_RowSetAdd 143 /* synopsis: rowset(P1)=r[P2] */
	12872	+#define OP_Param 144
	12873	+#define OP_FkCounter 145 /* synopsis: fkctr[P1]+=P2 */
	12874	+#define OP_MemMax 146 /* synopsis: r[P1]=max(r[P1],r[P2]) */
	12875	+#define OP_OffsetLimit 147 /* synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1) */
	12876	+#define OP_AggStep0 148 /* synopsis: accum=r[P3] step(r[P2@P5]) */
	12877	+#define OP_AggStep 149 /* synopsis: accum=r[P3] step(r[P2@P5]) */
	12878	+#define OP_AggFinal 150 /* synopsis: accum=r[P1] N=P2 */
	12879	+#define OP_Expire 151
	12880	+#define OP_TableLock 152 /* synopsis: iDb=P1 root=P2 write=P3 */
	12881	+#define OP_VBegin 153
	12882	+#define OP_VCreate 154
	12883	+#define OP_VDestroy 155
	12884	+#define OP_VOpen 156
	12885	+#define OP_VColumn 157 /* synopsis: r[P3]=vcolumn(P2) */
	12886	+#define OP_VRename 158
	12887	+#define OP_Pagecount 159
	12888	+#define OP_MaxPgcnt 160
	12889	+#define OP_CursorHint 161
	12890	+#define OP_Noop 162
	12891	+#define OP_Explain 163
12869	12892
12870	12893	/* Properties such as "out2" or "jump" that are specified in
12871	12894	** comments following the "case" for each opcode in the vdbe.c
12872	12895	** are encoded into bitvectors as follows:
12873	12896	*/
		@@ -12883,32 +12906,32 @@
12883	12906	/* 16 */ 0x03, 0x03, 0x01, 0x12, 0x01, 0x03, 0x03, 0x09,\
12884	12907	/* 24 */ 0x09, 0x09, 0x09, 0x26, 0x26, 0x09, 0x09, 0x09,\
12885	12908	/* 32 */ 0x09, 0x09, 0x03, 0x03, 0x0b, 0x0b, 0x0b, 0x0b,\
12886	12909	/* 40 */ 0x0b, 0x0b, 0x01, 0x26, 0x26, 0x26, 0x26, 0x26,\
12887	12910	/* 48 */ 0x26, 0x26, 0x26, 0x26, 0x26, 0x01, 0x12, 0x01,\
12888		-/* 56 */ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x23, 0x0b,\
12889		-/* 64 */ 0x01, 0x01, 0x03, 0x03, 0x03, 0x01, 0x01, 0x01,\
12890		-/* 72 */ 0x02, 0x02, 0x08, 0x00, 0x10, 0x10, 0x10, 0x10,\
12891		-/* 80 */ 0x00, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10, 0x00,\
12892		-/* 88 */ 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x00, 0x00,\
12893		-/* 96 */ 0x00, 0x10, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00,\
	12911	+/* 56 */ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x23,\
	12912	+/* 64 */ 0x0b, 0x01, 0x01, 0x03, 0x03, 0x03, 0x01, 0x01,\
	12913	+/* 72 */ 0x01, 0x02, 0x02, 0x08, 0x00, 0x10, 0x10, 0x10,\
	12914	+/* 80 */ 0x10, 0x00, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10,\
	12915	+/* 88 */ 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x00,\
	12916	+/* 96 */ 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00,\
12894	12917	/* 104 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
12895		-/* 112 */ 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,\
12896		-/* 120 */ 0x00, 0x00, 0x10, 0x00, 0x04, 0x04, 0x00, 0x00,\
12897		-/* 128 */ 0x10, 0x10, 0x00, 0x00, 0x10, 0x10, 0x10, 0x00,\
12898		-/* 136 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x10, 0x00,\
12899		-/* 144 */ 0x04, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
12900		-/* 152 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00,\
12901		-/* 160 */ 0x00, 0x00,}
	12918	+/* 112 */ 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,\
	12919	+/* 120 */ 0x00, 0x00, 0x00, 0x10, 0x00, 0x04, 0x04, 0x00,\
	12920	+/* 128 */ 0x00, 0x10, 0x10, 0x00, 0x10, 0x00, 0x10, 0x10,\
	12921	+/* 136 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,\
	12922	+/* 144 */ 0x10, 0x00, 0x04, 0x1a, 0x00, 0x00, 0x00, 0x00,\
	12923	+/* 152 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,\
	12924	+/* 160 */ 0x10, 0x00, 0x00, 0x00,}
12902	12925
12903	12926	/* The sqlite3P2Values() routine is able to run faster if it knows
12904	12927	** the value of the largest JUMP opcode. The smaller the maximum
12905	12928	** JUMP opcode the better, so the mkopcodeh.tcl script that
12906	12929	** generated this include file strives to group all JUMP opcodes
12907	12930	** together near the beginning of the list.
12908	12931	*/
12909		-#define SQLITE_MX_JUMP_OPCODE 71 /* Maximum JUMP opcode */
	12932	+#define SQLITE_MX_JUMP_OPCODE 72 /* Maximum JUMP opcode */
12910	12933
12911	12934	/************ End of opcodes.h *******************************************/
12912	12935	/************ Continuing where we left off in vdbe.h *********************/
12913	12936
12914	12937	/*
		@@ -14074,10 +14097,11 @@
14074	14097	u8 suppressErr; /* Do not issue error messages if true */
14075	14098	u8 vtabOnConflict; /* Value to return for s3_vtab_on_conflict() */
14076	14099	u8 isTransactionSavepoint; /* True if the outermost savepoint is a TS */
14077	14100	u8 mTrace; /* zero or more SQLITE_TRACE flags */
14078	14101	u8 skipBtreeMutex; /* True if no shared-cache backends */
	14102	+ u8 nSqlExec; /* Number of pending OP_SqlExec opcodes */
14079	14103	int nextPagesize; /* Pagesize after VACUUM if >0 */
14080	14104	u32 magic; /* Magic number for detect library misuse */
14081	14105	int nChange; /* Value returned by sqlite3_changes() */
14082	14106	int nTotalChange; /* Value returned by sqlite3_total_changes() */
14083	14107	int aLimit[SQLITE_N_LIMIT]; /* Limits */
		@@ -14589,18 +14613,18 @@
14589	14613	char zColAff; / String defining the affinity of each column */
14590	14614	ExprList pCheck; / All CHECK constraints */
14591	14615	/* ... also used as column name list in a VIEW */
14592	14616	int tnum; /* Root BTree page for this table */
14593	14617	u32 nTabRef; /* Number of pointers to this Table */
	14618	+ u32 tabFlags; /* Mask of TF_* values */
14594	14619	i16 iPKey; /* If not negative, use aCol[iPKey] as the rowid */
14595	14620	i16 nCol; /* Number of columns in this table */
14596	14621	LogEst nRowLogEst; /* Estimated rows in table - from sqlite_stat1 table */
14597	14622	LogEst szTabRow; /* Estimated size of each table row in bytes */
14598	14623	#ifdef SQLITE_ENABLE_COSTMULT
14599	14624	LogEst costMult; /* Cost multiplier for using this table */
14600	14625	#endif
14601		- u8 tabFlags; /* Mask of TF_* values */
14602	14626	u8 keyConf; /* What to do in case of uniqueness conflict on iPKey */
14603	14627	#ifndef SQLITE_OMIT_ALTERTABLE
14604	14628	int addColOffset; /* Offset in CREATE TABLE stmt to add a new column */
14605	14629	#endif
14606	14630	#ifndef SQLITE_OMIT_VIRTUALTABLE
		@@ -14620,27 +14644,29 @@
14620	14644	** followed by non-hidden columns. Example: "CREATE VIRTUAL TABLE x USING
14621	14645	** vtab1(a HIDDEN, b);". Since "b" is a non-hidden column but "a" is hidden,
14622	14646	** the TF_OOOHidden attribute would apply in this case. Such tables require
14623	14647	** special handling during INSERT processing.
14624	14648	*/
14625		-#define TF_Readonly 0x01 /* Read-only system table */
14626		-#define TF_Ephemeral 0x02 /* An ephemeral table */
14627		-#define TF_HasPrimaryKey 0x04 /* Table has a primary key */
14628		-#define TF_Autoincrement 0x08 /* Integer primary key is autoincrement */
14629		-#define TF_Virtual 0x10 /* Is a virtual table */
14630		-#define TF_WithoutRowid 0x20 /* No rowid. PRIMARY KEY is the key */
14631		-#define TF_NoVisibleRowid 0x40 /* No user-visible "rowid" column */
14632		-#define TF_OOOHidden 0x80 /* Out-of-Order hidden columns */
14633		-
	14649	+#define TF_Readonly 0x0001 /* Read-only system table */
	14650	+#define TF_Ephemeral 0x0002 /* An ephemeral table */
	14651	+#define TF_HasPrimaryKey 0x0004 /* Table has a primary key */
	14652	+#define TF_Autoincrement 0x0008 /* Integer primary key is autoincrement */
	14653	+#define TF_HasStat1 0x0010 /* nRowLogEst set from sqlite_stat1 */
	14654	+#define TF_WithoutRowid 0x0020 /* No rowid. PRIMARY KEY is the key */
	14655	+#define TF_NoVisibleRowid 0x0040 /* No user-visible "rowid" column */
	14656	+#define TF_OOOHidden 0x0080 /* Out-of-Order hidden columns */
	14657	+#define TF_StatsUsed 0x0100 /* Query planner decisions affected by
	14658	+ ** Index.aiRowLogEst[] values */
	14659	+#define TF_HasNotNull 0x0200 /* Contains NOT NULL constraints */
14634	14660
14635	14661	/*
14636	14662	** Test to see whether or not a table is a virtual table. This is
14637	14663	** done as a macro so that it will be optimized out when virtual
14638	14664	** table support is omitted from the build.
14639	14665	*/
14640	14666	#ifndef SQLITE_OMIT_VIRTUALTABLE
14641		-# define IsVirtual(X) (((X)->tabFlags & TF_Virtual)!=0)
	14667	+# define IsVirtual(X) ((X)->nModuleArg)
14642	14668	#else
14643	14669	# define IsVirtual(X) 0
14644	14670	#endif
14645	14671
14646	14672	/*
		@@ -14871,10 +14897,11 @@
14871	14897	unsigned bUnordered:1; /* Use this index for == or IN queries only */
14872	14898	unsigned uniqNotNull:1; /* True if UNIQUE and NOT NULL for all columns */
14873	14899	unsigned isResized:1; /* True if resizeIndexObject() has been called */
14874	14900	unsigned isCovering:1; /* True if this is a covering index */
14875	14901	unsigned noSkipScan:1; /* Do not try to use skip-scan if true */
	14902	+ unsigned hasStat1:1; /* aiRowLogEst values come from sqlite_stat1 */
14876	14903	#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
14877	14904	int nSample; /* Number of elements in aSample[] */
14878	14905	int nSampleCol; /* Size of IndexSample.anEq[] and so on */
14879	14906	tRowcnt aAvgEq; / Average nEq values for keys not in aSample */
14880	14907	IndexSample aSample; / Samples of the left-most key */
		@@ -15181,11 +15208,11 @@
15181	15208	** form is used for name resolution with nested FROM clauses.
15182	15209	*/
15183	15210	struct ExprList {
15184	15211	int nExpr; /* Number of expressions on the list */
15185	15212	struct ExprList_item { /* For each expression in the list */
15186		- Expr pExpr; / The list of expressions */
	15213	+ Expr pExpr; / The parse tree for this expression */
15187	15214	char zName; / Token associated with this expression */
15188	15215	char zSpan; / Original text of the expression */
15189	15216	u8 sortOrder; /* 1 for DESC or 0 for ASC */
15190	15217	unsigned done :1; /* A flag to indicate when processing is finished */
15191	15218	unsigned bSpanIsTab :1; /* zSpan holds DB.TABLE.COLUMN */
		@@ -16504,10 +16531,11 @@
16504	16531	SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3,int,const char);
16505	16532	SQLITE_PRIVATE void sqlite3Vacuum(Parse,Token);
16506	16533	SQLITE_PRIVATE int sqlite3RunVacuum(char*, sqlite3, int);
16507	16534	SQLITE_PRIVATE char sqlite3NameFromToken(sqlite3, Token*);
16508	16535	SQLITE_PRIVATE int sqlite3ExprCompare(Expr, Expr, int);
	16536	+SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr, Expr, int);
16509	16537	SQLITE_PRIVATE int sqlite3ExprListCompare(ExprList, ExprList, int);
16510	16538	SQLITE_PRIVATE int sqlite3ExprImpliesExpr(Expr, Expr, int);
16511	16539	SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext, Expr);
16512	16540	SQLITE_PRIVATE void sqlite3ExprAnalyzeAggList(NameContext,ExprList);
16513	16541	SQLITE_PRIVATE int sqlite3ExprCoveredByIndex(Expr, int iCur, Index pIdx);
		@@ -17450,11 +17478,11 @@
17450	17478	"COMPILER=gcc-" __VERSION__,
17451	17479	#endif
17452	17480	#if SQLITE_COVERAGE_TEST
17453	17481	"COVERAGE_TEST",
17454	17482	#endif
17455		-#if SQLITE_DEBUG
	17483	+#ifdef SQLITE_DEBUG
17456	17484	"DEBUG",
17457	17485	#endif
17458	17486	#if SQLITE_DEFAULT_LOCKING_MODE
17459	17487	"DEFAULT_LOCKING_MODE=" CTIMEOPT_VAL(SQLITE_DEFAULT_LOCKING_MODE),
17460	17488	#endif
		@@ -19505,22 +19533,23 @@
19505	19533	**
19506	19534	** Move the date backwards to the beginning of the current day,
19507	19535	** or month or year.
19508	19536	*/
19509	19537	if( sqlite3_strnicmp(z, "start of ", 9)!=0 ) break;
	19538	+ if( !p->validJD && !p->validYMD && !p->validHMS ) break;
19510	19539	z += 9;
19511	19540	computeYMD(p);
19512	19541	p->validHMS = 1;
19513	19542	p->h = p->m = 0;
19514	19543	p->s = 0.0;
	19544	+ p->rawS = 0;
19515	19545	p->validTZ = 0;
19516	19546	p->validJD = 0;
19517	19547	if( sqlite3_stricmp(z,"month")==0 ){
19518	19548	p->D = 1;
19519	19549	rc = 0;
19520	19550	}else if( sqlite3_stricmp(z,"year")==0 ){
19521		- computeYMD(p);
19522	19551	p->M = 1;
19523	19552	p->D = 1;
19524	19553	rc = 0;
19525	19554	}else if( sqlite3_stricmp(z,"day")==0 ){
19526	19555	rc = 0;
		@@ -24050,12 +24079,12 @@
24050	24079	#ifdef SQLITE_DEBUG
24051	24080	assert( p->nRef>0 \|\| p->owner==0 );
24052	24081	p->owner = tid;
24053	24082	p->nRef++;
24054	24083	if( p->trace ){
24055		- OSTRACE(("ENTER-MUTEX tid=%lu, mutex=%p (%d), nRef=%d\n",
24056		- tid, p, p->trace, p->nRef));
	24084	+ OSTRACE(("ENTER-MUTEX tid=%lu, mutex(%d)=%p (%d), nRef=%d\n",
	24085	+ tid, p->id, p, p->trace, p->nRef));
24057	24086	}
24058	24087	#endif
24059	24088	}
24060	24089
24061	24090	static int winMutexTry(sqlite3_mutex *p){
		@@ -24093,12 +24122,12 @@
24093	24122	#else
24094	24123	UNUSED_PARAMETER(p);
24095	24124	#endif
24096	24125	#ifdef SQLITE_DEBUG
24097	24126	if( p->trace ){
24098		- OSTRACE(("TRY-MUTEX tid=%lu, mutex=%p (%d), owner=%lu, nRef=%d, rc=%s\n",
24099		- tid, p, p->trace, p->owner, p->nRef, sqlite3ErrName(rc)));
	24127	+ OSTRACE(("TRY-MUTEX tid=%lu, mutex(%d)=%p (%d), owner=%lu, nRef=%d, rc=%s\n",
	24128	+ tid, p->id, p, p->trace, p->owner, p->nRef, sqlite3ErrName(rc)));
24100	24129	}
24101	24130	#endif
24102	24131	return rc;
24103	24132	}
24104	24133
		@@ -24122,12 +24151,12 @@
24122	24151	#endif
24123	24152	assert( winMutex_isInit==1 );
24124	24153	LeaveCriticalSection(&p->mutex);
24125	24154	#ifdef SQLITE_DEBUG
24126	24155	if( p->trace ){
24127		- OSTRACE(("LEAVE-MUTEX tid=%lu, mutex=%p (%d), nRef=%d\n",
24128		- tid, p, p->trace, p->nRef));
	24156	+ OSTRACE(("LEAVE-MUTEX tid=%lu, mutex(%d)=%p (%d), nRef=%d\n",
	24157	+ tid, p->id, p, p->trace, p->nRef));
24129	24158	}
24130	24159	#endif
24131	24160	}
24132	24161
24133	24162	SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){
		@@ -24383,10 +24412,17 @@
24383	24412	** implementation of malloc_good_size(), which must be called in debug
24384	24413	** mode and specifically when the DMD "Dark Matter Detector" is enabled
24385	24414	** or else a crash results. Hence, do not attempt to optimize out the
24386	24415	** following xRoundup() call. */
24387	24416	nFull = sqlite3GlobalConfig.m.xRoundup(n);
	24417	+
	24418	+#ifdef SQLITE_MAX_MEMORY
	24419	+ if( sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED)+nFull>SQLITE_MAX_MEMORY ){
	24420	+ *pp = 0;
	24421	+ return;
	24422	+ }
	24423	+#endif
24388	24424
24389	24425	sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, n);
24390	24426	if( mem0.alarmThreshold>0 ){
24391	24427	sqlite3_int64 nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
24392	24428	if( nUsed >= mem0.alarmThreshold - nFull ){
		@@ -24572,11 +24608,11 @@
24572	24608	return sqlite3GlobalConfig.m.xSize(p);
24573	24609	}
24574	24610	SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3 db, void p){
24575	24611	assert( p!=0 );
24576	24612	if( db==0 \|\| !isLookaside(db,p) ){
24577		-#if SQLITE_DEBUG
	24613	+#ifdef SQLITE_DEBUG
24578	24614	if( db==0 ){
24579	24615	assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
24580	24616	assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
24581	24617	}else{
24582	24618	assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE\|MEMTYPE_HEAP)) );
		@@ -24633,11 +24669,11 @@
24633	24669	measureAllocationSize(db, p);
24634	24670	return;
24635	24671	}
24636	24672	if( isLookaside(db, p) ){
24637	24673	LookasideSlot pBuf = (LookasideSlot)p;
24638		-#if SQLITE_DEBUG
	24674	+#ifdef SQLITE_DEBUG
24639	24675	/* Trash all content in the buffer being freed */
24640	24676	memset(p, 0xaa, db->lookaside.sz);
24641	24677	#endif
24642	24678	pBuf->pNext = db->lookaside.pFree;
24643	24679	db->lookaside.pFree = pBuf;
		@@ -25002,11 +25038,11 @@
25002	25038
25003	25039	/*
25004	25040	** Conversion types fall into various categories as defined by the
25005	25041	** following enumeration.
25006	25042	*/
25007		-#define etRADIX 0 /* Integer types. %d, %x, %o, and so forth */
	25043	+#define etRADIX 0 /* non-decimal integer types. %x %o */
25008	25044	#define etFLOAT 1 /* Floating point. %f */
25009	25045	#define etEXP 2 /* Exponentional notation. %e and %E */
25010	25046	#define etGENERIC 3 /* Floating or exponential, depending on exponent. %g */
25011	25047	#define etSIZE 4 /* Return number of characters processed so far. %n */
25012	25048	#define etSTRING 5 /* Strings. %s */
		@@ -25020,12 +25056,13 @@
25020	25056	#define etTOKEN 11 /* a pointer to a Token structure */
25021	25057	#define etSRCLIST 12 /* a pointer to a SrcList */
25022	25058	#define etPOINTER 13 /* The %p conversion */
25023	25059	#define etSQLESCAPE3 14 /* %w -> Strings with '\"' doubled */
25024	25060	#define etORDINAL 15 /* %r -> 1st, 2nd, 3rd, 4th, etc. English only */
	25061	+#define etDECIMAL 16 /* %d or %u, but not %x, %o */
25025	25062
25026		-#define etINVALID 16 /* Any unrecognized conversion type */
	25063	+#define etINVALID 17 /* Any unrecognized conversion type */
25027	25064
25028	25065
25029	25066	/*
25030	25067	** An "etByte" is an 8-bit unsigned value.
25031	25068	*/
		@@ -25045,40 +25082,40 @@
25045	25082	} et_info;
25046	25083
25047	25084	/*
25048	25085	** Allowed values for et_info.flags
25049	25086	*/
25050		-#define FLAG_SIGNED 1 /* True if the value to convert is signed */
25051		-#define FLAG_STRING 4 /* Allow infinity precision */
	25087	+#define FLAG_SIGNED 1 /* True if the value to convert is signed */
	25088	+#define FLAG_STRING 4 /* Allow infinite precision */
25052	25089
25053	25090
25054	25091	/*
25055	25092	** The following table is searched linearly, so it is good to put the
25056	25093	** most frequently used conversion types first.
25057	25094	*/
25058	25095	static const char aDigits[] = "0123456789ABCDEF0123456789abcdef";
25059	25096	static const char aPrefix[] = "-x0\000X0";
25060	25097	static const et_info fmtinfo[] = {
25061		- { 'd', 10, 1, etRADIX, 0, 0 },
	25098	+ { 'd', 10, 1, etDECIMAL, 0, 0 },
25062	25099	{ 's', 0, 4, etSTRING, 0, 0 },
25063	25100	{ 'g', 0, 1, etGENERIC, 30, 0 },
25064	25101	{ 'z', 0, 4, etDYNSTRING, 0, 0 },
25065	25102	{ 'q', 0, 4, etSQLESCAPE, 0, 0 },
25066	25103	{ 'Q', 0, 4, etSQLESCAPE2, 0, 0 },
25067	25104	{ 'w', 0, 4, etSQLESCAPE3, 0, 0 },
25068	25105	{ 'c', 0, 0, etCHARX, 0, 0 },
25069	25106	{ 'o', 8, 0, etRADIX, 0, 2 },
25070		- { 'u', 10, 0, etRADIX, 0, 0 },
	25107	+ { 'u', 10, 0, etDECIMAL, 0, 0 },
25071	25108	{ 'x', 16, 0, etRADIX, 16, 1 },
25072	25109	{ 'X', 16, 0, etRADIX, 0, 4 },
25073	25110	#ifndef SQLITE_OMIT_FLOATING_POINT
25074	25111	{ 'f', 0, 1, etFLOAT, 0, 0 },
25075	25112	{ 'e', 0, 1, etEXP, 30, 0 },
25076	25113	{ 'E', 0, 1, etEXP, 14, 0 },
25077	25114	{ 'G', 0, 1, etGENERIC, 14, 0 },
25078	25115	#endif
25079		- { 'i', 10, 1, etRADIX, 0, 0 },
	25116	+ { 'i', 10, 1, etDECIMAL, 0, 0 },
25080	25117	{ 'n', 0, 0, etSIZE, 0, 0 },
25081	25118	{ '%', 0, 0, etPERCENT, 0, 0 },
25082	25119	{ 'p', 16, 0, etPOINTER, 0, 1 },
25083	25120
25084	25121	/* All the rest are undocumented and are for internal use only */
		@@ -25166,18 +25203,17 @@
25166	25203	int precision; /* Precision of the current field */
25167	25204	int length; /* Length of the field */
25168	25205	int idx; /* A general purpose loop counter */
25169	25206	int width; /* Width of the current field */
25170	25207	etByte flag_leftjustify; /* True if "-" flag is present */
25171		- etByte flag_plussign; /* True if "+" flag is present */
25172		- etByte flag_blanksign; /* True if " " flag is present */
	25208	+ etByte flag_prefix; /* '+' or ' ' or 0 for prefix */
25173	25209	etByte flag_alternateform; /* True if "#" flag is present */
25174	25210	etByte flag_altform2; /* True if "!" flag is present */
25175	25211	etByte flag_zeropad; /* True if field width constant starts with zero */
25176		- etByte flag_long; /* True if "l" flag is present */
25177		- etByte flag_longlong; /* True if the "ll" flag is present */
	25212	+ etByte flag_long; /* 1 for the "l" flag, 2 for "ll", 0 by default */
25178	25213	etByte done; /* Loop termination flag */
	25214	+ etByte cThousand; /* Thousands separator for %d and %u */
25179	25215	etByte xtype = etINVALID; /* Conversion paradigm */
25180	25216	u8 bArgList; /* True for SQLITE_PRINTF_SQLFUNC */
25181	25217	char prefix; /* Prefix character. "+" or "-" or " " or '\0'. */
25182	25218	sqlite_uint64 longvalue; /* Value for integer types */
25183	25219	LONGDOUBLE_TYPE realvalue; /* Value for real types */
		@@ -25216,21 +25252,22 @@
25216	25252	if( (c=(*++fmt))==0 ){
25217	25253	sqlite3StrAccumAppend(pAccum, "%", 1);
25218	25254	break;
25219	25255	}
25220	25256	/* Find out what flags are present */
25221		- flag_leftjustify = flag_plussign = flag_blanksign =
	25257	+ flag_leftjustify = flag_prefix = cThousand =
25222	25258	flag_alternateform = flag_altform2 = flag_zeropad = 0;
25223	25259	done = 0;
25224	25260	do{
25225	25261	switch( c ){
25226	25262	case '-': flag_leftjustify = 1; break;
25227		- case '+': flag_plussign = 1; break;
25228		- case ' ': flag_blanksign = 1; break;
	25263	+ case '+': flag_prefix = '+'; break;
	25264	+ case ' ': flag_prefix = ' '; break;
25229	25265	case '#': flag_alternateform = 1; break;
25230	25266	case '!': flag_altform2 = 1; break;
25231	25267	case '0': flag_zeropad = 1; break;
	25268	+ case ',': cThousand = ','; break;
25232	25269	default: done = 1; break;
25233	25270	}
25234	25271	}while( !done && (c=(*++fmt))!=0 );
25235	25272	/* Get the field width */
25236	25273	if( c=='*' ){
		@@ -25296,17 +25333,15 @@
25296	25333	/* Get the conversion type modifier */
25297	25334	if( c=='l' ){
25298	25335	flag_long = 1;
25299	25336	c = *++fmt;
25300	25337	if( c=='l' ){
25301		- flag_longlong = 1;
	25338	+ flag_long = 2;
25302	25339	c = *++fmt;
25303		- }else{
25304		- flag_longlong = 0;
25305	25340	}
25306	25341	}else{
25307		- flag_long = flag_longlong = 0;
	25342	+ flag_long = 0;
25308	25343	}
25309	25344	/* Fetch the info entry for the field */
25310	25345	infop = &fmtinfo[0];
25311	25346	xtype = etINVALID;
25312	25347	for(idx=0; idx<ArraySize(fmtinfo); idx++){
		@@ -25320,41 +25355,42 @@
25320	25355	/*
25321	25356	** At this point, variables are initialized as follows:
25322	25357	**
25323	25358	** flag_alternateform TRUE if a '#' is present.
25324	25359	** flag_altform2 TRUE if a '!' is present.
25325		- ** flag_plussign TRUE if a '+' is present.
	25360	+ ** flag_prefix '+' or ' ' or zero
25326	25361	** flag_leftjustify TRUE if a '-' is present or if the
25327	25362	** field width was negative.
25328	25363	** flag_zeropad TRUE if the width began with 0.
25329		- ** flag_long TRUE if the letter 'l' (ell) prefixed
25330		- ** the conversion character.
25331		- ** flag_longlong TRUE if the letter 'll' (ell ell) prefixed
25332		- ** the conversion character.
25333		- ** flag_blanksign TRUE if a ' ' is present.
	25364	+ ** flag_long 1 for "l", 2 for "ll"
25334	25365	** width The specified field width. This is
25335	25366	** always non-negative. Zero is the default.
25336	25367	** precision The specified precision. The default
25337	25368	** is -1.
25338	25369	** xtype The class of the conversion.
25339	25370	** infop Pointer to the appropriate info struct.
25340	25371	*/
25341	25372	switch( xtype ){
25342	25373	case etPOINTER:
25343		- flag_longlong = sizeof(char*)==sizeof(i64);
25344		- flag_long = sizeof(char*)==sizeof(long int);
	25374	+ flag_long = sizeof(char*)==sizeof(i64) ? 2 :
	25375	+ sizeof(char*)==sizeof(long int) ? 1 : 0;
25345	25376	/* Fall through into the next case */
25346	25377	case etORDINAL:
25347		- case etRADIX:
	25378	+ case etRADIX:
	25379	+ cThousand = 0;
	25380	+ /* Fall through into the next case */
	25381	+ case etDECIMAL:
25348	25382	if( infop->flags & FLAG_SIGNED ){
25349	25383	i64 v;
25350	25384	if( bArgList ){
25351	25385	v = getIntArg(pArgList);
25352		- }else if( flag_longlong ){
25353		- v = va_arg(ap,i64);
25354	25386	}else if( flag_long ){
25355		- v = va_arg(ap,long int);
	25387	+ if( flag_long==2 ){
	25388	+ v = va_arg(ap,i64) ;
	25389	+ }else{
	25390	+ v = va_arg(ap,long int);
	25391	+ }
25356	25392	}else{
25357	25393	v = va_arg(ap,int);
25358	25394	}
25359	25395	if( v<0 ){
25360	25396	if( v==SMALLEST_INT64 ){
		@@ -25363,35 +25399,35 @@
25363	25399	longvalue = -v;
25364	25400	}
25365	25401	prefix = '-';
25366	25402	}else{
25367	25403	longvalue = v;
25368		- if( flag_plussign ) prefix = '+';
25369		- else if( flag_blanksign ) prefix = ' ';
25370		- else prefix = 0;
	25404	+ prefix = flag_prefix;
25371	25405	}
25372	25406	}else{
25373	25407	if( bArgList ){
25374	25408	longvalue = (u64)getIntArg(pArgList);
25375		- }else if( flag_longlong ){
25376		- longvalue = va_arg(ap,u64);
25377	25409	}else if( flag_long ){
25378		- longvalue = va_arg(ap,unsigned long int);
	25410	+ if( flag_long==2 ){
	25411	+ longvalue = va_arg(ap,u64);
	25412	+ }else{
	25413	+ longvalue = va_arg(ap,unsigned long int);
	25414	+ }
25379	25415	}else{
25380	25416	longvalue = va_arg(ap,unsigned int);
25381	25417	}
25382	25418	prefix = 0;
25383	25419	}
25384	25420	if( longvalue==0 ) flag_alternateform = 0;
25385	25421	if( flag_zeropad && precision<width-(prefix!=0) ){
25386	25422	precision = width-(prefix!=0);
25387	25423	}
25388		- if( precision<etBUFSIZE-10 ){
	25424	+ if( precision<etBUFSIZE-10-etBUFSIZE/3 ){
25389	25425	nOut = etBUFSIZE;
25390	25426	zOut = buf;
25391	25427	}else{
25392		- nOut = precision + 10;
	25428	+ nOut = precision + 10 + precision/3;
25393	25429	zOut = zExtra = sqlite3Malloc( nOut );
25394	25430	if( zOut==0 ){
25395	25431	setStrAccumError(pAccum, STRACCUM_NOMEM);
25396	25432	return;
25397	25433	}
		@@ -25413,12 +25449,27 @@
25413	25449	*(--bufpt) = cset[longvalue%base];
25414	25450	longvalue = longvalue/base;
25415	25451	}while( longvalue>0 );
25416	25452	}
25417	25453	length = (int)(&zOut[nOut-1]-bufpt);
25418		- for(idx=precision-length; idx>0; idx--){
	25454	+ while( precision>length ){
25419	25455	(--bufpt) = '0'; / Zero pad */
	25456	+ length++;
	25457	+ }
	25458	+ if( cThousand ){
	25459	+ int nn = (length - 1)/3; /* Number of "," to insert */
	25460	+ int ix = (length - 1)%3 + 1;
	25461	+ bufpt -= nn;
	25462	+ for(idx=0; nn>0; idx++){
	25463	+ bufpt[idx] = bufpt[idx+nn];
	25464	+ ix--;
	25465	+ if( ix==0 ){
	25466	+ bufpt[++idx] = cThousand;
	25467	+ nn--;
	25468	+ ix = 3;
	25469	+ }
	25470	+ }
25420	25471	}
25421	25472	if( prefix ) (--bufpt) = prefix; / Add sign */
25422	25473	if( flag_alternateform && infop->prefix ){ /* Add "0" or "0x" */
25423	25474	const char *pre;
25424	25475	char x;
		@@ -25441,13 +25492,11 @@
25441	25492	if( precision<0 ) precision = 6; /* Set default precision */
25442	25493	if( realvalue<0.0 ){
25443	25494	realvalue = -realvalue;
25444	25495	prefix = '-';
25445	25496	}else{
25446		- if( flag_plussign ) prefix = '+';
25447		- else if( flag_blanksign ) prefix = ' ';
25448		- else prefix = 0;
	25497	+ prefix = flag_prefix;
25449	25498	}
25450	25499	if( xtype==etGENERIC && precision>0 ) precision--;
25451	25500	testcase( precision>0xfff );
25452	25501	for(idx=precision&0xfff, rounder=0.5; idx>0; idx--, rounder*=0.1){}
25453	25502	if( xtype==etFLOAT ) realvalue += rounder;
		@@ -29464,117 +29513,119 @@
29464	29513	/* 50 */ "Divide" OpHelp("r[P3]=r[P2]/r[P1]"),
29465	29514	/* 51 */ "Remainder" OpHelp("r[P3]=r[P2]%r[P1]"),
29466	29515	/* 52 */ "Concat" OpHelp("r[P3]=r[P2]+r[P1]"),
29467	29516	/* 53 */ "Last" OpHelp(""),
29468	29517	/* 54 */ "BitNot" OpHelp("r[P1]= ~r[P1]"),
29469		- /* 55 */ "SorterSort" OpHelp(""),
29470		- /* 56 */ "Sort" OpHelp(""),
29471		- /* 57 */ "Rewind" OpHelp(""),
29472		- /* 58 */ "IdxLE" OpHelp("key=r[P3@P4]"),
29473		- /* 59 */ "IdxGT" OpHelp("key=r[P3@P4]"),
29474		- /* 60 */ "IdxLT" OpHelp("key=r[P3@P4]"),
29475		- /* 61 */ "IdxGE" OpHelp("key=r[P3@P4]"),
29476		- /* 62 */ "RowSetRead" OpHelp("r[P3]=rowset(P1)"),
29477		- /* 63 */ "RowSetTest" OpHelp("if r[P3] in rowset(P1) goto P2"),
29478		- /* 64 */ "Program" OpHelp(""),
29479		- /* 65 */ "FkIfZero" OpHelp("if fkctr[P1]==0 goto P2"),
29480		- /* 66 */ "IfPos" OpHelp("if r[P1]>0 then r[P1]-=P3, goto P2"),
29481		- /* 67 */ "IfNotZero" OpHelp("if r[P1]!=0 then r[P1]--, goto P2"),
29482		- /* 68 */ "DecrJumpZero" OpHelp("if (--r[P1])==0 goto P2"),
29483		- /* 69 */ "IncrVacuum" OpHelp(""),
29484		- /* 70 */ "VNext" OpHelp(""),
29485		- /* 71 */ "Init" OpHelp("Start at P2"),
29486		- /* 72 */ "Return" OpHelp(""),
29487		- /* 73 */ "EndCoroutine" OpHelp(""),
29488		- /* 74 */ "HaltIfNull" OpHelp("if r[P3]=null halt"),
29489		- /* 75 */ "Halt" OpHelp(""),
29490		- /* 76 */ "Integer" OpHelp("r[P2]=P1"),
29491		- /* 77 */ "Int64" OpHelp("r[P2]=P4"),
29492		- /* 78 */ "String" OpHelp("r[P2]='P4' (len=P1)"),
29493		- /* 79 */ "Null" OpHelp("r[P2..P3]=NULL"),
29494		- /* 80 */ "SoftNull" OpHelp("r[P1]=NULL"),
29495		- /* 81 */ "Blob" OpHelp("r[P2]=P4 (len=P1)"),
29496		- /* 82 */ "Variable" OpHelp("r[P2]=parameter(P1,P4)"),
29497		- /* 83 */ "Move" OpHelp("r[P2@P3]=r[P1@P3]"),
29498		- /* 84 */ "Copy" OpHelp("r[P2@P3+1]=r[P1@P3+1]"),
29499		- /* 85 */ "SCopy" OpHelp("r[P2]=r[P1]"),
29500		- /* 86 */ "IntCopy" OpHelp("r[P2]=r[P1]"),
29501		- /* 87 */ "ResultRow" OpHelp("output=r[P1@P2]"),
29502		- /* 88 */ "CollSeq" OpHelp(""),
29503		- /* 89 */ "Function0" OpHelp("r[P3]=func(r[P2@P5])"),
29504		- /* 90 */ "Function" OpHelp("r[P3]=func(r[P2@P5])"),
29505		- /* 91 */ "AddImm" OpHelp("r[P1]=r[P1]+P2"),
29506		- /* 92 */ "RealAffinity" OpHelp(""),
29507		- /* 93 */ "Cast" OpHelp("affinity(r[P1])"),
29508		- /* 94 */ "Permutation" OpHelp(""),
29509		- /* 95 */ "Compare" OpHelp("r[P1@P3] <-> r[P2@P3]"),
29510		- /* 96 */ "Column" OpHelp("r[P3]=PX"),
	29518	+ /* 55 */ "IfSmaller" OpHelp(""),
	29519	+ /* 56 */ "SorterSort" OpHelp(""),
	29520	+ /* 57 */ "Sort" OpHelp(""),
	29521	+ /* 58 */ "Rewind" OpHelp(""),
	29522	+ /* 59 */ "IdxLE" OpHelp("key=r[P3@P4]"),
	29523	+ /* 60 */ "IdxGT" OpHelp("key=r[P3@P4]"),
	29524	+ /* 61 */ "IdxLT" OpHelp("key=r[P3@P4]"),
	29525	+ /* 62 */ "IdxGE" OpHelp("key=r[P3@P4]"),
	29526	+ /* 63 */ "RowSetRead" OpHelp("r[P3]=rowset(P1)"),
	29527	+ /* 64 */ "RowSetTest" OpHelp("if r[P3] in rowset(P1) goto P2"),
	29528	+ /* 65 */ "Program" OpHelp(""),
	29529	+ /* 66 */ "FkIfZero" OpHelp("if fkctr[P1]==0 goto P2"),
	29530	+ /* 67 */ "IfPos" OpHelp("if r[P1]>0 then r[P1]-=P3, goto P2"),
	29531	+ /* 68 */ "IfNotZero" OpHelp("if r[P1]!=0 then r[P1]--, goto P2"),
	29532	+ /* 69 */ "DecrJumpZero" OpHelp("if (--r[P1])==0 goto P2"),
	29533	+ /* 70 */ "IncrVacuum" OpHelp(""),
	29534	+ /* 71 */ "VNext" OpHelp(""),
	29535	+ /* 72 */ "Init" OpHelp("Start at P2"),
	29536	+ /* 73 */ "Return" OpHelp(""),
	29537	+ /* 74 */ "EndCoroutine" OpHelp(""),
	29538	+ /* 75 */ "HaltIfNull" OpHelp("if r[P3]=null halt"),
	29539	+ /* 76 */ "Halt" OpHelp(""),
	29540	+ /* 77 */ "Integer" OpHelp("r[P2]=P1"),
	29541	+ /* 78 */ "Int64" OpHelp("r[P2]=P4"),
	29542	+ /* 79 */ "String" OpHelp("r[P2]='P4' (len=P1)"),
	29543	+ /* 80 */ "Null" OpHelp("r[P2..P3]=NULL"),
	29544	+ /* 81 */ "SoftNull" OpHelp("r[P1]=NULL"),
	29545	+ /* 82 */ "Blob" OpHelp("r[P2]=P4 (len=P1)"),
	29546	+ /* 83 */ "Variable" OpHelp("r[P2]=parameter(P1,P4)"),
	29547	+ /* 84 */ "Move" OpHelp("r[P2@P3]=r[P1@P3]"),
	29548	+ /* 85 */ "Copy" OpHelp("r[P2@P3+1]=r[P1@P3+1]"),
	29549	+ /* 86 */ "SCopy" OpHelp("r[P2]=r[P1]"),
	29550	+ /* 87 */ "IntCopy" OpHelp("r[P2]=r[P1]"),
	29551	+ /* 88 */ "ResultRow" OpHelp("output=r[P1@P2]"),
	29552	+ /* 89 */ "CollSeq" OpHelp(""),
	29553	+ /* 90 */ "Function0" OpHelp("r[P3]=func(r[P2@P5])"),
	29554	+ /* 91 */ "Function" OpHelp("r[P3]=func(r[P2@P5])"),
	29555	+ /* 92 */ "AddImm" OpHelp("r[P1]=r[P1]+P2"),
	29556	+ /* 93 */ "RealAffinity" OpHelp(""),
	29557	+ /* 94 */ "Cast" OpHelp("affinity(r[P1])"),
	29558	+ /* 95 */ "Permutation" OpHelp(""),
	29559	+ /* 96 */ "Compare" OpHelp("r[P1@P3] <-> r[P2@P3]"),
29511	29560	/* 97 */ "String8" OpHelp("r[P2]='P4'"),
29512		- /* 98 */ "Affinity" OpHelp("affinity(r[P1@P2])"),
29513		- /* 99 */ "MakeRecord" OpHelp("r[P3]=mkrec(r[P1@P2])"),
29514		- /* 100 */ "Count" OpHelp("r[P2]=count()"),
29515		- /* 101 */ "ReadCookie" OpHelp(""),
29516		- /* 102 */ "SetCookie" OpHelp(""),
29517		- /* 103 */ "ReopenIdx" OpHelp("root=P2 iDb=P3"),
29518		- /* 104 */ "OpenRead" OpHelp("root=P2 iDb=P3"),
29519		- /* 105 */ "OpenWrite" OpHelp("root=P2 iDb=P3"),
29520		- /* 106 */ "OpenAutoindex" OpHelp("nColumn=P2"),
29521		- /* 107 */ "OpenEphemeral" OpHelp("nColumn=P2"),
29522		- /* 108 */ "SorterOpen" OpHelp(""),
29523		- /* 109 */ "SequenceTest" OpHelp("if( cursor[P1].ctr++ ) pc = P2"),
29524		- /* 110 */ "OpenPseudo" OpHelp("P3 columns in r[P2]"),
29525		- /* 111 */ "Close" OpHelp(""),
29526		- /* 112 */ "ColumnsUsed" OpHelp(""),
29527		- /* 113 */ "Sequence" OpHelp("r[P2]=cursor[P1].ctr++"),
29528		- /* 114 */ "NewRowid" OpHelp("r[P2]=rowid"),
29529		- /* 115 */ "Insert" OpHelp("intkey=r[P3] data=r[P2]"),
29530		- /* 116 */ "InsertInt" OpHelp("intkey=P3 data=r[P2]"),
29531		- /* 117 */ "Delete" OpHelp(""),
29532		- /* 118 */ "ResetCount" OpHelp(""),
29533		- /* 119 */ "SorterCompare" OpHelp("if key(P1)!=trim(r[P3],P4) goto P2"),
29534		- /* 120 */ "SorterData" OpHelp("r[P2]=data"),
29535		- /* 121 */ "RowData" OpHelp("r[P2]=data"),
29536		- /* 122 */ "Rowid" OpHelp("r[P2]=rowid"),
29537		- /* 123 */ "NullRow" OpHelp(""),
29538		- /* 124 */ "SorterInsert" OpHelp("key=r[P2]"),
29539		- /* 125 */ "IdxInsert" OpHelp("key=r[P2]"),
29540		- /* 126 */ "IdxDelete" OpHelp("key=r[P2@P3]"),
29541		- /* 127 */ "Seek" OpHelp("Move P3 to P1.rowid"),
29542		- /* 128 */ "IdxRowid" OpHelp("r[P2]=rowid"),
29543		- /* 129 */ "Destroy" OpHelp(""),
29544		- /* 130 */ "Clear" OpHelp(""),
29545		- /* 131 */ "ResetSorter" OpHelp(""),
	29561	+ /* 98 */ "Column" OpHelp("r[P3]=PX"),
	29562	+ /* 99 */ "Affinity" OpHelp("affinity(r[P1@P2])"),
	29563	+ /* 100 */ "MakeRecord" OpHelp("r[P3]=mkrec(r[P1@P2])"),
	29564	+ /* 101 */ "Count" OpHelp("r[P2]=count()"),
	29565	+ /* 102 */ "ReadCookie" OpHelp(""),
	29566	+ /* 103 */ "SetCookie" OpHelp(""),
	29567	+ /* 104 */ "ReopenIdx" OpHelp("root=P2 iDb=P3"),
	29568	+ /* 105 */ "OpenRead" OpHelp("root=P2 iDb=P3"),
	29569	+ /* 106 */ "OpenWrite" OpHelp("root=P2 iDb=P3"),
	29570	+ /* 107 */ "OpenAutoindex" OpHelp("nColumn=P2"),
	29571	+ /* 108 */ "OpenEphemeral" OpHelp("nColumn=P2"),
	29572	+ /* 109 */ "SorterOpen" OpHelp(""),
	29573	+ /* 110 */ "SequenceTest" OpHelp("if( cursor[P1].ctr++ ) pc = P2"),
	29574	+ /* 111 */ "OpenPseudo" OpHelp("P3 columns in r[P2]"),
	29575	+ /* 112 */ "Close" OpHelp(""),
	29576	+ /* 113 */ "ColumnsUsed" OpHelp(""),
	29577	+ /* 114 */ "Sequence" OpHelp("r[P2]=cursor[P1].ctr++"),
	29578	+ /* 115 */ "NewRowid" OpHelp("r[P2]=rowid"),
	29579	+ /* 116 */ "Insert" OpHelp("intkey=r[P3] data=r[P2]"),
	29580	+ /* 117 */ "InsertInt" OpHelp("intkey=P3 data=r[P2]"),
	29581	+ /* 118 */ "Delete" OpHelp(""),
	29582	+ /* 119 */ "ResetCount" OpHelp(""),
	29583	+ /* 120 */ "SorterCompare" OpHelp("if key(P1)!=trim(r[P3],P4) goto P2"),
	29584	+ /* 121 */ "SorterData" OpHelp("r[P2]=data"),
	29585	+ /* 122 */ "RowData" OpHelp("r[P2]=data"),
	29586	+ /* 123 */ "Rowid" OpHelp("r[P2]=rowid"),
	29587	+ /* 124 */ "NullRow" OpHelp(""),
	29588	+ /* 125 */ "SorterInsert" OpHelp("key=r[P2]"),
	29589	+ /* 126 */ "IdxInsert" OpHelp("key=r[P2]"),
	29590	+ /* 127 */ "IdxDelete" OpHelp("key=r[P2@P3]"),
	29591	+ /* 128 */ "Seek" OpHelp("Move P3 to P1.rowid"),
	29592	+ /* 129 */ "IdxRowid" OpHelp("r[P2]=rowid"),
	29593	+ /* 130 */ "Destroy" OpHelp(""),
	29594	+ /* 131 */ "Clear" OpHelp(""),
29546	29595	/* 132 */ "Real" OpHelp("r[P2]=P4"),
29547		- /* 133 */ "CreateIndex" OpHelp("r[P2]=root iDb=P1"),
29548		- /* 134 */ "CreateTable" OpHelp("r[P2]=root iDb=P1"),
29549		- /* 135 */ "ParseSchema" OpHelp(""),
29550		- /* 136 */ "LoadAnalysis" OpHelp(""),
29551		- /* 137 */ "DropTable" OpHelp(""),
29552		- /* 138 */ "DropIndex" OpHelp(""),
29553		- /* 139 */ "DropTrigger" OpHelp(""),
29554		- /* 140 */ "IntegrityCk" OpHelp(""),
29555		- /* 141 */ "RowSetAdd" OpHelp("rowset(P1)=r[P2]"),
29556		- /* 142 */ "Param" OpHelp(""),
29557		- /* 143 */ "FkCounter" OpHelp("fkctr[P1]+=P2"),
29558		- /* 144 */ "MemMax" OpHelp("r[P1]=max(r[P1],r[P2])"),
29559		- /* 145 */ "OffsetLimit" OpHelp("if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)"),
29560		- /* 146 */ "AggStep0" OpHelp("accum=r[P3] step(r[P2@P5])"),
29561		- /* 147 */ "AggStep" OpHelp("accum=r[P3] step(r[P2@P5])"),
29562		- /* 148 */ "AggFinal" OpHelp("accum=r[P1] N=P2"),
29563		- /* 149 */ "Expire" OpHelp(""),
29564		- /* 150 */ "TableLock" OpHelp("iDb=P1 root=P2 write=P3"),
29565		- /* 151 */ "VBegin" OpHelp(""),
29566		- /* 152 */ "VCreate" OpHelp(""),
29567		- /* 153 */ "VDestroy" OpHelp(""),
29568		- /* 154 */ "VOpen" OpHelp(""),
29569		- /* 155 */ "VColumn" OpHelp("r[P3]=vcolumn(P2)"),
29570		- /* 156 */ "VRename" OpHelp(""),
29571		- /* 157 */ "Pagecount" OpHelp(""),
29572		- /* 158 */ "MaxPgcnt" OpHelp(""),
29573		- /* 159 */ "CursorHint" OpHelp(""),
29574		- /* 160 */ "Noop" OpHelp(""),
29575		- /* 161 */ "Explain" OpHelp(""),
	29596	+ /* 133 */ "ResetSorter" OpHelp(""),
	29597	+ /* 134 */ "CreateIndex" OpHelp("r[P2]=root iDb=P1"),
	29598	+ /* 135 */ "CreateTable" OpHelp("r[P2]=root iDb=P1"),
	29599	+ /* 136 */ "SqlExec" OpHelp(""),
	29600	+ /* 137 */ "ParseSchema" OpHelp(""),
	29601	+ /* 138 */ "LoadAnalysis" OpHelp(""),
	29602	+ /* 139 */ "DropTable" OpHelp(""),
	29603	+ /* 140 */ "DropIndex" OpHelp(""),
	29604	+ /* 141 */ "DropTrigger" OpHelp(""),
	29605	+ /* 142 */ "IntegrityCk" OpHelp(""),
	29606	+ /* 143 */ "RowSetAdd" OpHelp("rowset(P1)=r[P2]"),
	29607	+ /* 144 */ "Param" OpHelp(""),
	29608	+ /* 145 */ "FkCounter" OpHelp("fkctr[P1]+=P2"),
	29609	+ /* 146 */ "MemMax" OpHelp("r[P1]=max(r[P1],r[P2])"),
	29610	+ /* 147 */ "OffsetLimit" OpHelp("if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)"),
	29611	+ /* 148 */ "AggStep0" OpHelp("accum=r[P3] step(r[P2@P5])"),
	29612	+ /* 149 */ "AggStep" OpHelp("accum=r[P3] step(r[P2@P5])"),
	29613	+ /* 150 */ "AggFinal" OpHelp("accum=r[P1] N=P2"),
	29614	+ /* 151 */ "Expire" OpHelp(""),
	29615	+ /* 152 */ "TableLock" OpHelp("iDb=P1 root=P2 write=P3"),
	29616	+ /* 153 */ "VBegin" OpHelp(""),
	29617	+ /* 154 */ "VCreate" OpHelp(""),
	29618	+ /* 155 */ "VDestroy" OpHelp(""),
	29619	+ /* 156 */ "VOpen" OpHelp(""),
	29620	+ /* 157 */ "VColumn" OpHelp("r[P3]=vcolumn(P2)"),
	29621	+ /* 158 */ "VRename" OpHelp(""),
	29622	+ /* 159 */ "Pagecount" OpHelp(""),
	29623	+ /* 160 */ "MaxPgcnt" OpHelp(""),
	29624	+ /* 161 */ "CursorHint" OpHelp(""),
	29625	+ /* 162 */ "Noop" OpHelp(""),
	29626	+ /* 163 */ "Explain" OpHelp(""),
29576	29627	};
29577	29628	return azName[i];
29578	29629	}
29579	29630	#endif
29580	29631
		@@ -37952,46 +38003,84 @@
37952	38003	* be freed immediately and any attempt to access any of that freed
37953	38004	* data will almost certainly result in an immediate access violation.
37954	38005	******************************************************************************
37955	38006	*/
37956	38007	#ifndef SQLITE_WIN32_HEAP_CREATE
37957		-# define SQLITE_WIN32_HEAP_CREATE (TRUE)
	38008	+# define SQLITE_WIN32_HEAP_CREATE (TRUE)
	38009	+#endif
	38010	+
	38011	+/*
	38012	+ * This is the maximum possible initial size of the Win32-specific heap, in
	38013	+ * bytes.
	38014	+ */
	38015	+#ifndef SQLITE_WIN32_HEAP_MAX_INIT_SIZE
	38016	+# define SQLITE_WIN32_HEAP_MAX_INIT_SIZE (4294967295U)
	38017	+#endif
	38018	+
	38019	+/*
	38020	+ * This is the extra space for the initial size of the Win32-specific heap,
	38021	+ * in bytes. This value may be zero.
	38022	+ */
	38023	+#ifndef SQLITE_WIN32_HEAP_INIT_EXTRA
	38024	+# define SQLITE_WIN32_HEAP_INIT_EXTRA (4194304)
	38025	+#endif
	38026	+
	38027	+/*
	38028	+ * Calculate the maximum legal cache size, in pages, based on the maximum
	38029	+ * possible initial heap size and the default page size, setting aside the
	38030	+ * needed extra space.
	38031	+ */
	38032	+#ifndef SQLITE_WIN32_MAX_CACHE_SIZE
	38033	+# define SQLITE_WIN32_MAX_CACHE_SIZE (((SQLITE_WIN32_HEAP_MAX_INIT_SIZE) - \
	38034	+ (SQLITE_WIN32_HEAP_INIT_EXTRA)) / \
	38035	+ (SQLITE_DEFAULT_PAGE_SIZE))
37958	38036	#endif
37959	38037
37960	38038	/*
37961	38039	* This is cache size used in the calculation of the initial size of the
37962	38040	* Win32-specific heap. It cannot be negative.
37963	38041	*/
37964	38042	#ifndef SQLITE_WIN32_CACHE_SIZE
37965	38043	# if SQLITE_DEFAULT_CACHE_SIZE>=0
37966		-# define SQLITE_WIN32_CACHE_SIZE (SQLITE_DEFAULT_CACHE_SIZE)
	38044	+# define SQLITE_WIN32_CACHE_SIZE (SQLITE_DEFAULT_CACHE_SIZE)
37967	38045	# else
37968		-# define SQLITE_WIN32_CACHE_SIZE (-(SQLITE_DEFAULT_CACHE_SIZE))
	38046	+# define SQLITE_WIN32_CACHE_SIZE (-(SQLITE_DEFAULT_CACHE_SIZE))
37969	38047	# endif
37970	38048	#endif
37971	38049
	38050	+/*
	38051	+ * Make sure that the calculated cache size, in pages, cannot cause the
	38052	+ * initial size of the Win32-specific heap to exceed the maximum amount
	38053	+ * of memory that can be specified in the call to HeapCreate.
	38054	+ */
	38055	+#if SQLITE_WIN32_CACHE_SIZE>SQLITE_WIN32_MAX_CACHE_SIZE
	38056	+# undef SQLITE_WIN32_CACHE_SIZE
	38057	+# define SQLITE_WIN32_CACHE_SIZE (2000)
	38058	+#endif
	38059	+
37972	38060	/*
37973	38061	* The initial size of the Win32-specific heap. This value may be zero.
37974	38062	*/
37975	38063	#ifndef SQLITE_WIN32_HEAP_INIT_SIZE
37976		-# define SQLITE_WIN32_HEAP_INIT_SIZE ((SQLITE_WIN32_CACHE_SIZE) * \
37977		- (SQLITE_DEFAULT_PAGE_SIZE) + 4194304)
	38064	+# define SQLITE_WIN32_HEAP_INIT_SIZE ((SQLITE_WIN32_CACHE_SIZE) * \
	38065	+ (SQLITE_DEFAULT_PAGE_SIZE) + \
	38066	+ (SQLITE_WIN32_HEAP_INIT_EXTRA))
37978	38067	#endif
37979	38068
37980	38069	/*
37981	38070	* The maximum size of the Win32-specific heap. This value may be zero.
37982	38071	*/
37983	38072	#ifndef SQLITE_WIN32_HEAP_MAX_SIZE
37984		-# define SQLITE_WIN32_HEAP_MAX_SIZE (0)
	38073	+# define SQLITE_WIN32_HEAP_MAX_SIZE (0)
37985	38074	#endif
37986	38075
37987	38076	/*
37988	38077	* The extra flags to use in calls to the Win32 heap APIs. This value may be
37989	38078	* zero for the default behavior.
37990	38079	*/
37991	38080	#ifndef SQLITE_WIN32_HEAP_FLAGS
37992		-# define SQLITE_WIN32_HEAP_FLAGS (0)
	38081	+# define SQLITE_WIN32_HEAP_FLAGS (0)
37993	38082	#endif
37994	38083
37995	38084
37996	38085	/*
37997	38086	** The winMemData structure stores information required by the Win32-specific
		@@ -44084,11 +44173,11 @@
44084	44173	** This routine is for use inside of assert() statements only. For
44085	44174	** example:
44086	44175	**
44087	44176	** assert( sqlite3PcachePageSanity(pPg) );
44088	44177	*/
44089		-#if SQLITE_DEBUG
	44178	+#ifdef SQLITE_DEBUG
44090	44179	SQLITE_PRIVATE int sqlite3PcachePageSanity(PgHdr *pPg){
44091	44180	PCache *pCache;
44092	44181	assert( pPg!=0 );
44093	44182	assert( pPg->pgno>0 \|\| pPg->pPager==0 ); /* Page number is 1 or more */
44094	44183	pCache = pPg->pCache;
		@@ -60177,21 +60266,22 @@
60177	60266	}
60178	60267	#endif
60179	60268
60180	60269
60181	60270	/*
60182		-** Defragment the page given. All Cells are moved to the
60183		-** end of the page and all free space is collected into one
60184		-** big FreeBlk that occurs in between the header and cell
60185		-** pointer array and the cell content area.
	60271	+** Defragment the page given. This routine reorganizes cells within the
	60272	+** page so that there are no free-blocks on the free-block list.
	60273	+**
	60274	+** Parameter nMaxFrag is the maximum amount of fragmented space that may be
	60275	+** present in the page after this routine returns.
60186	60276	**
60187	60277	** EVIDENCE-OF: R-44582-60138 SQLite may from time to time reorganize a
60188	60278	** b-tree page so that there are no freeblocks or fragment bytes, all
60189	60279	** unused bytes are contained in the unallocated space region, and all
60190	60280	** cells are packed tightly at the end of the page.
60191	60281	*/
60192		-static int defragmentPage(MemPage *pPage){
	60282	+static int defragmentPage(MemPage *pPage, int nMaxFrag){
60193	60283	int i; /* Loop counter */
60194	60284	int pc; /* Address of the i-th cell */
60195	60285	int hdr; /* Offset to the page header */
60196	60286	int size; /* Size of a cell */
60197	60287	int usableSize; /* Number of usable bytes on a page */
		@@ -60202,11 +60292,10 @@
60202	60292	unsigned char temp; / Temp area for cell content */
60203	60293	unsigned char src; / Source of content */
60204	60294	int iCellFirst; /* First allowable cell index */
60205	60295	int iCellLast; /* Last possible cell index */
60206	60296
60207		-
60208	60297	assert( sqlite3PagerIswriteable(pPage->pDbPage) );
60209	60298	assert( pPage->pBt!=0 );
60210	60299	assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE );
60211	60300	assert( pPage->nOverflow==0 );
60212	60301	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
		@@ -60214,13 +60303,60 @@
60214	60303	src = data = pPage->aData;
60215	60304	hdr = pPage->hdrOffset;
60216	60305	cellOffset = pPage->cellOffset;
60217	60306	nCell = pPage->nCell;
60218	60307	assert( nCell==get2byte(&data[hdr+3]) );
	60308	+ iCellFirst = cellOffset + 2*nCell;
60219	60309	usableSize = pPage->pBt->usableSize;
	60310	+
	60311	+ /* This block handles pages with two or fewer free blocks and nMaxFrag
	60312	+ ** or fewer fragmented bytes. In this case it is faster to move the
	60313	+ ** two (or one) blocks of cells using memmove() and add the required
	60314	+ ** offsets to each pointer in the cell-pointer array than it is to
	60315	+ ** reconstruct the entire page. */
	60316	+ if( (int)data[hdr+7]<=nMaxFrag ){
	60317	+ int iFree = get2byte(&data[hdr+1]);
	60318	+ if( iFree ){
	60319	+ int iFree2 = get2byte(&data[iFree]);
	60320	+
	60321	+ /* pageFindSlot() has already verified that free blocks are sorted
	60322	+ ** in order of offset within the page, and that no block extends
	60323	+ ** past the end of the page. Provided the two free slots do not
	60324	+ ** overlap, this guarantees that the memmove() calls below will not
	60325	+ ** overwrite the usableSize byte buffer, even if the database page
	60326	+ ** is corrupt. */
	60327	+ assert( iFree2==0 \|\| iFree2>iFree );
	60328	+ assert( iFree+get2byte(&data[iFree+2]) <= usableSize );
	60329	+ assert( iFree2==0 \|\| iFree2+get2byte(&data[iFree2+2]) <= usableSize );
	60330	+
	60331	+ if( 0==iFree2 \|\| (data[iFree2]==0 && data[iFree2+1]==0) ){
	60332	+ u8 pEnd = &data[cellOffset + nCell2];
	60333	+ u8 *pAddr;
	60334	+ int sz2 = 0;
	60335	+ int sz = get2byte(&data[iFree+2]);
	60336	+ int top = get2byte(&data[hdr+5]);
	60337	+ if( iFree2 ){
	60338	+ if( iFree+sz>iFree2 ) return SQLITE_CORRUPT_BKPT;
	60339	+ sz2 = get2byte(&data[iFree2+2]);
	60340	+ assert( iFree+sz+sz2+iFree2-(iFree+sz) <= usableSize );
	60341	+ memmove(&data[iFree+sz+sz2], &data[iFree+sz], iFree2-(iFree+sz));
	60342	+ sz += sz2;
	60343	+ }
	60344	+ cbrk = top+sz;
	60345	+ assert( cbrk+(iFree-top) <= usableSize );
	60346	+ memmove(&data[cbrk], &data[top], iFree-top);
	60347	+ for(pAddr=&data[cellOffset]; pAddr<pEnd; pAddr+=2){
	60348	+ pc = get2byte(pAddr);
	60349	+ if( pc<iFree ){ put2byte(pAddr, pc+sz); }
	60350	+ else if( pc<iFree2 ){ put2byte(pAddr, pc+sz2); }
	60351	+ }
	60352	+ goto defragment_out;
	60353	+ }
	60354	+ }
	60355	+ }
	60356	+
60220	60357	cbrk = usableSize;
60221		- iCellFirst = cellOffset + 2*nCell;
60222	60358	iCellLast = usableSize - 4;
60223	60359	for(i=0; i<nCell; i++){
60224	60360	u8 pAddr; / The i-th cell pointer */
60225	60361	pAddr = &data[cellOffset + i*2];
60226	60362	pc = get2byte(pAddr);
		@@ -60250,20 +60386,22 @@
60250	60386	memcpy(&temp[x], &data[x], (cbrk+size) - x);
60251	60387	src = temp;
60252	60388	}
60253	60389	memcpy(&data[cbrk], &src[pc], size);
60254	60390	}
	60391	+ data[hdr+7] = 0;
	60392	+
	60393	+ defragment_out:
	60394	+ if( data[hdr+7]+cbrk-iCellFirst!=pPage->nFree ){
	60395	+ return SQLITE_CORRUPT_BKPT;
	60396	+ }
60255	60397	assert( cbrk>=iCellFirst );
60256	60398	put2byte(&data[hdr+5], cbrk);
60257	60399	data[hdr+1] = 0;
60258	60400	data[hdr+2] = 0;
60259		- data[hdr+7] = 0;
60260	60401	memset(&data[iCellFirst], 0, cbrk-iCellFirst);
60261	60402	assert( sqlite3PagerIswriteable(pPage->pDbPage) );
60262		- if( cbrk-iCellFirst!=pPage->nFree ){
60263		- return SQLITE_CORRUPT_BKPT;
60264		- }
60265	60403	return SQLITE_OK;
60266	60404	}
60267	60405
60268	60406	/*
60269	60407	** Search the free-list on page pPg for space to store a cell nByte bytes in
		@@ -60397,14 +60535,14 @@
60397	60535	** to see if defragmentation is necessary.
60398	60536	*/
60399	60537	testcase( gap+2+nByte==top );
60400	60538	if( gap+2+nByte>top ){
60401	60539	assert( pPage->nCell>0 \|\| CORRUPT_DB );
60402		- rc = defragmentPage(pPage);
	60540	+ rc = defragmentPage(pPage, MIN(4, pPage->nFree - (2+nByte)));
60403	60541	if( rc ) return rc;
60404	60542	top = get2byteNotZero(&data[hdr+5]);
60405		- assert( gap+nByte<=top );
	60543	+ assert( gap+2+nByte<=top );
60406	60544	}
60407	60545
60408	60546
60409	60547	/* Allocate memory from the gap in between the cell pointer array
60410	60548	** and the cell content area. The btreeInitPage() call has already
		@@ -63636,11 +63774,11 @@
63636	63774	pCur->aiIdx[pCur->iPage] = 0;
63637	63775	return getAndInitPage(pBt, newPgno, &pCur->apPage[pCur->iPage],
63638	63776	pCur, pCur->curPagerFlags);
63639	63777	}
63640	63778
63641		-#if SQLITE_DEBUG
	63779	+#ifdef SQLITE_DEBUG
63642	63780	/*
63643	63781	** Page pParent is an internal (non-leaf) tree page. This function
63644	63782	** asserts that page number iChild is the left-child if the iIdx'th
63645	63783	** cell in page pParent. Or, if iIdx is equal to the total number of
63646	63784	** cells in pParent, that page number iChild is the right-child of
		@@ -64178,10 +64316,34 @@
64178	64316	** have been deleted? This API will need to change to return an error code
64179	64317	** as well as the boolean result value.
64180	64318	*/
64181	64319	return (CURSOR_VALID!=pCur->eState);
64182	64320	}
	64321	+
	64322	+/*
	64323	+** Return an estimate for the number of rows in the table that pCur is
	64324	+** pointing to. Return a negative number if no estimate is currently
	64325	+** available.
	64326	+*/
	64327	+SQLITE_PRIVATE i64 sqlite3BtreeRowCountEst(BtCursor *pCur){
	64328	+ i64 n;
	64329	+ u8 i;
	64330	+
	64331	+ assert( cursorOwnsBtShared(pCur) );
	64332	+ assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
	64333	+
	64334	+ /* Currently this interface is only called by the OP_IfSmaller
	64335	+ ** opcode, and it that case the cursor will always be valid and
	64336	+ ** will always point to a leaf node. */
	64337	+ if( NEVER(pCur->eState!=CURSOR_VALID) ) return -1;
	64338	+ if( NEVER(pCur->apPage[pCur->iPage]->leaf==0) ) return -1;
	64339	+
	64340	+ for(n=1, i=0; i<=pCur->iPage; i++){
	64341	+ n *= pCur->apPage[i]->nCell;
	64342	+ }
	64343	+ return n;
	64344	+}
64183	64345
64184	64346	/*
64185	64347	** Advance the cursor to the next entry in the database. If
64186	64348	** successful then set *pRes=0. If the cursor
64187	64349	** was already pointing to the last entry in the database before
		@@ -65023,11 +65185,11 @@
65023	65185	** pPrior Where to write the pgno of the first overflow page
65024	65186	**
65025	65187	** Use a call to btreeParseCellPtr() to verify that the values above
65026	65188	** were computed correctly.
65027	65189	*/
65028		-#if SQLITE_DEBUG
	65190	+#ifdef SQLITE_DEBUG
65029	65191	{
65030	65192	CellInfo info;
65031	65193	pPage->xParseCell(pPage, pCell, &info);
65032	65194	assert( nHeader==(int)(info.pPayload - pCell) );
65033	65195	assert( info.nKey==pX->nKey );
		@@ -66549,11 +66711,11 @@
66549	66711	** copied into the parent, because if the parent is page 1 then it will
66550	66712	** by smaller than the child due to the database header, and so all the
66551	66713	** free space needs to be up front.
66552	66714	*/
66553	66715	assert( nNew==1 \|\| CORRUPT_DB );
66554		- rc = defragmentPage(apNew[0]);
	66716	+ rc = defragmentPage(apNew[0], -1);
66555	66717	testcase( rc!=SQLITE_OK );
66556	66718	assert( apNew[0]->nFree ==
66557	66719	(get2byte(&apNew[0]->aData[5])-apNew[0]->cellOffset-apNew[0]->nCell*2)
66558	66720	\|\| rc!=SQLITE_OK
66559	66721	);
		@@ -71201,10 +71363,11 @@
71201	71363	** Remember the SQL string for a prepared statement.
71202	71364	*/
71203	71365	SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe p, const char z, int n, int isPrepareV2){
71204	71366	assert( isPrepareV2==1 \|\| isPrepareV2==0 );
71205	71367	if( p==0 ) return;
	71368	+ if( !isPrepareV2 ) p->expmask = 0;
71206	71369	#if defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_ENABLE_SQLLOG)
71207	71370	if( !isPrepareV2 ) return;
71208	71371	#endif
71209	71372	assert( p->zSql==0 );
71210	71373	p->zSql = sqlite3DbStrNDup(p->db, z, n);
		@@ -71229,10 +71392,11 @@
71229	71392	pB->pPrev = pTmp;
71230	71393	zTmp = pA->zSql;
71231	71394	pA->zSql = pB->zSql;
71232	71395	pB->zSql = zTmp;
71233	71396	pB->isPrepareV2 = pA->isPrepareV2;
	71397	+ pB->expmask = pA->expmask;
71234	71398	}
71235	71399
71236	71400	/*
71237	71401	** Resize the Vdbe.aOp array so that it is at least nOp elements larger
71238	71402	** than its current size. nOp is guaranteed to be less than or equal
		@@ -73753,17 +73917,17 @@
73753	73917	** Then the internal cache might have been left in an inconsistent
73754	73918	** state. We need to rollback the statement transaction, if there is
73755	73919	** one, or the complete transaction if there is no statement transaction.
73756	73920	*/
73757	73921
	73922	+ if( p->magic!=VDBE_MAGIC_RUN ){
	73923	+ return SQLITE_OK;
	73924	+ }
73758	73925	if( db->mallocFailed ){
73759	73926	p->rc = SQLITE_NOMEM_BKPT;
73760	73927	}
73761	73928	closeAllCursors(p);
73762		- if( p->magic!=VDBE_MAGIC_RUN ){
73763		- return SQLITE_OK;
73764		- }
73765	73929	checkActiveVdbeCnt(db);
73766	73930
73767	73931	/* No commit or rollback needed if the program never started or if the
73768	73932	** SQL statement does not read or write a database file. */
73769	73933	if( p->pc>=0 && p->bIsReader ){
		@@ -74706,11 +74870,11 @@
74706	74870	}
74707	74871	assert( u<=pKeyInfo->nField + 1 );
74708	74872	p->nField = u;
74709	74873	}
74710	74874
74711		-#if SQLITE_DEBUG
	74875	+#ifdef SQLITE_DEBUG
74712	74876	/*
74713	74877	** This function compares two index or table record keys in the same way
74714	74878	** as the sqlite3VdbeRecordCompare() routine. Unlike VdbeRecordCompare(),
74715	74879	** this function deserializes and compares values using the
74716	74880	** sqlite3VdbeSerialGet() and sqlite3MemCompare() functions. It is used
		@@ -74811,11 +74975,11 @@
74811	74975	if( pKeyInfo->db->mallocFailed ) return 1;
74812	74976	return 0;
74813	74977	}
74814	74978	#endif
74815	74979
74816		-#if SQLITE_DEBUG
	74980	+#ifdef SQLITE_DEBUG
74817	74981	/*
74818	74982	** Count the number of fields (a.k.a. columns) in the record given by
74819	74983	** pKey,nKey. The verify that this count is less than or equal to the
74820	74984	** limit given by pKeyInfo->nField + pKeyInfo->nXField.
74821	74985	**
		@@ -75694,12 +75858,12 @@
75694	75858	** to sqlite3_reoptimize() that re-preparing the statement may result
75695	75859	** in a better query plan.
75696	75860	*/
75697	75861	SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe *v, int iVar){
75698	75862	assert( iVar>0 );
75699		- if( iVar>32 ){
75700		- v->expmask = 0xffffffff;
	75863	+ if( iVar>=32 ){
	75864	+ v->expmask \|= 0x80000000;
75701	75865	}else{
75702	75866	v->expmask \|= ((u32)1 << (iVar-1));
75703	75867	}
75704	75868	}
75705	75869
		@@ -75965,11 +76129,12 @@
75965	76129	sqlite3_mutex_enter(mutex);
75966	76130	for(i=0; i<p->nVar; i++){
75967	76131	sqlite3VdbeMemRelease(&p->aVar[i]);
75968	76132	p->aVar[i].flags = MEM_Null;
75969	76133	}
75970		- if( p->isPrepareV2 && p->expmask ){
	76134	+ assert( p->isPrepareV2 \|\| p->expmask==0 );
	76135	+ if( p->expmask ){
75971	76136	p->expired = 1;
75972	76137	}
75973	76138	sqlite3_mutex_leave(mutex);
75974	76139	return rc;
75975	76140	}
		@@ -77069,13 +77234,12 @@
77069	77234	** parameter in the WHERE clause might influence the choice of query plan
77070	77235	** for a statement, then the statement will be automatically recompiled,
77071	77236	** as if there had been a schema change, on the first sqlite3_step() call
77072	77237	** following any change to the bindings of that parameter.
77073	77238	*/
77074		- if( p->isPrepareV2 &&
77075		- ((i<32 && p->expmask & ((u32)1 << i)) \|\| p->expmask==0xffffffff)
77076		- ){
	77239	+ assert( p->isPrepareV2 \|\| p->expmask==0 );
	77240	+ if( p->expmask!=0 && (p->expmask & (i>=31 ? 0x80000000 : (u32)1<<i))!=0 ){
77077	77241	p->expired = 1;
77078	77242	}
77079	77243	return SQLITE_OK;
77080	77244	}
77081	77245
		@@ -77334,14 +77498,16 @@
77334	77498	Vdbe pFrom = (Vdbe)pFromStmt;
77335	77499	Vdbe pTo = (Vdbe)pToStmt;
77336	77500	if( pFrom->nVar!=pTo->nVar ){
77337	77501	return SQLITE_ERROR;
77338	77502	}
77339		- if( pTo->isPrepareV2 && pTo->expmask ){
	77503	+ assert( pTo->isPrepareV2 \|\| pTo->expmask==0 );
	77504	+ if( pTo->expmask ){
77340	77505	pTo->expired = 1;
77341	77506	}
77342		- if( pFrom->isPrepareV2 && pFrom->expmask ){
	77507	+ assert( pFrom->isPrepareV2 \|\| pFrom->expmask==0 );
	77508	+ if( pFrom->expmask ){
77343	77509	pFrom->expired = 1;
77344	77510	}
77345	77511	return sqlite3TransferBindings(pFromStmt, pToStmt);
77346	77512	}
77347	77513	#endif
		@@ -79658,39 +79824,39 @@
79658	79824	if( pCtx->pOut != pOut ){
79659	79825	pCtx->pOut = pOut;
79660	79826	for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
79661	79827	}
79662	79828
79663		- memAboutToChange(p, pCtx->pOut);
	79829	+ memAboutToChange(p, pOut);
79664	79830	#ifdef SQLITE_DEBUG
79665	79831	for(i=0; i<pCtx->argc; i++){
79666	79832	assert( memIsValid(pCtx->argv[i]) );
79667	79833	REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
79668	79834	}
79669	79835	#endif
79670		- MemSetTypeFlag(pCtx->pOut, MEM_Null);
	79836	+ MemSetTypeFlag(pOut, MEM_Null);
79671	79837	pCtx->fErrorOrAux = 0;
79672	79838	(pCtx->pFunc->xSFunc)(pCtx, pCtx->argc, pCtx->argv);/ IMP: R-24505-23230 */
79673	79839
79674	79840	/* If the function returned an error, throw an exception */
79675	79841	if( pCtx->fErrorOrAux ){
79676	79842	if( pCtx->isError ){
79677		- sqlite3VdbeError(p, "%s", sqlite3_value_text(pCtx->pOut));
	79843	+ sqlite3VdbeError(p, "%s", sqlite3_value_text(pOut));
79678	79844	rc = pCtx->isError;
79679	79845	}
79680	79846	sqlite3VdbeDeleteAuxData(db, &p->pAuxData, pCtx->iOp, pOp->p1);
79681	79847	if( rc ) goto abort_due_to_error;
79682	79848	}
79683	79849
79684	79850	/* Copy the result of the function into register P3 */
79685	79851	if( pOut->flags & (MEM_Str\|MEM_Blob) ){
79686		- sqlite3VdbeChangeEncoding(pCtx->pOut, encoding);
79687		- if( sqlite3VdbeMemTooBig(pCtx->pOut) ) goto too_big;
	79852	+ sqlite3VdbeChangeEncoding(pOut, encoding);
	79853	+ if( sqlite3VdbeMemTooBig(pOut) ) goto too_big;
79688	79854	}
79689	79855
79690		- REGISTER_TRACE(pOp->p3, pCtx->pOut);
79691		- UPDATE_MAX_BLOBSIZE(pCtx->pOut);
	79856	+ REGISTER_TRACE(pOp->p3, pOut);
	79857	+ UPDATE_MAX_BLOBSIZE(pOut);
79692	79858	break;
79693	79859	}
79694	79860
79695	79861	/* Opcode: BitAnd P1 P2 P3 * *
79696	79862	** Synopsis: r[P3]=r[P1]&r[P2]
		@@ -80187,11 +80353,11 @@
80187	80353	pKeyInfo = pOp->p4.pKeyInfo;
80188	80354	assert( n>0 );
80189	80355	assert( pKeyInfo!=0 );
80190	80356	p1 = pOp->p1;
80191	80357	p2 = pOp->p2;
80192		-#if SQLITE_DEBUG
	80358	+#ifdef SQLITE_DEBUG
80193	80359	if( aPermute ){
80194	80360	int k, mx = 0;
80195	80361	for(k=0; k<n; k++) if( aPermute[k]>mx ) mx = aPermute[k];
80196	80362	assert( p1>0 && p1+mx<=(p->nMem+1 - p->nCursor)+1 );
80197	80363	assert( p2>0 && p2+mx<=(p->nMem+1 - p->nCursor)+1 );
		@@ -82836,10 +83002,37 @@
82836	83002	assert( pOp->p2==0 );
82837	83003	}
82838	83004	break;
82839	83005	}
82840	83006
	83007	+/* Opcode: IfSmaller P1 P2 P3 * *
	83008	+**
	83009	+** Estimate the number of rows in the table P1. Jump to P2 if that
	83010	+ estimate is less than approximately 2(0.1*P3).
	83011	+*/
	83012	+case OP_IfSmaller: { /* jump */
	83013	+ VdbeCursor *pC;
	83014	+ BtCursor *pCrsr;
	83015	+ int res;
	83016	+ i64 sz;
	83017	+
	83018	+ assert( pOp->p1>=0 && pOp->p1<p->nCursor );
	83019	+ pC = p->apCsr[pOp->p1];
	83020	+ assert( pC!=0 );
	83021	+ pCrsr = pC->uc.pCursor;
	83022	+ assert( pCrsr );
	83023	+ rc = sqlite3BtreeFirst(pCrsr, &res);
	83024	+ if( rc ) goto abort_due_to_error;
	83025	+ if( res==0 ){
	83026	+ sz = sqlite3BtreeRowCountEst(pCrsr);
	83027	+ if( ALWAYS(sz>=0) && sqlite3LogEst((u64)sz)<pOp->p3 ) res = 1;
	83028	+ }
	83029	+ VdbeBranchTaken(res!=0,2);
	83030	+ if( res ) goto jump_to_p2;
	83031	+ break;
	83032	+}
	83033	+
82841	83034
82842	83035	/* Opcode: SorterSort P1 P2 * * *
82843	83036	**
82844	83037	** After all records have been inserted into the Sorter object
82845	83038	** identified by P1, invoke this opcode to actually do the sorting.
		@@ -83479,10 +83672,22 @@
83479	83672	rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, flags);
83480	83673	if( rc ) goto abort_due_to_error;
83481	83674	pOut->u.i = pgno;
83482	83675	break;
83483	83676	}
	83677	+
	83678	+/* Opcode: SqlExec * * * P4 *
	83679	+**
	83680	+** Run the SQL statement or statements specified in the P4 string.
	83681	+*/
	83682	+case OP_SqlExec: {
	83683	+ db->nSqlExec++;
	83684	+ rc = sqlite3_exec(db, pOp->p4.z, 0, 0, 0);
	83685	+ db->nSqlExec--;
	83686	+ if( rc ) goto abort_due_to_error;
	83687	+ break;
	83688	+}
83484	83689
83485	83690	/* Opcode: ParseSchema P1 * * P4 *
83486	83691	**
83487	83692	** Read and parse all entries from the SQLITE_MASTER table of database P1
83488	83693	** that match the WHERE clause P4.
		@@ -83600,11 +83805,11 @@
83600	83805	**
83601	83806	** Do an analysis of the currently open database. Store in
83602	83807	** register P1 the text of an error message describing any problems.
83603	83808	** If no problems are found, store a NULL in register P1.
83604	83809	**
83605		-** The register P3 contains the maximum number of allowed errors.
	83810	+** The register P3 contains one less than the maximum number of allowed errors.
83606	83811	** At most reg(P3) errors will be reported.
83607	83812	** In other words, the analysis stops as soon as reg(P1) errors are
83608	83813	** seen. Reg(P1) is updated with the number of errors remaining.
83609	83814	**
83610	83815	** The root page numbers of all tables in the database are integers
		@@ -83633,18 +83838,18 @@
83633	83838	assert( (pnErr->flags & (MEM_Str\|MEM_Blob))==0 );
83634	83839	pIn1 = &aMem[pOp->p1];
83635	83840	assert( pOp->p5<db->nDb );
83636	83841	assert( DbMaskTest(p->btreeMask, pOp->p5) );
83637	83842	z = sqlite3BtreeIntegrityCheck(db->aDb[pOp->p5].pBt, aRoot, nRoot,
83638		- (int)pnErr->u.i, &nErr);
83639		- pnErr->u.i -= nErr;
	83843	+ (int)pnErr->u.i+1, &nErr);
83640	83844	sqlite3VdbeMemSetNull(pIn1);
83641	83845	if( nErr==0 ){
83642	83846	assert( z==0 );
83643	83847	}else if( z==0 ){
83644	83848	goto no_mem;
83645	83849	}else{
	83850	+ pnErr->u.i -= nErr-1;
83646	83851	sqlite3VdbeMemSetStr(pIn1, z, -1, SQLITE_UTF8, sqlite3_free);
83647	83852	}
83648	83853	UPDATE_MAX_BLOBSIZE(pIn1);
83649	83854	sqlite3VdbeChangeEncoding(pIn1, encoding);
83650	83855	break;
		@@ -88787,15 +88992,15 @@
88787	88992	** The return value from the callback should be one of the WRC_*
88788	88993	** constants to specify how to proceed with the walk.
88789	88994	**
88790	88995	** WRC_Continue Continue descending down the tree.
88791	88996	**
88792		-** WRC_Prune Do not descend into child nodes. But allow
	88997	+** WRC_Prune Do not descend into child nodes, but allow
88793	88998	** the walk to continue with sibling nodes.
88794	88999	**
88795	89000	** WRC_Abort Do no more callbacks. Unwind the stack and
88796		-** return the top-level walk call.
	89001	+** return from the top-level walk call.
88797	89002	**
88798	89003	** The return value from this routine is WRC_Abort to abandon the tree walk
88799	89004	** and WRC_Continue to continue.
88800	89005	*/
88801	89006	static SQLITE_NOINLINE int walkExpr(Walker pWalker, Expr pExpr){
		@@ -89153,11 +89358,12 @@
89153	89358	}
89154	89359	}
89155	89360	}
89156	89361
89157	89362	/* Start at the inner-most context and move outward until a match is found */
89158		- while( pNC && cnt==0 ){
	89363	+ assert( pNC && cnt==0 );
	89364	+ do{
89159	89365	ExprList *pEList;
89160	89366	SrcList *pSrcList = pNC->pSrcList;
89161	89367
89162	89368	if( pSrcList ){
89163	89369	for(i=0, pItem=pSrcList->a; i<pSrcList->nSrc; i++, pItem++){
		@@ -89338,15 +89544,15 @@
89338	89544	}
89339	89545
89340	89546	/* Advance to the next name context. The loop will exit when either
89341	89547	** we have a match (cnt>0) or when we run out of name contexts.
89342	89548	*/
89343		- if( cnt==0 ){
89344		- pNC = pNC->pNext;
89345		- nSubquery++;
89346		- }
89347		- }
	89549	+ if( cnt ) break;
	89550	+ pNC = pNC->pNext;
	89551	+ nSubquery++;
	89552	+ }while( pNC );
	89553	+
89348	89554
89349	89555	/*
89350	89556	** If X and Y are NULL (in other words if only the column name Z is
89351	89557	** supplied) and the value of Z is enclosed in double-quotes, then
89352	89558	** Z is a string literal if it doesn't match any column names. In that
		@@ -89532,37 +89738,42 @@
89532	89738	break;
89533	89739	}
89534	89740	#endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT)
89535	89741	&& !defined(SQLITE_OMIT_SUBQUERY) */
89536	89742
89537		- /* A lone identifier is the name of a column.
89538		- */
89539		- case TK_ID: {
89540		- return lookupName(pParse, 0, 0, pExpr->u.zToken, pNC, pExpr);
89541		- }
89542		-
89543		- /* A table name and column name: ID.ID
	89743	+ /* A column name: ID
	89744	+ ** Or table name and column name: ID.ID
89544	89745	** Or a database, table and column: ID.ID.ID
	89746	+ **
	89747	+ ** The TK_ID and TK_OUT cases are combined so that there will only
	89748	+ ** be one call to lookupName(). Then the compiler will in-line
	89749	+ ** lookupName() for a size reduction and performance increase.
89545	89750	*/
	89751	+ case TK_ID:
89546	89752	case TK_DOT: {
89547	89753	const char *zColumn;
89548	89754	const char *zTable;
89549	89755	const char *zDb;
89550	89756	Expr *pRight;
89551	89757
89552		- /* if( pSrcList==0 ) break; */
89553		- notValid(pParse, pNC, "the \".\" operator", NC_IdxExpr);
89554		- pRight = pExpr->pRight;
89555		- if( pRight->op==TK_ID ){
	89758	+ if( pExpr->op==TK_ID ){
89556	89759	zDb = 0;
89557		- zTable = pExpr->pLeft->u.zToken;
89558		- zColumn = pRight->u.zToken;
	89760	+ zTable = 0;
	89761	+ zColumn = pExpr->u.zToken;
89559	89762	}else{
89560		- assert( pRight->op==TK_DOT );
89561		- zDb = pExpr->pLeft->u.zToken;
89562		- zTable = pRight->pLeft->u.zToken;
89563		- zColumn = pRight->pRight->u.zToken;
	89763	+ notValid(pParse, pNC, "the \".\" operator", NC_IdxExpr);
	89764	+ pRight = pExpr->pRight;
	89765	+ if( pRight->op==TK_ID ){
	89766	+ zDb = 0;
	89767	+ zTable = pExpr->pLeft->u.zToken;
	89768	+ zColumn = pRight->u.zToken;
	89769	+ }else{
	89770	+ assert( pRight->op==TK_DOT );
	89771	+ zDb = pExpr->pLeft->u.zToken;
	89772	+ zTable = pRight->pLeft->u.zToken;
	89773	+ zColumn = pRight->pRight->u.zToken;
	89774	+ }
89564	89775	}
89565	89776	return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr);
89566	89777	}
89567	89778
89568	89779	/* Resolve function names
		@@ -92833,11 +93044,11 @@
92833	93044	int nVal = sqlite3ExprVectorSize(pLeft);
92834	93045	Select *pSelect = (pExpr->flags & EP_xIsSelect) ? pExpr->x.pSelect : 0;
92835	93046	char *zRet;
92836	93047
92837	93048	assert( pExpr->op==TK_IN );
92838		- zRet = sqlite3DbMallocZero(pParse->db, nVal+1);
	93049	+ zRet = sqlite3DbMallocRaw(pParse->db, nVal+1);
92839	93050	if( zRet ){
92840	93051	int i;
92841	93052	for(i=0; i<nVal; i++){
92842	93053	Expr *pA = sqlite3VectorFieldSubexpr(pLeft, i);
92843	93054	char a = sqlite3ExprAffinity(pA);
		@@ -93738,11 +93949,11 @@
93738	93949	** Clear all column cache entries.
93739	93950	*/
93740	93951	SQLITE_PRIVATE void sqlite3ExprCacheClear(Parse *pParse){
93741	93952	int i;
93742	93953
93743		-#if SQLITE_DEBUG
	93954	+#ifdef SQLITE_DEBUG
93744	93955	if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
93745	93956	printf("CLEAR\n");
93746	93957	}
93747	93958	#endif
93748	93959	for(i=0; i<pParse->nColCache; i++){
		@@ -95145,10 +95356,21 @@
95145	95356	if( pA->a[i].sortOrder!=pB->a[i].sortOrder ) return 1;
95146	95357	if( sqlite3ExprCompare(pExprA, pExprB, iTab) ) return 1;
95147	95358	}
95148	95359	return 0;
95149	95360	}
	95361	+
	95362	+/*
	95363	+** Like sqlite3ExprCompare() except COLLATE operators at the top-level
	95364	+** are ignored.
	95365	+*/
	95366	+SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr pA, Expr pB, int iTab){
	95367	+ return sqlite3ExprCompare(
	95368	+ sqlite3ExprSkipCollate(pA),
	95369	+ sqlite3ExprSkipCollate(pB),
	95370	+ iTab);
	95371	+}
95150	95372
95151	95373	/*
95152	95374	** Return true if we can prove the pE2 will always be true if pE1 is
95153	95375	** true. Return false if we cannot complete the proof or if pE2 might
95154	95376	** be false. Examples:
		@@ -96698,10 +96920,11 @@
96698	96920	Stat4Sample current; /* Current row as a Stat4Sample */
96699	96921	u32 iPrn; /* Pseudo-random number used for sampling */
96700	96922	Stat4Sample aBest; / Array of nCol best samples */
96701	96923	int iMin; /* Index in a[] of entry with minimum score */
96702	96924	int nSample; /* Current number of samples */
	96925	+ int nMaxEqZero; /* Max leading 0 in anEq[] for any a[] entry */
96703	96926	int iGet; /* Index of current sample accessed by stat_get() */
96704	96927	Stat4Sample a; / Array of mxSample Stat4Sample objects */
96705	96928	sqlite3 db; / Database connection, for malloc() */
96706	96929	};
96707	96930
		@@ -96962,10 +97185,17 @@
96962	97185	int i;
96963	97186
96964	97187	assert( IsStat4 \|\| nEqZero==0 );
96965	97188
96966	97189	#ifdef SQLITE_ENABLE_STAT4
	97190	+ /* Stat4Accum.nMaxEqZero is set to the maximum number of leading 0
	97191	+ ** values in the anEq[] array of any sample in Stat4Accum.a[]. In
	97192	+ ** other words, if nMaxEqZero is n, then it is guaranteed that there
	97193	+ ** are no samples with Stat4Sample.anEq[m]==0 for (m>=n). */
	97194	+ if( nEqZero>p->nMaxEqZero ){
	97195	+ p->nMaxEqZero = nEqZero;
	97196	+ }
96967	97197	if( pNew->isPSample==0 ){
96968	97198	Stat4Sample *pUpgrade = 0;
96969	97199	assert( pNew->anEq[pNew->iCol]>0 );
96970	97200
96971	97201	/* This sample is being added because the prefix that ends in column
		@@ -97059,16 +97289,26 @@
97059	97289	if( p->nSample<p->mxSample \|\| sampleIsBetter(p, pBest, &p->a[p->iMin]) ){
97060	97290	sampleInsert(p, pBest, i);
97061	97291	}
97062	97292	}
97063	97293
97064		- /* Update the anEq[] fields of any samples already collected. */
	97294	+ /* Check that no sample contains an anEq[] entry with an index of
	97295	+ ** p->nMaxEqZero or greater set to zero. */
97065	97296	for(i=p->nSample-1; i>=0; i--){
97066	97297	int j;
97067		- for(j=iChng; j<p->nCol; j++){
97068		- if( p->a[i].anEq[j]==0 ) p->a[i].anEq[j] = p->current.anEq[j];
	97298	+ for(j=p->nMaxEqZero; j<p->nCol; j++) assert( p->a[i].anEq[j]>0 );
	97299	+ }
	97300	+
	97301	+ /* Update the anEq[] fields of any samples already collected. */
	97302	+ if( iChng<p->nMaxEqZero ){
	97303	+ for(i=p->nSample-1; i>=0; i--){
	97304	+ int j;
	97305	+ for(j=iChng; j<p->nCol; j++){
	97306	+ if( p->a[i].anEq[j]==0 ) p->a[i].anEq[j] = p->current.anEq[j];
	97307	+ }
97069	97308	}
	97309	+ p->nMaxEqZero = iChng;
97070	97310	}
97071	97311	#endif
97072	97312
97073	97313	#if defined(SQLITE_ENABLE_STAT3) && !defined(SQLITE_ENABLE_STAT4)
97074	97314	if( iChng==0 ){
		@@ -97778,44 +98018,32 @@
97778	98018	/* Form 1: Analyze everything */
97779	98019	for(i=0; i<db->nDb; i++){
97780	98020	if( i==1 ) continue; /* Do not analyze the TEMP database */
97781	98021	analyzeDatabase(pParse, i);
97782	98022	}
97783		- }else if( pName2->n==0 ){
97784		- /* Form 2: Analyze the database or table named */
97785		- iDb = sqlite3FindDb(db, pName1);
97786		- if( iDb>=0 ){
97787		- analyzeDatabase(pParse, iDb);
97788		- }else{
97789		- z = sqlite3NameFromToken(db, pName1);
97790		- if( z ){
97791		- if( (pIdx = sqlite3FindIndex(db, z, 0))!=0 ){
97792		- analyzeTable(pParse, pIdx->pTable, pIdx);
97793		- }else if( (pTab = sqlite3LocateTable(pParse, 0, z, 0))!=0 ){
97794		- analyzeTable(pParse, pTab, 0);
97795		- }
97796		- sqlite3DbFree(db, z);
97797		- }
97798		- }
97799		- }else{
97800		- /* Form 3: Analyze the fully qualified table name */
	98023	+ }else if( pName2->n==0 && (iDb = sqlite3FindDb(db, pName1))>=0 ){
	98024	+ /* Analyze the schema named as the argument */
	98025	+ analyzeDatabase(pParse, iDb);
	98026	+ }else{
	98027	+ /* Form 3: Analyze the table or index named as an argument */
97801	98028	iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName);
97802	98029	if( iDb>=0 ){
97803		- zDb = db->aDb[iDb].zDbSName;
	98030	+ zDb = pName2->n ? db->aDb[iDb].zDbSName : 0;
97804	98031	z = sqlite3NameFromToken(db, pTableName);
97805	98032	if( z ){
97806	98033	if( (pIdx = sqlite3FindIndex(db, z, zDb))!=0 ){
97807	98034	analyzeTable(pParse, pIdx->pTable, pIdx);
97808	98035	}else if( (pTab = sqlite3LocateTable(pParse, 0, z, zDb))!=0 ){
97809	98036	analyzeTable(pParse, pTab, 0);
97810	98037	}
97811	98038	sqlite3DbFree(db, z);
97812	98039	}
97813		- }
	98040	+ }
97814	98041	}
97815		- v = sqlite3GetVdbe(pParse);
97816		- if( v ) sqlite3VdbeAddOp0(v, OP_Expire);
	98042	+ if( db->nSqlExec==0 && (v = sqlite3GetVdbe(pParse))!=0 ){
	98043	+ sqlite3VdbeAddOp0(v, OP_Expire);
	98044	+ }
97817	98045	}
97818	98046
97819	98047	/*
97820	98048	** Used to pass information from the analyzer reader through to the
97821	98049	** callback routine.
		@@ -97940,19 +98168,24 @@
97940	98168	}
97941	98169	aiRowEst = pIndex->aiRowEst;
97942	98170	#endif
97943	98171	pIndex->bUnordered = 0;
97944	98172	decodeIntArray((char*)z, nCol, aiRowEst, pIndex->aiRowLogEst, pIndex);
97945		- if( pIndex->pPartIdxWhere==0 ) pTable->nRowLogEst = pIndex->aiRowLogEst[0];
	98173	+ pIndex->hasStat1 = 1;
	98174	+ if( pIndex->pPartIdxWhere==0 ){
	98175	+ pTable->nRowLogEst = pIndex->aiRowLogEst[0];
	98176	+ pTable->tabFlags \|= TF_HasStat1;
	98177	+ }
97946	98178	}else{
97947	98179	Index fakeIdx;
97948	98180	fakeIdx.szIdxRow = pTable->szTabRow;
97949	98181	#ifdef SQLITE_ENABLE_COSTMULT
97950	98182	fakeIdx.pTable = pTable;
97951	98183	#endif
97952	98184	decodeIntArray((char*)z, 1, 0, &pTable->nRowLogEst, &fakeIdx);
97953	98185	pTable->szTabRow = fakeIdx.szIdxRow;
	98186	+ pTable->tabFlags \|= TF_HasStat1;
97954	98187	}
97955	98188
97956	98189	return 0;
97957	98190	}
97958	98191
		@@ -98243,19 +98476,24 @@
98243	98476	SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
98244	98477	analysisInfo sInfo;
98245	98478	HashElem *i;
98246	98479	char *zSql;
98247	98480	int rc = SQLITE_OK;
	98481	+ Schema *pSchema = db->aDb[iDb].pSchema;
98248	98482
98249	98483	assert( iDb>=0 && iDb<db->nDb );
98250	98484	assert( db->aDb[iDb].pBt!=0 );
98251	98485
98252	98486	/* Clear any prior statistics */
98253	98487	assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
98254		- for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){
	98488	+ for(i=sqliteHashFirst(&pSchema->tblHash); i; i=sqliteHashNext(i)){
	98489	+ Table *pTab = sqliteHashData(i);
	98490	+ pTab->tabFlags &= ~TF_HasStat1;
	98491	+ }
	98492	+ for(i=sqliteHashFirst(&pSchema->idxHash); i; i=sqliteHashNext(i)){
98255	98493	Index *pIdx = sqliteHashData(i);
98256		- pIdx->aiRowLogEst[0] = 0;
	98494	+ pIdx->hasStat1 = 0;
98257	98495	#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
98258	98496	sqlite3DeleteIndexSamples(db, pIdx);
98259	98497	pIdx->aSample = 0;
98260	98498	#endif
98261	98499	}
		@@ -98274,23 +98512,23 @@
98274	98512	}
98275	98513	}
98276	98514
98277	98515	/* Set appropriate defaults on all indexes not in the sqlite_stat1 table */
98278	98516	assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
98279		- for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){
	98517	+ for(i=sqliteHashFirst(&pSchema->idxHash); i; i=sqliteHashNext(i)){
98280	98518	Index *pIdx = sqliteHashData(i);
98281		- if( pIdx->aiRowLogEst[0]==0 ) sqlite3DefaultRowEst(pIdx);
	98519	+ if( !pIdx->hasStat1 ) sqlite3DefaultRowEst(pIdx);
98282	98520	}
98283	98521
98284	98522	/* Load the statistics from the sqlite_stat4 table. */
98285	98523	#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
98286	98524	if( rc==SQLITE_OK && OptimizationEnabled(db, SQLITE_Stat34) ){
98287	98525	db->lookaside.bDisable++;
98288	98526	rc = loadStat4(db, sInfo.zDatabase);
98289	98527	db->lookaside.bDisable--;
98290	98528	}
98291		- for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){
	98529	+ for(i=sqliteHashFirst(&pSchema->idxHash); i; i=sqliteHashNext(i)){
98292	98530	Index *pIdx = sqliteHashData(i);
98293	98531	sqlite3_free(pIdx->aiRowEst);
98294	98532	pIdx->aiRowEst = 0;
98295	98533	}
98296	98534	#endif
		@@ -100271,10 +100509,11 @@
100271	100509	SQLITE_PRIVATE void sqlite3AddNotNull(Parse *pParse, int onError){
100272	100510	Table *p;
100273	100511	p = pParse->pNewTable;
100274	100512	if( p==0 \|\| NEVER(p->nCol<1) ) return;
100275	100513	p->aCol[p->nCol-1].notNull = (u8)onError;
	100514	+ p->tabFlags \|= TF_HasNotNull;
100276	100515	}
100277	100516
100278	100517	/*
100279	100518	** Scan the column type name zType (length nType) and return the
100280	100519	** associated affinity type.
		@@ -102609,10 +102848,13 @@
102609	102848	/* 10, 9, 8, 7, 6 */
102610	102849	LogEst aVal[] = { 33, 32, 30, 28, 26 };
102611	102850	LogEst *a = pIdx->aiRowLogEst;
102612	102851	int nCopy = MIN(ArraySize(aVal), pIdx->nKeyCol);
102613	102852	int i;
	102853	+
	102854	+ /* Indexes with default row estimates should not have stat1 data */
	102855	+ assert( !pIdx->hasStat1 );
102614	102856
102615	102857	/* Set the first entry (number of rows in the index) to the estimated
102616	102858	** number of rows in the table, or half the number of rows in the table
102617	102859	** for a partial index. But do not let the estimate drop below 10. */
102618	102860	a[0] = pIdx->pTable->nRowLogEst;
		@@ -109798,10 +110040,13 @@
109798	110040	VdbeComment((v, "%s", iField<0 ? "rowid" : pTab->aCol[iField].zName));
109799	110041	}
109800	110042	}
109801	110043	sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn, aRegIdx[ix]);
109802	110044	VdbeComment((v, "for %s", pIdx->zName));
	110045	+#ifdef SQLITE_ENABLE_NULL_TRIM
	110046	+ if( pIdx->idxType==2 ) sqlite3SetMakeRecordP5(v, pIdx->pTable);
	110047	+#endif
109803	110048
109804	110049	/* In an UPDATE operation, if this index is the PRIMARY KEY index
109805	110050	** of a WITHOUT ROWID table and there has been no change the
109806	110051	** primary key, then no collision is possible. The collision detection
109807	110052	** logic below can all be skipped. */
		@@ -109953,12 +110198,15 @@
109953	110198
109954	110199	/* Records with omitted columns are only allowed for schema format
109955	110200	** version 2 and later (SQLite version 3.1.4, 2005-02-20). */
109956	110201	if( pTab->pSchema->file_format<2 ) return;
109957	110202
109958		- for(i=pTab->nCol; i>1 && pTab->aCol[i-1].pDflt==0; i--){}
109959		- sqlite3VdbeChangeP5(v, i);
	110203	+ for(i=pTab->nCol-1; i>0; i--){
	110204	+ if( pTab->aCol[i].pDflt!=0 ) break;
	110205	+ if( pTab->aCol[i].colFlags & COLFLAG_PRIMKEY ) break;
	110206	+ }
	110207	+ sqlite3VdbeChangeP5(v, i+1);
109960	110208	}
109961	110209	#endif
109962	110210
109963	110211	/*
109964	110212	** This routine generates code to finish the INSERT or UPDATE operation
		@@ -110244,11 +110492,11 @@
110244	110492	}
110245	110493	if( sqlite3TriggerList(pParse, pDest) ){
110246	110494	return 0; /* tab1 must not have triggers */
110247	110495	}
110248	110496	#ifndef SQLITE_OMIT_VIRTUALTABLE
110249		- if( pDest->tabFlags & TF_Virtual ){
	110497	+ if( IsVirtual(pDest) ){
110250	110498	return 0; /* tab1 must not be a virtual table */
110251	110499	}
110252	110500	#endif
110253	110501	if( onError==OE_Default ){
110254	110502	if( pDest->iPKey>=0 ) onError = pDest->keyConf;
		@@ -110306,11 +110554,11 @@
110306	110554	}
110307	110555	if( HasRowid(pDest)!=HasRowid(pSrc) ){
110308	110556	return 0; /* source and destination must both be WITHOUT ROWID or not */
110309	110557	}
110310	110558	#ifndef SQLITE_OMIT_VIRTUALTABLE
110311		- if( pSrc->tabFlags & TF_Virtual ){
	110559	+ if( IsVirtual(pSrc) ){
110312	110560	return 0; /* tab2 must not be a virtual table */
110313	110561	}
110314	110562	#endif
110315	110563	if( pSrc->pSelect ){
110316	110564	return 0; /* tab2 may not be a view */
		@@ -110603,11 +110851,11 @@
110603	110851	/* Invoke the callback function if required */
110604	110852	if( xCallback && (SQLITE_ROW==rc \|\|
110605	110853	(SQLITE_DONE==rc && !callbackIsInit
110606	110854	&& db->flags&SQLITE_NullCallback)) ){
110607	110855	if( !callbackIsInit ){
110608		- azCols = sqlite3DbMallocZero(db, 2nColsizeof(const char*) + 1);
	110856	+ azCols = sqlite3DbMallocRaw(db, (2nCol+1)sizeof(const char*));
110609	110857	if( azCols==0 ){
110610	110858	goto exec_out;
110611	110859	}
110612	110860	for(i=0; i<nCol; i++){
110613	110861	azCols[i] = (char *)sqlite3_column_name(pStmt, i);
		@@ -110624,10 +110872,11 @@
110624	110872	if( !azVals[i] && sqlite3_column_type(pStmt, i)!=SQLITE_NULL ){
110625	110873	sqlite3OomFault(db);
110626	110874	goto exec_out;
110627	110875	}
110628	110876	}
	110877	+ azVals[i] = 0;
110629	110878	}
110630	110879	if( xCallback(pArg, nCol, azVals, azCols) ){
110631	110880	/* EVIDENCE-OF: R-38229-40159 If the callback function to
110632	110881	** sqlite3_exec() returns non-zero, then sqlite3_exec() will
110633	110882	** return SQLITE_ABORT. */
		@@ -112094,15 +112343,15 @@
112094	112343	#define PragTyp_JOURNAL_SIZE_LIMIT 20
112095	112344	#define PragTyp_LOCK_PROXY_FILE 21
112096	112345	#define PragTyp_LOCKING_MODE 22
112097	112346	#define PragTyp_PAGE_COUNT 23
112098	112347	#define PragTyp_MMAP_SIZE 24
112099		-#define PragTyp_PAGE_SIZE 25
112100		-#define PragTyp_SECURE_DELETE 26
112101		-#define PragTyp_SHRINK_MEMORY 27
112102		-#define PragTyp_SOFT_HEAP_LIMIT 28
112103		-#define PragTyp_STATS 29
	112348	+#define PragTyp_OPTIMIZE 25
	112349	+#define PragTyp_PAGE_SIZE 26
	112350	+#define PragTyp_SECURE_DELETE 27
	112351	+#define PragTyp_SHRINK_MEMORY 28
	112352	+#define PragTyp_SOFT_HEAP_LIMIT 29
112104	112353	#define PragTyp_SYNCHRONOUS 30
112105	112354	#define PragTyp_TABLE_INFO 31
112106	112355	#define PragTyp_TEMP_STORE 32
112107	112356	#define PragTyp_TEMP_STORE_DIRECTORY 33
112108	112357	#define PragTyp_THREADS 34
		@@ -112112,10 +112361,11 @@
112112	112361	#define PragTyp_HEXKEY 38
112113	112362	#define PragTyp_KEY 39
112114	112363	#define PragTyp_REKEY 40
112115	112364	#define PragTyp_LOCK_STATUS 41
112116	112365	#define PragTyp_PARSER_TRACE 42
	112366	+#define PragTyp_STATS 43
112117	112367
112118	112368	/* Property flags associated with various pragma. */
112119	112369	#define PragFlg_NeedSchema 0x01 /* Force schema load before running */
112120	112370	#define PragFlg_NoColumns 0x02 /* OP_ResultRow called with zero columns */
112121	112371	#define PragFlg_NoColumns1 0x04 /* zero columns if RHS argument is present */
		@@ -112135,51 +112385,52 @@
112135	112385	/* 2 */ "name",
112136	112386	/* 3 */ "type",
112137	112387	/* 4 */ "notnull",
112138	112388	/* 5 */ "dflt_value",
112139	112389	/* 6 */ "pk",
112140		- /* 7 / "table", / Used by: stats */
112141		- /* 8 */ "index",
112142		- /* 9 */ "width",
112143		- /* 10 */ "height",
112144		- /* 11 / "seqno", / Used by: index_info */
112145		- /* 12 */ "cid",
112146		- /* 13 */ "name",
112147		- /* 14 / "seqno", / Used by: index_xinfo */
112148		- /* 15 */ "cid",
112149		- /* 16 */ "name",
112150		- /* 17 */ "desc",
112151		- /* 18 */ "coll",
112152		- /* 19 */ "key",
112153		- /* 20 / "seq", / Used by: index_list */
112154		- /* 21 */ "name",
112155		- /* 22 */ "unique",
112156		- /* 23 */ "origin",
112157		- /* 24 */ "partial",
112158		- /* 25 / "seq", / Used by: database_list */
112159		- /* 26 */ "name",
112160		- /* 27 */ "file",
112161		- /* 28 / "seq", / Used by: collation_list */
112162		- /* 29 */ "name",
112163		- /* 30 / "id", / Used by: foreign_key_list */
112164		- /* 31 */ "seq",
112165		- /* 32 */ "table",
112166		- /* 33 */ "from",
112167		- /* 34 */ "to",
112168		- /* 35 */ "on_update",
112169		- /* 36 */ "on_delete",
112170		- /* 37 */ "match",
112171		- /* 38 / "table", / Used by: foreign_key_check */
112172		- /* 39 */ "rowid",
112173		- /* 40 */ "parent",
112174		- /* 41 */ "fkid",
112175		- /* 42 / "busy", / Used by: wal_checkpoint */
112176		- /* 43 */ "log",
112177		- /* 44 */ "checkpointed",
112178		- /* 45 / "timeout", / Used by: busy_timeout */
112179		- /* 46 / "database", / Used by: lock_status */
112180		- /* 47 */ "status",
	112390	+ /* 7 / "tbl", / Used by: stats */
	112391	+ /* 8 */ "idx",
	112392	+ /* 9 */ "wdth",
	112393	+ /* 10 */ "hght",
	112394	+ /* 11 */ "flgs",
	112395	+ /* 12 / "seqno", / Used by: index_info */
	112396	+ /* 13 */ "cid",
	112397	+ /* 14 */ "name",
	112398	+ /* 15 / "seqno", / Used by: index_xinfo */
	112399	+ /* 16 */ "cid",
	112400	+ /* 17 */ "name",
	112401	+ /* 18 */ "desc",
	112402	+ /* 19 */ "coll",
	112403	+ /* 20 */ "key",
	112404	+ /* 21 / "seq", / Used by: index_list */
	112405	+ /* 22 */ "name",
	112406	+ /* 23 */ "unique",
	112407	+ /* 24 */ "origin",
	112408	+ /* 25 */ "partial",
	112409	+ /* 26 / "seq", / Used by: database_list */
	112410	+ /* 27 */ "name",
	112411	+ /* 28 */ "file",
	112412	+ /* 29 / "seq", / Used by: collation_list */
	112413	+ /* 30 */ "name",
	112414	+ /* 31 / "id", / Used by: foreign_key_list */
	112415	+ /* 32 */ "seq",
	112416	+ /* 33 */ "table",
	112417	+ /* 34 */ "from",
	112418	+ /* 35 */ "to",
	112419	+ /* 36 */ "on_update",
	112420	+ /* 37 */ "on_delete",
	112421	+ /* 38 */ "match",
	112422	+ /* 39 / "table", / Used by: foreign_key_check */
	112423	+ /* 40 */ "rowid",
	112424	+ /* 41 */ "parent",
	112425	+ /* 42 */ "fkid",
	112426	+ /* 43 / "busy", / Used by: wal_checkpoint */
	112427	+ /* 44 */ "log",
	112428	+ /* 45 */ "checkpointed",
	112429	+ /* 46 / "timeout", / Used by: busy_timeout */
	112430	+ /* 47 / "database", / Used by: lock_status */
	112431	+ /* 48 */ "status",
112181	112432	};
112182	112433
112183	112434	/* Definitions of all built-in pragmas */
112184	112435	typedef struct PragmaName {
112185	112436	const char const zName; / Name of pragma */
		@@ -112221,11 +112472,11 @@
112221	112472	#endif
112222	112473	#endif
112223	112474	{/* zName: */ "busy_timeout",
112224	112475	/* ePragTyp: */ PragTyp_BUSY_TIMEOUT,
112225	112476	/* ePragFlg: */ PragFlg_Result0,
112226		- /* ColNames: */ 45, 1,
	112477	+ /* ColNames: */ 46, 1,
112227	112478	/* iArg: */ 0 },
112228	112479	#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
112229	112480	{/* zName: */ "cache_size",
112230	112481	/* ePragTyp: */ PragTyp_CACHE_SIZE,
112231	112482	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result0\|PragFlg_SchemaReq\|PragFlg_NoColumns1,
		@@ -112258,11 +112509,11 @@
112258	112509	#endif
112259	112510	#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
112260	112511	{/* zName: */ "collation_list",
112261	112512	/* ePragTyp: */ PragTyp_COLLATION_LIST,
112262	112513	/* ePragFlg: */ PragFlg_Result0,
112263		- /* ColNames: */ 28, 2,
	112514	+ /* ColNames: */ 29, 2,
112264	112515	/* iArg: */ 0 },
112265	112516	#endif
112266	112517	#if !defined(SQLITE_OMIT_COMPILEOPTION_DIAGS)
112267	112518	{/* zName: */ "compile_options",
112268	112519	/* ePragTyp: */ PragTyp_COMPILE_OPTIONS,
		@@ -112293,11 +112544,11 @@
112293	112544	#endif
112294	112545	#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
112295	112546	{/* zName: */ "database_list",
112296	112547	/* ePragTyp: */ PragTyp_DATABASE_LIST,
112297	112548	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result0,
112298		- /* ColNames: */ 25, 3,
	112549	+ /* ColNames: */ 26, 3,
112299	112550	/* iArg: */ 0 },
112300	112551	#endif
112301	112552	#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED)
112302	112553	{/* zName: */ "default_cache_size",
112303	112554	/* ePragTyp: */ PragTyp_DEFAULT_CACHE_SIZE,
		@@ -112330,18 +112581,18 @@
112330	112581	#endif
112331	112582	#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
112332	112583	{/* zName: */ "foreign_key_check",
112333	112584	/* ePragTyp: */ PragTyp_FOREIGN_KEY_CHECK,
112334	112585	/* ePragFlg: */ PragFlg_NeedSchema,
112335		- /* ColNames: */ 38, 4,
	112586	+ /* ColNames: */ 39, 4,
112336	112587	/* iArg: */ 0 },
112337	112588	#endif
112338	112589	#if !defined(SQLITE_OMIT_FOREIGN_KEY)
112339	112590	{/* zName: */ "foreign_key_list",
112340	112591	/* ePragTyp: */ PragTyp_FOREIGN_KEY_LIST,
112341	112592	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result1\|PragFlg_SchemaOpt,
112342		- /* ColNames: */ 30, 8,
	112593	+ /* ColNames: */ 31, 8,
112343	112594	/* iArg: */ 0 },
112344	112595	#endif
112345	112596	#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
112346	112597	#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
112347	112598	{/* zName: */ "foreign_keys",
		@@ -112400,21 +112651,21 @@
112400	112651	#endif
112401	112652	#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
112402	112653	{/* zName: */ "index_info",
112403	112654	/* ePragTyp: */ PragTyp_INDEX_INFO,
112404	112655	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result1\|PragFlg_SchemaOpt,
112405		- /* ColNames: */ 11, 3,
	112656	+ /* ColNames: */ 12, 3,
112406	112657	/* iArg: */ 0 },
112407	112658	{/* zName: */ "index_list",
112408	112659	/* ePragTyp: */ PragTyp_INDEX_LIST,
112409	112660	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result1\|PragFlg_SchemaOpt,
112410		- /* ColNames: */ 20, 5,
	112661	+ /* ColNames: */ 21, 5,
112411	112662	/* iArg: */ 0 },
112412	112663	{/* zName: */ "index_xinfo",
112413	112664	/* ePragTyp: */ PragTyp_INDEX_INFO,
112414	112665	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result1\|PragFlg_SchemaOpt,
112415		- /* ColNames: */ 14, 6,
	112666	+ /* ColNames: */ 15, 6,
112416	112667	/* iArg: */ 1 },
112417	112668	#endif
112418	112669	#if !defined(SQLITE_OMIT_INTEGRITY_CHECK)
112419	112670	{/* zName: */ "integrity_check",
112420	112671	/* ePragTyp: */ PragTyp_INTEGRITY_CHECK,
		@@ -112457,11 +112708,11 @@
112457	112708	#endif
112458	112709	#if defined(SQLITE_DEBUG) \|\| defined(SQLITE_TEST)
112459	112710	{/* zName: */ "lock_status",
112460	112711	/* ePragTyp: */ PragTyp_LOCK_STATUS,
112461	112712	/* ePragFlg: */ PragFlg_Result0,
112462		- /* ColNames: */ 46, 2,
	112713	+ /* ColNames: */ 47, 2,
112463	112714	/* iArg: */ 0 },
112464	112715	#endif
112465	112716	#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
112466	112717	{/* zName: */ "locking_mode",
112467	112718	/* ePragTyp: */ PragTyp_LOCKING_MODE,
		@@ -112476,10 +112727,17 @@
112476	112727	{/* zName: */ "mmap_size",
112477	112728	/* ePragTyp: */ PragTyp_MMAP_SIZE,
112478	112729	/* ePragFlg: */ 0,
112479	112730	/* ColNames: */ 0, 0,
112480	112731	/* iArg: */ 0 },
	112732	+#endif
	112733	+ {/* zName: */ "optimize",
	112734	+ /* ePragTyp: */ PragTyp_OPTIMIZE,
	112735	+ /* ePragFlg: */ PragFlg_Result1,
	112736	+ /* ColNames: */ 0, 0,
	112737	+ /* iArg: */ 0 },
	112738	+#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
112481	112739	{/* zName: */ "page_count",
112482	112740	/* ePragTyp: */ PragTyp_PAGE_COUNT,
112483	112741	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result0\|PragFlg_SchemaReq,
112484	112742	/* ColNames: */ 0, 0,
112485	112743	/* iArg: */ 0 },
		@@ -112574,15 +112832,15 @@
112574	112832	/* ePragFlg: */ PragFlg_Result0\|PragFlg_NoColumns1,
112575	112833	/* ColNames: */ 0, 0,
112576	112834	/* iArg: */ SQLITE_SqlTrace },
112577	112835	#endif
112578	112836	#endif
112579		-#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
	112837	+#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) && defined(SQLITE_DEBUG)
112580	112838	{/* zName: */ "stats",
112581	112839	/* ePragTyp: */ PragTyp_STATS,
112582	112840	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result0\|PragFlg_SchemaReq,
112583		- /* ColNames: */ 7, 4,
	112841	+ /* ColNames: */ 7, 5,
112584	112842	/* iArg: */ 0 },
112585	112843	#endif
112586	112844	#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
112587	112845	{/* zName: */ "synchronous",
112588	112846	/* ePragTyp: */ PragTyp_SYNCHRONOUS,
		@@ -112657,11 +112915,11 @@
112657	112915	/* ColNames: */ 0, 0,
112658	112916	/* iArg: */ 0 },
112659	112917	{/* zName: */ "wal_checkpoint",
112660	112918	/* ePragTyp: */ PragTyp_WAL_CHECKPOINT,
112661	112919	/* ePragFlg: */ PragFlg_NeedSchema,
112662		- /* ColNames: */ 42, 3,
	112920	+ /* ColNames: */ 43, 3,
112663	112921	/* iArg: */ 0 },
112664	112922	#endif
112665	112923	#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
112666	112924	{/* zName: */ "writable_schema",
112667	112925	/* ePragTyp: */ PragTyp_FLAG,
		@@ -112668,11 +112926,11 @@
112668	112926	/* ePragFlg: */ PragFlg_Result0\|PragFlg_NoColumns1,
112669	112927	/* ColNames: */ 0, 0,
112670	112928	/* iArg: */ SQLITE_WriteSchema\|SQLITE_RecoveryMode },
112671	112929	#endif
112672	112930	};
112673		-/* Number of pragmas: 60 on by default, 73 total. */
	112931	+/* Number of pragmas: 60 on by default, 74 total. */
112674	112932
112675	112933	/************ End of pragma.h ********************************************/
112676	112934	/************ Continuing where we left off in pragma.c *******************/
112677	112935
112678	112936	/*
		@@ -112937,10 +113195,26 @@
112937	113195	lwr = mid + 1;
112938	113196	}
112939	113197	}
112940	113198	return lwr>upr ? 0 : &aPragmaName[mid];
112941	113199	}
	113200	+
	113201	+/*
	113202	+** Helper subroutine for PRAGMA integrity_check:
	113203	+**
	113204	+** Generate code to output a single-column result row with the result
	113205	+** held in register regResult. Decrement the result count and halt if
	113206	+** the maximum number of result rows have been issued.
	113207	+*/
	113208	+static int integrityCheckResultRow(Vdbe *v, int regResult){
	113209	+ int addr;
	113210	+ sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, 1);
	113211	+ addr = sqlite3VdbeAddOp3(v, OP_IfPos, 1, sqlite3VdbeCurrentAddr(v)+2, 1);
	113212	+ VdbeCoverage(v);
	113213	+ sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
	113214	+ return addr;
	113215	+}
112942	113216
112943	113217	/*
112944	113218	** Process a pragma statement.
112945	113219	**
112946	113220	** Pragmas are of this form:
		@@ -113741,33 +114015,37 @@
113741	114015	}
113742	114016	}
113743	114017	}
113744	114018	break;
113745	114019
	114020	+#ifdef SQLITE_DEBUG
113746	114021	case PragTyp_STATS: {
113747	114022	Index *pIdx;
113748	114023	HashElem *i;
113749		- pParse->nMem = 4;
	114024	+ pParse->nMem = 5;
113750	114025	sqlite3CodeVerifySchema(pParse, iDb);
113751	114026	for(i=sqliteHashFirst(&pDb->pSchema->tblHash); i; i=sqliteHashNext(i)){
113752	114027	Table *pTab = sqliteHashData(i);
113753		- sqlite3VdbeMultiLoad(v, 1, "ssii",
	114028	+ sqlite3VdbeMultiLoad(v, 1, "ssiii",
113754	114029	pTab->zName,
113755	114030	0,
113756	114031	pTab->szTabRow,
113757		- pTab->nRowLogEst);
113758		- sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 4);
	114032	+ pTab->nRowLogEst,
	114033	+ pTab->tabFlags);
	114034	+ sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 5);
113759	114035	for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
113760		- sqlite3VdbeMultiLoad(v, 2, "sii",
	114036	+ sqlite3VdbeMultiLoad(v, 2, "siii",
113761	114037	pIdx->zName,
113762	114038	pIdx->szIdxRow,
113763		- pIdx->aiRowLogEst[0]);
113764		- sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 4);
	114039	+ pIdx->aiRowLogEst[0],
	114040	+ pIdx->hasStat1);
	114041	+ sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 5);
113765	114042	}
113766	114043	}
113767	114044	}
113768	114045	break;
	114046	+#endif
113769	114047
113770	114048	case PragTyp_INDEX_INFO: if( zRight ){
113771	114049	Index *pIdx;
113772	114050	Table *pTab;
113773	114051	pIdx = sqlite3FindIndex(db, zRight, zDb);
		@@ -114020,13 +114298,21 @@
114020	114298	#ifndef SQLITE_INTEGRITY_CHECK_ERROR_MAX
114021	114299	# define SQLITE_INTEGRITY_CHECK_ERROR_MAX 100
114022	114300	#endif
114023	114301
114024	114302	#ifndef SQLITE_OMIT_INTEGRITY_CHECK
114025		- /* Pragma "quick_check" is reduced version of
	114303	+ /* PRAGMA integrity_check
	114304	+ ** PRAGMA integrity_check(N)
	114305	+ ** PRAGMA quick_check
	114306	+ ** PRAGMA quick_check(N)
	114307	+ **
	114308	+ ** Verify the integrity of the database.
	114309	+ **
	114310	+ ** The "quick_check" is reduced version of
114026	114311	** integrity_check designed to detect most database corruption
114027		- ** without most of the overhead of a full integrity-check.
	114312	+ ** without the overhead of cross-checking indexes. Quick_check
	114313	+ ** is linear time wherease integrity_check is O(NlogN).
114028	114314	*/
114029	114315	case PragTyp_INTEGRITY_CHECK: {
114030	114316	int i, j, addr, mxErr;
114031	114317
114032	114318	int isQuick = (sqlite3Tolower(zLeft[0])=='q');
		@@ -114053,11 +114339,11 @@
114053	114339	sqlite3GetInt32(zRight, &mxErr);
114054	114340	if( mxErr<=0 ){
114055	114341	mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX;
114056	114342	}
114057	114343	}
114058		- sqlite3VdbeAddOp2(v, OP_Integer, mxErr, 1); /* reg[1] holds errors left */
	114344	+ sqlite3VdbeAddOp2(v, OP_Integer, mxErr-1, 1); /* reg[1] holds errors left */
114059	114345
114060	114346	/* Do an integrity check on each database file */
114061	114347	for(i=0; i<db->nDb; i++){
114062	114348	HashElem *x;
114063	114349	Hash *pTbls;
		@@ -114068,14 +114354,10 @@
114068	114354
114069	114355	if( OMIT_TEMPDB && i==1 ) continue;
114070	114356	if( iDb>=0 && i!=iDb ) continue;
114071	114357
114072	114358	sqlite3CodeVerifySchema(pParse, i);
114073		- addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Halt if out of errors */
114074		- VdbeCoverage(v);
114075		- sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
114076		- sqlite3VdbeJumpHere(v, addr);
114077	114359
114078	114360	/* Do an integrity check of the B-Tree
114079	114361	**
114080	114362	** Begin by finding the root pages numbers
114081	114363	** for all tables and indices in the database.
		@@ -114111,29 +114393,30 @@
114111	114393	sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
114112	114394	sqlite3MPrintf(db, "* in database %s *\n", db->aDb[i].zDbSName),
114113	114395	P4_DYNAMIC);
114114	114396	sqlite3VdbeAddOp3(v, OP_Move, 2, 4, 1);
114115	114397	sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 2);
114116		- sqlite3VdbeAddOp2(v, OP_ResultRow, 2, 1);
	114398	+ integrityCheckResultRow(v, 2);
114117	114399	sqlite3VdbeJumpHere(v, addr);
114118	114400
114119	114401	/* Make sure all the indices are constructed correctly.
114120	114402	*/
114121		- for(x=sqliteHashFirst(pTbls); x && !isQuick; x=sqliteHashNext(x)){
	114403	+ for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){
114122	114404	Table *pTab = sqliteHashData(x);
114123	114405	Index pIdx, pPk;
114124	114406	Index *pPrior = 0;
114125	114407	int loopTop;
114126	114408	int iDataCur, iIdxCur;
114127	114409	int r1 = -1;
114128	114410
114129		- if( pTab->pIndex==0 ) continue;
	114411	+ if( pTab->pCheck==0
	114412	+ && (pTab->tabFlags & TF_HasNotNull)==0
	114413	+ && (pTab->pIndex==0 \|\| isQuick)
	114414	+ ){
	114415	+ continue; /* No additional checks needed for this table */
	114416	+ }
114130	114417	pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
114131		- addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Stop if out of errors */
114132		- VdbeCoverage(v);
114133		- sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
114134		- sqlite3VdbeJumpHere(v, addr);
114135	114418	sqlite3ExprCacheClear(pParse);
114136	114419	sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenRead, 0,
114137	114420	1, 0, &iDataCur, &iIdxCur);
114138	114421	sqlite3VdbeAddOp2(v, OP_Integer, 0, 7);
114139	114422	for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
		@@ -114144,28 +114427,46 @@
114144	114427	sqlite3VdbeAddOp2(v, OP_Rewind, iDataCur, 0); VdbeCoverage(v);
114145	114428	loopTop = sqlite3VdbeAddOp2(v, OP_AddImm, 7, 1);
114146	114429	/* Verify that all NOT NULL columns really are NOT NULL */
114147	114430	for(j=0; j<pTab->nCol; j++){
114148	114431	char *zErr;
114149		- int jmp2, jmp3;
	114432	+ int jmp2;
114150	114433	if( j==pTab->iPKey ) continue;
114151	114434	if( pTab->aCol[j].notNull==0 ) continue;
114152	114435	sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, j, 3);
114153	114436	sqlite3VdbeChangeP5(v, OPFLAG_TYPEOFARG);
114154	114437	jmp2 = sqlite3VdbeAddOp1(v, OP_NotNull, 3); VdbeCoverage(v);
114155		- sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1); /* Decrement error limit */
114156	114438	zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName,
114157	114439	pTab->aCol[j].zName);
114158	114440	sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
114159		- sqlite3VdbeAddOp2(v, OP_ResultRow, 3, 1);
114160		- jmp3 = sqlite3VdbeAddOp1(v, OP_IfPos, 1); VdbeCoverage(v);
114161		- sqlite3VdbeAddOp0(v, OP_Halt);
	114441	+ integrityCheckResultRow(v, 3);
114162	114442	sqlite3VdbeJumpHere(v, jmp2);
114163		- sqlite3VdbeJumpHere(v, jmp3);
	114443	+ }
	114444	+ /* Verify CHECK constraints */
	114445	+ if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){
	114446	+ int addrCkFault = sqlite3VdbeMakeLabel(v);
	114447	+ int addrCkOk = sqlite3VdbeMakeLabel(v);
	114448	+ ExprList *pCheck = pTab->pCheck;
	114449	+ char *zErr;
	114450	+ int k;
	114451	+ pParse->iSelfTab = iDataCur;
	114452	+ sqlite3ExprCachePush(pParse);
	114453	+ for(k=pCheck->nExpr-1; k>0; k--){
	114454	+ sqlite3ExprIfFalse(pParse, pCheck->a[k].pExpr, addrCkFault, 0);
	114455	+ }
	114456	+ sqlite3ExprIfTrue(pParse, pCheck->a[0].pExpr, addrCkOk,
	114457	+ SQLITE_JUMPIFNULL);
	114458	+ sqlite3VdbeResolveLabel(v, addrCkFault);
	114459	+ zErr = sqlite3MPrintf(db, "CHECK constraint failed in %s",
	114460	+ pTab->zName);
	114461	+ sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
	114462	+ integrityCheckResultRow(v, 3);
	114463	+ sqlite3VdbeResolveLabel(v, addrCkOk);
	114464	+ sqlite3ExprCachePop(pParse);
114164	114465	}
114165	114466	/* Validate index entries for the current row */
114166		- for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
	114467	+ for(j=0, pIdx=pTab->pIndex; pIdx && !isQuick; pIdx=pIdx->pNext, j++){
114167	114468	int jmp2, jmp3, jmp4, jmp5;
114168	114469	int ckUniq = sqlite3VdbeMakeLabel(v);
114169	114470	if( pPk==pIdx ) continue;
114170	114471	r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 0, &jmp3,
114171	114472	pPrior, r1);
		@@ -114172,20 +114473,17 @@
114172	114473	pPrior = pIdx;
114173	114474	sqlite3VdbeAddOp2(v, OP_AddImm, 8+j, 1); /* increment entry count */
114174	114475	/* Verify that an index entry exists for the current table row */
114175	114476	jmp2 = sqlite3VdbeAddOp4Int(v, OP_Found, iIdxCur+j, ckUniq, r1,
114176	114477	pIdx->nColumn); VdbeCoverage(v);
114177		- sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1); /* Decrement error limit */
114178	114478	sqlite3VdbeLoadString(v, 3, "row ");
114179	114479	sqlite3VdbeAddOp3(v, OP_Concat, 7, 3, 3);
114180	114480	sqlite3VdbeLoadString(v, 4, " missing from index ");
114181	114481	sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3);
114182	114482	jmp5 = sqlite3VdbeLoadString(v, 4, pIdx->zName);
114183	114483	sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3);
114184		- sqlite3VdbeAddOp2(v, OP_ResultRow, 3, 1);
114185		- jmp4 = sqlite3VdbeAddOp1(v, OP_IfPos, 1); VdbeCoverage(v);
114186		- sqlite3VdbeAddOp0(v, OP_Halt);
	114484	+ jmp4 = integrityCheckResultRow(v, 3);
114187	114485	sqlite3VdbeJumpHere(v, jmp2);
114188	114486	/* For UNIQUE indexes, verify that only one entry exists with the
114189	114487	** current key. The entry is unique if (1) any column is NULL
114190	114488	** or (2) the next entry has a different key */
114191	114489	if( IsUniqueIndex(pIdx) ){
		@@ -114202,11 +114500,10 @@
114202	114500	jmp6 = sqlite3VdbeAddOp1(v, OP_Next, iIdxCur+j); VdbeCoverage(v);
114203	114501	sqlite3VdbeGoto(v, uniqOk);
114204	114502	sqlite3VdbeJumpHere(v, jmp6);
114205	114503	sqlite3VdbeAddOp4Int(v, OP_IdxGT, iIdxCur+j, uniqOk, r1,
114206	114504	pIdx->nKeyCol); VdbeCoverage(v);
114207		- sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1); /* Decrement error limit */
114208	114505	sqlite3VdbeLoadString(v, 3, "non-unique entry in index ");
114209	114506	sqlite3VdbeGoto(v, jmp5);
114210	114507	sqlite3VdbeResolveLabel(v, uniqOk);
114211	114508	}
114212	114509	sqlite3VdbeJumpHere(v, jmp4);
		@@ -114213,40 +114510,39 @@
114213	114510	sqlite3ResolvePartIdxLabel(pParse, jmp3);
114214	114511	}
114215	114512	sqlite3VdbeAddOp2(v, OP_Next, iDataCur, loopTop); VdbeCoverage(v);
114216	114513	sqlite3VdbeJumpHere(v, loopTop-1);
114217	114514	#ifndef SQLITE_OMIT_BTREECOUNT
114218		- sqlite3VdbeLoadString(v, 2, "wrong # of entries in index ");
114219		- for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
114220		- if( pPk==pIdx ) continue;
114221		- addr = sqlite3VdbeCurrentAddr(v);
114222		- sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr+2); VdbeCoverage(v);
114223		- sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
114224		- sqlite3VdbeAddOp2(v, OP_Count, iIdxCur+j, 3);
114225		- sqlite3VdbeAddOp3(v, OP_Eq, 8+j, addr+8, 3); VdbeCoverage(v);
114226		- sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
114227		- sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1);
114228		- sqlite3VdbeLoadString(v, 3, pIdx->zName);
114229		- sqlite3VdbeAddOp3(v, OP_Concat, 3, 2, 7);
114230		- sqlite3VdbeAddOp2(v, OP_ResultRow, 7, 1);
	114515	+ if( !isQuick ){
	114516	+ sqlite3VdbeLoadString(v, 2, "wrong # of entries in index ");
	114517	+ for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
	114518	+ if( pPk==pIdx ) continue;
	114519	+ sqlite3VdbeAddOp2(v, OP_Count, iIdxCur+j, 3);
	114520	+ addr = sqlite3VdbeAddOp3(v, OP_Eq, 8+j, 0, 3); VdbeCoverage(v);
	114521	+ sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
	114522	+ sqlite3VdbeLoadString(v, 3, pIdx->zName);
	114523	+ sqlite3VdbeAddOp3(v, OP_Concat, 3, 2, 7);
	114524	+ integrityCheckResultRow(v, 7);
	114525	+ sqlite3VdbeJumpHere(v, addr);
	114526	+ }
114231	114527	}
114232	114528	#endif /* SQLITE_OMIT_BTREECOUNT */
114233	114529	}
114234	114530	}
114235	114531	{
114236	114532	static const int iLn = VDBE_OFFSET_LINENO(2);
114237	114533	static const VdbeOpList endCode[] = {
114238	114534	{ OP_AddImm, 1, 0, 0}, /* 0 */
114239		- { OP_If, 1, 4, 0}, /* 1 */
	114535	+ { OP_IfNotZero, 1, 4, 0}, /* 1 */
114240	114536	{ OP_String8, 0, 3, 0}, /* 2 */
114241	114537	{ OP_ResultRow, 3, 1, 0}, /* 3 */
114242	114538	};
114243	114539	VdbeOp *aOp;
114244	114540
114245	114541	aOp = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode, iLn);
114246	114542	if( aOp ){
114247		- aOp[0].p2 = -mxErr;
	114543	+ aOp[0].p2 = 1-mxErr;
114248	114544	aOp[2].p4type = P4_STATIC;
114249	114545	aOp[2].p4.z = "ok";
114250	114546	}
114251	114547	}
114252	114548	}
		@@ -114466,10 +114762,122 @@
114466	114762	*/
114467	114763	case PragTyp_SHRINK_MEMORY: {
114468	114764	sqlite3_db_release_memory(db);
114469	114765	break;
114470	114766	}
	114767	+
	114768	+ /*
	114769	+ ** PRAGMA optimize
	114770	+ ** PRAGMA optimize(MASK)
	114771	+ ** PRAGMA schema.optimize
	114772	+ ** PRAGMA schema.optimize(MASK)
	114773	+ **
	114774	+ ** Attempt to optimize the database. All schemas are optimized in the first
	114775	+ ** two forms, and only the specified schema is optimized in the latter two.
	114776	+ **
	114777	+ ** The details of optimizations performed by this pragma are expected
	114778	+ ** to change and improve over time. Applications should anticipate that
	114779	+ ** this pragma will perform new optimizations in future releases.
	114780	+ **
	114781	+ ** The optional argument is a bitmask of optimizations to perform:
	114782	+ **
	114783	+ ** 0x0001 Debugging mode. Do not actually perform any optimizations
	114784	+ ** but instead return one line of text for each optimization
	114785	+ ** that would have been done. Off by default.
	114786	+ **
	114787	+ ** 0x0002 Run ANALYZE on tables that might benefit. On by default.
	114788	+ ** See below for additional information.
	114789	+ **
	114790	+ ** 0x0004 (Not yet implemented) Record usage and performance
	114791	+ ** information from the current session in the
	114792	+ ** database file so that it will be available to "optimize"
	114793	+ ** pragmas run by future database connections.
	114794	+ **
	114795	+ ** 0x0008 (Not yet implemented) Create indexes that might have
	114796	+ ** been helpful to recent queries
	114797	+ **
	114798	+ The default MASK is and always shall be 0xfffe. 0xfffe means perform all of the optimizations listed above except Debug Mode, including new
	114799	+ ** optimizations that have not yet been invented. If new optimizations are
	114800	+ ** ever added that should be off by default, those off-by-default
	114801	+ ** optimizations will have bitmasks of 0x10000 or larger.
	114802	+ **
	114803	+ ** DETERMINATION OF WHEN TO RUN ANALYZE
	114804	+ **
	114805	+ ** In the current implementation, a table is analyzed if only if all of
	114806	+ ** the following are true:
	114807	+ **
	114808	+ ** (1) MASK bit 0x02 is set.
	114809	+ **
	114810	+ ** (2) The query planner used sqlite_stat1-style statistics for one or
	114811	+ ** more indexes of the table at some point during the lifetime of
	114812	+ ** the current connection.
	114813	+ **
	114814	+ ** (3) One or more indexes of the table are currently unanalyzed OR
	114815	+ ** the number of rows in the table has increased by 25 times or more
	114816	+ ** since the last time ANALYZE was run.
	114817	+ **
	114818	+ ** The rules for when tables are analyzed are likely to change in
	114819	+ ** future releases.
	114820	+ */
	114821	+ case PragTyp_OPTIMIZE: {
	114822	+ int iDbLast; /* Loop termination point for the schema loop */
	114823	+ int iTabCur; /* Cursor for a table whose size needs checking */
	114824	+ HashElem k; / Loop over tables of a schema */
	114825	+ Schema pSchema; / The current schema */
	114826	+ Table pTab; / A table in the schema */
	114827	+ Index pIdx; / An index of the table */
	114828	+ LogEst szThreshold; /* Size threshold above which reanalysis is needd */
	114829	+ char zSubSql; / SQL statement for the OP_SqlExec opcode */
	114830	+ u32 opMask; /* Mask of operations to perform */
	114831	+
	114832	+ if( zRight ){
	114833	+ opMask = (u32)sqlite3Atoi(zRight);
	114834	+ if( (opMask & 0x02)==0 ) break;
	114835	+ }else{
	114836	+ opMask = 0xfffe;
	114837	+ }
	114838	+ iTabCur = pParse->nTab++;
	114839	+ for(iDbLast = zDb?iDb:db->nDb-1; iDb<=iDbLast; iDb++){
	114840	+ if( iDb==1 ) continue;
	114841	+ sqlite3CodeVerifySchema(pParse, iDb);
	114842	+ pSchema = db->aDb[iDb].pSchema;
	114843	+ for(k=sqliteHashFirst(&pSchema->tblHash); k; k=sqliteHashNext(k)){
	114844	+ pTab = (Table*)sqliteHashData(k);
	114845	+
	114846	+ /* If table pTab has not been used in a way that would benefit from
	114847	+ ** having analysis statistics during the current session, then skip it.
	114848	+ ** This also has the effect of skipping virtual tables and views */
	114849	+ if( (pTab->tabFlags & TF_StatsUsed)==0 ) continue;
	114850	+
	114851	+ /* Reanalyze if the table is 25 times larger than the last analysis */
	114852	+ szThreshold = pTab->nRowLogEst + 46; assert( sqlite3LogEst(25)==46 );
	114853	+ for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
	114854	+ if( !pIdx->hasStat1 ){
	114855	+ szThreshold = 0; /* Always analyze if any index lacks statistics */
	114856	+ break;
	114857	+ }
	114858	+ }
	114859	+ if( szThreshold ){
	114860	+ sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
	114861	+ sqlite3VdbeAddOp3(v, OP_IfSmaller, iTabCur,
	114862	+ sqlite3VdbeCurrentAddr(v)+2+(opMask&1), szThreshold);
	114863	+ VdbeCoverage(v);
	114864	+ }
	114865	+ zSubSql = sqlite3MPrintf(db, "ANALYZE \"%w\".\"%w\"",
	114866	+ db->aDb[iDb].zDbSName, pTab->zName);
	114867	+ if( opMask & 0x01 ){
	114868	+ int r1 = sqlite3GetTempReg(pParse);
	114869	+ sqlite3VdbeAddOp4(v, OP_String8, 0, r1, 0, zSubSql, P4_DYNAMIC);
	114870	+ sqlite3VdbeAddOp2(v, OP_ResultRow, r1, 1);
	114871	+ }else{
	114872	+ sqlite3VdbeAddOp4(v, OP_SqlExec, 0, 0, 0, zSubSql, P4_DYNAMIC);
	114873	+ }
	114874	+ }
	114875	+ }
	114876	+ sqlite3VdbeAddOp0(v, OP_Expire);
	114877	+ break;
	114878	+ }
114471	114879
114472	114880	/*
114473	114881	** PRAGMA busy_timeout
114474	114882	** PRAGMA busy_timeout = N
114475	114883	**
		@@ -123782,12 +124190,29 @@
123782	124190	** transient would cause the database file to appear to be deleted
123783	124191	** following reboot.
123784	124192	*/
123785	124193	SQLITE_PRIVATE void sqlite3Vacuum(Parse pParse, Token pNm){
123786	124194	Vdbe *v = sqlite3GetVdbe(pParse);
123787		- int iDb = pNm ? sqlite3TwoPartName(pParse, pNm, pNm, &pNm) : 0;
123788		- if( v && (iDb>=2 \|\| iDb==0) ){
	124195	+ int iDb = 0;
	124196	+ if( v==0 ) return;
	124197	+ if( pNm ){
	124198	+#ifndef SQLITE_BUG_COMPATIBLE_20160819
	124199	+ /* Default behavior: Report an error if the argument to VACUUM is
	124200	+ ** not recognized */
	124201	+ iDb = sqlite3TwoPartName(pParse, pNm, pNm, &pNm);
	124202	+ if( iDb<0 ) return;
	124203	+#else
	124204	+ /* When SQLITE_BUG_COMPATIBLE_20160819 is defined, unrecognized arguments
	124205	+ ** to VACUUM are silently ignored. This is a back-out of a bug fix that
	124206	+ ** occurred on 2016-08-19 (https://www.sqlite.org/src/info/083f9e6270).
	124207	+ ** The buggy behavior is required for binary compatibility with some
	124208	+ ** legacy applications. */
	124209	+ iDb = sqlite3FindDb(pParse->db, pNm);
	124210	+ if( iDb<0 ) iDb = 0;
	124211	+#endif
	124212	+ }
	124213	+ if( iDb!=1 ){
123789	124214	sqlite3VdbeAddOp1(v, OP_Vacuum, iDb);
123790	124215	sqlite3VdbeUsesBtree(v, iDb);
123791	124216	}
123792	124217	return;
123793	124218	}
		@@ -124377,12 +124802,11 @@
124377	124802
124378	124803	db = pParse->db;
124379	124804	iDb = sqlite3SchemaToIndex(db, pTable->pSchema);
124380	124805	assert( iDb>=0 );
124381	124806
124382		- pTable->tabFlags \|= TF_Virtual;
124383		- pTable->nModuleArg = 0;
	124807	+ assert( pTable->nModuleArg==0 );
124384	124808	addModuleArgument(db, pTable, sqlite3NameFromToken(db, pModuleName));
124385	124809	addModuleArgument(db, pTable, 0);
124386	124810	addModuleArgument(db, pTable, sqlite3DbStrDup(db, pTable->zName));
124387	124811	assert( (pParse->sNameToken.z==pName2->z && pName2->z!=0)
124388	124812	\|\| (pParse->sNameToken.z==pName1->z && pName2->z==0)
		@@ -124666,11 +125090,11 @@
124666	125090	const char *zMod;
124667	125091	Module *pMod;
124668	125092	int rc;
124669	125093
124670	125094	assert( pTab );
124671		- if( (pTab->tabFlags & TF_Virtual)==0 \|\| sqlite3GetVTable(db, pTab) ){
	125095	+ if( !IsVirtual(pTab) \|\| sqlite3GetVTable(db, pTab) ){
124672	125096	return SQLITE_OK;
124673	125097	}
124674	125098
124675	125099	/* Locate the required virtual table module */
124676	125100	zMod = pTab->azModuleArg[0];
		@@ -124736,11 +125160,11 @@
124736	125160	Table *pTab;
124737	125161	Module *pMod;
124738	125162	const char *zMod;
124739	125163
124740	125164	pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
124741		- assert( pTab && (pTab->tabFlags & TF_Virtual)!=0 && !pTab->pVTable );
	125165	+ assert( pTab && IsVirtual(pTab) && !pTab->pVTable );
124742	125166
124743	125167	/* Locate the required virtual table module */
124744	125168	zMod = pTab->azModuleArg[0];
124745	125169	pMod = (Module*)sqlite3HashFind(&db->aModule, zMod);
124746	125170
		@@ -124790,11 +125214,11 @@
124790	125214	sqlite3Error(db, SQLITE_MISUSE);
124791	125215	sqlite3_mutex_leave(db->mutex);
124792	125216	return SQLITE_MISUSE_BKPT;
124793	125217	}
124794	125218	pTab = pCtx->pTab;
124795		- assert( (pTab->tabFlags & TF_Virtual)!=0 );
	125219	+ assert( IsVirtual(pTab) );
124796	125220
124797	125221	pParse = sqlite3StackAllocZero(db, sizeof(*pParse));
124798	125222	if( pParse==0 ){
124799	125223	rc = SQLITE_NOMEM_BKPT;
124800	125224	}else{
		@@ -124804,11 +125228,11 @@
124804	125228
124805	125229	if( SQLITE_OK==sqlite3RunParser(pParse, zCreateTable, &zErr)
124806	125230	&& pParse->pNewTable
124807	125231	&& !db->mallocFailed
124808	125232	&& !pParse->pNewTable->pSelect
124809		- && (pParse->pNewTable->tabFlags & TF_Virtual)==0
	125233	+ && !IsVirtual(pParse->pNewTable)
124810	125234	){
124811	125235	if( !pTab->aCol ){
124812	125236	Table *pNew = pParse->pNewTable;
124813	125237	Index *pIdx;
124814	125238	pTab->aCol = pNew->aCol;
		@@ -125093,11 +125517,11 @@
125093	125517	/* Check to see the left operand is a column in a virtual table */
125094	125518	if( NEVER(pExpr==0) ) return pDef;
125095	125519	if( pExpr->op!=TK_COLUMN ) return pDef;
125096	125520	pTab = pExpr->pTab;
125097	125521	if( NEVER(pTab==0) ) return pDef;
125098		- if( (pTab->tabFlags & TF_Virtual)==0 ) return pDef;
	125522	+ if( !IsVirtual(pTab) ) return pDef;
125099	125523	pVtab = sqlite3GetVTable(db, pTab)->pVtab;
125100	125524	assert( pVtab!=0 );
125101	125525	assert( pVtab->pModule!=0 );
125102	125526	pMod = (sqlite3_module *)pVtab->pModule;
125103	125527	if( pMod->xFindFunction==0 ) return pDef;
		@@ -125188,12 +125612,11 @@
125188	125612	return 0;
125189	125613	}
125190	125614	pMod->pEpoTab = pTab;
125191	125615	pTab->nTabRef = 1;
125192	125616	pTab->pSchema = db->aDb[0].pSchema;
125193		- pTab->tabFlags \|= TF_Virtual;
125194		- pTab->nModuleArg = 0;
	125617	+ assert( pTab->nModuleArg==0 );
125195	125618	pTab->iPKey = -1;
125196	125619	addModuleArgument(db, pTab, sqlite3DbStrDup(db, pTab->zName));
125197	125620	addModuleArgument(db, pTab, 0);
125198	125621	addModuleArgument(db, pTab, sqlite3DbStrDup(db, pTab->zName));
125199	125622	rc = vtabCallConstructor(db, pTab, pMod, pModule->xConnect, &zErr);
		@@ -125260,11 +125683,11 @@
125260	125683	case SQLITE_VTAB_CONSTRAINT_SUPPORT: {
125261	125684	VtabCtx *p = db->pVtabCtx;
125262	125685	if( !p ){
125263	125686	rc = SQLITE_MISUSE_BKPT;
125264	125687	}else{
125265		- assert( p->pTab==0 \|\| (p->pTab->tabFlags & TF_Virtual)!=0 );
	125688	+ assert( p->pTab==0 \|\| IsVirtual(p->pTab) );
125266	125689	p->pVTable->bConstraint = (u8)va_arg(ap, int);
125267	125690	}
125268	125691	break;
125269	125692	}
125270	125693	default:
		@@ -125699,12 +126122,17 @@
125699	126122	WhereOrSet pOrSet; / Record best loops here, if not NULL */
125700	126123	#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
125701	126124	UnpackedRecord pRec; / Probe for stat4 (if required) */
125702	126125	int nRecValid; /* Number of valid fields currently in pRec */
125703	126126	#endif
	126127	+ unsigned int bldFlags; /* SQLITE_BLDF_* flags */
125704	126128	};
125705	126129
	126130	+/* Allowed values for WhereLoopBuider.bldFlags */
	126131	+#define SQLITE_BLDF_INDEXED 0x0001 /* An index is used */
	126132	+#define SQLITE_BLDF_UNIQUE 0x0002 /* All keys of a UNIQUE index used */
	126133	+
125706	126134	/*
125707	126135	** The WHERE clause processing routine has two halves. The
125708	126136	** first part does the start of the WHERE loop and the second
125709	126137	** half does the tail of the WHERE loop. An instance of
125710	126138	** this structure is returned by the first half and passed
		@@ -125715,11 +126143,11 @@
125715	126143	*/
125716	126144	struct WhereInfo {
125717	126145	Parse pParse; / Parsing and code generating context */
125718	126146	SrcList pTabList; / List of tables in the join */
125719	126147	ExprList pOrderBy; / The ORDER BY clause or NULL */
125720		- ExprList pDistinctSet; / DISTINCT over all these values */
	126148	+ ExprList pResultSet; / Result set of the query */
125721	126149	LogEst iLimit; /* LIMIT if wctrlFlags has WHERE_USE_LIMIT */
125722	126150	int aiCurOnePass[2]; /* OP_OpenWrite cursors for the ONEPASS opt */
125723	126151	int iContinue; /* Jump here to continue with next record */
125724	126152	int iBreak; /* Jump here to break out of the loop */
125725	126153	int savedNQueryLoop; /* pParse->nQueryLoop outside the WHERE loop */
		@@ -126899,10 +127327,11 @@
126899	127327	Parse pParse; / Parsing context */
126900	127328	sqlite3 db; / Database connection */
126901	127329	Vdbe v; / The prepared stmt under constructions */
126902	127330	struct SrcList_item pTabItem; / FROM clause term being coded */
126903	127331	int addrBrk; /* Jump here to break out of the loop */
	127332	+ int addrHalt; /* addrBrk for the outermost loop */
126904	127333	int addrCont; /* Jump here to continue with next cycle */
126905	127334	int iRowidReg = 0; /* Rowid is stored in this register, if not zero */
126906	127335	int iReleaseReg = 0; /* Temp register to free before returning */
126907	127336
126908	127337	pParse = pWInfo->pParse;
		@@ -126939,10 +127368,15 @@
126939	127368	if( pLevel->iFrom>0 && (pTabItem[0].fg.jointype & JT_LEFT)!=0 ){
126940	127369	pLevel->iLeftJoin = ++pParse->nMem;
126941	127370	sqlite3VdbeAddOp2(v, OP_Integer, 0, pLevel->iLeftJoin);
126942	127371	VdbeComment((v, "init LEFT JOIN no-match flag"));
126943	127372	}
	127373	+
	127374	+ /* Compute a safe address to jump to if we discover that the table for
	127375	+ ** this loop is empty and can never contribute content. */
	127376	+ for(j=iLevel; j>0 && pWInfo->a[j].iLeftJoin==0; j--){}
	127377	+ addrHalt = pWInfo->a[j].addrBrk;
126944	127378
126945	127379	/* Special case of a FROM clause subquery implemented as a co-routine */
126946	127380	if( pTabItem->fg.viaCoroutine ){
126947	127381	int regYield = pTabItem->regReturn;
126948	127382	sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pTabItem->addrFillSub);
		@@ -127124,11 +127558,11 @@
127124	127558	VdbeCoverageIf(v, pX->op==TK_LT);
127125	127559	VdbeCoverageIf(v, pX->op==TK_GE);
127126	127560	sqlite3ExprCacheAffinityChange(pParse, r1, 1);
127127	127561	sqlite3ReleaseTempReg(pParse, rTemp);
127128	127562	}else{
127129		- sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iCur, addrBrk);
	127563	+ sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iCur, addrHalt);
127130	127564	VdbeCoverageIf(v, bRev==0);
127131	127565	VdbeCoverageIf(v, bRev!=0);
127132	127566	}
127133	127567	if( pEnd ){
127134	127568	Expr *pX;
		@@ -127770,11 +128204,11 @@
127770	128204	pLevel->op = OP_Noop;
127771	128205	}else{
127772	128206	codeCursorHint(pTabItem, pWInfo, pLevel, 0);
127773	128207	pLevel->op = aStep[bRev];
127774	128208	pLevel->p1 = iCur;
127775		- pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrBrk);
	128209	+ pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrHalt);
127776	128210	VdbeCoverageIf(v, bRev==0);
127777	128211	VdbeCoverageIf(v, bRev!=0);
127778	128212	pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP;
127779	128213	}
127780	128214	}
		@@ -128095,19 +128529,10 @@
128095	128529	#ifdef SQLITE_EBCDIC
128096	128530	if( *pnoCase ) return 0;
128097	128531	#endif
128098	128532	pList = pExpr->x.pList;
128099	128533	pLeft = pList->a[1].pExpr;
128100		- if( pLeft->op!=TK_COLUMN
128101		- \|\| sqlite3ExprAffinity(pLeft)!=SQLITE_AFF_TEXT
128102		- \|\| IsVirtual(pLeft->pTab) /* Value might be numeric */
128103		- ){
128104		- /* IMP: R-02065-49465 The left-hand side of the LIKE or GLOB operator must
128105		- ** be the name of an indexed column with TEXT affinity. */
128106		- return 0;
128107		- }
128108		- assert( pLeft->iColumn!=(-1) ); /* Because IPK never has AFF_TEXT */
128109	128534
128110	128535	pRight = sqlite3ExprSkipCollate(pList->a[0].pExpr);
128111	128536	op = pRight->op;
128112	128537	if( op==TK_VARIABLE ){
128113	128538	Vdbe *pReprepare = pParse->pReprepare;
		@@ -128120,10 +128545,27 @@
128120	128545	assert( pRight->op==TK_VARIABLE \|\| pRight->op==TK_REGISTER );
128121	128546	}else if( op==TK_STRING ){
128122	128547	z = pRight->u.zToken;
128123	128548	}
128124	128549	if( z ){
	128550	+
	128551	+ /* If the RHS begins with a digit or a minus sign, then the LHS must
	128552	+ ** be an ordinary column (not a virtual table column) with TEXT affinity.
	128553	+ ** Otherwise the LHS might be numeric and "lhs >= rhs" would be false
	128554	+ ** even though "lhs LIKE rhs" is true. But if the RHS does not start
	128555	+ ** with a digit or '-', then "lhs LIKE rhs" will always be false if
	128556	+ ** the LHS is numeric and so the optimization still works.
	128557	+ */
	128558	+ if( sqlite3Isdigit(z[0]) \|\| z[0]=='-' ){
	128559	+ if( pLeft->op!=TK_COLUMN
	128560	+ \|\| sqlite3ExprAffinity(pLeft)!=SQLITE_AFF_TEXT
	128561	+ \|\| IsVirtual(pLeft->pTab) /* Value might be numeric */
	128562	+ ){
	128563	+ sqlite3ValueFree(pVal);
	128564	+ return 0;
	128565	+ }
	128566	+ }
128125	128567	cnt = 0;
128126	128568	while( (c=z[cnt])!=0 && c!=wc[0] && c!=wc[1] && c!=wc[2] ){
128127	128569	cnt++;
128128	128570	}
128129	128571	if( cnt!=0 && 255!=(u8)z[cnt-1] ){
		@@ -128748,11 +129190,11 @@
128748	129190	iCur = pFrom->a[i].iCursor;
128749	129191	for(pIdx=pFrom->a[i].pTab->pIndex; pIdx; pIdx=pIdx->pNext){
128750	129192	if( pIdx->aColExpr==0 ) continue;
128751	129193	for(i=0; i<pIdx->nKeyCol; i++){
128752	129194	if( pIdx->aiColumn[i]!=XN_EXPR ) continue;
128753		- if( sqlite3ExprCompare(pExpr, pIdx->aColExpr->a[i].pExpr, iCur)==0 ){
	129195	+ if( sqlite3ExprCompareSkip(pExpr, pIdx->aColExpr->a[i].pExpr, iCur)==0 ){
128754	129196	*piCur = iCur;
128755	129197	*piColumn = XN_EXPR;
128756	129198	return 1;
128757	129199	}
128758	129200	}
		@@ -129539,11 +129981,12 @@
129539	129981	do{
129540	129982	for(pTerm=pWC->a+k; k<pWC->nTerm; k++, pTerm++){
129541	129983	if( pTerm->leftCursor==iCur
129542	129984	&& pTerm->u.leftColumn==iColumn
129543	129985	&& (iColumn!=XN_EXPR
129544		- \|\| sqlite3ExprCompare(pTerm->pExpr->pLeft,pScan->pIdxExpr,iCur)==0)
	129986	+ \|\| sqlite3ExprCompareSkip(pTerm->pExpr->pLeft,
	129987	+ pScan->pIdxExpr,iCur)==0)
129545	129988	&& (pScan->iEquiv<=1 \|\| !ExprHasProperty(pTerm->pExpr, EP_FromJoin))
129546	129989	){
129547	129990	if( (pTerm->eOperator & WO_EQUIV)!=0
129548	129991	&& pScan->nEquiv<ArraySize(pScan->aiCur)
129549	129992	&& (pX = sqlite3ExprSkipCollate(pTerm->pExpr->pRight))->op==TK_COLUMN
		@@ -131716,10 +132159,15 @@
131716	132159	testcase( eOp & WO_IS );
131717	132160	testcase( eOp & WO_ISNULL );
131718	132161	continue;
131719	132162	}
131720	132163
	132164	+ if( IsUniqueIndex(pProbe) && saved_nEq==pProbe->nKeyCol-1 ){
	132165	+ pBuilder->bldFlags \|= SQLITE_BLDF_UNIQUE;
	132166	+ }else{
	132167	+ pBuilder->bldFlags \|= SQLITE_BLDF_INDEXED;
	132168	+ }
131721	132169	pNew->wsFlags = saved_wsFlags;
131722	132170	pNew->u.btree.nEq = saved_nEq;
131723	132171	pNew->u.btree.nBtm = saved_nBtm;
131724	132172	pNew->u.btree.nTop = saved_nTop;
131725	132173	pNew->nLTerm = saved_nLTerm;
		@@ -132263,11 +132711,19 @@
132263	132711	pNew->nOut = rSize;
132264	132712	if( rc ) break;
132265	132713	}
132266	132714	}
132267	132715
	132716	+ pBuilder->bldFlags = 0;
132268	132717	rc = whereLoopAddBtreeIndex(pBuilder, pSrc, pProbe, 0);
	132718	+ if( pBuilder->bldFlags==SQLITE_BLDF_INDEXED ){
	132719	+ /* If a non-unique index is used, or if a prefix of the key for
	132720	+ ** unique index is used (making the index functionally non-unique)
	132721	+ ** then the sqlite_stat1 data becomes important for scoring the
	132722	+ ** plan */
	132723	+ pTab->tabFlags \|= TF_StatsUsed;
	132724	+ }
132269	132725	#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
132270	132726	sqlite3Stat4ProbeFree(pBuilder->pRec);
132271	132727	pBuilder->nRecValid = 0;
132272	132728	pBuilder->pRec = 0;
132273	132729	#endif
		@@ -133443,13 +133899,13 @@
133443	133899	&& (pWInfo->wctrlFlags & WHERE_DISTINCTBY)==0
133444	133900	&& pWInfo->eDistinct==WHERE_DISTINCT_NOOP
133445	133901	&& nRowEst
133446	133902	){
133447	133903	Bitmask notUsed;
133448		- int rc = wherePathSatisfiesOrderBy(pWInfo, pWInfo->pDistinctSet, pFrom,
	133904	+ int rc = wherePathSatisfiesOrderBy(pWInfo, pWInfo->pResultSet, pFrom,
133449	133905	WHERE_DISTINCTBY, nLoop-1, pFrom->aLoop[nLoop-1], &notUsed);
133450		- if( rc==pWInfo->pDistinctSet->nExpr ){
	133906	+ if( rc==pWInfo->pResultSet->nExpr ){
133451	133907	pWInfo->eDistinct = WHERE_DISTINCT_ORDERED;
133452	133908	}
133453	133909	}
133454	133910	if( pWInfo->pOrderBy ){
133455	133911	if( pWInfo->wctrlFlags & WHERE_DISTINCTBY ){
		@@ -133682,11 +134138,11 @@
133682	134138	SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
133683	134139	Parse pParse, / The parser context */
133684	134140	SrcList pTabList, / FROM clause: A list of all tables to be scanned */
133685	134141	Expr pWhere, / The WHERE clause */
133686	134142	ExprList pOrderBy, / An ORDER BY (or GROUP BY) clause, or NULL */
133687		- ExprList pDistinctSet, / Try not to output two rows that duplicate these */
	134143	+ ExprList pResultSet, / Query result set. Req'd for DISTINCT */
133688	134144	u16 wctrlFlags, /* The WHERE_* flags defined in sqliteInt.h */
133689	134145	int iAuxArg /* If WHERE_OR_SUBCLAUSE is set, index cursor number
133690	134146	** If WHERE_USE_LIMIT, then the limit amount */
133691	134147	){
133692	134148	int nByteWInfo; /* Num. bytes allocated for WhereInfo struct */
		@@ -133758,11 +134214,11 @@
133758	134214	goto whereBeginError;
133759	134215	}
133760	134216	pWInfo->pParse = pParse;
133761	134217	pWInfo->pTabList = pTabList;
133762	134218	pWInfo->pOrderBy = pOrderBy;
133763		- pWInfo->pDistinctSet = pDistinctSet;
	134219	+ pWInfo->pResultSet = pResultSet;
133764	134220	pWInfo->aiCurOnePass[0] = pWInfo->aiCurOnePass[1] = -1;
133765	134221	pWInfo->nLevel = nTabList;
133766	134222	pWInfo->iBreak = pWInfo->iContinue = sqlite3VdbeMakeLabel(v);
133767	134223	pWInfo->wctrlFlags = wctrlFlags;
133768	134224	pWInfo->iLimit = iAuxArg;
		@@ -133836,17 +134292,17 @@
133836	134292	/* Analyze all of the subexpressions. */
133837	134293	sqlite3WhereExprAnalyze(pTabList, &pWInfo->sWC);
133838	134294	if( db->mallocFailed ) goto whereBeginError;
133839	134295
133840	134296	if( wctrlFlags & WHERE_WANT_DISTINCT ){
133841		- if( isDistinctRedundant(pParse, pTabList, &pWInfo->sWC, pDistinctSet) ){
	134297	+ if( isDistinctRedundant(pParse, pTabList, &pWInfo->sWC, pResultSet) ){
133842	134298	/* The DISTINCT marking is pointless. Ignore it. */
133843	134299	pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE;
133844	134300	}else if( pOrderBy==0 ){
133845	134301	/* Try to ORDER BY the result set to make distinct processing easier */
133846	134302	pWInfo->wctrlFlags \|= WHERE_DISTINCTBY;
133847		- pWInfo->pOrderBy = pDistinctSet;
	134303	+ pWInfo->pOrderBy = pResultSet;
133848	134304	}
133849	134305	}
133850	134306
133851	134307	/* Construct the WhereLoop objects */
133852	134308	#if defined(WHERETRACE_ENABLED)
		@@ -133918,14 +134374,14 @@
133918	134374	}
133919	134375	}
133920	134376	#endif
133921	134377	/* Attempt to omit tables from the join that do not effect the result */
133922	134378	if( pWInfo->nLevel>=2
133923		- && pDistinctSet!=0
	134379	+ && pResultSet!=0
133924	134380	&& OptimizationEnabled(db, SQLITE_OmitNoopJoin)
133925	134381	){
133926		- Bitmask tabUsed = sqlite3WhereExprListUsage(pMaskSet, pDistinctSet);
	134382	+ Bitmask tabUsed = sqlite3WhereExprListUsage(pMaskSet, pResultSet);
133927	134383	if( sWLB.pOrderBy ){
133928	134384	tabUsed \|= sqlite3WhereExprListUsage(pMaskSet, sWLB.pOrderBy);
133929	134385	}
133930	134386	while( pWInfo->nLevel>=2 ){
133931	134387	WhereTerm pTerm, pEnd;
		@@ -134704,166 +135160,166 @@
134704	135160	**
134705	135161	********* Begin parsing tables ********************************************/
134706	135162	#define YY_ACTTAB_COUNT (1567)
134707	135163	static const YYACTIONTYPE yy_action[] = {
134708	135164	/* 0 */ 325, 832, 351, 825, 5, 203, 203, 819, 99, 100,
134709		- /* 10 */ 90, 842, 842, 854, 857, 846, 846, 97, 97, 98,
	135165	+ /* 10 */ 90, 978, 978, 853, 856, 845, 845, 97, 97, 98,
134710	135166	/* 20 */ 98, 98, 98, 301, 96, 96, 96, 96, 95, 95,
134711		- /* 30 */ 94, 94, 94, 93, 351, 325, 977, 977, 824, 824,
134712		- /* 40 */ 826, 947, 354, 99, 100, 90, 842, 842, 854, 857,
134713		- /* 50 */ 846, 846, 97, 97, 98, 98, 98, 98, 338, 96,
	135167	+ /* 30 */ 94, 94, 94, 93, 351, 325, 976, 976, 824, 824,
	135168	+ /* 40 */ 826, 946, 354, 99, 100, 90, 978, 978, 853, 856,
	135169	+ /* 50 */ 845, 845, 97, 97, 98, 98, 98, 98, 338, 96,
134714	135170	/* 60 */ 96, 96, 96, 95, 95, 94, 94, 94, 93, 351,
134715		- /* 70 */ 95, 95, 94, 94, 94, 93, 351, 791, 977, 977,
	135171	+ /* 70 */ 95, 95, 94, 94, 94, 93, 351, 791, 976, 976,
134716	135172	/* 80 */ 325, 94, 94, 94, 93, 351, 792, 75, 99, 100,
134717		- /* 90 */ 90, 842, 842, 854, 857, 846, 846, 97, 97, 98,
	135173	+ /* 90 */ 90, 978, 978, 853, 856, 845, 845, 97, 97, 98,
134718	135174	/* 100 */ 98, 98, 98, 450, 96, 96, 96, 96, 95, 95,
134719	135175	/* 110 */ 94, 94, 94, 93, 351, 1333, 155, 155, 2, 325,
134720	135176	/* 120 */ 275, 146, 132, 52, 52, 93, 351, 99, 100, 90,
134721		- /* 130 */ 842, 842, 854, 857, 846, 846, 97, 97, 98, 98,
	135177	+ /* 130 */ 978, 978, 853, 856, 845, 845, 97, 97, 98, 98,
134722	135178	/* 140 */ 98, 98, 101, 96, 96, 96, 96, 95, 95, 94,
134723		- /* 150 */ 94, 94, 93, 351, 958, 958, 325, 268, 428, 413,
134724		- /* 160 */ 411, 61, 752, 752, 99, 100, 90, 842, 842, 854,
134725		- /* 170 */ 857, 846, 846, 97, 97, 98, 98, 98, 98, 60,
	135179	+ /* 150 */ 94, 94, 93, 351, 957, 957, 325, 268, 428, 413,
	135180	+ /* 160 */ 411, 61, 752, 752, 99, 100, 90, 978, 978, 853,
	135181	+ /* 170 */ 856, 845, 845, 97, 97, 98, 98, 98, 98, 60,
134726	135182	/* 180 */ 96, 96, 96, 96, 95, 95, 94, 94, 94, 93,
134727		- /* 190 */ 351, 325, 270, 329, 273, 277, 959, 960, 250, 99,
134728		- /* 200 */ 100, 90, 842, 842, 854, 857, 846, 846, 97, 97,
	135183	+ /* 190 */ 351, 325, 270, 329, 273, 277, 958, 959, 250, 99,
	135184	+ /* 200 */ 100, 90, 978, 978, 853, 856, 845, 845, 97, 97,
134729	135185	/* 210 */ 98, 98, 98, 98, 301, 96, 96, 96, 96, 95,
134730		- /* 220 */ 95, 94, 94, 94, 93, 351, 325, 938, 1326, 698,
134731		- /* 230 */ 706, 1326, 242, 412, 99, 100, 90, 842, 842, 854,
134732		- /* 240 */ 857, 846, 846, 97, 97, 98, 98, 98, 98, 347,
	135186	+ /* 220 */ 95, 94, 94, 94, 93, 351, 325, 937, 1326, 698,
	135187	+ /* 230 */ 706, 1326, 242, 412, 99, 100, 90, 978, 978, 853,
	135188	+ /* 240 */ 856, 845, 845, 97, 97, 98, 98, 98, 98, 347,
134733	135189	/* 250 */ 96, 96, 96, 96, 95, 95, 94, 94, 94, 93,
134734		- /* 260 */ 351, 325, 938, 1327, 384, 699, 1327, 381, 379, 99,
134735		- /* 270 */ 100, 90, 842, 842, 854, 857, 846, 846, 97, 97,
	135190	+ /* 260 */ 351, 325, 937, 1327, 384, 699, 1327, 381, 379, 99,
	135191	+ /* 270 */ 100, 90, 978, 978, 853, 856, 845, 845, 97, 97,
134736	135192	/* 280 */ 98, 98, 98, 98, 701, 96, 96, 96, 96, 95,
134737	135193	/* 290 */ 95, 94, 94, 94, 93, 351, 325, 92, 89, 178,
134738		- /* 300 */ 833, 936, 373, 700, 99, 100, 90, 842, 842, 854,
134739		- /* 310 */ 857, 846, 846, 97, 97, 98, 98, 98, 98, 375,
	135194	+ /* 300 */ 833, 935, 373, 700, 99, 100, 90, 978, 978, 853,
	135195	+ /* 310 */ 856, 845, 845, 97, 97, 98, 98, 98, 98, 375,
134740	135196	/* 320 */ 96, 96, 96, 96, 95, 95, 94, 94, 94, 93,
134741		- /* 330 */ 351, 325, 1276, 947, 354, 818, 936, 739, 739, 99,
134742		- /* 340 */ 100, 90, 842, 842, 854, 857, 846, 846, 97, 97,
	135197	+ /* 330 */ 351, 325, 1275, 946, 354, 818, 935, 739, 739, 99,
	135198	+ /* 340 */ 100, 90, 978, 978, 853, 856, 845, 845, 97, 97,
134743	135199	/* 350 */ 98, 98, 98, 98, 230, 96, 96, 96, 96, 95,
134744		- /* 360 */ 95, 94, 94, 94, 93, 351, 325, 969, 227, 92,
134745		- /* 370 */ 89, 178, 373, 300, 99, 100, 90, 842, 842, 854,
134746		- /* 380 */ 857, 846, 846, 97, 97, 98, 98, 98, 98, 921,
	135200	+ /* 360 */ 95, 94, 94, 94, 93, 351, 325, 968, 227, 92,
	135201	+ /* 370 */ 89, 178, 373, 300, 99, 100, 90, 978, 978, 853,
	135202	+ /* 380 */ 856, 845, 845, 97, 97, 98, 98, 98, 98, 920,
134747	135203	/* 390 */ 96, 96, 96, 96, 95, 95, 94, 94, 94, 93,
134748	135204	/* 400 */ 351, 325, 449, 447, 447, 447, 147, 737, 737, 99,
134749		- /* 410 */ 100, 90, 842, 842, 854, 857, 846, 846, 97, 97,
	135205	+ /* 410 */ 100, 90, 978, 978, 853, 856, 845, 845, 97, 97,
134750	135206	/* 420 */ 98, 98, 98, 98, 296, 96, 96, 96, 96, 95,
134751		- /* 430 */ 95, 94, 94, 94, 93, 351, 325, 419, 231, 958,
134752		- /* 440 */ 958, 158, 25, 422, 99, 100, 90, 842, 842, 854,
134753		- /* 450 */ 857, 846, 846, 97, 97, 98, 98, 98, 98, 450,
	135207	+ /* 430 */ 95, 94, 94, 94, 93, 351, 325, 419, 231, 957,
	135208	+ /* 440 */ 957, 158, 25, 422, 99, 100, 90, 978, 978, 853,
	135209	+ /* 450 */ 856, 845, 845, 97, 97, 98, 98, 98, 98, 450,
134754	135210	/* 460 */ 96, 96, 96, 96, 95, 95, 94, 94, 94, 93,
134755		- /* 470 */ 351, 443, 224, 224, 420, 958, 958, 962, 325, 52,
134756		- /* 480 */ 52, 959, 960, 176, 415, 78, 99, 100, 90, 842,
134757		- /* 490 */ 842, 854, 857, 846, 846, 97, 97, 98, 98, 98,
	135211	+ /* 470 */ 351, 443, 224, 224, 420, 957, 957, 961, 325, 52,
	135212	+ /* 480 */ 52, 958, 959, 176, 415, 78, 99, 100, 90, 978,
	135213	+ /* 490 */ 978, 853, 856, 845, 845, 97, 97, 98, 98, 98,
134758	135214	/* 500 */ 98, 379, 96, 96, 96, 96, 95, 95, 94, 94,
134759		- /* 510 */ 94, 93, 351, 325, 428, 418, 298, 959, 960, 962,
134760		- /* 520 */ 81, 99, 88, 90, 842, 842, 854, 857, 846, 846,
	135215	+ /* 510 */ 94, 93, 351, 325, 428, 418, 298, 958, 959, 961,
	135216	+ /* 520 */ 81, 99, 88, 90, 978, 978, 853, 856, 845, 845,
134761	135217	/* 530 */ 97, 97, 98, 98, 98, 98, 717, 96, 96, 96,
134762		- /* 540 */ 96, 95, 95, 94, 94, 94, 93, 351, 325, 843,
134763		- /* 550 */ 843, 855, 858, 996, 318, 343, 379, 100, 90, 842,
134764		- /* 560 */ 842, 854, 857, 846, 846, 97, 97, 98, 98, 98,
	135218	+ /* 540 */ 96, 95, 95, 94, 94, 94, 93, 351, 325, 842,
	135219	+ /* 550 */ 842, 854, 857, 996, 318, 343, 379, 100, 90, 978,
	135220	+ /* 560 */ 978, 853, 856, 845, 845, 97, 97, 98, 98, 98,
134765	135221	/* 570 */ 98, 450, 96, 96, 96, 96, 95, 95, 94, 94,
134766	135222	/* 580 */ 94, 93, 351, 325, 350, 350, 350, 260, 377, 340,
134767		- /* 590 */ 929, 52, 52, 90, 842, 842, 854, 857, 846, 846,
	135223	+ /* 590 */ 928, 52, 52, 90, 978, 978, 853, 856, 845, 845,
134768	135224	/* 600 */ 97, 97, 98, 98, 98, 98, 361, 96, 96, 96,
134769	135225	/* 610 */ 96, 95, 95, 94, 94, 94, 93, 351, 86, 445,
134770		- /* 620 */ 847, 3, 1203, 361, 360, 378, 344, 813, 958, 958,
134771		- /* 630 */ 1300, 86, 445, 729, 3, 212, 169, 287, 405, 282,
	135226	+ /* 620 */ 846, 3, 1202, 361, 360, 378, 344, 813, 957, 957,
	135227	+ /* 630 */ 1299, 86, 445, 729, 3, 212, 169, 287, 405, 282,
134772	135228	/* 640 */ 404, 199, 232, 450, 300, 760, 83, 84, 280, 245,
134773	135229	/* 650 */ 262, 365, 251, 85, 352, 352, 92, 89, 178, 83,
134774	135230	/* 660 */ 84, 242, 412, 52, 52, 448, 85, 352, 352, 246,
134775		- /* 670 */ 959, 960, 194, 455, 670, 402, 399, 398, 448, 243,
	135231	+ /* 670 */ 958, 959, 194, 455, 670, 402, 399, 398, 448, 243,
134776	135232	/* 680 */ 221, 114, 434, 776, 361, 450, 397, 268, 747, 224,
134777	135233	/* 690 */ 224, 132, 132, 198, 832, 434, 452, 451, 428, 427,
134778	135234	/* 700 */ 819, 415, 734, 713, 132, 52, 52, 832, 268, 452,
134779		- /* 710 */ 451, 734, 194, 819, 363, 402, 399, 398, 450, 1271,
134780		- /* 720 */ 1271, 23, 958, 958, 86, 445, 397, 3, 228, 429,
134781		- /* 730 */ 895, 824, 824, 826, 827, 19, 203, 720, 52, 52,
	135235	+ /* 710 */ 451, 734, 194, 819, 363, 402, 399, 398, 450, 1270,
	135236	+ /* 720 */ 1270, 23, 957, 957, 86, 445, 397, 3, 228, 429,
	135237	+ /* 730 */ 894, 824, 824, 826, 827, 19, 203, 720, 52, 52,
134782	135238	/* 740 */ 428, 408, 439, 249, 824, 824, 826, 827, 19, 229,
134783	135239	/* 750 */ 403, 153, 83, 84, 761, 177, 241, 450, 721, 85,
134784		- /* 760 */ 352, 352, 120, 157, 959, 960, 58, 977, 409, 355,
	135240	+ /* 760 */ 352, 352, 120, 157, 958, 959, 58, 976, 409, 355,
134785	135241	/* 770 */ 330, 448, 268, 428, 430, 320, 790, 32, 32, 86,
134786	135242	/* 780 */ 445, 776, 3, 341, 98, 98, 98, 98, 434, 96,
134787	135243	/* 790 */ 96, 96, 96, 95, 95, 94, 94, 94, 93, 351,
134788		- /* 800 */ 832, 120, 452, 451, 813, 887, 819, 83, 84, 977,
134789		- /* 810 */ 813, 132, 410, 920, 85, 352, 352, 132, 407, 789,
134790		- /* 820 */ 958, 958, 92, 89, 178, 917, 448, 262, 370, 261,
134791		- /* 830 */ 82, 914, 80, 262, 370, 261, 776, 824, 824, 826,
134792		- /* 840 */ 827, 19, 934, 434, 96, 96, 96, 96, 95, 95,
134793		- /* 850 */ 94, 94, 94, 93, 351, 832, 74, 452, 451, 958,
134794		- /* 860 */ 958, 819, 959, 960, 120, 92, 89, 178, 945, 2,
134795		- /* 870 */ 918, 965, 268, 1, 976, 76, 445, 762, 3, 708,
134796		- /* 880 */ 901, 901, 387, 958, 958, 757, 919, 371, 740, 778,
	135244	+ /* 800 */ 832, 120, 452, 451, 813, 886, 819, 83, 84, 976,
	135245	+ /* 810 */ 813, 132, 410, 919, 85, 352, 352, 132, 407, 789,
	135246	+ /* 820 */ 957, 957, 92, 89, 178, 916, 448, 262, 370, 261,
	135247	+ /* 830 */ 82, 913, 80, 262, 370, 261, 776, 824, 824, 826,
	135248	+ /* 840 */ 827, 19, 933, 434, 96, 96, 96, 96, 95, 95,
	135249	+ /* 850 */ 94, 94, 94, 93, 351, 832, 74, 452, 451, 957,
	135250	+ /* 860 */ 957, 819, 958, 959, 120, 92, 89, 178, 944, 2,
	135251	+ /* 870 */ 917, 964, 268, 1, 975, 76, 445, 762, 3, 708,
	135252	+ /* 880 */ 900, 900, 387, 957, 957, 757, 918, 371, 740, 778,
134797	135253	/* 890 */ 756, 257, 824, 824, 826, 827, 19, 417, 741, 450,
134798		- /* 900 */ 24, 959, 960, 83, 84, 369, 958, 958, 177, 226,
134799		- /* 910 */ 85, 352, 352, 885, 315, 314, 313, 215, 311, 10,
134800		- /* 920 */ 10, 683, 448, 349, 348, 959, 960, 909, 777, 157,
134801		- /* 930 */ 120, 958, 958, 337, 776, 416, 711, 310, 450, 434,
134802		- /* 940 */ 450, 321, 450, 791, 103, 200, 175, 450, 959, 960,
134803		- /* 950 */ 908, 832, 792, 452, 451, 9, 9, 819, 10, 10,
	135254	+ /* 900 */ 24, 958, 959, 83, 84, 369, 957, 957, 177, 226,
	135255	+ /* 910 */ 85, 352, 352, 884, 315, 314, 313, 215, 311, 10,
	135256	+ /* 920 */ 10, 683, 448, 349, 348, 958, 959, 908, 777, 157,
	135257	+ /* 930 */ 120, 957, 957, 337, 776, 416, 711, 310, 450, 434,
	135258	+ /* 940 */ 450, 321, 450, 791, 103, 200, 175, 450, 958, 959,
	135259	+ /* 950 */ 907, 832, 792, 452, 451, 9, 9, 819, 10, 10,
134804	135260	/* 960 */ 52, 52, 51, 51, 180, 716, 248, 10, 10, 171,
134805		- /* 970 */ 170, 167, 339, 959, 960, 247, 984, 702, 702, 450,
134806		- /* 980 */ 715, 233, 686, 982, 889, 983, 182, 914, 824, 824,
	135261	+ /* 970 */ 170, 167, 339, 958, 959, 247, 984, 702, 702, 450,
	135262	+ /* 980 */ 715, 233, 686, 982, 888, 983, 182, 913, 824, 824,
134807	135263	/* 990 */ 826, 827, 19, 183, 256, 423, 132, 181, 394, 10,
134808		- /* 1000 */ 10, 889, 891, 749, 958, 958, 917, 268, 985, 198,
	135264	+ /* 1000 */ 10, 888, 890, 749, 957, 957, 916, 268, 985, 198,
134809	135265	/* 1010 */ 985, 349, 348, 425, 415, 299, 817, 832, 326, 825,
134810	135266	/* 1020 */ 120, 332, 133, 819, 268, 98, 98, 98, 98, 91,
134811	135267	/* 1030 */ 96, 96, 96, 96, 95, 95, 94, 94, 94, 93,
134812		- /* 1040 */ 351, 157, 810, 371, 382, 359, 959, 960, 358, 268,
134813		- /* 1050 */ 450, 918, 368, 324, 824, 824, 826, 450, 709, 450,
134814		- /* 1060 */ 264, 380, 889, 450, 877, 746, 253, 919, 255, 433,
	135268	+ /* 1040 */ 351, 157, 810, 371, 382, 359, 958, 959, 358, 268,
	135269	+ /* 1050 */ 450, 917, 368, 324, 824, 824, 826, 450, 709, 450,
	135270	+ /* 1060 */ 264, 380, 888, 450, 876, 746, 253, 918, 255, 433,
134815	135271	/* 1070 */ 36, 36, 234, 450, 234, 120, 269, 37, 37, 12,
134816	135272	/* 1080 */ 12, 334, 272, 27, 27, 450, 330, 118, 450, 162,
134817	135273	/* 1090 */ 742, 280, 450, 38, 38, 450, 985, 356, 985, 450,
134818		- /* 1100 */ 709, 1210, 450, 132, 450, 39, 39, 450, 40, 40,
	135274	+ /* 1100 */ 709, 1209, 450, 132, 450, 39, 39, 450, 40, 40,
134819	135275	/* 1110 */ 450, 362, 41, 41, 450, 42, 42, 450, 254, 28,
134820	135276	/* 1120 */ 28, 450, 29, 29, 31, 31, 450, 43, 43, 450,
134821	135277	/* 1130 */ 44, 44, 450, 714, 45, 45, 450, 11, 11, 767,
134822	135278	/* 1140 */ 450, 46, 46, 450, 268, 450, 105, 105, 450, 47,
134823	135279	/* 1150 */ 47, 450, 48, 48, 450, 237, 33, 33, 450, 172,
134824	135280	/* 1160 */ 49, 49, 450, 50, 50, 34, 34, 274, 122, 122,
134825		- /* 1170 */ 450, 123, 123, 450, 124, 124, 450, 898, 56, 56,
134826		- /* 1180 */ 450, 897, 35, 35, 450, 267, 450, 817, 450, 817,
	135281	+ /* 1170 */ 450, 123, 123, 450, 124, 124, 450, 897, 56, 56,
	135282	+ /* 1180 */ 450, 896, 35, 35, 450, 267, 450, 817, 450, 817,
134827	135283	/* 1190 */ 106, 106, 450, 53, 53, 385, 107, 107, 450, 817,
134828	135284	/* 1200 */ 108, 108, 817, 450, 104, 104, 121, 121, 119, 119,
134829	135285	/* 1210 */ 450, 117, 112, 112, 450, 276, 450, 225, 111, 111,
134830		- /* 1220 */ 450, 730, 450, 109, 109, 450, 673, 674, 675, 912,
	135286	+ /* 1220 */ 450, 730, 450, 109, 109, 450, 673, 674, 675, 911,
134831	135287	/* 1230 */ 110, 110, 317, 998, 55, 55, 57, 57, 692, 331,
134832		- /* 1240 */ 54, 54, 26, 26, 696, 30, 30, 317, 937, 197,
	135288	+ /* 1240 */ 54, 54, 26, 26, 696, 30, 30, 317, 936, 197,
134833	135289	/* 1250 */ 196, 195, 335, 281, 336, 446, 331, 745, 689, 436,
134834		- /* 1260 */ 440, 444, 120, 72, 386, 223, 175, 345, 757, 933,
	135290	+ /* 1260 */ 440, 444, 120, 72, 386, 223, 175, 345, 757, 932,
134835	135291	/* 1270 */ 20, 286, 319, 756, 815, 372, 374, 202, 202, 202,
134836		- /* 1280 */ 263, 395, 285, 74, 208, 21, 696, 719, 718, 884,
	135292	+ /* 1280 */ 263, 395, 285, 74, 208, 21, 696, 719, 718, 883,
134837	135293	/* 1290 */ 120, 120, 120, 120, 120, 754, 278, 828, 77, 74,
134838		- /* 1300 */ 726, 727, 785, 783, 880, 202, 999, 208, 894, 893,
134839		- /* 1310 */ 894, 893, 694, 816, 763, 116, 774, 1290, 431, 432,
	135294	+ /* 1300 */ 726, 727, 785, 783, 879, 202, 999, 208, 893, 892,
	135295	+ /* 1310 */ 893, 892, 694, 816, 763, 116, 774, 1289, 431, 432,
134840	135296	/* 1320 */ 302, 999, 390, 303, 823, 697, 691, 680, 159, 289,
134841		- /* 1330 */ 679, 884, 681, 952, 291, 218, 293, 7, 316, 828,
134842		- /* 1340 */ 173, 805, 259, 364, 252, 911, 376, 713, 295, 435,
134843		- /* 1350 */ 308, 168, 955, 993, 135, 400, 990, 284, 882, 881,
134844		- /* 1360 */ 205, 928, 926, 59, 333, 62, 144, 156, 130, 72,
	135297	+ /* 1330 */ 679, 883, 681, 951, 291, 218, 293, 7, 316, 828,
	135298	+ /* 1340 */ 173, 805, 259, 364, 252, 910, 376, 713, 295, 435,
	135299	+ /* 1350 */ 308, 168, 954, 993, 135, 400, 990, 284, 881, 880,
	135300	+ /* 1360 */ 205, 927, 925, 59, 333, 62, 144, 156, 130, 72,
134845	135301	/* 1370 */ 802, 366, 367, 393, 137, 185, 189, 160, 139, 383,
134846		- /* 1380 */ 67, 896, 140, 141, 142, 148, 389, 812, 775, 266,
134847		- /* 1390 */ 219, 190, 154, 391, 913, 876, 271, 406, 191, 322,
	135302	+ /* 1380 */ 67, 895, 140, 141, 142, 148, 389, 812, 775, 266,
	135303	+ /* 1390 */ 219, 190, 154, 391, 912, 875, 271, 406, 191, 322,
134848	135304	/* 1400 */ 682, 733, 192, 342, 732, 724, 731, 711, 723, 421,
134849	135305	/* 1410 */ 705, 71, 323, 6, 204, 771, 288, 79, 297, 346,
134850		- /* 1420 */ 772, 704, 290, 283, 703, 770, 292, 294, 967, 239,
134851		- /* 1430 */ 769, 102, 862, 438, 426, 240, 424, 442, 73, 213,
134852		- /* 1440 */ 688, 238, 22, 453, 953, 214, 217, 216, 454, 677,
	135306	+ /* 1420 */ 772, 704, 290, 283, 703, 770, 292, 294, 966, 239,
	135307	+ /* 1430 */ 769, 102, 861, 438, 426, 240, 424, 442, 73, 213,
	135308	+ /* 1440 */ 688, 238, 22, 453, 952, 214, 217, 216, 454, 677,
134853	135309	/* 1450 */ 676, 671, 753, 125, 115, 235, 126, 669, 353, 166,
134854		- /* 1460 */ 127, 244, 179, 357, 306, 304, 305, 307, 113, 892,
134855		- /* 1470 */ 327, 890, 811, 328, 134, 128, 136, 138, 743, 258,
134856		- /* 1480 */ 907, 184, 143, 129, 910, 186, 63, 64, 145, 187,
134857		- /* 1490 */ 906, 65, 8, 66, 13, 188, 202, 899, 265, 149,
	135310	+ /* 1460 */ 127, 244, 179, 357, 306, 304, 305, 307, 113, 891,
	135311	+ /* 1470 */ 327, 889, 811, 328, 134, 128, 136, 138, 743, 258,
	135312	+ /* 1480 */ 906, 184, 143, 129, 909, 186, 63, 64, 145, 187,
	135313	+ /* 1490 */ 905, 65, 8, 66, 13, 188, 202, 898, 265, 149,
134858	135314	/* 1500 */ 987, 388, 150, 685, 161, 392, 285, 193, 279, 396,
134859	135315	/* 1510 */ 151, 401, 68, 14, 15, 722, 69, 236, 831, 131,
134860		- /* 1520 */ 830, 860, 70, 751, 16, 414, 755, 4, 174, 220,
134861		- /* 1530 */ 222, 784, 201, 152, 779, 77, 74, 17, 18, 875,
134862		- /* 1540 */ 861, 859, 916, 864, 915, 207, 206, 942, 163, 437,
134863		- /* 1550 */ 948, 943, 164, 209, 1002, 441, 863, 165, 210, 829,
134864		- /* 1560 */ 695, 87, 312, 211, 1292, 1291, 309,
	135316	+ /* 1520 */ 830, 859, 70, 751, 16, 414, 755, 4, 174, 220,
	135317	+ /* 1530 */ 222, 784, 201, 152, 779, 77, 74, 17, 18, 874,
	135318	+ /* 1540 */ 860, 858, 915, 863, 914, 207, 206, 941, 163, 437,
	135319	+ /* 1550 */ 947, 942, 164, 209, 1002, 441, 862, 165, 210, 829,
	135320	+ /* 1560 */ 695, 87, 312, 211, 1291, 1290, 309,
134865	135321	};
134866	135322	static const YYCODETYPE yy_lookahead[] = {
134867	135323	/* 0 */ 19, 95, 53, 97, 22, 24, 24, 101, 27, 28,
134868	135324	/* 10 */ 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
134869	135325	/* 20 */ 39, 40, 41, 152, 43, 44, 45, 46, 47, 48,
		@@ -135112,55 +135568,55 @@
135112	135568	/* 300 */ 1256, 1200, 1206, 1260, 1247, 1261, 1263, 1262, 1266, 1278,
135113	135569	/* 310 */ 1282, 1292, 1294, 1297, 1298, 1299, 1300, 1221, 1224, 1228,
135114	135570	/* 320 */ 1288, 1291, 1276, 1277, 1295,
135115	135571	};
135116	135572	static const YYACTIONTYPE yy_default[] = {
135117		- /* 0 */ 1281, 1271, 1271, 1271, 1203, 1203, 1203, 1203, 1271, 1096,
135118		- /* 10 */ 1125, 1125, 1255, 1332, 1332, 1332, 1332, 1332, 1332, 1202,
135119		- /* 20 */ 1332, 1332, 1332, 1332, 1271, 1100, 1131, 1332, 1332, 1332,
135120		- /* 30 */ 1332, 1204, 1205, 1332, 1332, 1332, 1254, 1256, 1141, 1140,
135121		- /* 40 */ 1139, 1138, 1237, 1112, 1136, 1129, 1133, 1204, 1198, 1199,
135122		- /* 50 */ 1197, 1201, 1205, 1332, 1132, 1167, 1182, 1166, 1332, 1332,
	135573	+ /* 0 */ 1280, 1270, 1270, 1270, 1202, 1202, 1202, 1202, 1270, 1096,
	135574	+ /* 10 */ 1125, 1125, 1254, 1332, 1332, 1332, 1332, 1332, 1332, 1201,
	135575	+ /* 20 */ 1332, 1332, 1332, 1332, 1270, 1100, 1131, 1332, 1332, 1332,
	135576	+ /* 30 */ 1332, 1203, 1204, 1332, 1332, 1332, 1253, 1255, 1141, 1140,
	135577	+ /* 40 */ 1139, 1138, 1236, 1112, 1136, 1129, 1133, 1203, 1197, 1198,
	135578	+ /* 50 */ 1196, 1200, 1204, 1332, 1132, 1167, 1181, 1166, 1332, 1332,
135123	135579	/* 60 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135124	135580	/* 70 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135125	135581	/* 80 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135126	135582	/* 90 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135127		- /* 100 */ 1332, 1332, 1332, 1332, 1176, 1181, 1188, 1180, 1177, 1169,
	135583	+ /* 100 */ 1332, 1332, 1332, 1332, 1175, 1180, 1187, 1179, 1176, 1169,
135128	135584	/* 110 */ 1168, 1170, 1171, 1332, 1019, 1067, 1332, 1332, 1332, 1172,
135129		- /* 120 */ 1332, 1173, 1185, 1184, 1183, 1262, 1289, 1288, 1332, 1332,
	135585	+ /* 120 */ 1332, 1173, 1184, 1183, 1182, 1261, 1288, 1287, 1332, 1332,
135130	135586	/* 130 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135131	135587	/* 140 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135132		- /* 150 */ 1332, 1332, 1332, 1332, 1332, 1281, 1271, 1025, 1025, 1332,
135133		- /* 160 */ 1271, 1271, 1271, 1271, 1271, 1271, 1267, 1100, 1091, 1332,
	135588	+ /* 150 */ 1332, 1332, 1332, 1332, 1332, 1280, 1270, 1025, 1025, 1332,
	135589	+ /* 160 */ 1270, 1270, 1270, 1270, 1270, 1270, 1266, 1100, 1091, 1332,
135134	135590	/* 170 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135135		- /* 180 */ 1259, 1257, 1332, 1218, 1332, 1332, 1332, 1332, 1332, 1332,
	135591	+ /* 180 */ 1258, 1256, 1332, 1217, 1332, 1332, 1332, 1332, 1332, 1332,
135136	135592	/* 190 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135137	135593	/* 200 */ 1332, 1332, 1332, 1332, 1096, 1332, 1332, 1332, 1332, 1332,
135138		- /* 210 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1283, 1332, 1232,
	135594	+ /* 210 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1282, 1332, 1231,
135139	135595	/* 220 */ 1096, 1096, 1096, 1098, 1080, 1090, 1004, 1135, 1114, 1114,
135140		- /* 230 */ 1321, 1135, 1321, 1042, 1303, 1039, 1125, 1114, 1200, 1125,
	135596	+ /* 230 */ 1321, 1135, 1321, 1042, 1302, 1039, 1125, 1114, 1199, 1125,
135141	135597	/* 240 */ 1125, 1097, 1090, 1332, 1324, 1105, 1105, 1323, 1323, 1105,
135142	135598	/* 250 */ 1146, 1070, 1135, 1076, 1076, 1076, 1076, 1105, 1016, 1135,
135143		- /* 260 */ 1146, 1070, 1070, 1135, 1105, 1016, 1236, 1318, 1105, 1105,
135144		- /* 270 */ 1016, 1211, 1105, 1016, 1105, 1016, 1211, 1068, 1068, 1068,
135145		- /* 280 */ 1057, 1211, 1068, 1042, 1068, 1057, 1068, 1068, 1118, 1113,
135146		- /* 290 */ 1118, 1113, 1118, 1113, 1118, 1113, 1105, 1206, 1105, 1332,
135147		- /* 300 */ 1211, 1215, 1215, 1211, 1130, 1119, 1128, 1126, 1135, 1022,
135148		- /* 310 */ 1060, 1286, 1286, 1282, 1282, 1282, 1282, 1329, 1329, 1267,
135149		- /* 320 */ 1298, 1298, 1044, 1044, 1298, 1332, 1332, 1332, 1332, 1332,
135150		- /* 330 */ 1332, 1293, 1332, 1220, 1332, 1332, 1332, 1332, 1332, 1332,
	135599	+ /* 260 */ 1146, 1070, 1070, 1135, 1105, 1016, 1235, 1318, 1105, 1105,
	135600	+ /* 270 */ 1016, 1210, 1105, 1016, 1105, 1016, 1210, 1068, 1068, 1068,
	135601	+ /* 280 */ 1057, 1210, 1068, 1042, 1068, 1057, 1068, 1068, 1118, 1113,
	135602	+ /* 290 */ 1118, 1113, 1118, 1113, 1118, 1113, 1105, 1205, 1105, 1332,
	135603	+ /* 300 */ 1210, 1214, 1214, 1210, 1130, 1119, 1128, 1126, 1135, 1022,
	135604	+ /* 310 */ 1060, 1285, 1285, 1281, 1281, 1281, 1281, 1329, 1329, 1266,
	135605	+ /* 320 */ 1297, 1297, 1044, 1044, 1297, 1332, 1332, 1332, 1332, 1332,
	135606	+ /* 330 */ 1332, 1292, 1332, 1219, 1332, 1332, 1332, 1332, 1332, 1332,
135151	135607	/* 340 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135152		- /* 350 */ 1332, 1332, 1152, 1332, 1000, 1264, 1332, 1332, 1263, 1332,
	135608	+ /* 350 */ 1332, 1332, 1152, 1332, 1000, 1263, 1332, 1332, 1262, 1332,
135153	135609	/* 360 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135154	135610	/* 370 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1320,
135155		- /* 380 */ 1332, 1332, 1332, 1332, 1332, 1332, 1235, 1234, 1332, 1332,
	135611	+ /* 380 */ 1332, 1332, 1332, 1332, 1332, 1332, 1234, 1233, 1332, 1332,
135156	135612	/* 390 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135157	135613	/* 400 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135158		- /* 410 */ 1332, 1082, 1332, 1332, 1332, 1307, 1332, 1332, 1332, 1332,
	135614	+ /* 410 */ 1332, 1082, 1332, 1332, 1332, 1306, 1332, 1332, 1332, 1332,
135159	135615	/* 420 */ 1332, 1332, 1332, 1127, 1332, 1120, 1332, 1332, 1311, 1332,
135160		- /* 430 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1273,
135161		- /* 440 */ 1332, 1332, 1332, 1272, 1332, 1332, 1332, 1332, 1332, 1154,
	135616	+ /* 430 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1272,
	135617	+ /* 440 */ 1332, 1332, 1332, 1271, 1332, 1332, 1332, 1332, 1332, 1154,
135162	135618	/* 450 */ 1332, 1153, 1157, 1332, 1010, 1332,
135163	135619	};
135164	135620	/******** End of lemon-generated parsing tables ***************************/
135165	135621
135166	135622	/* The next table maps tokens (terminal symbols) into fallback tokens.
		@@ -135602,147 +136058,147 @@
135602	136058	/* 169 */ "expr ::= expr EQ\|NE expr",
135603	136059	/* 170 */ "expr ::= expr BITAND\|BITOR\|LSHIFT\|RSHIFT expr",
135604	136060	/* 171 */ "expr ::= expr PLUS\|MINUS expr",
135605	136061	/* 172 */ "expr ::= expr STAR\|SLASH\|REM expr",
135606	136062	/* 173 */ "expr ::= expr CONCAT expr",
135607		- /* 174 */ "likeop ::= LIKE_KW\|MATCH",
135608		- /* 175 */ "likeop ::= NOT LIKE_KW\|MATCH",
135609		- /* 176 */ "expr ::= expr likeop expr",
135610		- /* 177 */ "expr ::= expr likeop expr ESCAPE expr",
135611		- /* 178 */ "expr ::= expr ISNULL\|NOTNULL",
135612		- /* 179 */ "expr ::= expr NOT NULL",
135613		- /* 180 */ "expr ::= expr IS expr",
135614		- /* 181 */ "expr ::= expr IS NOT expr",
135615		- /* 182 */ "expr ::= NOT expr",
135616		- /* 183 */ "expr ::= BITNOT expr",
135617		- /* 184 */ "expr ::= MINUS expr",
135618		- /* 185 */ "expr ::= PLUS expr",
135619		- /* 186 */ "between_op ::= BETWEEN",
135620		- /* 187 */ "between_op ::= NOT BETWEEN",
135621		- /* 188 */ "expr ::= expr between_op expr AND expr",
135622		- /* 189 */ "in_op ::= IN",
135623		- /* 190 */ "in_op ::= NOT IN",
135624		- /* 191 */ "expr ::= expr in_op LP exprlist RP",
135625		- /* 192 */ "expr ::= LP select RP",
135626		- /* 193 */ "expr ::= expr in_op LP select RP",
135627		- /* 194 */ "expr ::= expr in_op nm dbnm paren_exprlist",
135628		- /* 195 */ "expr ::= EXISTS LP select RP",
135629		- /* 196 */ "expr ::= CASE case_operand case_exprlist case_else END",
135630		- /* 197 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
135631		- /* 198 */ "case_exprlist ::= WHEN expr THEN expr",
135632		- /* 199 */ "case_else ::= ELSE expr",
135633		- /* 200 */ "case_else ::=",
135634		- /* 201 */ "case_operand ::= expr",
135635		- /* 202 */ "case_operand ::=",
135636		- /* 203 */ "exprlist ::=",
135637		- /* 204 */ "nexprlist ::= nexprlist COMMA expr",
135638		- /* 205 */ "nexprlist ::= expr",
135639		- /* 206 */ "paren_exprlist ::=",
135640		- /* 207 */ "paren_exprlist ::= LP exprlist RP",
135641		- /* 208 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt",
135642		- /* 209 */ "uniqueflag ::= UNIQUE",
135643		- /* 210 */ "uniqueflag ::=",
135644		- /* 211 */ "eidlist_opt ::=",
135645		- /* 212 */ "eidlist_opt ::= LP eidlist RP",
135646		- /* 213 */ "eidlist ::= eidlist COMMA nm collate sortorder",
135647		- /* 214 */ "eidlist ::= nm collate sortorder",
135648		- /* 215 */ "collate ::=",
135649		- /* 216 */ "collate ::= COLLATE ID\|STRING",
135650		- /* 217 */ "cmd ::= DROP INDEX ifexists fullname",
135651		- /* 218 */ "cmd ::= VACUUM",
135652		- /* 219 */ "cmd ::= VACUUM nm",
135653		- /* 220 */ "cmd ::= PRAGMA nm dbnm",
135654		- /* 221 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
135655		- /* 222 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
135656		- /* 223 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
135657		- /* 224 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
135658		- /* 225 */ "plus_num ::= PLUS INTEGER\|FLOAT",
135659		- /* 226 */ "minus_num ::= MINUS INTEGER\|FLOAT",
135660		- /* 227 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
135661		- /* 228 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
135662		- /* 229 */ "trigger_time ::= BEFORE",
135663		- /* 230 */ "trigger_time ::= AFTER",
135664		- /* 231 */ "trigger_time ::= INSTEAD OF",
135665		- /* 232 */ "trigger_time ::=",
135666		- /* 233 */ "trigger_event ::= DELETE\|INSERT",
135667		- /* 234 */ "trigger_event ::= UPDATE",
135668		- /* 235 */ "trigger_event ::= UPDATE OF idlist",
135669		- /* 236 */ "when_clause ::=",
135670		- /* 237 */ "when_clause ::= WHEN expr",
135671		- /* 238 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
135672		- /* 239 */ "trigger_cmd_list ::= trigger_cmd SEMI",
135673		- /* 240 */ "trnm ::= nm DOT nm",
135674		- /* 241 */ "tridxby ::= INDEXED BY nm",
135675		- /* 242 */ "tridxby ::= NOT INDEXED",
135676		- /* 243 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt",
135677		- /* 244 */ "trigger_cmd ::= insert_cmd INTO trnm idlist_opt select",
135678		- /* 245 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt",
135679		- /* 246 */ "trigger_cmd ::= select",
135680		- /* 247 */ "expr ::= RAISE LP IGNORE RP",
135681		- /* 248 */ "expr ::= RAISE LP raisetype COMMA nm RP",
135682		- /* 249 */ "raisetype ::= ROLLBACK",
135683		- /* 250 */ "raisetype ::= ABORT",
135684		- /* 251 */ "raisetype ::= FAIL",
135685		- /* 252 */ "cmd ::= DROP TRIGGER ifexists fullname",
135686		- /* 253 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
135687		- /* 254 */ "cmd ::= DETACH database_kw_opt expr",
135688		- /* 255 */ "key_opt ::=",
135689		- /* 256 */ "key_opt ::= KEY expr",
135690		- /* 257 */ "cmd ::= REINDEX",
135691		- /* 258 */ "cmd ::= REINDEX nm dbnm",
135692		- /* 259 */ "cmd ::= ANALYZE",
135693		- /* 260 */ "cmd ::= ANALYZE nm dbnm",
135694		- /* 261 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
135695		- /* 262 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist",
135696		- /* 263 */ "add_column_fullname ::= fullname",
135697		- /* 264 */ "cmd ::= create_vtab",
135698		- /* 265 */ "cmd ::= create_vtab LP vtabarglist RP",
135699		- /* 266 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm",
135700		- /* 267 */ "vtabarg ::=",
135701		- /* 268 */ "vtabargtoken ::= ANY",
135702		- /* 269 */ "vtabargtoken ::= lp anylist RP",
135703		- /* 270 */ "lp ::= LP",
135704		- /* 271 */ "with ::=",
135705		- /* 272 */ "with ::= WITH wqlist",
135706		- /* 273 */ "with ::= WITH RECURSIVE wqlist",
135707		- /* 274 */ "wqlist ::= nm eidlist_opt AS LP select RP",
135708		- /* 275 */ "wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP",
135709		- /* 276 */ "input ::= cmdlist",
135710		- /* 277 */ "cmdlist ::= cmdlist ecmd",
135711		- /* 278 */ "cmdlist ::= ecmd",
135712		- /* 279 */ "ecmd ::= SEMI",
135713		- /* 280 */ "ecmd ::= explain cmdx SEMI",
135714		- /* 281 */ "explain ::=",
135715		- /* 282 */ "trans_opt ::=",
135716		- /* 283 */ "trans_opt ::= TRANSACTION",
135717		- /* 284 */ "trans_opt ::= TRANSACTION nm",
135718		- /* 285 */ "savepoint_opt ::= SAVEPOINT",
135719		- /* 286 */ "savepoint_opt ::=",
135720		- /* 287 */ "cmd ::= create_table create_table_args",
135721		- /* 288 */ "columnlist ::= columnlist COMMA columnname carglist",
135722		- /* 289 */ "columnlist ::= columnname carglist",
135723		- /* 290 */ "nm ::= ID\|INDEXED",
135724		- /* 291 */ "nm ::= STRING",
135725		- /* 292 */ "nm ::= JOIN_KW",
135726		- /* 293 */ "typetoken ::= typename",
135727		- /* 294 */ "typename ::= ID\|STRING",
135728		- /* 295 */ "signed ::= plus_num",
135729		- /* 296 */ "signed ::= minus_num",
135730		- /* 297 */ "carglist ::= carglist ccons",
135731		- /* 298 */ "carglist ::=",
135732		- /* 299 */ "ccons ::= NULL onconf",
135733		- /* 300 */ "conslist_opt ::= COMMA conslist",
135734		- /* 301 */ "conslist ::= conslist tconscomma tcons",
135735		- /* 302 */ "conslist ::= tcons",
135736		- /* 303 */ "tconscomma ::=",
135737		- /* 304 */ "defer_subclause_opt ::= defer_subclause",
135738		- /* 305 */ "resolvetype ::= raisetype",
135739		- /* 306 */ "selectnowith ::= oneselect",
135740		- /* 307 */ "oneselect ::= values",
135741		- /* 308 */ "sclp ::= selcollist COMMA",
135742		- /* 309 */ "as ::= ID\|STRING",
135743		- /* 310 */ "expr ::= term",
	136063	+ /* 174 */ "likeop ::= NOT LIKE_KW\|MATCH",
	136064	+ /* 175 */ "expr ::= expr likeop expr",
	136065	+ /* 176 */ "expr ::= expr likeop expr ESCAPE expr",
	136066	+ /* 177 */ "expr ::= expr ISNULL\|NOTNULL",
	136067	+ /* 178 */ "expr ::= expr NOT NULL",
	136068	+ /* 179 */ "expr ::= expr IS expr",
	136069	+ /* 180 */ "expr ::= expr IS NOT expr",
	136070	+ /* 181 */ "expr ::= NOT expr",
	136071	+ /* 182 */ "expr ::= BITNOT expr",
	136072	+ /* 183 */ "expr ::= MINUS expr",
	136073	+ /* 184 */ "expr ::= PLUS expr",
	136074	+ /* 185 */ "between_op ::= BETWEEN",
	136075	+ /* 186 */ "between_op ::= NOT BETWEEN",
	136076	+ /* 187 */ "expr ::= expr between_op expr AND expr",
	136077	+ /* 188 */ "in_op ::= IN",
	136078	+ /* 189 */ "in_op ::= NOT IN",
	136079	+ /* 190 */ "expr ::= expr in_op LP exprlist RP",
	136080	+ /* 191 */ "expr ::= LP select RP",
	136081	+ /* 192 */ "expr ::= expr in_op LP select RP",
	136082	+ /* 193 */ "expr ::= expr in_op nm dbnm paren_exprlist",
	136083	+ /* 194 */ "expr ::= EXISTS LP select RP",
	136084	+ /* 195 */ "expr ::= CASE case_operand case_exprlist case_else END",
	136085	+ /* 196 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
	136086	+ /* 197 */ "case_exprlist ::= WHEN expr THEN expr",
	136087	+ /* 198 */ "case_else ::= ELSE expr",
	136088	+ /* 199 */ "case_else ::=",
	136089	+ /* 200 */ "case_operand ::= expr",
	136090	+ /* 201 */ "case_operand ::=",
	136091	+ /* 202 */ "exprlist ::=",
	136092	+ /* 203 */ "nexprlist ::= nexprlist COMMA expr",
	136093	+ /* 204 */ "nexprlist ::= expr",
	136094	+ /* 205 */ "paren_exprlist ::=",
	136095	+ /* 206 */ "paren_exprlist ::= LP exprlist RP",
	136096	+ /* 207 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt",
	136097	+ /* 208 */ "uniqueflag ::= UNIQUE",
	136098	+ /* 209 */ "uniqueflag ::=",
	136099	+ /* 210 */ "eidlist_opt ::=",
	136100	+ /* 211 */ "eidlist_opt ::= LP eidlist RP",
	136101	+ /* 212 */ "eidlist ::= eidlist COMMA nm collate sortorder",
	136102	+ /* 213 */ "eidlist ::= nm collate sortorder",
	136103	+ /* 214 */ "collate ::=",
	136104	+ /* 215 */ "collate ::= COLLATE ID\|STRING",
	136105	+ /* 216 */ "cmd ::= DROP INDEX ifexists fullname",
	136106	+ /* 217 */ "cmd ::= VACUUM",
	136107	+ /* 218 */ "cmd ::= VACUUM nm",
	136108	+ /* 219 */ "cmd ::= PRAGMA nm dbnm",
	136109	+ /* 220 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
	136110	+ /* 221 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
	136111	+ /* 222 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
	136112	+ /* 223 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
	136113	+ /* 224 */ "plus_num ::= PLUS INTEGER\|FLOAT",
	136114	+ /* 225 */ "minus_num ::= MINUS INTEGER\|FLOAT",
	136115	+ /* 226 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
	136116	+ /* 227 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
	136117	+ /* 228 */ "trigger_time ::= BEFORE",
	136118	+ /* 229 */ "trigger_time ::= AFTER",
	136119	+ /* 230 */ "trigger_time ::= INSTEAD OF",
	136120	+ /* 231 */ "trigger_time ::=",
	136121	+ /* 232 */ "trigger_event ::= DELETE\|INSERT",
	136122	+ /* 233 */ "trigger_event ::= UPDATE",
	136123	+ /* 234 */ "trigger_event ::= UPDATE OF idlist",
	136124	+ /* 235 */ "when_clause ::=",
	136125	+ /* 236 */ "when_clause ::= WHEN expr",
	136126	+ /* 237 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
	136127	+ /* 238 */ "trigger_cmd_list ::= trigger_cmd SEMI",
	136128	+ /* 239 */ "trnm ::= nm DOT nm",
	136129	+ /* 240 */ "tridxby ::= INDEXED BY nm",
	136130	+ /* 241 */ "tridxby ::= NOT INDEXED",
	136131	+ /* 242 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt",
	136132	+ /* 243 */ "trigger_cmd ::= insert_cmd INTO trnm idlist_opt select",
	136133	+ /* 244 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt",
	136134	+ /* 245 */ "trigger_cmd ::= select",
	136135	+ /* 246 */ "expr ::= RAISE LP IGNORE RP",
	136136	+ /* 247 */ "expr ::= RAISE LP raisetype COMMA nm RP",
	136137	+ /* 248 */ "raisetype ::= ROLLBACK",
	136138	+ /* 249 */ "raisetype ::= ABORT",
	136139	+ /* 250 */ "raisetype ::= FAIL",
	136140	+ /* 251 */ "cmd ::= DROP TRIGGER ifexists fullname",
	136141	+ /* 252 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
	136142	+ /* 253 */ "cmd ::= DETACH database_kw_opt expr",
	136143	+ /* 254 */ "key_opt ::=",
	136144	+ /* 255 */ "key_opt ::= KEY expr",
	136145	+ /* 256 */ "cmd ::= REINDEX",
	136146	+ /* 257 */ "cmd ::= REINDEX nm dbnm",
	136147	+ /* 258 */ "cmd ::= ANALYZE",
	136148	+ /* 259 */ "cmd ::= ANALYZE nm dbnm",
	136149	+ /* 260 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
	136150	+ /* 261 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist",
	136151	+ /* 262 */ "add_column_fullname ::= fullname",
	136152	+ /* 263 */ "cmd ::= create_vtab",
	136153	+ /* 264 */ "cmd ::= create_vtab LP vtabarglist RP",
	136154	+ /* 265 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm",
	136155	+ /* 266 */ "vtabarg ::=",
	136156	+ /* 267 */ "vtabargtoken ::= ANY",
	136157	+ /* 268 */ "vtabargtoken ::= lp anylist RP",
	136158	+ /* 269 */ "lp ::= LP",
	136159	+ /* 270 */ "with ::=",
	136160	+ /* 271 */ "with ::= WITH wqlist",
	136161	+ /* 272 */ "with ::= WITH RECURSIVE wqlist",
	136162	+ /* 273 */ "wqlist ::= nm eidlist_opt AS LP select RP",
	136163	+ /* 274 */ "wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP",
	136164	+ /* 275 */ "input ::= cmdlist",
	136165	+ /* 276 */ "cmdlist ::= cmdlist ecmd",
	136166	+ /* 277 */ "cmdlist ::= ecmd",
	136167	+ /* 278 */ "ecmd ::= SEMI",
	136168	+ /* 279 */ "ecmd ::= explain cmdx SEMI",
	136169	+ /* 280 */ "explain ::=",
	136170	+ /* 281 */ "trans_opt ::=",
	136171	+ /* 282 */ "trans_opt ::= TRANSACTION",
	136172	+ /* 283 */ "trans_opt ::= TRANSACTION nm",
	136173	+ /* 284 */ "savepoint_opt ::= SAVEPOINT",
	136174	+ /* 285 */ "savepoint_opt ::=",
	136175	+ /* 286 */ "cmd ::= create_table create_table_args",
	136176	+ /* 287 */ "columnlist ::= columnlist COMMA columnname carglist",
	136177	+ /* 288 */ "columnlist ::= columnname carglist",
	136178	+ /* 289 */ "nm ::= ID\|INDEXED",
	136179	+ /* 290 */ "nm ::= STRING",
	136180	+ /* 291 */ "nm ::= JOIN_KW",
	136181	+ /* 292 */ "typetoken ::= typename",
	136182	+ /* 293 */ "typename ::= ID\|STRING",
	136183	+ /* 294 */ "signed ::= plus_num",
	136184	+ /* 295 */ "signed ::= minus_num",
	136185	+ /* 296 */ "carglist ::= carglist ccons",
	136186	+ /* 297 */ "carglist ::=",
	136187	+ /* 298 */ "ccons ::= NULL onconf",
	136188	+ /* 299 */ "conslist_opt ::= COMMA conslist",
	136189	+ /* 300 */ "conslist ::= conslist tconscomma tcons",
	136190	+ /* 301 */ "conslist ::= tcons",
	136191	+ /* 302 */ "tconscomma ::=",
	136192	+ /* 303 */ "defer_subclause_opt ::= defer_subclause",
	136193	+ /* 304 */ "resolvetype ::= raisetype",
	136194	+ /* 305 */ "selectnowith ::= oneselect",
	136195	+ /* 306 */ "oneselect ::= values",
	136196	+ /* 307 */ "sclp ::= selcollist COMMA",
	136197	+ /* 308 */ "as ::= ID\|STRING",
	136198	+ /* 309 */ "expr ::= term",
	136199	+ /* 310 */ "likeop ::= LIKE_KW\|MATCH",
135744	136200	/* 311 */ "exprlist ::= nexprlist",
135745	136201	/* 312 */ "nmnum ::= plus_num",
135746	136202	/* 313 */ "nmnum ::= nm",
135747	136203	/* 314 */ "nmnum ::= ON",
135748	136204	/* 315 */ "nmnum ::= DELETE",
		@@ -136375,11 +136831,10 @@
136375	136831	{ 173, 3 },
136376	136832	{ 173, 3 },
136377	136833	{ 173, 3 },
136378	136834	{ 173, 3 },
136379	136835	{ 173, 3 },
136380		- { 221, 1 },
136381	136836	{ 221, 2 },
136382	136837	{ 173, 3 },
136383	136838	{ 173, 5 },
136384	136839	{ 173, 2 },
136385	136840	{ 173, 3 },
		@@ -136512,10 +136967,11 @@
136512	136967	{ 194, 1 },
136513	136968	{ 195, 1 },
136514	136969	{ 209, 2 },
136515	136970	{ 210, 1 },
136516	136971	{ 173, 1 },
	136972	+ { 221, 1 },
136517	136973	{ 208, 1 },
136518	136974	{ 230, 1 },
136519	136975	{ 230, 1 },
136520	136976	{ 230, 1 },
136521	136977	{ 230, 1 },
		@@ -136654,11 +137110,11 @@
136654	137110	case 42: /* autoinc ::= */ yytestcase(yyruleno==42);
136655	137111	case 57: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==57);
136656	137112	case 67: /* defer_subclause_opt ::= */ yytestcase(yyruleno==67);
136657	137113	case 76: /* ifexists ::= */ yytestcase(yyruleno==76);
136658	137114	case 90: /* distinct ::= */ yytestcase(yyruleno==90);
136659		- case 215: /* collate ::= */ yytestcase(yyruleno==215);
	137115	+ case 214: /* collate ::= */ yytestcase(yyruleno==214);
136660	137116	{yymsp[1].minor.yy194 = 0;}
136661	137117	break;
136662	137118	case 17: /* ifnotexists ::= IF NOT EXISTS */
136663	137119	{yymsp[-2].minor.yy194 = 1;}
136664	137120	break;
		@@ -136798,13 +137254,13 @@
136798	137254	case 144: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==144);
136799	137255	{yymsp[-1].minor.yy194 = yymsp[0].minor.yy194;}
136800	137256	break;
136801	137257	case 58: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */
136802	137258	case 75: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==75);
136803		- case 187: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==187);
136804		- case 190: /* in_op ::= NOT IN */ yytestcase(yyruleno==190);
136805		- case 216: /* collate ::= COLLATE ID\|STRING */ yytestcase(yyruleno==216);
	137259	+ case 186: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==186);
	137260	+ case 189: /* in_op ::= NOT IN */ yytestcase(yyruleno==189);
	137261	+ case 215: /* collate ::= COLLATE ID\|STRING */ yytestcase(yyruleno==215);
136806	137262	{yymsp[-1].minor.yy194 = 1;}
136807	137263	break;
136808	137264	case 59: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
136809	137265	{yymsp[-1].minor.yy194 = 0;}
136810	137266	break;
		@@ -136964,13 +137420,13 @@
136964	137420	{yymsp[0].minor.yy194 = SF_All;}
136965	137421	break;
136966	137422	case 91: /* sclp ::= */
136967	137423	case 119: /* orderby_opt ::= */ yytestcase(yyruleno==119);
136968	137424	case 126: /* groupby_opt ::= */ yytestcase(yyruleno==126);
136969		- case 203: /* exprlist ::= */ yytestcase(yyruleno==203);
136970		- case 206: /* paren_exprlist ::= */ yytestcase(yyruleno==206);
136971		- case 211: /* eidlist_opt ::= */ yytestcase(yyruleno==211);
	137425	+ case 202: /* exprlist ::= */ yytestcase(yyruleno==202);
	137426	+ case 205: /* paren_exprlist ::= */ yytestcase(yyruleno==205);
	137427	+ case 210: /* eidlist_opt ::= */ yytestcase(yyruleno==210);
136972	137428	{yymsp[1].minor.yy148 = 0;}
136973	137429	break;
136974	137430	case 92: /* selcollist ::= sclp expr as */
136975	137431	{
136976	137432	yymsp[-2].minor.yy148 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy148, yymsp[-1].minor.yy190.pExpr);
		@@ -136992,12 +137448,12 @@
136992	137448	yymsp[-3].minor.yy148 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy148, pDot);
136993	137449	}
136994	137450	break;
136995	137451	case 95: /* as ::= AS nm */
136996	137452	case 106: /* dbnm ::= DOT nm */ yytestcase(yyruleno==106);
136997		- case 225: /* plus_num ::= PLUS INTEGER\|FLOAT */ yytestcase(yyruleno==225);
136998		- case 226: /* minus_num ::= MINUS INTEGER\|FLOAT */ yytestcase(yyruleno==226);
	137453	+ case 224: /* plus_num ::= PLUS INTEGER\|FLOAT */ yytestcase(yyruleno==224);
	137454	+ case 225: /* minus_num ::= MINUS INTEGER\|FLOAT */ yytestcase(yyruleno==225);
136999	137455	{yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;}
137000	137456	break;
137001	137457	case 97: /* from ::= */
137002	137458	{yymsp[1].minor.yy185 = sqlite3DbMallocZero(pParse->db, sizeof(*yymsp[1].minor.yy185));}
137003	137459	break;
		@@ -137076,18 +137532,18 @@
137076	137532	{yymsp[-3].minor.yy194 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/X-overwrites-A/}
137077	137533	break;
137078	137534	case 112: /* on_opt ::= ON expr */
137079	137535	case 129: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==129);
137080	137536	case 136: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==136);
137081		- case 199: /* case_else ::= ELSE expr */ yytestcase(yyruleno==199);
	137537	+ case 198: /* case_else ::= ELSE expr */ yytestcase(yyruleno==198);
137082	137538	{yymsp[-1].minor.yy72 = yymsp[0].minor.yy190.pExpr;}
137083	137539	break;
137084	137540	case 113: /* on_opt ::= */
137085	137541	case 128: /* having_opt ::= */ yytestcase(yyruleno==128);
137086	137542	case 135: /* where_opt ::= */ yytestcase(yyruleno==135);
137087		- case 200: /* case_else ::= */ yytestcase(yyruleno==200);
137088		- case 202: /* case_operand ::= */ yytestcase(yyruleno==202);
	137543	+ case 199: /* case_else ::= */ yytestcase(yyruleno==199);
	137544	+ case 201: /* case_operand ::= */ yytestcase(yyruleno==201);
137089	137545	{yymsp[1].minor.yy72 = 0;}
137090	137546	break;
137091	137547	case 115: /* indexed_opt ::= INDEXED BY nm */
137092	137548	{yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;}
137093	137549	break;
		@@ -137230,11 +137686,11 @@
137230	137686	case 158: /* term ::= INTEGER */
137231	137687	{
137232	137688	yylhsminor.yy190.pExpr = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1);
137233	137689	yylhsminor.yy190.zStart = yymsp[0].minor.yy0.z;
137234	137690	yylhsminor.yy190.zEnd = yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n;
137235		- if( yylhsminor.yy190.pExpr ) yylhsminor.yy190.pExpr->flags \|= EP_Leaf;
	137691	+ if( yylhsminor.yy190.pExpr ) yylhsminor.yy190.pExpr->flags \|= EP_Leaf\|EP_Resolved;
137236	137692	}
137237	137693	yymsp[0].minor.yy190 = yylhsminor.yy190;
137238	137694	break;
137239	137695	case 159: /* expr ::= VARIABLE */
137240	137696	{
		@@ -137320,17 +137776,14 @@
137320	137776	case 171: /* expr ::= expr PLUS\|MINUS expr */ yytestcase(yyruleno==171);
137321	137777	case 172: /* expr ::= expr STAR\|SLASH\|REM expr */ yytestcase(yyruleno==172);
137322	137778	case 173: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==173);
137323	137779	{spanBinaryExpr(pParse,yymsp[-1].major,&yymsp[-2].minor.yy190,&yymsp[0].minor.yy190);}
137324	137780	break;
137325		- case 174: /* likeop ::= LIKE_KW\|MATCH */
137326		-{yymsp[0].minor.yy0=yymsp[0].minor.yy0;/A-overwrites-X/}
137327		- break;
137328		- case 175: /* likeop ::= NOT LIKE_KW\|MATCH */
	137781	+ case 174: /* likeop ::= NOT LIKE_KW\|MATCH */
137329	137782	{yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n\|=0x80000000; /yymsp[-1].minor.yy0-overwrite-yymsp[0].minor.yy0/}
137330	137783	break;
137331		- case 176: /* expr ::= expr likeop expr */
	137784	+ case 175: /* expr ::= expr likeop expr */
137332	137785	{
137333	137786	ExprList *pList;
137334	137787	int bNot = yymsp[-1].minor.yy0.n & 0x80000000;
137335	137788	yymsp[-1].minor.yy0.n &= 0x7fffffff;
137336	137789	pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy190.pExpr);
		@@ -137339,11 +137792,11 @@
137339	137792	exprNot(pParse, bNot, &yymsp[-2].minor.yy190);
137340	137793	yymsp[-2].minor.yy190.zEnd = yymsp[0].minor.yy190.zEnd;
137341	137794	if( yymsp[-2].minor.yy190.pExpr ) yymsp[-2].minor.yy190.pExpr->flags \|= EP_InfixFunc;
137342	137795	}
137343	137796	break;
137344		- case 177: /* expr ::= expr likeop expr ESCAPE expr */
	137797	+ case 176: /* expr ::= expr likeop expr ESCAPE expr */
137345	137798	{
137346	137799	ExprList *pList;
137347	137800	int bNot = yymsp[-3].minor.yy0.n & 0x80000000;
137348	137801	yymsp[-3].minor.yy0.n &= 0x7fffffff;
137349	137802	pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy190.pExpr);
		@@ -137353,43 +137806,43 @@
137353	137806	exprNot(pParse, bNot, &yymsp[-4].minor.yy190);
137354	137807	yymsp[-4].minor.yy190.zEnd = yymsp[0].minor.yy190.zEnd;
137355	137808	if( yymsp[-4].minor.yy190.pExpr ) yymsp[-4].minor.yy190.pExpr->flags \|= EP_InfixFunc;
137356	137809	}
137357	137810	break;
137358		- case 178: /* expr ::= expr ISNULL\|NOTNULL */
	137811	+ case 177: /* expr ::= expr ISNULL\|NOTNULL */
137359	137812	{spanUnaryPostfix(pParse,yymsp[0].major,&yymsp[-1].minor.yy190,&yymsp[0].minor.yy0);}
137360	137813	break;
137361		- case 179: /* expr ::= expr NOT NULL */
	137814	+ case 178: /* expr ::= expr NOT NULL */
137362	137815	{spanUnaryPostfix(pParse,TK_NOTNULL,&yymsp[-2].minor.yy190,&yymsp[0].minor.yy0);}
137363	137816	break;
137364		- case 180: /* expr ::= expr IS expr */
	137817	+ case 179: /* expr ::= expr IS expr */
137365	137818	{
137366	137819	spanBinaryExpr(pParse,TK_IS,&yymsp[-2].minor.yy190,&yymsp[0].minor.yy190);
137367	137820	binaryToUnaryIfNull(pParse, yymsp[0].minor.yy190.pExpr, yymsp[-2].minor.yy190.pExpr, TK_ISNULL);
137368	137821	}
137369	137822	break;
137370		- case 181: /* expr ::= expr IS NOT expr */
	137823	+ case 180: /* expr ::= expr IS NOT expr */
137371	137824	{
137372	137825	spanBinaryExpr(pParse,TK_ISNOT,&yymsp[-3].minor.yy190,&yymsp[0].minor.yy190);
137373	137826	binaryToUnaryIfNull(pParse, yymsp[0].minor.yy190.pExpr, yymsp[-3].minor.yy190.pExpr, TK_NOTNULL);
137374	137827	}
137375	137828	break;
137376		- case 182: /* expr ::= NOT expr */
137377		- case 183: /* expr ::= BITNOT expr */ yytestcase(yyruleno==183);
	137829	+ case 181: /* expr ::= NOT expr */
	137830	+ case 182: /* expr ::= BITNOT expr */ yytestcase(yyruleno==182);
137378	137831	{spanUnaryPrefix(&yymsp[-1].minor.yy190,pParse,yymsp[-1].major,&yymsp[0].minor.yy190,&yymsp[-1].minor.yy0);/A-overwrites-B/}
137379	137832	break;
137380		- case 184: /* expr ::= MINUS expr */
	137833	+ case 183: /* expr ::= MINUS expr */
137381	137834	{spanUnaryPrefix(&yymsp[-1].minor.yy190,pParse,TK_UMINUS,&yymsp[0].minor.yy190,&yymsp[-1].minor.yy0);/A-overwrites-B/}
137382	137835	break;
137383		- case 185: /* expr ::= PLUS expr */
	137836	+ case 184: /* expr ::= PLUS expr */
137384	137837	{spanUnaryPrefix(&yymsp[-1].minor.yy190,pParse,TK_UPLUS,&yymsp[0].minor.yy190,&yymsp[-1].minor.yy0);/A-overwrites-B/}
137385	137838	break;
137386		- case 186: /* between_op ::= BETWEEN */
137387		- case 189: /* in_op ::= IN */ yytestcase(yyruleno==189);
	137839	+ case 185: /* between_op ::= BETWEEN */
	137840	+ case 188: /* in_op ::= IN */ yytestcase(yyruleno==188);
137388	137841	{yymsp[0].minor.yy194 = 0;}
137389	137842	break;
137390		- case 188: /* expr ::= expr between_op expr AND expr */
	137843	+ case 187: /* expr ::= expr between_op expr AND expr */
137391	137844	{
137392	137845	ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy190.pExpr);
137393	137846	pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy190.pExpr);
137394	137847	yymsp[-4].minor.yy190.pExpr = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy190.pExpr, 0);
137395	137848	if( yymsp[-4].minor.yy190.pExpr ){
		@@ -137399,11 +137852,11 @@
137399	137852	}
137400	137853	exprNot(pParse, yymsp[-3].minor.yy194, &yymsp[-4].minor.yy190);
137401	137854	yymsp[-4].minor.yy190.zEnd = yymsp[0].minor.yy190.zEnd;
137402	137855	}
137403	137856	break;
137404		- case 191: /* expr ::= expr in_op LP exprlist RP */
	137857	+ case 190: /* expr ::= expr in_op LP exprlist RP */
137405	137858	{
137406	137859	if( yymsp[-1].minor.yy148==0 ){
137407	137860	/* Expressions of the form
137408	137861	**
137409	137862	** expr1 IN ()
		@@ -137452,26 +137905,26 @@
137452	137905	exprNot(pParse, yymsp[-3].minor.yy194, &yymsp[-4].minor.yy190);
137453	137906	}
137454	137907	yymsp[-4].minor.yy190.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
137455	137908	}
137456	137909	break;
137457		- case 192: /* expr ::= LP select RP */
	137910	+ case 191: /* expr ::= LP select RP */
137458	137911	{
137459	137912	spanSet(&yymsp[-2].minor.yy190,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /A-overwrites-B/
137460	137913	yymsp[-2].minor.yy190.pExpr = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
137461	137914	sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy190.pExpr, yymsp[-1].minor.yy243);
137462	137915	}
137463	137916	break;
137464		- case 193: /* expr ::= expr in_op LP select RP */
	137917	+ case 192: /* expr ::= expr in_op LP select RP */
137465	137918	{
137466	137919	yymsp[-4].minor.yy190.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy190.pExpr, 0);
137467	137920	sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy190.pExpr, yymsp[-1].minor.yy243);
137468	137921	exprNot(pParse, yymsp[-3].minor.yy194, &yymsp[-4].minor.yy190);
137469	137922	yymsp[-4].minor.yy190.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
137470	137923	}
137471	137924	break;
137472		- case 194: /* expr ::= expr in_op nm dbnm paren_exprlist */
	137925	+ case 193: /* expr ::= expr in_op nm dbnm paren_exprlist */
137473	137926	{
137474	137927	SrcList *pSrc = sqlite3SrcListAppend(pParse->db, 0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);
137475	137928	Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);
137476	137929	if( yymsp[0].minor.yy148 ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy148);
137477	137930	yymsp[-4].minor.yy190.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy190.pExpr, 0);
		@@ -137478,19 +137931,19 @@
137478	137931	sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy190.pExpr, pSelect);
137479	137932	exprNot(pParse, yymsp[-3].minor.yy194, &yymsp[-4].minor.yy190);
137480	137933	yymsp[-4].minor.yy190.zEnd = yymsp[-1].minor.yy0.z ? &yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n] : &yymsp[-2].minor.yy0.z[yymsp[-2].minor.yy0.n];
137481	137934	}
137482	137935	break;
137483		- case 195: /* expr ::= EXISTS LP select RP */
	137936	+ case 194: /* expr ::= EXISTS LP select RP */
137484	137937	{
137485	137938	Expr *p;
137486	137939	spanSet(&yymsp[-3].minor.yy190,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0); /A-overwrites-B/
137487	137940	p = yymsp[-3].minor.yy190.pExpr = sqlite3PExpr(pParse, TK_EXISTS, 0, 0);
137488	137941	sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy243);
137489	137942	}
137490	137943	break;
137491		- case 196: /* expr ::= CASE case_operand case_exprlist case_else END */
	137944	+ case 195: /* expr ::= CASE case_operand case_exprlist case_else END */
137492	137945	{
137493	137946	spanSet(&yymsp[-4].minor.yy190,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0); /A-overwrites-C/
137494	137947	yymsp[-4].minor.yy190.pExpr = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy72, 0);
137495	137948	if( yymsp[-4].minor.yy190.pExpr ){
137496	137949	yymsp[-4].minor.yy190.pExpr->x.pList = yymsp[-1].minor.yy72 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy148,yymsp[-1].minor.yy72) : yymsp[-2].minor.yy148;
		@@ -137499,313 +137952,314 @@
137499	137952	sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy148);
137500	137953	sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy72);
137501	137954	}
137502	137955	}
137503	137956	break;
137504		- case 197: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
	137957	+ case 196: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
137505	137958	{
137506	137959	yymsp[-4].minor.yy148 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy148, yymsp[-2].minor.yy190.pExpr);
137507	137960	yymsp[-4].minor.yy148 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy148, yymsp[0].minor.yy190.pExpr);
137508	137961	}
137509	137962	break;
137510		- case 198: /* case_exprlist ::= WHEN expr THEN expr */
	137963	+ case 197: /* case_exprlist ::= WHEN expr THEN expr */
137511	137964	{
137512	137965	yymsp[-3].minor.yy148 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy190.pExpr);
137513	137966	yymsp[-3].minor.yy148 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy148, yymsp[0].minor.yy190.pExpr);
137514	137967	}
137515	137968	break;
137516		- case 201: /* case_operand ::= expr */
	137969	+ case 200: /* case_operand ::= expr */
137517	137970	{yymsp[0].minor.yy72 = yymsp[0].minor.yy190.pExpr; /A-overwrites-X/}
137518	137971	break;
137519		- case 204: /* nexprlist ::= nexprlist COMMA expr */
	137972	+ case 203: /* nexprlist ::= nexprlist COMMA expr */
137520	137973	{yymsp[-2].minor.yy148 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy148,yymsp[0].minor.yy190.pExpr);}
137521	137974	break;
137522		- case 205: /* nexprlist ::= expr */
	137975	+ case 204: /* nexprlist ::= expr */
137523	137976	{yymsp[0].minor.yy148 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy190.pExpr); /A-overwrites-Y/}
137524	137977	break;
137525		- case 207: /* paren_exprlist ::= LP exprlist RP */
137526		- case 212: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==212);
	137978	+ case 206: /* paren_exprlist ::= LP exprlist RP */
	137979	+ case 211: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==211);
137527	137980	{yymsp[-2].minor.yy148 = yymsp[-1].minor.yy148;}
137528	137981	break;
137529		- case 208: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
	137982	+ case 207: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
137530	137983	{
137531	137984	sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0,
137532	137985	sqlite3SrcListAppend(pParse->db,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy148, yymsp[-10].minor.yy194,
137533	137986	&yymsp[-11].minor.yy0, yymsp[0].minor.yy72, SQLITE_SO_ASC, yymsp[-8].minor.yy194, SQLITE_IDXTYPE_APPDEF);
137534	137987	}
137535	137988	break;
137536		- case 209: /* uniqueflag ::= UNIQUE */
137537		- case 250: /* raisetype ::= ABORT */ yytestcase(yyruleno==250);
	137989	+ case 208: /* uniqueflag ::= UNIQUE */
	137990	+ case 249: /* raisetype ::= ABORT */ yytestcase(yyruleno==249);
137538	137991	{yymsp[0].minor.yy194 = OE_Abort;}
137539	137992	break;
137540		- case 210: /* uniqueflag ::= */
	137993	+ case 209: /* uniqueflag ::= */
137541	137994	{yymsp[1].minor.yy194 = OE_None;}
137542	137995	break;
137543		- case 213: /* eidlist ::= eidlist COMMA nm collate sortorder */
	137996	+ case 212: /* eidlist ::= eidlist COMMA nm collate sortorder */
137544	137997	{
137545	137998	yymsp[-4].minor.yy148 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy148, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy194, yymsp[0].minor.yy194);
137546	137999	}
137547	138000	break;
137548		- case 214: /* eidlist ::= nm collate sortorder */
	138001	+ case 213: /* eidlist ::= nm collate sortorder */
137549	138002	{
137550	138003	yymsp[-2].minor.yy148 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy194, yymsp[0].minor.yy194); /A-overwrites-Y/
137551	138004	}
137552	138005	break;
137553		- case 217: /* cmd ::= DROP INDEX ifexists fullname */
	138006	+ case 216: /* cmd ::= DROP INDEX ifexists fullname */
137554	138007	{sqlite3DropIndex(pParse, yymsp[0].minor.yy185, yymsp[-1].minor.yy194);}
137555	138008	break;
137556		- case 218: /* cmd ::= VACUUM */
	138009	+ case 217: /* cmd ::= VACUUM */
137557	138010	{sqlite3Vacuum(pParse,0);}
137558	138011	break;
137559		- case 219: /* cmd ::= VACUUM nm */
	138012	+ case 218: /* cmd ::= VACUUM nm */
137560	138013	{sqlite3Vacuum(pParse,&yymsp[0].minor.yy0);}
137561	138014	break;
137562		- case 220: /* cmd ::= PRAGMA nm dbnm */
	138015	+ case 219: /* cmd ::= PRAGMA nm dbnm */
137563	138016	{sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
137564	138017	break;
137565		- case 221: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
	138018	+ case 220: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
137566	138019	{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);}
137567	138020	break;
137568		- case 222: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
	138021	+ case 221: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
137569	138022	{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);}
137570	138023	break;
137571		- case 223: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
	138024	+ case 222: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
137572	138025	{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);}
137573	138026	break;
137574		- case 224: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
	138027	+ case 223: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
137575	138028	{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);}
137576	138029	break;
137577		- case 227: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
	138030	+ case 226: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
137578	138031	{
137579	138032	Token all;
137580	138033	all.z = yymsp[-3].minor.yy0.z;
137581	138034	all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
137582	138035	sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy145, &all);
137583	138036	}
137584	138037	break;
137585		- case 228: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
	138038	+ case 227: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
137586	138039	{
137587	138040	sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy194, yymsp[-4].minor.yy332.a, yymsp[-4].minor.yy332.b, yymsp[-2].minor.yy185, yymsp[0].minor.yy72, yymsp[-10].minor.yy194, yymsp[-8].minor.yy194);
137588	138041	yymsp[-10].minor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0); /A-overwrites-T/
137589	138042	}
137590	138043	break;
137591		- case 229: /* trigger_time ::= BEFORE */
	138044	+ case 228: /* trigger_time ::= BEFORE */
137592	138045	{ yymsp[0].minor.yy194 = TK_BEFORE; }
137593	138046	break;
137594		- case 230: /* trigger_time ::= AFTER */
	138047	+ case 229: /* trigger_time ::= AFTER */
137595	138048	{ yymsp[0].minor.yy194 = TK_AFTER; }
137596	138049	break;
137597		- case 231: /* trigger_time ::= INSTEAD OF */
	138050	+ case 230: /* trigger_time ::= INSTEAD OF */
137598	138051	{ yymsp[-1].minor.yy194 = TK_INSTEAD;}
137599	138052	break;
137600		- case 232: /* trigger_time ::= */
	138053	+ case 231: /* trigger_time ::= */
137601	138054	{ yymsp[1].minor.yy194 = TK_BEFORE; }
137602	138055	break;
137603		- case 233: /* trigger_event ::= DELETE\|INSERT */
137604		- case 234: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==234);
	138056	+ case 232: /* trigger_event ::= DELETE\|INSERT */
	138057	+ case 233: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==233);
137605	138058	{yymsp[0].minor.yy332.a = yymsp[0].major; /A-overwrites-X/ yymsp[0].minor.yy332.b = 0;}
137606	138059	break;
137607		- case 235: /* trigger_event ::= UPDATE OF idlist */
	138060	+ case 234: /* trigger_event ::= UPDATE OF idlist */
137608	138061	{yymsp[-2].minor.yy332.a = TK_UPDATE; yymsp[-2].minor.yy332.b = yymsp[0].minor.yy254;}
137609	138062	break;
137610		- case 236: /* when_clause ::= */
137611		- case 255: /* key_opt ::= */ yytestcase(yyruleno==255);
	138063	+ case 235: /* when_clause ::= */
	138064	+ case 254: /* key_opt ::= */ yytestcase(yyruleno==254);
137612	138065	{ yymsp[1].minor.yy72 = 0; }
137613	138066	break;
137614		- case 237: /* when_clause ::= WHEN expr */
137615		- case 256: /* key_opt ::= KEY expr */ yytestcase(yyruleno==256);
	138067	+ case 236: /* when_clause ::= WHEN expr */
	138068	+ case 255: /* key_opt ::= KEY expr */ yytestcase(yyruleno==255);
137616	138069	{ yymsp[-1].minor.yy72 = yymsp[0].minor.yy190.pExpr; }
137617	138070	break;
137618		- case 238: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
	138071	+ case 237: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
137619	138072	{
137620	138073	assert( yymsp[-2].minor.yy145!=0 );
137621	138074	yymsp[-2].minor.yy145->pLast->pNext = yymsp[-1].minor.yy145;
137622	138075	yymsp[-2].minor.yy145->pLast = yymsp[-1].minor.yy145;
137623	138076	}
137624	138077	break;
137625		- case 239: /* trigger_cmd_list ::= trigger_cmd SEMI */
	138078	+ case 238: /* trigger_cmd_list ::= trigger_cmd SEMI */
137626	138079	{
137627	138080	assert( yymsp[-1].minor.yy145!=0 );
137628	138081	yymsp[-1].minor.yy145->pLast = yymsp[-1].minor.yy145;
137629	138082	}
137630	138083	break;
137631		- case 240: /* trnm ::= nm DOT nm */
	138084	+ case 239: /* trnm ::= nm DOT nm */
137632	138085	{
137633	138086	yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;
137634	138087	sqlite3ErrorMsg(pParse,
137635	138088	"qualified table names are not allowed on INSERT, UPDATE, and DELETE "
137636	138089	"statements within triggers");
137637	138090	}
137638	138091	break;
137639		- case 241: /* tridxby ::= INDEXED BY nm */
	138092	+ case 240: /* tridxby ::= INDEXED BY nm */
137640	138093	{
137641	138094	sqlite3ErrorMsg(pParse,
137642	138095	"the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
137643	138096	"within triggers");
137644	138097	}
137645	138098	break;
137646		- case 242: /* tridxby ::= NOT INDEXED */
	138099	+ case 241: /* tridxby ::= NOT INDEXED */
137647	138100	{
137648	138101	sqlite3ErrorMsg(pParse,
137649	138102	"the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
137650	138103	"within triggers");
137651	138104	}
137652	138105	break;
137653		- case 243: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt */
	138106	+ case 242: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt */
137654	138107	{yymsp[-6].minor.yy145 = sqlite3TriggerUpdateStep(pParse->db, &yymsp[-4].minor.yy0, yymsp[-1].minor.yy148, yymsp[0].minor.yy72, yymsp[-5].minor.yy194);}
137655	138108	break;
137656		- case 244: /* trigger_cmd ::= insert_cmd INTO trnm idlist_opt select */
	138109	+ case 243: /* trigger_cmd ::= insert_cmd INTO trnm idlist_opt select */
137657	138110	{yymsp[-4].minor.yy145 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy254, yymsp[0].minor.yy243, yymsp[-4].minor.yy194);/A-overwrites-R/}
137658	138111	break;
137659		- case 245: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt */
	138112	+ case 244: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt */
137660	138113	{yymsp[-4].minor.yy145 = sqlite3TriggerDeleteStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[0].minor.yy72);}
137661	138114	break;
137662		- case 246: /* trigger_cmd ::= select */
	138115	+ case 245: /* trigger_cmd ::= select */
137663	138116	{yymsp[0].minor.yy145 = sqlite3TriggerSelectStep(pParse->db, yymsp[0].minor.yy243); /A-overwrites-X/}
137664	138117	break;
137665		- case 247: /* expr ::= RAISE LP IGNORE RP */
	138118	+ case 246: /* expr ::= RAISE LP IGNORE RP */
137666	138119	{
137667	138120	spanSet(&yymsp[-3].minor.yy190,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0); /A-overwrites-X/
137668	138121	yymsp[-3].minor.yy190.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0);
137669	138122	if( yymsp[-3].minor.yy190.pExpr ){
137670	138123	yymsp[-3].minor.yy190.pExpr->affinity = OE_Ignore;
137671	138124	}
137672	138125	}
137673	138126	break;
137674		- case 248: /* expr ::= RAISE LP raisetype COMMA nm RP */
	138127	+ case 247: /* expr ::= RAISE LP raisetype COMMA nm RP */
137675	138128	{
137676	138129	spanSet(&yymsp[-5].minor.yy190,&yymsp[-5].minor.yy0,&yymsp[0].minor.yy0); /A-overwrites-X/
137677	138130	yymsp[-5].minor.yy190.pExpr = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1);
137678	138131	if( yymsp[-5].minor.yy190.pExpr ) {
137679	138132	yymsp[-5].minor.yy190.pExpr->affinity = (char)yymsp[-3].minor.yy194;
137680	138133	}
137681	138134	}
137682	138135	break;
137683		- case 249: /* raisetype ::= ROLLBACK */
	138136	+ case 248: /* raisetype ::= ROLLBACK */
137684	138137	{yymsp[0].minor.yy194 = OE_Rollback;}
137685	138138	break;
137686		- case 251: /* raisetype ::= FAIL */
	138139	+ case 250: /* raisetype ::= FAIL */
137687	138140	{yymsp[0].minor.yy194 = OE_Fail;}
137688	138141	break;
137689		- case 252: /* cmd ::= DROP TRIGGER ifexists fullname */
	138142	+ case 251: /* cmd ::= DROP TRIGGER ifexists fullname */
137690	138143	{
137691	138144	sqlite3DropTrigger(pParse,yymsp[0].minor.yy185,yymsp[-1].minor.yy194);
137692	138145	}
137693	138146	break;
137694		- case 253: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
	138147	+ case 252: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
137695	138148	{
137696	138149	sqlite3Attach(pParse, yymsp[-3].minor.yy190.pExpr, yymsp[-1].minor.yy190.pExpr, yymsp[0].minor.yy72);
137697	138150	}
137698	138151	break;
137699		- case 254: /* cmd ::= DETACH database_kw_opt expr */
	138152	+ case 253: /* cmd ::= DETACH database_kw_opt expr */
137700	138153	{
137701	138154	sqlite3Detach(pParse, yymsp[0].minor.yy190.pExpr);
137702	138155	}
137703	138156	break;
137704		- case 257: /* cmd ::= REINDEX */
	138157	+ case 256: /* cmd ::= REINDEX */
137705	138158	{sqlite3Reindex(pParse, 0, 0);}
137706	138159	break;
137707		- case 258: /* cmd ::= REINDEX nm dbnm */
	138160	+ case 257: /* cmd ::= REINDEX nm dbnm */
137708	138161	{sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
137709	138162	break;
137710		- case 259: /* cmd ::= ANALYZE */
	138163	+ case 258: /* cmd ::= ANALYZE */
137711	138164	{sqlite3Analyze(pParse, 0, 0);}
137712	138165	break;
137713		- case 260: /* cmd ::= ANALYZE nm dbnm */
	138166	+ case 259: /* cmd ::= ANALYZE nm dbnm */
137714	138167	{sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
137715	138168	break;
137716		- case 261: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
	138169	+ case 260: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
137717	138170	{
137718	138171	sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy185,&yymsp[0].minor.yy0);
137719	138172	}
137720	138173	break;
137721		- case 262: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
	138174	+ case 261: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
137722	138175	{
137723	138176	yymsp[-1].minor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-1].minor.yy0.z) + pParse->sLastToken.n;
137724	138177	sqlite3AlterFinishAddColumn(pParse, &yymsp[-1].minor.yy0);
137725	138178	}
137726	138179	break;
137727		- case 263: /* add_column_fullname ::= fullname */
	138180	+ case 262: /* add_column_fullname ::= fullname */
137728	138181	{
137729	138182	disableLookaside(pParse);
137730	138183	sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy185);
137731	138184	}
137732	138185	break;
137733		- case 264: /* cmd ::= create_vtab */
	138186	+ case 263: /* cmd ::= create_vtab */
137734	138187	{sqlite3VtabFinishParse(pParse,0);}
137735	138188	break;
137736		- case 265: /* cmd ::= create_vtab LP vtabarglist RP */
	138189	+ case 264: /* cmd ::= create_vtab LP vtabarglist RP */
137737	138190	{sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
137738	138191	break;
137739		- case 266: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
	138192	+ case 265: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
137740	138193	{
137741	138194	sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy194);
137742	138195	}
137743	138196	break;
137744		- case 267: /* vtabarg ::= */
	138197	+ case 266: /* vtabarg ::= */
137745	138198	{sqlite3VtabArgInit(pParse);}
137746	138199	break;
137747		- case 268: /* vtabargtoken ::= ANY */
137748		- case 269: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==269);
137749		- case 270: /* lp ::= LP */ yytestcase(yyruleno==270);
	138200	+ case 267: /* vtabargtoken ::= ANY */
	138201	+ case 268: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==268);
	138202	+ case 269: /* lp ::= LP */ yytestcase(yyruleno==269);
137750	138203	{sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
137751	138204	break;
137752		- case 271: /* with ::= */
	138205	+ case 270: /* with ::= */
137753	138206	{yymsp[1].minor.yy285 = 0;}
137754	138207	break;
137755		- case 272: /* with ::= WITH wqlist */
	138208	+ case 271: /* with ::= WITH wqlist */
137756	138209	{ yymsp[-1].minor.yy285 = yymsp[0].minor.yy285; }
137757	138210	break;
137758		- case 273: /* with ::= WITH RECURSIVE wqlist */
	138211	+ case 272: /* with ::= WITH RECURSIVE wqlist */
137759	138212	{ yymsp[-2].minor.yy285 = yymsp[0].minor.yy285; }
137760	138213	break;
137761		- case 274: /* wqlist ::= nm eidlist_opt AS LP select RP */
	138214	+ case 273: /* wqlist ::= nm eidlist_opt AS LP select RP */
137762	138215	{
137763	138216	yymsp[-5].minor.yy285 = sqlite3WithAdd(pParse, 0, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy148, yymsp[-1].minor.yy243); /A-overwrites-X/
137764	138217	}
137765	138218	break;
137766		- case 275: /* wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */
	138219	+ case 274: /* wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */
137767	138220	{
137768	138221	yymsp[-7].minor.yy285 = sqlite3WithAdd(pParse, yymsp[-7].minor.yy285, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy148, yymsp[-1].minor.yy243);
137769	138222	}
137770	138223	break;
137771	138224	default:
137772		- /* (276) input ::= cmdlist */ yytestcase(yyruleno==276);
137773		- /* (277) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==277);
137774		- /* (278) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=278);
137775		- /* (279) ecmd ::= SEMI */ yytestcase(yyruleno==279);
137776		- /* (280) ecmd ::= explain cmdx SEMI */ yytestcase(yyruleno==280);
137777		- /* (281) explain ::= */ yytestcase(yyruleno==281);
137778		- /* (282) trans_opt ::= */ yytestcase(yyruleno==282);
137779		- /* (283) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==283);
137780		- /* (284) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==284);
137781		- /* (285) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==285);
137782		- /* (286) savepoint_opt ::= */ yytestcase(yyruleno==286);
137783		- /* (287) cmd ::= create_table create_table_args */ yytestcase(yyruleno==287);
137784		- /* (288) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==288);
137785		- /* (289) columnlist ::= columnname carglist */ yytestcase(yyruleno==289);
137786		- /* (290) nm ::= ID\|INDEXED */ yytestcase(yyruleno==290);
137787		- /* (291) nm ::= STRING */ yytestcase(yyruleno==291);
137788		- /* (292) nm ::= JOIN_KW */ yytestcase(yyruleno==292);
137789		- /* (293) typetoken ::= typename */ yytestcase(yyruleno==293);
137790		- /* (294) typename ::= ID\|STRING */ yytestcase(yyruleno==294);
137791		- /* (295) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=295);
137792		- /* (296) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=296);
137793		- /* (297) carglist ::= carglist ccons */ yytestcase(yyruleno==297);
137794		- /* (298) carglist ::= */ yytestcase(yyruleno==298);
137795		- /* (299) ccons ::= NULL onconf */ yytestcase(yyruleno==299);
137796		- /* (300) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==300);
137797		- /* (301) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==301);
137798		- /* (302) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=302);
137799		- /* (303) tconscomma ::= */ yytestcase(yyruleno==303);
137800		- /* (304) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=304);
137801		- /* (305) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=305);
137802		- /* (306) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=306);
137803		- /* (307) oneselect ::= values */ yytestcase(yyruleno==307);
137804		- /* (308) sclp ::= selcollist COMMA */ yytestcase(yyruleno==308);
137805		- /* (309) as ::= ID\|STRING */ yytestcase(yyruleno==309);
137806		- /* (310) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=310);
	138225	+ /* (275) input ::= cmdlist */ yytestcase(yyruleno==275);
	138226	+ /* (276) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==276);
	138227	+ /* (277) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=277);
	138228	+ /* (278) ecmd ::= SEMI */ yytestcase(yyruleno==278);
	138229	+ /* (279) ecmd ::= explain cmdx SEMI */ yytestcase(yyruleno==279);
	138230	+ /* (280) explain ::= */ yytestcase(yyruleno==280);
	138231	+ /* (281) trans_opt ::= */ yytestcase(yyruleno==281);
	138232	+ /* (282) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==282);
	138233	+ /* (283) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==283);
	138234	+ /* (284) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==284);
	138235	+ /* (285) savepoint_opt ::= */ yytestcase(yyruleno==285);
	138236	+ /* (286) cmd ::= create_table create_table_args */ yytestcase(yyruleno==286);
	138237	+ /* (287) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==287);
	138238	+ /* (288) columnlist ::= columnname carglist */ yytestcase(yyruleno==288);
	138239	+ /* (289) nm ::= ID\|INDEXED */ yytestcase(yyruleno==289);
	138240	+ /* (290) nm ::= STRING */ yytestcase(yyruleno==290);
	138241	+ /* (291) nm ::= JOIN_KW */ yytestcase(yyruleno==291);
	138242	+ /* (292) typetoken ::= typename */ yytestcase(yyruleno==292);
	138243	+ /* (293) typename ::= ID\|STRING */ yytestcase(yyruleno==293);
	138244	+ /* (294) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=294);
	138245	+ /* (295) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=295);
	138246	+ /* (296) carglist ::= carglist ccons */ yytestcase(yyruleno==296);
	138247	+ /* (297) carglist ::= */ yytestcase(yyruleno==297);
	138248	+ /* (298) ccons ::= NULL onconf */ yytestcase(yyruleno==298);
	138249	+ /* (299) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==299);
	138250	+ /* (300) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==300);
	138251	+ /* (301) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=301);
	138252	+ /* (302) tconscomma ::= */ yytestcase(yyruleno==302);
	138253	+ /* (303) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=303);
	138254	+ /* (304) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=304);
	138255	+ /* (305) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=305);
	138256	+ /* (306) oneselect ::= values */ yytestcase(yyruleno==306);
	138257	+ /* (307) sclp ::= selcollist COMMA */ yytestcase(yyruleno==307);
	138258	+ /* (308) as ::= ID\|STRING */ yytestcase(yyruleno==308);
	138259	+ /* (309) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=309);
	138260	+ /* (310) likeop ::= LIKE_KW\|MATCH */ yytestcase(yyruleno==310);
137807	138261	/* (311) exprlist ::= nexprlist */ yytestcase(yyruleno==311);
137808	138262	/* (312) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=312);
137809	138263	/* (313) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=313);
137810	138264	/* (314) nmnum ::= ON */ yytestcase(yyruleno==314);
137811	138265	/* (315) nmnum ::= DELETE */ yytestcase(yyruleno==315);
		@@ -138854,12 +139308,12 @@
138854	139308	** memory obtained from sqlite3_malloc() and to make *pzErrMsg point to that
138855	139309	** error message.
138856	139310	*/
138857	139311	SQLITE_PRIVATE int sqlite3RunParser(Parse pParse, const char zSql, char **pzErrMsg){
138858	139312	int nErr = 0; /* Number of errors encountered */
138859		- int i; /* Loop counter */
138860	139313	void pEngine; / The LEMON-generated LALR(1) parser */
	139314	+ int n = 0; /* Length of the next token token */
138861	139315	int tokenType; /* type of the next token */
138862	139316	int lastTokenParsed = -1; /* type of the previous token */
138863	139317	sqlite3 db = pParse->db; / The database connection */
138864	139318	int mxSqlLen; /* Max length of an SQL string */
138865	139319	#ifdef sqlite3Parser_ENGINEALWAYSONSTACK
		@@ -138871,11 +139325,10 @@
138871	139325	if( db->nVdbeActive==0 ){
138872	139326	db->u1.isInterrupted = 0;
138873	139327	}
138874	139328	pParse->rc = SQLITE_OK;
138875	139329	pParse->zTail = zSql;
138876		- i = 0;
138877	139330	assert( pzErrMsg!=0 );
138878	139331	/* sqlite3ParserTrace(stdout, "parser: "); */
138879	139332	#ifdef sqlite3Parser_ENGINEALWAYSONSTACK
138880	139333	pEngine = zSpace;
138881	139334	sqlite3ParserInit(pEngine);
		@@ -138889,16 +139342,14 @@
138889	139342	assert( pParse->pNewTable==0 );
138890	139343	assert( pParse->pNewTrigger==0 );
138891	139344	assert( pParse->nVar==0 );
138892	139345	assert( pParse->pVList==0 );
138893	139346	while( 1 ){
138894		- assert( i>=0 );
138895		- if( zSql[i]!=0 ){
138896		- pParse->sLastToken.z = &zSql[i];
138897		- pParse->sLastToken.n = sqlite3GetToken((u8*)&zSql[i],&tokenType);
138898		- i += pParse->sLastToken.n;
138899		- if( i>mxSqlLen ){
	139347	+ if( zSql[0]!=0 ){
	139348	+ n = sqlite3GetToken((u8*)zSql, &tokenType);
	139349	+ mxSqlLen -= n;
	139350	+ if( mxSqlLen<0 ){
138900	139351	pParse->rc = SQLITE_TOOBIG;
138901	139352	break;
138902	139353	}
138903	139354	}else{
138904	139355	/* Upon reaching the end of input, call the parser two more times
		@@ -138908,30 +139359,34 @@
138908	139359	}else if( lastTokenParsed==0 ){
138909	139360	break;
138910	139361	}else{
138911	139362	tokenType = TK_SEMI;
138912	139363	}
	139364	+ zSql -= n;
138913	139365	}
138914	139366	if( tokenType>=TK_SPACE ){
138915	139367	assert( tokenType==TK_SPACE \|\| tokenType==TK_ILLEGAL );
138916	139368	if( db->u1.isInterrupted ){
138917	139369	pParse->rc = SQLITE_INTERRUPT;
138918	139370	break;
138919	139371	}
138920	139372	if( tokenType==TK_ILLEGAL ){
138921		- sqlite3ErrorMsg(pParse, "unrecognized token: \"%T\"",
138922		- &pParse->sLastToken);
	139373	+ sqlite3ErrorMsg(pParse, "unrecognized token: \"%.*s\"", n, zSql);
138923	139374	break;
138924	139375	}
	139376	+ zSql += n;
138925	139377	}else{
	139378	+ pParse->sLastToken.z = zSql;
	139379	+ pParse->sLastToken.n = n;
138926	139380	sqlite3Parser(pEngine, tokenType, pParse->sLastToken, pParse);
138927	139381	lastTokenParsed = tokenType;
	139382	+ zSql += n;
138928	139383	if( pParse->rc!=SQLITE_OK \|\| db->mallocFailed ) break;
138929	139384	}
138930	139385	}
138931	139386	assert( nErr==0 );
138932		- pParse->zTail = &zSql[i];
	139387	+ pParse->zTail = zSql;
138933	139388	#ifdef YYTRACKMAXSTACKDEPTH
138934	139389	sqlite3_mutex_enter(sqlite3MallocMutex());
138935	139390	sqlite3StatusHighwater(SQLITE_STATUS_PARSER_STACK,
138936	139391	sqlite3ParserStackPeak(pEngine)
138937	139392	);
		@@ -140301,10 +140756,25 @@
140301	140756	return 0;
140302	140757	}
140303	140758	#endif
140304	140759	return db->lastRowid;
140305	140760	}
	140761	+
	140762	+/*
	140763	+** Set the value returned by the sqlite3_last_insert_rowid() API function.
	140764	+*/
	140765	+SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3 *db, sqlite3_int64 iRowid){
	140766	+#ifdef SQLITE_ENABLE_API_ARMOR
	140767	+ if( !sqlite3SafetyCheckOk(db) ){
	140768	+ (void)SQLITE_MISUSE_BKPT;
	140769	+ return;
	140770	+ }
	140771	+#endif
	140772	+ sqlite3_mutex_enter(db->mutex);
	140773	+ db->lastRowid = iRowid;
	140774	+ sqlite3_mutex_leave(db->mutex);
	140775	+}
140306	140776
140307	140777	/*
140308	140778	** Return the number of changes in the most recent call to sqlite3_exec().
140309	140779	*/
140310	140780	SQLITE_API int sqlite3_changes(sqlite3 *db){
		@@ -148111,12 +148581,14 @@
148111	148581	** segments.
148112	148582	*/
148113	148583	const u32 nMinMerge = 64; /* Minimum amount of incr-merge work to do */
148114	148584
148115	148585	Fts3Table p = (Fts3Table)pVtab;
148116		- int rc = sqlite3Fts3PendingTermsFlush(p);
	148586	+ int rc;
	148587	+ i64 iLastRowid = sqlite3_last_insert_rowid(p->db);
148117	148588
	148589	+ rc = sqlite3Fts3PendingTermsFlush(p);
148118	148590	if( rc==SQLITE_OK
148119	148591	&& p->nLeafAdd>(nMinMerge/16)
148120	148592	&& p->nAutoincrmerge && p->nAutoincrmerge!=0xff
148121	148593	){
148122	148594	int mxLevel = 0; /* Maximum relative level value in db */
		@@ -148127,10 +148599,11 @@
148127	148599	A = p->nLeafAdd * mxLevel;
148128	148600	A += (A/2);
148129	148601	if( A>(int)nMinMerge ) rc = sqlite3Fts3Incrmerge(p, A, p->nAutoincrmerge);
148130	148602	}
148131	148603	sqlite3Fts3SegmentsClose(p);
	148604	+ sqlite3_set_last_insert_rowid(p->db, iLastRowid);
148132	148605	return rc;
148133	148606	}
148134	148607
148135	148608	/*
148136	148609	** If it is currently unknown whether or not the FTS table has an %_stat
		@@ -168462,10 +168935,11 @@
168462	168935	int nStep; /* Rows processed for current object */
168463	168936	int nProgress; /* Rows processed for all objects */
168464	168937	RbuObjIter objiter; /* Iterator for skipping through tbl/idx */
168465	168938	const char zVfsName; / Name of automatically created rbu vfs */
168466	168939	rbu_file pTargetFd; / File handle open on target db */
	168940	+ int nPagePerSector; /* Pages per sector for pTargetFd */
168467	168941	i64 iOalSz;
168468	168942	i64 nPhaseOneStep;
168469	168943
168470	168944	/* The following state variables are used as part of the incremental
168471	168945	** checkpoint stage (eStage==RBU_STAGE_CKPT). See comments surrounding
		@@ -170726,10 +171200,27 @@
170726	171200
170727	171201	if( p->rc==SQLITE_OK ){
170728	171202	if( p->nFrame==0 \|\| (pState && pState->iWalCksum!=p->iWalCksum) ){
170729	171203	p->rc = SQLITE_DONE;
170730	171204	p->eStage = RBU_STAGE_DONE;
	171205	+ }else{
	171206	+ int nSectorSize;
	171207	+ sqlite3_file *pDb = p->pTargetFd->pReal;
	171208	+ sqlite3_file *pWal = p->pTargetFd->pWalFd->pReal;
	171209	+ assert( p->nPagePerSector==0 );
	171210	+ nSectorSize = pDb->pMethods->xSectorSize(pDb);
	171211	+ if( nSectorSize>p->pgsz ){
	171212	+ p->nPagePerSector = nSectorSize / p->pgsz;
	171213	+ }else{
	171214	+ p->nPagePerSector = 1;
	171215	+ }
	171216	+
	171217	+ /* Call xSync() on the wal file. This causes SQLite to sync the
	171218	+ ** directory in which the target database and the wal file reside, in
	171219	+ ** case it has not been synced since the rename() call in
	171220	+ ** rbuMoveOalFile(). */
	171221	+ p->rc = pWal->pMethods->xSync(pWal, SQLITE_SYNC_NORMAL);
170731	171222	}
170732	171223	}
170733	171224	}
170734	171225
170735	171226	/*
		@@ -171381,13 +171872,30 @@
171381	171872	if( p->rc==SQLITE_OK ){
171382	171873	p->eStage = RBU_STAGE_DONE;
171383	171874	p->rc = SQLITE_DONE;
171384	171875	}
171385	171876	}else{
171386		- RbuFrame *pFrame = &p->aFrame[p->nStep];
171387		- rbuCheckpointFrame(p, pFrame);
171388		- p->nStep++;
	171877	+ /* At one point the following block copied a single frame from the
	171878	+ ** wal file to the database file. So that one call to sqlite3rbu_step()
	171879	+ ** checkpointed a single frame.
	171880	+ **
	171881	+ ** However, if the sector-size is larger than the page-size, and the
	171882	+ ** application calls sqlite3rbu_savestate() or close() immediately
	171883	+ ** after this step, then rbu_step() again, then a power failure occurs,
	171884	+ ** then the database page written here may be damaged. Work around
	171885	+ ** this by checkpointing frames until the next page in the aFrame[]
	171886	+ ** lies on a different disk sector to the current one. */
	171887	+ u32 iSector;
	171888	+ do{
	171889	+ RbuFrame *pFrame = &p->aFrame[p->nStep];
	171890	+ iSector = (pFrame->iDbPage-1) / p->nPagePerSector;
	171891	+ rbuCheckpointFrame(p, pFrame);
	171892	+ p->nStep++;
	171893	+ }while( p->nStep<p->nFrame
	171894	+ && iSector==((p->aFrame[p->nStep].iDbPage-1) / p->nPagePerSector)
	171895	+ && p->rc==SQLITE_OK
	171896	+ );
171389	171897	}
171390	171898	p->nProgress++;
171391	171899	}
171392	171900	break;
171393	171901	}
		@@ -171823,10 +172331,16 @@
171823	172331
171824	172332	/* Commit the transaction to the -oal file. /
171825	172333	if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_OAL ){
171826	172334	p->rc = sqlite3_exec(p->dbMain, "COMMIT", 0, 0, &p->zErrmsg);
171827	172335	}
	172336	+
	172337	+ /* Sync the db file if currently doing an incremental checkpoint */
	172338	+ if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_CKPT ){
	172339	+ sqlite3_file *pDb = p->pTargetFd->pReal;
	172340	+ p->rc = pDb->pMethods->xSync(pDb, SQLITE_SYNC_NORMAL);
	172341	+ }
171828	172342
171829	172343	rbuSaveState(p, p->eStage);
171830	172344
171831	172345	if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_OAL ){
171832	172346	p->rc = sqlite3_exec(p->dbRbu, "COMMIT", 0, 0, &p->zErrmsg);
		@@ -171947,10 +172461,16 @@
171947	172461	assert( p->eStage>=RBU_STAGE_OAL && p->eStage<=RBU_STAGE_DONE );
171948	172462	if( p->eStage==RBU_STAGE_OAL ){
171949	172463	assert( rc!=SQLITE_DONE );
171950	172464	if( rc==SQLITE_OK ) rc = sqlite3_exec(p->dbMain, "COMMIT", 0, 0, 0);
171951	172465	}
	172466	+
	172467	+ /* Sync the db file */
	172468	+ if( rc==SQLITE_OK && p->eStage==RBU_STAGE_CKPT ){
	172469	+ sqlite3_file *pDb = p->pTargetFd->pReal;
	172470	+ rc = pDb->pMethods->xSync(pDb, SQLITE_SYNC_NORMAL);
	172471	+ }
171952	172472
171953	172473	p->rc = rc;
171954	172474	rbuSaveState(p, p->eStage);
171955	172475	rc = p->rc;
171956	172476
		@@ -181079,11 +181599,13 @@
181079	181599	typedef unsigned short u16;
181080	181600	typedef short i16;
181081	181601	typedef sqlite3_int64 i64;
181082	181602	typedef sqlite3_uint64 u64;
181083	181603
181084		-#define ArraySize(x) ((int)(sizeof(x) / sizeof(x[0])))
	181604	+#ifndef ArraySize
	181605	+# define ArraySize(x) ((int)(sizeof(x) / sizeof(x[0])))
	181606	+#endif
181085	181607
181086	181608	#define testcase(x)
181087	181609	#define ALWAYS(x) 1
181088	181610	#define NEVER(x) 0
181089	181611
		@@ -186302,11 +186824,14 @@
186302	186824	if( p1->bEof==0 ){
186303	186825	if( (p1->iRowid==iLast)
186304	186826	\|\| (bFromValid && fts5RowidCmp(pExpr, p1->iRowid, iFrom)<0)
186305	186827	){
186306	186828	int rc = fts5ExprNodeNext(pExpr, p1, bFromValid, iFrom);
186307		- if( rc!=SQLITE_OK ) return rc;
	186829	+ if( rc!=SQLITE_OK ){
	186830	+ pNode->bNomatch = 0;
	186831	+ return rc;
	186832	+ }
186308	186833	}
186309	186834	}
186310	186835	}
186311	186836
186312	186837	fts5ExprNodeTest_OR(pExpr, pNode);
		@@ -186333,11 +186858,14 @@
186333	186858	Fts5ExprNode *pChild = pAnd->apChild[iChild];
186334	186859	int cmp = fts5RowidCmp(pExpr, iLast, pChild->iRowid);
186335	186860	if( cmp>0 ){
186336	186861	/* Advance pChild until it points to iLast or laster */
186337	186862	rc = fts5ExprNodeNext(pExpr, pChild, 1, iLast);
186338		- if( rc!=SQLITE_OK ) return rc;
	186863	+ if( rc!=SQLITE_OK ){
	186864	+ pAnd->bNomatch = 0;
	186865	+ return rc;
	186866	+ }
186339	186867	}
186340	186868
186341	186869	/* If the child node is now at EOF, so is the parent AND node. Otherwise,
186342	186870	** the child node is guaranteed to have advanced at least as far as
186343	186871	** rowid iLast. So if it is not at exactly iLast, pChild->iRowid is the
		@@ -186372,10 +186900,12 @@
186372	186900	i64 iFrom
186373	186901	){
186374	186902	int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
186375	186903	if( rc==SQLITE_OK ){
186376	186904	rc = fts5ExprNodeTest_AND(pExpr, pNode);
	186905	+ }else{
	186906	+ pNode->bNomatch = 0;
186377	186907	}
186378	186908	return rc;
186379	186909	}
186380	186910
186381	186911	static int fts5ExprNodeTest_NOT(
		@@ -186414,10 +186944,13 @@
186414	186944	){
186415	186945	int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
186416	186946	if( rc==SQLITE_OK ){
186417	186947	rc = fts5ExprNodeTest_NOT(pExpr, pNode);
186418	186948	}
	186949	+ if( rc!=SQLITE_OK ){
	186950	+ pNode->bNomatch = 0;
	186951	+ }
186419	186952	return rc;
186420	186953	}
186421	186954
186422	186955	/*
186423	186956	** If pNode currently points to a match, this function returns SQLITE_OK
		@@ -197534,11 +198067,11 @@
197534	198067	int nArg, /* Number of args */
197535	198068	sqlite3_value *apUnused / Function arguments */
197536	198069	){
197537	198070	assert( nArg==0 );
197538	198071	UNUSED_PARAM2(nArg, apUnused);
197539		- sqlite3_result_text(pCtx, "fts5: 2017-02-13 16:02:40 ada05cfa86ad7f5645450ac7a2a21c9aa6e57d2c", -1, SQLITE_TRANSIENT);
	198072	+ sqlite3_result_text(pCtx, "fts5: 2017-03-10 17:03:11 f8560c60d10c0365b33342ab05b5a953987b0471", -1, SQLITE_TRANSIENT);
197540	198073	}
197541	198074
197542	198075	static int fts5Init(sqlite3 *db){
197543	198076	static const sqlite3_module fts5Mod = {
197544	198077	/* iVersion */ 2,
		@@ -198197,15 +198730,10 @@
198197	198730	sqlite3_step(pDel);
198198	198731	rc = sqlite3_reset(pDel);
198199	198732	}
198200	198733	}
198201	198734
198202		- /* Write the averages record */
198203		- if( rc==SQLITE_OK ){
198204		- rc = fts5StorageSaveTotals(p);
198205		- }
198206		-
198207	198735	return rc;
198208	198736	}
198209	198737
198210	198738	/*
198211	198739	** Delete all entries in the FTS5 index.
		@@ -198405,15 +198933,10 @@
198405	198933	if( rc==SQLITE_OK ){
198406	198934	rc = fts5StorageInsertDocsize(p, iRowid, &buf);
198407	198935	}
198408	198936	sqlite3_free(buf.p);
198409	198937
198410		- /* Write the averages record */
198411		- if( rc==SQLITE_OK ){
198412		- rc = fts5StorageSaveTotals(p);
198413		- }
198414		-
198415	198938	return rc;
198416	198939	}
198417	198940
198418	198941	static int fts5StorageCount(Fts5Storage p, const char zSuffix, i64 *pnRow){
198419	198942	Fts5Config *pConfig = p->pConfig;
		@@ -198744,16 +199267,21 @@
198744	199267
198745	199268	/*
198746	199269	** Flush any data currently held in-memory to disk.
198747	199270	*/
198748	199271	static int sqlite3Fts5StorageSync(Fts5Storage *p, int bCommit){
198749		- if( bCommit && p->bTotalsValid ){
198750		- int rc = fts5StorageSaveTotals(p);
198751		- p->bTotalsValid = 0;
198752		- if( rc!=SQLITE_OK ) return rc;
	199272	+ int rc = SQLITE_OK;
	199273	+ i64 iLastRowid = sqlite3_last_insert_rowid(p->pConfig->db);
	199274	+ if( p->bTotalsValid ){
	199275	+ rc = fts5StorageSaveTotals(p);
	199276	+ if( bCommit ) p->bTotalsValid = 0;
198753	199277	}
198754		- return sqlite3Fts5IndexSync(p->pIndex, bCommit);
	199278	+ if( rc==SQLITE_OK ){
	199279	+ rc = sqlite3Fts5IndexSync(p->pIndex, bCommit);
	199280	+ }
	199281	+ sqlite3_set_last_insert_rowid(p->pConfig->db, iLastRowid);
	199282	+ return rc;
198755	199283	}
198756	199284
198757	199285	static int sqlite3Fts5StorageRollback(Fts5Storage *p){
198758	199286	p->bTotalsValid = 0;
198759	199287	return sqlite3Fts5IndexRollback(p->pIndex);
198760	199288

	--- src/sqlite3.c
	+++ src/sqlite3.c
	@@ -1,8 +1,8 @@
1	/******************************************************************************
2	** This file is an amalgamation of many separate C source files from SQLite
3	** version 3.17.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.
	@@ -396,13 +396,13 @@
396	**
397	** See also: [sqlite3_libversion()],
398	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
399	** [sqlite_version()] and [sqlite_source_id()].
400	*/
401	#define SQLITE_VERSION "3.17.0"
402	#define SQLITE_VERSION_NUMBER 3017000
403	#define SQLITE_SOURCE_ID "2017-02-13 16:02:40 ada05cfa86ad7f5645450ac7a2a21c9aa6e57d2c"
404
405	/*
406	** CAPI3REF: Run-Time Library Version Numbers
407	** KEYWORDS: sqlite3_version sqlite3_sourceid
408	**
	@@ -2315,24 +2315,34 @@
2315	** as an undeclared column named ROWID, OID, or _ROWID_ as long as those
2316	** names are not also used by explicitly declared columns. ^If
2317	** the table has a column of type [INTEGER PRIMARY KEY] then that column
2318	** is another alias for the rowid.
2319	**
2320	** ^The sqlite3_last_insert_rowid(D) interface returns the [rowid] of the
2321	** most recent successful [INSERT] into a rowid table or [virtual table]
2322	** on database connection D.
2323	** ^Inserts into [WITHOUT ROWID] tables are not recorded.
2324	** ^If no successful [INSERT]s into rowid tables
2325	** have ever occurred on the database connection D,
2326	** then sqlite3_last_insert_rowid(D) returns zero.
2327	**
2328	** ^(If an [INSERT] occurs within a trigger or within a [virtual table]
2329	** method, then this routine will return the [rowid] of the inserted
2330	** row as long as the trigger or virtual table method is running.
2331	** But once the trigger or virtual table method ends, the value returned
2332	** by this routine reverts to what it was before the trigger or virtual
2333	** table method began.)^











2334	**
2335	** ^An [INSERT] that fails due to a constraint violation is not a
2336	** successful [INSERT] and does not change the value returned by this
2337	** routine. ^Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK,
2338	** and INSERT OR ABORT make no changes to the return value of this
	@@ -2355,10 +2365,20 @@
2355	** unpredictable and might not equal either the old or the new
2356	** last insert [rowid].
2357	*/
2358	SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);
2359










2360	/*
2361	** CAPI3REF: Count The Number Of Rows Modified
2362	** METHOD: sqlite3
2363	**
2364	** ^This function returns the number of rows modified, inserted or
	@@ -12457,10 +12477,11 @@
12457	SQLITE_PRIVATE const void sqlite3BtreePayloadFetch(BtCursor, u32 *pAmt);
12458	SQLITE_PRIVATE u32 sqlite3BtreePayloadSize(BtCursor*);
12459
12460	SQLITE_PRIVATE char sqlite3BtreeIntegrityCheck(Btree, int aRoot, int nRoot, int, int);
12461	SQLITE_PRIVATE struct Pager sqlite3BtreePager(Btree);

12462
12463	#ifndef SQLITE_OMIT_INCRBLOB
12464	SQLITE_PRIVATE int sqlite3BtreePayloadChecked(BtCursor, u32 offset, u32 amt, void);
12465	SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor, u32 offset, u32 amt, void);
12466	SQLITE_PRIVATE void sqlite3BtreeIncrblobCursor(BtCursor *);
	@@ -12757,117 +12778,119 @@
12757	#define OP_Divide 50 /* same as TK_SLASH, synopsis: r[P3]=r[P2]/r[P1] */
12758	#define OP_Remainder 51 /* same as TK_REM, synopsis: r[P3]=r[P2]%r[P1] */
12759	#define OP_Concat 52 /* same as TK_CONCAT, synopsis: r[P3]=r[P2]+r[P1] */
12760	#define OP_Last 53
12761	#define OP_BitNot 54 /* same as TK_BITNOT, synopsis: r[P1]= ~r[P1] */
12762	#define OP_SorterSort 55
12763	#define OP_Sort 56
12764	#define OP_Rewind 57
12765	#define OP_IdxLE 58 /* synopsis: key=r[P3@P4] */
12766	#define OP_IdxGT 59 /* synopsis: key=r[P3@P4] */
12767	#define OP_IdxLT 60 /* synopsis: key=r[P3@P4] */
12768	#define OP_IdxGE 61 /* synopsis: key=r[P3@P4] */
12769	#define OP_RowSetRead 62 /* synopsis: r[P3]=rowset(P1) */
12770	#define OP_RowSetTest 63 /* synopsis: if r[P3] in rowset(P1) goto P2 */
12771	#define OP_Program 64
12772	#define OP_FkIfZero 65 /* synopsis: if fkctr[P1]==0 goto P2 */
12773	#define OP_IfPos 66 /* synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 */
12774	#define OP_IfNotZero 67 /* synopsis: if r[P1]!=0 then r[P1]--, goto P2 */
12775	#define OP_DecrJumpZero 68 /* synopsis: if (--r[P1])==0 goto P2 */
12776	#define OP_IncrVacuum 69
12777	#define OP_VNext 70
12778	#define OP_Init 71 /* synopsis: Start at P2 */
12779	#define OP_Return 72
12780	#define OP_EndCoroutine 73
12781	#define OP_HaltIfNull 74 /* synopsis: if r[P3]=null halt */
12782	#define OP_Halt 75
12783	#define OP_Integer 76 /* synopsis: r[P2]=P1 */
12784	#define OP_Int64 77 /* synopsis: r[P2]=P4 */
12785	#define OP_String 78 /* synopsis: r[P2]='P4' (len=P1) */
12786	#define OP_Null 79 /* synopsis: r[P2..P3]=NULL */
12787	#define OP_SoftNull 80 /* synopsis: r[P1]=NULL */
12788	#define OP_Blob 81 /* synopsis: r[P2]=P4 (len=P1) */
12789	#define OP_Variable 82 /* synopsis: r[P2]=parameter(P1,P4) */
12790	#define OP_Move 83 /* synopsis: r[P2@P3]=r[P1@P3] */
12791	#define OP_Copy 84 /* synopsis: r[P2@P3+1]=r[P1@P3+1] */
12792	#define OP_SCopy 85 /* synopsis: r[P2]=r[P1] */
12793	#define OP_IntCopy 86 /* synopsis: r[P2]=r[P1] */
12794	#define OP_ResultRow 87 /* synopsis: output=r[P1@P2] */
12795	#define OP_CollSeq 88
12796	#define OP_Function0 89 /* synopsis: r[P3]=func(r[P2@P5]) */
12797	#define OP_Function 90 /* synopsis: r[P3]=func(r[P2@P5]) */
12798	#define OP_AddImm 91 /* synopsis: r[P1]=r[P1]+P2 */
12799	#define OP_RealAffinity 92
12800	#define OP_Cast 93 /* synopsis: affinity(r[P1]) */
12801	#define OP_Permutation 94
12802	#define OP_Compare 95 /* synopsis: r[P1@P3] <-> r[P2@P3] */
12803	#define OP_Column 96 /* synopsis: r[P3]=PX */
12804	#define OP_String8 97 /* same as TK_STRING, synopsis: r[P2]='P4' */
12805	#define OP_Affinity 98 /* synopsis: affinity(r[P1@P2]) */
12806	#define OP_MakeRecord 99 /* synopsis: r[P3]=mkrec(r[P1@P2]) */
12807	#define OP_Count 100 /* synopsis: r[P2]=count() */
12808	#define OP_ReadCookie 101
12809	#define OP_SetCookie 102
12810	#define OP_ReopenIdx 103 /* synopsis: root=P2 iDb=P3 */
12811	#define OP_OpenRead 104 /* synopsis: root=P2 iDb=P3 */
12812	#define OP_OpenWrite 105 /* synopsis: root=P2 iDb=P3 */
12813	#define OP_OpenAutoindex 106 /* synopsis: nColumn=P2 */
12814	#define OP_OpenEphemeral 107 /* synopsis: nColumn=P2 */
12815	#define OP_SorterOpen 108
12816	#define OP_SequenceTest 109 /* synopsis: if( cursor[P1].ctr++ ) pc = P2 */
12817	#define OP_OpenPseudo 110 /* synopsis: P3 columns in r[P2] */
12818	#define OP_Close 111
12819	#define OP_ColumnsUsed 112
12820	#define OP_Sequence 113 /* synopsis: r[P2]=cursor[P1].ctr++ */
12821	#define OP_NewRowid 114 /* synopsis: r[P2]=rowid */
12822	#define OP_Insert 115 /* synopsis: intkey=r[P3] data=r[P2] */
12823	#define OP_InsertInt 116 /* synopsis: intkey=P3 data=r[P2] */
12824	#define OP_Delete 117
12825	#define OP_ResetCount 118
12826	#define OP_SorterCompare 119 /* synopsis: if key(P1)!=trim(r[P3],P4) goto P2 */
12827	#define OP_SorterData 120 /* synopsis: r[P2]=data */
12828	#define OP_RowData 121 /* synopsis: r[P2]=data */
12829	#define OP_Rowid 122 /* synopsis: r[P2]=rowid */
12830	#define OP_NullRow 123
12831	#define OP_SorterInsert 124 /* synopsis: key=r[P2] */
12832	#define OP_IdxInsert 125 /* synopsis: key=r[P2] */
12833	#define OP_IdxDelete 126 /* synopsis: key=r[P2@P3] */
12834	#define OP_Seek 127 /* synopsis: Move P3 to P1.rowid */
12835	#define OP_IdxRowid 128 /* synopsis: r[P2]=rowid */
12836	#define OP_Destroy 129
12837	#define OP_Clear 130
12838	#define OP_ResetSorter 131
12839	#define OP_Real 132 /* same as TK_FLOAT, synopsis: r[P2]=P4 */
12840	#define OP_CreateIndex 133 /* synopsis: r[P2]=root iDb=P1 */
12841	#define OP_CreateTable 134 /* synopsis: r[P2]=root iDb=P1 */
12842	#define OP_ParseSchema 135
12843	#define OP_LoadAnalysis 136
12844	#define OP_DropTable 137
12845	#define OP_DropIndex 138
12846	#define OP_DropTrigger 139
12847	#define OP_IntegrityCk 140
12848	#define OP_RowSetAdd 141 /* synopsis: rowset(P1)=r[P2] */
12849	#define OP_Param 142
12850	#define OP_FkCounter 143 /* synopsis: fkctr[P1]+=P2 */
12851	#define OP_MemMax 144 /* synopsis: r[P1]=max(r[P1],r[P2]) */
12852	#define OP_OffsetLimit 145 /* synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1) */
12853	#define OP_AggStep0 146 /* synopsis: accum=r[P3] step(r[P2@P5]) */
12854	#define OP_AggStep 147 /* synopsis: accum=r[P3] step(r[P2@P5]) */
12855	#define OP_AggFinal 148 /* synopsis: accum=r[P1] N=P2 */
12856	#define OP_Expire 149
12857	#define OP_TableLock 150 /* synopsis: iDb=P1 root=P2 write=P3 */
12858	#define OP_VBegin 151
12859	#define OP_VCreate 152
12860	#define OP_VDestroy 153
12861	#define OP_VOpen 154
12862	#define OP_VColumn 155 /* synopsis: r[P3]=vcolumn(P2) */
12863	#define OP_VRename 156
12864	#define OP_Pagecount 157
12865	#define OP_MaxPgcnt 158
12866	#define OP_CursorHint 159
12867	#define OP_Noop 160
12868	#define OP_Explain 161


12869
12870	/* Properties such as "out2" or "jump" that are specified in
12871	** comments following the "case" for each opcode in the vdbe.c
12872	** are encoded into bitvectors as follows:
12873	*/
	@@ -12883,32 +12906,32 @@
12883	/* 16 */ 0x03, 0x03, 0x01, 0x12, 0x01, 0x03, 0x03, 0x09,\
12884	/* 24 */ 0x09, 0x09, 0x09, 0x26, 0x26, 0x09, 0x09, 0x09,\
12885	/* 32 */ 0x09, 0x09, 0x03, 0x03, 0x0b, 0x0b, 0x0b, 0x0b,\
12886	/* 40 */ 0x0b, 0x0b, 0x01, 0x26, 0x26, 0x26, 0x26, 0x26,\
12887	/* 48 */ 0x26, 0x26, 0x26, 0x26, 0x26, 0x01, 0x12, 0x01,\
12888	/* 56 */ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x23, 0x0b,\
12889	/* 64 */ 0x01, 0x01, 0x03, 0x03, 0x03, 0x01, 0x01, 0x01,\
12890	/* 72 */ 0x02, 0x02, 0x08, 0x00, 0x10, 0x10, 0x10, 0x10,\
12891	/* 80 */ 0x00, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10, 0x00,\
12892	/* 88 */ 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x00, 0x00,\
12893	/* 96 */ 0x00, 0x10, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00,\
12894	/* 104 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
12895	/* 112 */ 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,\
12896	/* 120 */ 0x00, 0x00, 0x10, 0x00, 0x04, 0x04, 0x00, 0x00,\
12897	/* 128 */ 0x10, 0x10, 0x00, 0x00, 0x10, 0x10, 0x10, 0x00,\
12898	/* 136 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x10, 0x00,\
12899	/* 144 */ 0x04, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
12900	/* 152 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00,\
12901	/* 160 */ 0x00, 0x00,}
12902
12903	/* The sqlite3P2Values() routine is able to run faster if it knows
12904	** the value of the largest JUMP opcode. The smaller the maximum
12905	** JUMP opcode the better, so the mkopcodeh.tcl script that
12906	** generated this include file strives to group all JUMP opcodes
12907	** together near the beginning of the list.
12908	*/
12909	#define SQLITE_MX_JUMP_OPCODE 71 /* Maximum JUMP opcode */
12910
12911	/************ End of opcodes.h *******************************************/
12912	/************ Continuing where we left off in vdbe.h *********************/
12913
12914	/*
	@@ -14074,10 +14097,11 @@
14074	u8 suppressErr; /* Do not issue error messages if true */
14075	u8 vtabOnConflict; /* Value to return for s3_vtab_on_conflict() */
14076	u8 isTransactionSavepoint; /* True if the outermost savepoint is a TS */
14077	u8 mTrace; /* zero or more SQLITE_TRACE flags */
14078	u8 skipBtreeMutex; /* True if no shared-cache backends */

14079	int nextPagesize; /* Pagesize after VACUUM if >0 */
14080	u32 magic; /* Magic number for detect library misuse */
14081	int nChange; /* Value returned by sqlite3_changes() */
14082	int nTotalChange; /* Value returned by sqlite3_total_changes() */
14083	int aLimit[SQLITE_N_LIMIT]; /* Limits */
	@@ -14589,18 +14613,18 @@
14589	char zColAff; / String defining the affinity of each column */
14590	ExprList pCheck; / All CHECK constraints */
14591	/* ... also used as column name list in a VIEW */
14592	int tnum; /* Root BTree page for this table */
14593	u32 nTabRef; /* Number of pointers to this Table */

14594	i16 iPKey; /* If not negative, use aCol[iPKey] as the rowid */
14595	i16 nCol; /* Number of columns in this table */
14596	LogEst nRowLogEst; /* Estimated rows in table - from sqlite_stat1 table */
14597	LogEst szTabRow; /* Estimated size of each table row in bytes */
14598	#ifdef SQLITE_ENABLE_COSTMULT
14599	LogEst costMult; /* Cost multiplier for using this table */
14600	#endif
14601	u8 tabFlags; /* Mask of TF_* values */
14602	u8 keyConf; /* What to do in case of uniqueness conflict on iPKey */
14603	#ifndef SQLITE_OMIT_ALTERTABLE
14604	int addColOffset; /* Offset in CREATE TABLE stmt to add a new column */
14605	#endif
14606	#ifndef SQLITE_OMIT_VIRTUALTABLE
	@@ -14620,27 +14644,29 @@
14620	** followed by non-hidden columns. Example: "CREATE VIRTUAL TABLE x USING
14621	** vtab1(a HIDDEN, b);". Since "b" is a non-hidden column but "a" is hidden,
14622	** the TF_OOOHidden attribute would apply in this case. Such tables require
14623	** special handling during INSERT processing.
14624	*/
14625	#define TF_Readonly 0x01 /* Read-only system table */
14626	#define TF_Ephemeral 0x02 /* An ephemeral table */
14627	#define TF_HasPrimaryKey 0x04 /* Table has a primary key */
14628	#define TF_Autoincrement 0x08 /* Integer primary key is autoincrement */
14629	#define TF_Virtual 0x10 /* Is a virtual table */
14630	#define TF_WithoutRowid 0x20 /* No rowid. PRIMARY KEY is the key */
14631	#define TF_NoVisibleRowid 0x40 /* No user-visible "rowid" column */
14632	#define TF_OOOHidden 0x80 /* Out-of-Order hidden columns */
14633


14634
14635	/*
14636	** Test to see whether or not a table is a virtual table. This is
14637	** done as a macro so that it will be optimized out when virtual
14638	** table support is omitted from the build.
14639	*/
14640	#ifndef SQLITE_OMIT_VIRTUALTABLE
14641	# define IsVirtual(X) (((X)->tabFlags & TF_Virtual)!=0)
14642	#else
14643	# define IsVirtual(X) 0
14644	#endif
14645
14646	/*
	@@ -14871,10 +14897,11 @@
14871	unsigned bUnordered:1; /* Use this index for == or IN queries only */
14872	unsigned uniqNotNull:1; /* True if UNIQUE and NOT NULL for all columns */
14873	unsigned isResized:1; /* True if resizeIndexObject() has been called */
14874	unsigned isCovering:1; /* True if this is a covering index */
14875	unsigned noSkipScan:1; /* Do not try to use skip-scan if true */

14876	#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
14877	int nSample; /* Number of elements in aSample[] */
14878	int nSampleCol; /* Size of IndexSample.anEq[] and so on */
14879	tRowcnt aAvgEq; / Average nEq values for keys not in aSample */
14880	IndexSample aSample; / Samples of the left-most key */
	@@ -15181,11 +15208,11 @@
15181	** form is used for name resolution with nested FROM clauses.
15182	*/
15183	struct ExprList {
15184	int nExpr; /* Number of expressions on the list */
15185	struct ExprList_item { /* For each expression in the list */
15186	Expr pExpr; / The list of expressions */
15187	char zName; / Token associated with this expression */
15188	char zSpan; / Original text of the expression */
15189	u8 sortOrder; /* 1 for DESC or 0 for ASC */
15190	unsigned done :1; /* A flag to indicate when processing is finished */
15191	unsigned bSpanIsTab :1; /* zSpan holds DB.TABLE.COLUMN */
	@@ -16504,10 +16531,11 @@
16504	SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3,int,const char);
16505	SQLITE_PRIVATE void sqlite3Vacuum(Parse,Token);
16506	SQLITE_PRIVATE int sqlite3RunVacuum(char*, sqlite3, int);
16507	SQLITE_PRIVATE char sqlite3NameFromToken(sqlite3, Token*);
16508	SQLITE_PRIVATE int sqlite3ExprCompare(Expr, Expr, int);

16509	SQLITE_PRIVATE int sqlite3ExprListCompare(ExprList, ExprList, int);
16510	SQLITE_PRIVATE int sqlite3ExprImpliesExpr(Expr, Expr, int);
16511	SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext, Expr);
16512	SQLITE_PRIVATE void sqlite3ExprAnalyzeAggList(NameContext,ExprList);
16513	SQLITE_PRIVATE int sqlite3ExprCoveredByIndex(Expr, int iCur, Index pIdx);
	@@ -17450,11 +17478,11 @@
17450	"COMPILER=gcc-" __VERSION__,
17451	#endif
17452	#if SQLITE_COVERAGE_TEST
17453	"COVERAGE_TEST",
17454	#endif
17455	#if SQLITE_DEBUG
17456	"DEBUG",
17457	#endif
17458	#if SQLITE_DEFAULT_LOCKING_MODE
17459	"DEFAULT_LOCKING_MODE=" CTIMEOPT_VAL(SQLITE_DEFAULT_LOCKING_MODE),
17460	#endif
	@@ -19505,22 +19533,23 @@
19505	**
19506	** Move the date backwards to the beginning of the current day,
19507	** or month or year.
19508	*/
19509	if( sqlite3_strnicmp(z, "start of ", 9)!=0 ) break;

19510	z += 9;
19511	computeYMD(p);
19512	p->validHMS = 1;
19513	p->h = p->m = 0;
19514	p->s = 0.0;

19515	p->validTZ = 0;
19516	p->validJD = 0;
19517	if( sqlite3_stricmp(z,"month")==0 ){
19518	p->D = 1;
19519	rc = 0;
19520	}else if( sqlite3_stricmp(z,"year")==0 ){
19521	computeYMD(p);
19522	p->M = 1;
19523	p->D = 1;
19524	rc = 0;
19525	}else if( sqlite3_stricmp(z,"day")==0 ){
19526	rc = 0;
	@@ -24050,12 +24079,12 @@
24050	#ifdef SQLITE_DEBUG
24051	assert( p->nRef>0 \|\| p->owner==0 );
24052	p->owner = tid;
24053	p->nRef++;
24054	if( p->trace ){
24055	OSTRACE(("ENTER-MUTEX tid=%lu, mutex=%p (%d), nRef=%d\n",
24056	tid, p, p->trace, p->nRef));
24057	}
24058	#endif
24059	}
24060
24061	static int winMutexTry(sqlite3_mutex *p){
	@@ -24093,12 +24122,12 @@
24093	#else
24094	UNUSED_PARAMETER(p);
24095	#endif
24096	#ifdef SQLITE_DEBUG
24097	if( p->trace ){
24098	OSTRACE(("TRY-MUTEX tid=%lu, mutex=%p (%d), owner=%lu, nRef=%d, rc=%s\n",
24099	tid, p, p->trace, p->owner, p->nRef, sqlite3ErrName(rc)));
24100	}
24101	#endif
24102	return rc;
24103	}
24104
	@@ -24122,12 +24151,12 @@
24122	#endif
24123	assert( winMutex_isInit==1 );
24124	LeaveCriticalSection(&p->mutex);
24125	#ifdef SQLITE_DEBUG
24126	if( p->trace ){
24127	OSTRACE(("LEAVE-MUTEX tid=%lu, mutex=%p (%d), nRef=%d\n",
24128	tid, p, p->trace, p->nRef));
24129	}
24130	#endif
24131	}
24132
24133	SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){
	@@ -24383,10 +24412,17 @@
24383	** implementation of malloc_good_size(), which must be called in debug
24384	** mode and specifically when the DMD "Dark Matter Detector" is enabled
24385	** or else a crash results. Hence, do not attempt to optimize out the
24386	** following xRoundup() call. */
24387	nFull = sqlite3GlobalConfig.m.xRoundup(n);







24388
24389	sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, n);
24390	if( mem0.alarmThreshold>0 ){
24391	sqlite3_int64 nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
24392	if( nUsed >= mem0.alarmThreshold - nFull ){
	@@ -24572,11 +24608,11 @@
24572	return sqlite3GlobalConfig.m.xSize(p);
24573	}
24574	SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3 db, void p){
24575	assert( p!=0 );
24576	if( db==0 \|\| !isLookaside(db,p) ){
24577	#if SQLITE_DEBUG
24578	if( db==0 ){
24579	assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
24580	assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
24581	}else{
24582	assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE\|MEMTYPE_HEAP)) );
	@@ -24633,11 +24669,11 @@
24633	measureAllocationSize(db, p);
24634	return;
24635	}
24636	if( isLookaside(db, p) ){
24637	LookasideSlot pBuf = (LookasideSlot)p;
24638	#if SQLITE_DEBUG
24639	/* Trash all content in the buffer being freed */
24640	memset(p, 0xaa, db->lookaside.sz);
24641	#endif
24642	pBuf->pNext = db->lookaside.pFree;
24643	db->lookaside.pFree = pBuf;
	@@ -25002,11 +25038,11 @@
25002
25003	/*
25004	** Conversion types fall into various categories as defined by the
25005	** following enumeration.
25006	*/
25007	#define etRADIX 0 /* Integer types. %d, %x, %o, and so forth */
25008	#define etFLOAT 1 /* Floating point. %f */
25009	#define etEXP 2 /* Exponentional notation. %e and %E */
25010	#define etGENERIC 3 /* Floating or exponential, depending on exponent. %g */
25011	#define etSIZE 4 /* Return number of characters processed so far. %n */
25012	#define etSTRING 5 /* Strings. %s */
	@@ -25020,12 +25056,13 @@
25020	#define etTOKEN 11 /* a pointer to a Token structure */
25021	#define etSRCLIST 12 /* a pointer to a SrcList */
25022	#define etPOINTER 13 /* The %p conversion */
25023	#define etSQLESCAPE3 14 /* %w -> Strings with '\"' doubled */
25024	#define etORDINAL 15 /* %r -> 1st, 2nd, 3rd, 4th, etc. English only */

25025
25026	#define etINVALID 16 /* Any unrecognized conversion type */
25027
25028
25029	/*
25030	** An "etByte" is an 8-bit unsigned value.
25031	*/
	@@ -25045,40 +25082,40 @@
25045	} et_info;
25046
25047	/*
25048	** Allowed values for et_info.flags
25049	*/
25050	#define FLAG_SIGNED 1 /* True if the value to convert is signed */
25051	#define FLAG_STRING 4 /* Allow infinity precision */
25052
25053
25054	/*
25055	** The following table is searched linearly, so it is good to put the
25056	** most frequently used conversion types first.
25057	*/
25058	static const char aDigits[] = "0123456789ABCDEF0123456789abcdef";
25059	static const char aPrefix[] = "-x0\000X0";
25060	static const et_info fmtinfo[] = {
25061	{ 'd', 10, 1, etRADIX, 0, 0 },
25062	{ 's', 0, 4, etSTRING, 0, 0 },
25063	{ 'g', 0, 1, etGENERIC, 30, 0 },
25064	{ 'z', 0, 4, etDYNSTRING, 0, 0 },
25065	{ 'q', 0, 4, etSQLESCAPE, 0, 0 },
25066	{ 'Q', 0, 4, etSQLESCAPE2, 0, 0 },
25067	{ 'w', 0, 4, etSQLESCAPE3, 0, 0 },
25068	{ 'c', 0, 0, etCHARX, 0, 0 },
25069	{ 'o', 8, 0, etRADIX, 0, 2 },
25070	{ 'u', 10, 0, etRADIX, 0, 0 },
25071	{ 'x', 16, 0, etRADIX, 16, 1 },
25072	{ 'X', 16, 0, etRADIX, 0, 4 },
25073	#ifndef SQLITE_OMIT_FLOATING_POINT
25074	{ 'f', 0, 1, etFLOAT, 0, 0 },
25075	{ 'e', 0, 1, etEXP, 30, 0 },
25076	{ 'E', 0, 1, etEXP, 14, 0 },
25077	{ 'G', 0, 1, etGENERIC, 14, 0 },
25078	#endif
25079	{ 'i', 10, 1, etRADIX, 0, 0 },
25080	{ 'n', 0, 0, etSIZE, 0, 0 },
25081	{ '%', 0, 0, etPERCENT, 0, 0 },
25082	{ 'p', 16, 0, etPOINTER, 0, 1 },
25083
25084	/* All the rest are undocumented and are for internal use only */
	@@ -25166,18 +25203,17 @@
25166	int precision; /* Precision of the current field */
25167	int length; /* Length of the field */
25168	int idx; /* A general purpose loop counter */
25169	int width; /* Width of the current field */
25170	etByte flag_leftjustify; /* True if "-" flag is present */
25171	etByte flag_plussign; /* True if "+" flag is present */
25172	etByte flag_blanksign; /* True if " " flag is present */
25173	etByte flag_alternateform; /* True if "#" flag is present */
25174	etByte flag_altform2; /* True if "!" flag is present */
25175	etByte flag_zeropad; /* True if field width constant starts with zero */
25176	etByte flag_long; /* True if "l" flag is present */
25177	etByte flag_longlong; /* True if the "ll" flag is present */
25178	etByte done; /* Loop termination flag */

25179	etByte xtype = etINVALID; /* Conversion paradigm */
25180	u8 bArgList; /* True for SQLITE_PRINTF_SQLFUNC */
25181	char prefix; /* Prefix character. "+" or "-" or " " or '\0'. */
25182	sqlite_uint64 longvalue; /* Value for integer types */
25183	LONGDOUBLE_TYPE realvalue; /* Value for real types */
	@@ -25216,21 +25252,22 @@
25216	if( (c=(*++fmt))==0 ){
25217	sqlite3StrAccumAppend(pAccum, "%", 1);
25218	break;
25219	}
25220	/* Find out what flags are present */
25221	flag_leftjustify = flag_plussign = flag_blanksign =
25222	flag_alternateform = flag_altform2 = flag_zeropad = 0;
25223	done = 0;
25224	do{
25225	switch( c ){
25226	case '-': flag_leftjustify = 1; break;
25227	case '+': flag_plussign = 1; break;
25228	case ' ': flag_blanksign = 1; break;
25229	case '#': flag_alternateform = 1; break;
25230	case '!': flag_altform2 = 1; break;
25231	case '0': flag_zeropad = 1; break;

25232	default: done = 1; break;
25233	}
25234	}while( !done && (c=(*++fmt))!=0 );
25235	/* Get the field width */
25236	if( c=='*' ){
	@@ -25296,17 +25333,15 @@
25296	/* Get the conversion type modifier */
25297	if( c=='l' ){
25298	flag_long = 1;
25299	c = *++fmt;
25300	if( c=='l' ){
25301	flag_longlong = 1;
25302	c = *++fmt;
25303	}else{
25304	flag_longlong = 0;
25305	}
25306	}else{
25307	flag_long = flag_longlong = 0;
25308	}
25309	/* Fetch the info entry for the field */
25310	infop = &fmtinfo[0];
25311	xtype = etINVALID;
25312	for(idx=0; idx<ArraySize(fmtinfo); idx++){
	@@ -25320,41 +25355,42 @@
25320	/*
25321	** At this point, variables are initialized as follows:
25322	**
25323	** flag_alternateform TRUE if a '#' is present.
25324	** flag_altform2 TRUE if a '!' is present.
25325	** flag_plussign TRUE if a '+' is present.
25326	** flag_leftjustify TRUE if a '-' is present or if the
25327	** field width was negative.
25328	** flag_zeropad TRUE if the width began with 0.
25329	** flag_long TRUE if the letter 'l' (ell) prefixed
25330	** the conversion character.
25331	** flag_longlong TRUE if the letter 'll' (ell ell) prefixed
25332	** the conversion character.
25333	** flag_blanksign TRUE if a ' ' is present.
25334	** width The specified field width. This is
25335	** always non-negative. Zero is the default.
25336	** precision The specified precision. The default
25337	** is -1.
25338	** xtype The class of the conversion.
25339	** infop Pointer to the appropriate info struct.
25340	*/
25341	switch( xtype ){
25342	case etPOINTER:
25343	flag_longlong = sizeof(char*)==sizeof(i64);
25344	flag_long = sizeof(char*)==sizeof(long int);
25345	/* Fall through into the next case */
25346	case etORDINAL:
25347	case etRADIX:



25348	if( infop->flags & FLAG_SIGNED ){
25349	i64 v;
25350	if( bArgList ){
25351	v = getIntArg(pArgList);
25352	}else if( flag_longlong ){
25353	v = va_arg(ap,i64);
25354	}else if( flag_long ){
25355	v = va_arg(ap,long int);




25356	}else{
25357	v = va_arg(ap,int);
25358	}
25359	if( v<0 ){
25360	if( v==SMALLEST_INT64 ){
	@@ -25363,35 +25399,35 @@
25363	longvalue = -v;
25364	}
25365	prefix = '-';
25366	}else{
25367	longvalue = v;
25368	if( flag_plussign ) prefix = '+';
25369	else if( flag_blanksign ) prefix = ' ';
25370	else prefix = 0;
25371	}
25372	}else{
25373	if( bArgList ){
25374	longvalue = (u64)getIntArg(pArgList);
25375	}else if( flag_longlong ){
25376	longvalue = va_arg(ap,u64);
25377	}else if( flag_long ){
25378	longvalue = va_arg(ap,unsigned long int);




25379	}else{
25380	longvalue = va_arg(ap,unsigned int);
25381	}
25382	prefix = 0;
25383	}
25384	if( longvalue==0 ) flag_alternateform = 0;
25385	if( flag_zeropad && precision<width-(prefix!=0) ){
25386	precision = width-(prefix!=0);
25387	}
25388	if( precision<etBUFSIZE-10 ){
25389	nOut = etBUFSIZE;
25390	zOut = buf;
25391	}else{
25392	nOut = precision + 10;
25393	zOut = zExtra = sqlite3Malloc( nOut );
25394	if( zOut==0 ){
25395	setStrAccumError(pAccum, STRACCUM_NOMEM);
25396	return;
25397	}
	@@ -25413,12 +25449,27 @@
25413	*(--bufpt) = cset[longvalue%base];
25414	longvalue = longvalue/base;
25415	}while( longvalue>0 );
25416	}
25417	length = (int)(&zOut[nOut-1]-bufpt);
25418	for(idx=precision-length; idx>0; idx--){
25419	(--bufpt) = '0'; / Zero pad */















25420	}
25421	if( prefix ) (--bufpt) = prefix; / Add sign */
25422	if( flag_alternateform && infop->prefix ){ /* Add "0" or "0x" */
25423	const char *pre;
25424	char x;
	@@ -25441,13 +25492,11 @@
25441	if( precision<0 ) precision = 6; /* Set default precision */
25442	if( realvalue<0.0 ){
25443	realvalue = -realvalue;
25444	prefix = '-';
25445	}else{
25446	if( flag_plussign ) prefix = '+';
25447	else if( flag_blanksign ) prefix = ' ';
25448	else prefix = 0;
25449	}
25450	if( xtype==etGENERIC && precision>0 ) precision--;
25451	testcase( precision>0xfff );
25452	for(idx=precision&0xfff, rounder=0.5; idx>0; idx--, rounder*=0.1){}
25453	if( xtype==etFLOAT ) realvalue += rounder;
	@@ -29464,117 +29513,119 @@
29464	/* 50 */ "Divide" OpHelp("r[P3]=r[P2]/r[P1]"),
29465	/* 51 */ "Remainder" OpHelp("r[P3]=r[P2]%r[P1]"),
29466	/* 52 */ "Concat" OpHelp("r[P3]=r[P2]+r[P1]"),
29467	/* 53 */ "Last" OpHelp(""),
29468	/* 54 */ "BitNot" OpHelp("r[P1]= ~r[P1]"),
29469	/* 55 */ "SorterSort" OpHelp(""),
29470	/* 56 */ "Sort" OpHelp(""),
29471	/* 57 */ "Rewind" OpHelp(""),
29472	/* 58 */ "IdxLE" OpHelp("key=r[P3@P4]"),
29473	/* 59 */ "IdxGT" OpHelp("key=r[P3@P4]"),
29474	/* 60 */ "IdxLT" OpHelp("key=r[P3@P4]"),
29475	/* 61 */ "IdxGE" OpHelp("key=r[P3@P4]"),
29476	/* 62 */ "RowSetRead" OpHelp("r[P3]=rowset(P1)"),
29477	/* 63 */ "RowSetTest" OpHelp("if r[P3] in rowset(P1) goto P2"),
29478	/* 64 */ "Program" OpHelp(""),
29479	/* 65 */ "FkIfZero" OpHelp("if fkctr[P1]==0 goto P2"),
29480	/* 66 */ "IfPos" OpHelp("if r[P1]>0 then r[P1]-=P3, goto P2"),
29481	/* 67 */ "IfNotZero" OpHelp("if r[P1]!=0 then r[P1]--, goto P2"),
29482	/* 68 */ "DecrJumpZero" OpHelp("if (--r[P1])==0 goto P2"),
29483	/* 69 */ "IncrVacuum" OpHelp(""),
29484	/* 70 */ "VNext" OpHelp(""),
29485	/* 71 */ "Init" OpHelp("Start at P2"),
29486	/* 72 */ "Return" OpHelp(""),
29487	/* 73 */ "EndCoroutine" OpHelp(""),
29488	/* 74 */ "HaltIfNull" OpHelp("if r[P3]=null halt"),
29489	/* 75 */ "Halt" OpHelp(""),
29490	/* 76 */ "Integer" OpHelp("r[P2]=P1"),
29491	/* 77 */ "Int64" OpHelp("r[P2]=P4"),
29492	/* 78 */ "String" OpHelp("r[P2]='P4' (len=P1)"),
29493	/* 79 */ "Null" OpHelp("r[P2..P3]=NULL"),
29494	/* 80 */ "SoftNull" OpHelp("r[P1]=NULL"),
29495	/* 81 */ "Blob" OpHelp("r[P2]=P4 (len=P1)"),
29496	/* 82 */ "Variable" OpHelp("r[P2]=parameter(P1,P4)"),
29497	/* 83 */ "Move" OpHelp("r[P2@P3]=r[P1@P3]"),
29498	/* 84 */ "Copy" OpHelp("r[P2@P3+1]=r[P1@P3+1]"),
29499	/* 85 */ "SCopy" OpHelp("r[P2]=r[P1]"),
29500	/* 86 */ "IntCopy" OpHelp("r[P2]=r[P1]"),
29501	/* 87 */ "ResultRow" OpHelp("output=r[P1@P2]"),
29502	/* 88 */ "CollSeq" OpHelp(""),
29503	/* 89 */ "Function0" OpHelp("r[P3]=func(r[P2@P5])"),
29504	/* 90 */ "Function" OpHelp("r[P3]=func(r[P2@P5])"),
29505	/* 91 */ "AddImm" OpHelp("r[P1]=r[P1]+P2"),
29506	/* 92 */ "RealAffinity" OpHelp(""),
29507	/* 93 */ "Cast" OpHelp("affinity(r[P1])"),
29508	/* 94 */ "Permutation" OpHelp(""),
29509	/* 95 */ "Compare" OpHelp("r[P1@P3] <-> r[P2@P3]"),
29510	/* 96 */ "Column" OpHelp("r[P3]=PX"),
29511	/* 97 */ "String8" OpHelp("r[P2]='P4'"),
29512	/* 98 */ "Affinity" OpHelp("affinity(r[P1@P2])"),
29513	/* 99 */ "MakeRecord" OpHelp("r[P3]=mkrec(r[P1@P2])"),
29514	/* 100 */ "Count" OpHelp("r[P2]=count()"),
29515	/* 101 */ "ReadCookie" OpHelp(""),
29516	/* 102 */ "SetCookie" OpHelp(""),
29517	/* 103 */ "ReopenIdx" OpHelp("root=P2 iDb=P3"),
29518	/* 104 */ "OpenRead" OpHelp("root=P2 iDb=P3"),
29519	/* 105 */ "OpenWrite" OpHelp("root=P2 iDb=P3"),
29520	/* 106 */ "OpenAutoindex" OpHelp("nColumn=P2"),
29521	/* 107 */ "OpenEphemeral" OpHelp("nColumn=P2"),
29522	/* 108 */ "SorterOpen" OpHelp(""),
29523	/* 109 */ "SequenceTest" OpHelp("if( cursor[P1].ctr++ ) pc = P2"),
29524	/* 110 */ "OpenPseudo" OpHelp("P3 columns in r[P2]"),
29525	/* 111 */ "Close" OpHelp(""),
29526	/* 112 */ "ColumnsUsed" OpHelp(""),
29527	/* 113 */ "Sequence" OpHelp("r[P2]=cursor[P1].ctr++"),
29528	/* 114 */ "NewRowid" OpHelp("r[P2]=rowid"),
29529	/* 115 */ "Insert" OpHelp("intkey=r[P3] data=r[P2]"),
29530	/* 116 */ "InsertInt" OpHelp("intkey=P3 data=r[P2]"),
29531	/* 117 */ "Delete" OpHelp(""),
29532	/* 118 */ "ResetCount" OpHelp(""),
29533	/* 119 */ "SorterCompare" OpHelp("if key(P1)!=trim(r[P3],P4) goto P2"),
29534	/* 120 */ "SorterData" OpHelp("r[P2]=data"),
29535	/* 121 */ "RowData" OpHelp("r[P2]=data"),
29536	/* 122 */ "Rowid" OpHelp("r[P2]=rowid"),
29537	/* 123 */ "NullRow" OpHelp(""),
29538	/* 124 */ "SorterInsert" OpHelp("key=r[P2]"),
29539	/* 125 */ "IdxInsert" OpHelp("key=r[P2]"),
29540	/* 126 */ "IdxDelete" OpHelp("key=r[P2@P3]"),
29541	/* 127 */ "Seek" OpHelp("Move P3 to P1.rowid"),
29542	/* 128 */ "IdxRowid" OpHelp("r[P2]=rowid"),
29543	/* 129 */ "Destroy" OpHelp(""),
29544	/* 130 */ "Clear" OpHelp(""),
29545	/* 131 */ "ResetSorter" OpHelp(""),
29546	/* 132 */ "Real" OpHelp("r[P2]=P4"),
29547	/* 133 */ "CreateIndex" OpHelp("r[P2]=root iDb=P1"),
29548	/* 134 */ "CreateTable" OpHelp("r[P2]=root iDb=P1"),
29549	/* 135 */ "ParseSchema" OpHelp(""),
29550	/* 136 */ "LoadAnalysis" OpHelp(""),
29551	/* 137 */ "DropTable" OpHelp(""),
29552	/* 138 */ "DropIndex" OpHelp(""),
29553	/* 139 */ "DropTrigger" OpHelp(""),
29554	/* 140 */ "IntegrityCk" OpHelp(""),
29555	/* 141 */ "RowSetAdd" OpHelp("rowset(P1)=r[P2]"),
29556	/* 142 */ "Param" OpHelp(""),
29557	/* 143 */ "FkCounter" OpHelp("fkctr[P1]+=P2"),
29558	/* 144 */ "MemMax" OpHelp("r[P1]=max(r[P1],r[P2])"),
29559	/* 145 */ "OffsetLimit" OpHelp("if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)"),
29560	/* 146 */ "AggStep0" OpHelp("accum=r[P3] step(r[P2@P5])"),
29561	/* 147 */ "AggStep" OpHelp("accum=r[P3] step(r[P2@P5])"),
29562	/* 148 */ "AggFinal" OpHelp("accum=r[P1] N=P2"),
29563	/* 149 */ "Expire" OpHelp(""),
29564	/* 150 */ "TableLock" OpHelp("iDb=P1 root=P2 write=P3"),
29565	/* 151 */ "VBegin" OpHelp(""),
29566	/* 152 */ "VCreate" OpHelp(""),
29567	/* 153 */ "VDestroy" OpHelp(""),
29568	/* 154 */ "VOpen" OpHelp(""),
29569	/* 155 */ "VColumn" OpHelp("r[P3]=vcolumn(P2)"),
29570	/* 156 */ "VRename" OpHelp(""),
29571	/* 157 */ "Pagecount" OpHelp(""),
29572	/* 158 */ "MaxPgcnt" OpHelp(""),
29573	/* 159 */ "CursorHint" OpHelp(""),
29574	/* 160 */ "Noop" OpHelp(""),
29575	/* 161 */ "Explain" OpHelp(""),


29576	};
29577	return azName[i];
29578	}
29579	#endif
29580
	@@ -37952,46 +38003,84 @@
37952	* be freed immediately and any attempt to access any of that freed
37953	* data will almost certainly result in an immediate access violation.
37954	******************************************************************************
37955	*/
37956	#ifndef SQLITE_WIN32_HEAP_CREATE
37957	# define SQLITE_WIN32_HEAP_CREATE (TRUE)



























37958	#endif
37959
37960	/*
37961	* This is cache size used in the calculation of the initial size of the
37962	* Win32-specific heap. It cannot be negative.
37963	*/
37964	#ifndef SQLITE_WIN32_CACHE_SIZE
37965	# if SQLITE_DEFAULT_CACHE_SIZE>=0
37966	# define SQLITE_WIN32_CACHE_SIZE (SQLITE_DEFAULT_CACHE_SIZE)
37967	# else
37968	# define SQLITE_WIN32_CACHE_SIZE (-(SQLITE_DEFAULT_CACHE_SIZE))
37969	# endif
37970	#endif
37971










37972	/*
37973	* The initial size of the Win32-specific heap. This value may be zero.
37974	*/
37975	#ifndef SQLITE_WIN32_HEAP_INIT_SIZE
37976	# define SQLITE_WIN32_HEAP_INIT_SIZE ((SQLITE_WIN32_CACHE_SIZE) * \
37977	(SQLITE_DEFAULT_PAGE_SIZE) + 4194304)

37978	#endif
37979
37980	/*
37981	* The maximum size of the Win32-specific heap. This value may be zero.
37982	*/
37983	#ifndef SQLITE_WIN32_HEAP_MAX_SIZE
37984	# define SQLITE_WIN32_HEAP_MAX_SIZE (0)
37985	#endif
37986
37987	/*
37988	* The extra flags to use in calls to the Win32 heap APIs. This value may be
37989	* zero for the default behavior.
37990	*/
37991	#ifndef SQLITE_WIN32_HEAP_FLAGS
37992	# define SQLITE_WIN32_HEAP_FLAGS (0)
37993	#endif
37994
37995
37996	/*
37997	** The winMemData structure stores information required by the Win32-specific
	@@ -44084,11 +44173,11 @@
44084	** This routine is for use inside of assert() statements only. For
44085	** example:
44086	**
44087	** assert( sqlite3PcachePageSanity(pPg) );
44088	*/
44089	#if SQLITE_DEBUG
44090	SQLITE_PRIVATE int sqlite3PcachePageSanity(PgHdr *pPg){
44091	PCache *pCache;
44092	assert( pPg!=0 );
44093	assert( pPg->pgno>0 \|\| pPg->pPager==0 ); /* Page number is 1 or more */
44094	pCache = pPg->pCache;
	@@ -60177,21 +60266,22 @@
60177	}
60178	#endif
60179
60180
60181	/*
60182	** Defragment the page given. All Cells are moved to the
60183	** end of the page and all free space is collected into one
60184	** big FreeBlk that occurs in between the header and cell
60185	** pointer array and the cell content area.

60186	**
60187	** EVIDENCE-OF: R-44582-60138 SQLite may from time to time reorganize a
60188	** b-tree page so that there are no freeblocks or fragment bytes, all
60189	** unused bytes are contained in the unallocated space region, and all
60190	** cells are packed tightly at the end of the page.
60191	*/
60192	static int defragmentPage(MemPage *pPage){
60193	int i; /* Loop counter */
60194	int pc; /* Address of the i-th cell */
60195	int hdr; /* Offset to the page header */
60196	int size; /* Size of a cell */
60197	int usableSize; /* Number of usable bytes on a page */
	@@ -60202,11 +60292,10 @@
60202	unsigned char temp; / Temp area for cell content */
60203	unsigned char src; / Source of content */
60204	int iCellFirst; /* First allowable cell index */
60205	int iCellLast; /* Last possible cell index */
60206
60207
60208	assert( sqlite3PagerIswriteable(pPage->pDbPage) );
60209	assert( pPage->pBt!=0 );
60210	assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE );
60211	assert( pPage->nOverflow==0 );
60212	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
	@@ -60214,13 +60303,60 @@
60214	src = data = pPage->aData;
60215	hdr = pPage->hdrOffset;
60216	cellOffset = pPage->cellOffset;
60217	nCell = pPage->nCell;
60218	assert( nCell==get2byte(&data[hdr+3]) );

60219	usableSize = pPage->pBt->usableSize;















































60220	cbrk = usableSize;
60221	iCellFirst = cellOffset + 2*nCell;
60222	iCellLast = usableSize - 4;
60223	for(i=0; i<nCell; i++){
60224	u8 pAddr; / The i-th cell pointer */
60225	pAddr = &data[cellOffset + i*2];
60226	pc = get2byte(pAddr);
	@@ -60250,20 +60386,22 @@
60250	memcpy(&temp[x], &data[x], (cbrk+size) - x);
60251	src = temp;
60252	}
60253	memcpy(&data[cbrk], &src[pc], size);
60254	}






60255	assert( cbrk>=iCellFirst );
60256	put2byte(&data[hdr+5], cbrk);
60257	data[hdr+1] = 0;
60258	data[hdr+2] = 0;
60259	data[hdr+7] = 0;
60260	memset(&data[iCellFirst], 0, cbrk-iCellFirst);
60261	assert( sqlite3PagerIswriteable(pPage->pDbPage) );
60262	if( cbrk-iCellFirst!=pPage->nFree ){
60263	return SQLITE_CORRUPT_BKPT;
60264	}
60265	return SQLITE_OK;
60266	}
60267
60268	/*
60269	** Search the free-list on page pPg for space to store a cell nByte bytes in
	@@ -60397,14 +60535,14 @@
60397	** to see if defragmentation is necessary.
60398	*/
60399	testcase( gap+2+nByte==top );
60400	if( gap+2+nByte>top ){
60401	assert( pPage->nCell>0 \|\| CORRUPT_DB );
60402	rc = defragmentPage(pPage);
60403	if( rc ) return rc;
60404	top = get2byteNotZero(&data[hdr+5]);
60405	assert( gap+nByte<=top );
60406	}
60407
60408
60409	/* Allocate memory from the gap in between the cell pointer array
60410	** and the cell content area. The btreeInitPage() call has already
	@@ -63636,11 +63774,11 @@
63636	pCur->aiIdx[pCur->iPage] = 0;
63637	return getAndInitPage(pBt, newPgno, &pCur->apPage[pCur->iPage],
63638	pCur, pCur->curPagerFlags);
63639	}
63640
63641	#if SQLITE_DEBUG
63642	/*
63643	** Page pParent is an internal (non-leaf) tree page. This function
63644	** asserts that page number iChild is the left-child if the iIdx'th
63645	** cell in page pParent. Or, if iIdx is equal to the total number of
63646	** cells in pParent, that page number iChild is the right-child of
	@@ -64178,10 +64316,34 @@
64178	** have been deleted? This API will need to change to return an error code
64179	** as well as the boolean result value.
64180	*/
64181	return (CURSOR_VALID!=pCur->eState);
64182	}
























64183
64184	/*
64185	** Advance the cursor to the next entry in the database. If
64186	** successful then set *pRes=0. If the cursor
64187	** was already pointing to the last entry in the database before
	@@ -65023,11 +65185,11 @@
65023	** pPrior Where to write the pgno of the first overflow page
65024	**
65025	** Use a call to btreeParseCellPtr() to verify that the values above
65026	** were computed correctly.
65027	*/
65028	#if SQLITE_DEBUG
65029	{
65030	CellInfo info;
65031	pPage->xParseCell(pPage, pCell, &info);
65032	assert( nHeader==(int)(info.pPayload - pCell) );
65033	assert( info.nKey==pX->nKey );
	@@ -66549,11 +66711,11 @@
66549	** copied into the parent, because if the parent is page 1 then it will
66550	** by smaller than the child due to the database header, and so all the
66551	** free space needs to be up front.
66552	*/
66553	assert( nNew==1 \|\| CORRUPT_DB );
66554	rc = defragmentPage(apNew[0]);
66555	testcase( rc!=SQLITE_OK );
66556	assert( apNew[0]->nFree ==
66557	(get2byte(&apNew[0]->aData[5])-apNew[0]->cellOffset-apNew[0]->nCell*2)
66558	\|\| rc!=SQLITE_OK
66559	);
	@@ -71201,10 +71363,11 @@
71201	** Remember the SQL string for a prepared statement.
71202	*/
71203	SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe p, const char z, int n, int isPrepareV2){
71204	assert( isPrepareV2==1 \|\| isPrepareV2==0 );
71205	if( p==0 ) return;

71206	#if defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_ENABLE_SQLLOG)
71207	if( !isPrepareV2 ) return;
71208	#endif
71209	assert( p->zSql==0 );
71210	p->zSql = sqlite3DbStrNDup(p->db, z, n);
	@@ -71229,10 +71392,11 @@
71229	pB->pPrev = pTmp;
71230	zTmp = pA->zSql;
71231	pA->zSql = pB->zSql;
71232	pB->zSql = zTmp;
71233	pB->isPrepareV2 = pA->isPrepareV2;

71234	}
71235
71236	/*
71237	** Resize the Vdbe.aOp array so that it is at least nOp elements larger
71238	** than its current size. nOp is guaranteed to be less than or equal
	@@ -73753,17 +73917,17 @@
73753	** Then the internal cache might have been left in an inconsistent
73754	** state. We need to rollback the statement transaction, if there is
73755	** one, or the complete transaction if there is no statement transaction.
73756	*/
73757



73758	if( db->mallocFailed ){
73759	p->rc = SQLITE_NOMEM_BKPT;
73760	}
73761	closeAllCursors(p);
73762	if( p->magic!=VDBE_MAGIC_RUN ){
73763	return SQLITE_OK;
73764	}
73765	checkActiveVdbeCnt(db);
73766
73767	/* No commit or rollback needed if the program never started or if the
73768	** SQL statement does not read or write a database file. */
73769	if( p->pc>=0 && p->bIsReader ){
	@@ -74706,11 +74870,11 @@
74706	}
74707	assert( u<=pKeyInfo->nField + 1 );
74708	p->nField = u;
74709	}
74710
74711	#if SQLITE_DEBUG
74712	/*
74713	** This function compares two index or table record keys in the same way
74714	** as the sqlite3VdbeRecordCompare() routine. Unlike VdbeRecordCompare(),
74715	** this function deserializes and compares values using the
74716	** sqlite3VdbeSerialGet() and sqlite3MemCompare() functions. It is used
	@@ -74811,11 +74975,11 @@
74811	if( pKeyInfo->db->mallocFailed ) return 1;
74812	return 0;
74813	}
74814	#endif
74815
74816	#if SQLITE_DEBUG
74817	/*
74818	** Count the number of fields (a.k.a. columns) in the record given by
74819	** pKey,nKey. The verify that this count is less than or equal to the
74820	** limit given by pKeyInfo->nField + pKeyInfo->nXField.
74821	**
	@@ -75694,12 +75858,12 @@
75694	** to sqlite3_reoptimize() that re-preparing the statement may result
75695	** in a better query plan.
75696	*/
75697	SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe *v, int iVar){
75698	assert( iVar>0 );
75699	if( iVar>32 ){
75700	v->expmask = 0xffffffff;
75701	}else{
75702	v->expmask \|= ((u32)1 << (iVar-1));
75703	}
75704	}
75705
	@@ -75965,11 +76129,12 @@
75965	sqlite3_mutex_enter(mutex);
75966	for(i=0; i<p->nVar; i++){
75967	sqlite3VdbeMemRelease(&p->aVar[i]);
75968	p->aVar[i].flags = MEM_Null;
75969	}
75970	if( p->isPrepareV2 && p->expmask ){

75971	p->expired = 1;
75972	}
75973	sqlite3_mutex_leave(mutex);
75974	return rc;
75975	}
	@@ -77069,13 +77234,12 @@
77069	** parameter in the WHERE clause might influence the choice of query plan
77070	** for a statement, then the statement will be automatically recompiled,
77071	** as if there had been a schema change, on the first sqlite3_step() call
77072	** following any change to the bindings of that parameter.
77073	*/
77074	if( p->isPrepareV2 &&
77075	((i<32 && p->expmask & ((u32)1 << i)) \|\| p->expmask==0xffffffff)
77076	){
77077	p->expired = 1;
77078	}
77079	return SQLITE_OK;
77080	}
77081
	@@ -77334,14 +77498,16 @@
77334	Vdbe pFrom = (Vdbe)pFromStmt;
77335	Vdbe pTo = (Vdbe)pToStmt;
77336	if( pFrom->nVar!=pTo->nVar ){
77337	return SQLITE_ERROR;
77338	}
77339	if( pTo->isPrepareV2 && pTo->expmask ){

77340	pTo->expired = 1;
77341	}
77342	if( pFrom->isPrepareV2 && pFrom->expmask ){

77343	pFrom->expired = 1;
77344	}
77345	return sqlite3TransferBindings(pFromStmt, pToStmt);
77346	}
77347	#endif
	@@ -79658,39 +79824,39 @@
79658	if( pCtx->pOut != pOut ){
79659	pCtx->pOut = pOut;
79660	for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
79661	}
79662
79663	memAboutToChange(p, pCtx->pOut);
79664	#ifdef SQLITE_DEBUG
79665	for(i=0; i<pCtx->argc; i++){
79666	assert( memIsValid(pCtx->argv[i]) );
79667	REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
79668	}
79669	#endif
79670	MemSetTypeFlag(pCtx->pOut, MEM_Null);
79671	pCtx->fErrorOrAux = 0;
79672	(pCtx->pFunc->xSFunc)(pCtx, pCtx->argc, pCtx->argv);/ IMP: R-24505-23230 */
79673
79674	/* If the function returned an error, throw an exception */
79675	if( pCtx->fErrorOrAux ){
79676	if( pCtx->isError ){
79677	sqlite3VdbeError(p, "%s", sqlite3_value_text(pCtx->pOut));
79678	rc = pCtx->isError;
79679	}
79680	sqlite3VdbeDeleteAuxData(db, &p->pAuxData, pCtx->iOp, pOp->p1);
79681	if( rc ) goto abort_due_to_error;
79682	}
79683
79684	/* Copy the result of the function into register P3 */
79685	if( pOut->flags & (MEM_Str\|MEM_Blob) ){
79686	sqlite3VdbeChangeEncoding(pCtx->pOut, encoding);
79687	if( sqlite3VdbeMemTooBig(pCtx->pOut) ) goto too_big;
79688	}
79689
79690	REGISTER_TRACE(pOp->p3, pCtx->pOut);
79691	UPDATE_MAX_BLOBSIZE(pCtx->pOut);
79692	break;
79693	}
79694
79695	/* Opcode: BitAnd P1 P2 P3 * *
79696	** Synopsis: r[P3]=r[P1]&r[P2]
	@@ -80187,11 +80353,11 @@
80187	pKeyInfo = pOp->p4.pKeyInfo;
80188	assert( n>0 );
80189	assert( pKeyInfo!=0 );
80190	p1 = pOp->p1;
80191	p2 = pOp->p2;
80192	#if SQLITE_DEBUG
80193	if( aPermute ){
80194	int k, mx = 0;
80195	for(k=0; k<n; k++) if( aPermute[k]>mx ) mx = aPermute[k];
80196	assert( p1>0 && p1+mx<=(p->nMem+1 - p->nCursor)+1 );
80197	assert( p2>0 && p2+mx<=(p->nMem+1 - p->nCursor)+1 );
	@@ -82836,10 +83002,37 @@
82836	assert( pOp->p2==0 );
82837	}
82838	break;
82839	}
82840



























82841
82842	/* Opcode: SorterSort P1 P2 * * *
82843	**
82844	** After all records have been inserted into the Sorter object
82845	** identified by P1, invoke this opcode to actually do the sorting.
	@@ -83479,10 +83672,22 @@
83479	rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, flags);
83480	if( rc ) goto abort_due_to_error;
83481	pOut->u.i = pgno;
83482	break;
83483	}












83484
83485	/* Opcode: ParseSchema P1 * * P4 *
83486	**
83487	** Read and parse all entries from the SQLITE_MASTER table of database P1
83488	** that match the WHERE clause P4.
	@@ -83600,11 +83805,11 @@
83600	**
83601	** Do an analysis of the currently open database. Store in
83602	** register P1 the text of an error message describing any problems.
83603	** If no problems are found, store a NULL in register P1.
83604	**
83605	** The register P3 contains the maximum number of allowed errors.
83606	** At most reg(P3) errors will be reported.
83607	** In other words, the analysis stops as soon as reg(P1) errors are
83608	** seen. Reg(P1) is updated with the number of errors remaining.
83609	**
83610	** The root page numbers of all tables in the database are integers
	@@ -83633,18 +83838,18 @@
83633	assert( (pnErr->flags & (MEM_Str\|MEM_Blob))==0 );
83634	pIn1 = &aMem[pOp->p1];
83635	assert( pOp->p5<db->nDb );
83636	assert( DbMaskTest(p->btreeMask, pOp->p5) );
83637	z = sqlite3BtreeIntegrityCheck(db->aDb[pOp->p5].pBt, aRoot, nRoot,
83638	(int)pnErr->u.i, &nErr);
83639	pnErr->u.i -= nErr;
83640	sqlite3VdbeMemSetNull(pIn1);
83641	if( nErr==0 ){
83642	assert( z==0 );
83643	}else if( z==0 ){
83644	goto no_mem;
83645	}else{

83646	sqlite3VdbeMemSetStr(pIn1, z, -1, SQLITE_UTF8, sqlite3_free);
83647	}
83648	UPDATE_MAX_BLOBSIZE(pIn1);
83649	sqlite3VdbeChangeEncoding(pIn1, encoding);
83650	break;
	@@ -88787,15 +88992,15 @@
88787	** The return value from the callback should be one of the WRC_*
88788	** constants to specify how to proceed with the walk.
88789	**
88790	** WRC_Continue Continue descending down the tree.
88791	**
88792	** WRC_Prune Do not descend into child nodes. But allow
88793	** the walk to continue with sibling nodes.
88794	**
88795	** WRC_Abort Do no more callbacks. Unwind the stack and
88796	** return the top-level walk call.
88797	**
88798	** The return value from this routine is WRC_Abort to abandon the tree walk
88799	** and WRC_Continue to continue.
88800	*/
88801	static SQLITE_NOINLINE int walkExpr(Walker pWalker, Expr pExpr){
	@@ -89153,11 +89358,12 @@
89153	}
89154	}
89155	}
89156
89157	/* Start at the inner-most context and move outward until a match is found */
89158	while( pNC && cnt==0 ){

89159	ExprList *pEList;
89160	SrcList *pSrcList = pNC->pSrcList;
89161
89162	if( pSrcList ){
89163	for(i=0, pItem=pSrcList->a; i<pSrcList->nSrc; i++, pItem++){
	@@ -89338,15 +89544,15 @@
89338	}
89339
89340	/* Advance to the next name context. The loop will exit when either
89341	** we have a match (cnt>0) or when we run out of name contexts.
89342	*/
89343	if( cnt==0 ){
89344	pNC = pNC->pNext;
89345	nSubquery++;
89346	}
89347	}
89348
89349	/*
89350	** If X and Y are NULL (in other words if only the column name Z is
89351	** supplied) and the value of Z is enclosed in double-quotes, then
89352	** Z is a string literal if it doesn't match any column names. In that
	@@ -89532,37 +89738,42 @@
89532	break;
89533	}
89534	#endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT)
89535	&& !defined(SQLITE_OMIT_SUBQUERY) */
89536
89537	/* A lone identifier is the name of a column.
89538	*/
89539	case TK_ID: {
89540	return lookupName(pParse, 0, 0, pExpr->u.zToken, pNC, pExpr);
89541	}
89542
89543	/* A table name and column name: ID.ID
89544	** Or a database, table and column: ID.ID.ID




89545	*/

89546	case TK_DOT: {
89547	const char *zColumn;
89548	const char *zTable;
89549	const char *zDb;
89550	Expr *pRight;
89551
89552	/* if( pSrcList==0 ) break; */
89553	notValid(pParse, pNC, "the \".\" operator", NC_IdxExpr);
89554	pRight = pExpr->pRight;
89555	if( pRight->op==TK_ID ){
89556	zDb = 0;
89557	zTable = pExpr->pLeft->u.zToken;
89558	zColumn = pRight->u.zToken;
89559	}else{
89560	assert( pRight->op==TK_DOT );
89561	zDb = pExpr->pLeft->u.zToken;
89562	zTable = pRight->pLeft->u.zToken;
89563	zColumn = pRight->pRight->u.zToken;








89564	}
89565	return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr);
89566	}
89567
89568	/* Resolve function names
	@@ -92833,11 +93044,11 @@
92833	int nVal = sqlite3ExprVectorSize(pLeft);
92834	Select *pSelect = (pExpr->flags & EP_xIsSelect) ? pExpr->x.pSelect : 0;
92835	char *zRet;
92836
92837	assert( pExpr->op==TK_IN );
92838	zRet = sqlite3DbMallocZero(pParse->db, nVal+1);
92839	if( zRet ){
92840	int i;
92841	for(i=0; i<nVal; i++){
92842	Expr *pA = sqlite3VectorFieldSubexpr(pLeft, i);
92843	char a = sqlite3ExprAffinity(pA);
	@@ -93738,11 +93949,11 @@
93738	** Clear all column cache entries.
93739	*/
93740	SQLITE_PRIVATE void sqlite3ExprCacheClear(Parse *pParse){
93741	int i;
93742
93743	#if SQLITE_DEBUG
93744	if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
93745	printf("CLEAR\n");
93746	}
93747	#endif
93748	for(i=0; i<pParse->nColCache; i++){
	@@ -95145,10 +95356,21 @@
95145	if( pA->a[i].sortOrder!=pB->a[i].sortOrder ) return 1;
95146	if( sqlite3ExprCompare(pExprA, pExprB, iTab) ) return 1;
95147	}
95148	return 0;
95149	}











95150
95151	/*
95152	** Return true if we can prove the pE2 will always be true if pE1 is
95153	** true. Return false if we cannot complete the proof or if pE2 might
95154	** be false. Examples:
	@@ -96698,10 +96920,11 @@
96698	Stat4Sample current; /* Current row as a Stat4Sample */
96699	u32 iPrn; /* Pseudo-random number used for sampling */
96700	Stat4Sample aBest; / Array of nCol best samples */
96701	int iMin; /* Index in a[] of entry with minimum score */
96702	int nSample; /* Current number of samples */

96703	int iGet; /* Index of current sample accessed by stat_get() */
96704	Stat4Sample a; / Array of mxSample Stat4Sample objects */
96705	sqlite3 db; / Database connection, for malloc() */
96706	};
96707
	@@ -96962,10 +97185,17 @@
96962	int i;
96963
96964	assert( IsStat4 \|\| nEqZero==0 );
96965
96966	#ifdef SQLITE_ENABLE_STAT4







96967	if( pNew->isPSample==0 ){
96968	Stat4Sample *pUpgrade = 0;
96969	assert( pNew->anEq[pNew->iCol]>0 );
96970
96971	/* This sample is being added because the prefix that ends in column
	@@ -97059,16 +97289,26 @@
97059	if( p->nSample<p->mxSample \|\| sampleIsBetter(p, pBest, &p->a[p->iMin]) ){
97060	sampleInsert(p, pBest, i);
97061	}
97062	}
97063
97064	/* Update the anEq[] fields of any samples already collected. */

97065	for(i=p->nSample-1; i>=0; i--){
97066	int j;
97067	for(j=iChng; j<p->nCol; j++){
97068	if( p->a[i].anEq[j]==0 ) p->a[i].anEq[j] = p->current.anEq[j];








97069	}

97070	}
97071	#endif
97072
97073	#if defined(SQLITE_ENABLE_STAT3) && !defined(SQLITE_ENABLE_STAT4)
97074	if( iChng==0 ){
	@@ -97778,44 +98018,32 @@
97778	/* Form 1: Analyze everything */
97779	for(i=0; i<db->nDb; i++){
97780	if( i==1 ) continue; /* Do not analyze the TEMP database */
97781	analyzeDatabase(pParse, i);
97782	}
97783	}else if( pName2->n==0 ){
97784	/* Form 2: Analyze the database or table named */
97785	iDb = sqlite3FindDb(db, pName1);
97786	if( iDb>=0 ){
97787	analyzeDatabase(pParse, iDb);
97788	}else{
97789	z = sqlite3NameFromToken(db, pName1);
97790	if( z ){
97791	if( (pIdx = sqlite3FindIndex(db, z, 0))!=0 ){
97792	analyzeTable(pParse, pIdx->pTable, pIdx);
97793	}else if( (pTab = sqlite3LocateTable(pParse, 0, z, 0))!=0 ){
97794	analyzeTable(pParse, pTab, 0);
97795	}
97796	sqlite3DbFree(db, z);
97797	}
97798	}
97799	}else{
97800	/* Form 3: Analyze the fully qualified table name */
97801	iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName);
97802	if( iDb>=0 ){
97803	zDb = db->aDb[iDb].zDbSName;
97804	z = sqlite3NameFromToken(db, pTableName);
97805	if( z ){
97806	if( (pIdx = sqlite3FindIndex(db, z, zDb))!=0 ){
97807	analyzeTable(pParse, pIdx->pTable, pIdx);
97808	}else if( (pTab = sqlite3LocateTable(pParse, 0, z, zDb))!=0 ){
97809	analyzeTable(pParse, pTab, 0);
97810	}
97811	sqlite3DbFree(db, z);
97812	}
97813	}
97814	}
97815	v = sqlite3GetVdbe(pParse);
97816	if( v ) sqlite3VdbeAddOp0(v, OP_Expire);

97817	}
97818
97819	/*
97820	** Used to pass information from the analyzer reader through to the
97821	** callback routine.
	@@ -97940,19 +98168,24 @@
97940	}
97941	aiRowEst = pIndex->aiRowEst;
97942	#endif
97943	pIndex->bUnordered = 0;
97944	decodeIntArray((char*)z, nCol, aiRowEst, pIndex->aiRowLogEst, pIndex);
97945	if( pIndex->pPartIdxWhere==0 ) pTable->nRowLogEst = pIndex->aiRowLogEst[0];




97946	}else{
97947	Index fakeIdx;
97948	fakeIdx.szIdxRow = pTable->szTabRow;
97949	#ifdef SQLITE_ENABLE_COSTMULT
97950	fakeIdx.pTable = pTable;
97951	#endif
97952	decodeIntArray((char*)z, 1, 0, &pTable->nRowLogEst, &fakeIdx);
97953	pTable->szTabRow = fakeIdx.szIdxRow;

97954	}
97955
97956	return 0;
97957	}
97958
	@@ -98243,19 +98476,24 @@
98243	SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
98244	analysisInfo sInfo;
98245	HashElem *i;
98246	char *zSql;
98247	int rc = SQLITE_OK;

98248
98249	assert( iDb>=0 && iDb<db->nDb );
98250	assert( db->aDb[iDb].pBt!=0 );
98251
98252	/* Clear any prior statistics */
98253	assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
98254	for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){




98255	Index *pIdx = sqliteHashData(i);
98256	pIdx->aiRowLogEst[0] = 0;
98257	#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
98258	sqlite3DeleteIndexSamples(db, pIdx);
98259	pIdx->aSample = 0;
98260	#endif
98261	}
	@@ -98274,23 +98512,23 @@
98274	}
98275	}
98276
98277	/* Set appropriate defaults on all indexes not in the sqlite_stat1 table */
98278	assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
98279	for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){
98280	Index *pIdx = sqliteHashData(i);
98281	if( pIdx->aiRowLogEst[0]==0 ) sqlite3DefaultRowEst(pIdx);
98282	}
98283
98284	/* Load the statistics from the sqlite_stat4 table. */
98285	#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
98286	if( rc==SQLITE_OK && OptimizationEnabled(db, SQLITE_Stat34) ){
98287	db->lookaside.bDisable++;
98288	rc = loadStat4(db, sInfo.zDatabase);
98289	db->lookaside.bDisable--;
98290	}
98291	for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){
98292	Index *pIdx = sqliteHashData(i);
98293	sqlite3_free(pIdx->aiRowEst);
98294	pIdx->aiRowEst = 0;
98295	}
98296	#endif
	@@ -100271,10 +100509,11 @@
100271	SQLITE_PRIVATE void sqlite3AddNotNull(Parse *pParse, int onError){
100272	Table *p;
100273	p = pParse->pNewTable;
100274	if( p==0 \|\| NEVER(p->nCol<1) ) return;
100275	p->aCol[p->nCol-1].notNull = (u8)onError;

100276	}
100277
100278	/*
100279	** Scan the column type name zType (length nType) and return the
100280	** associated affinity type.
	@@ -102609,10 +102848,13 @@
102609	/* 10, 9, 8, 7, 6 */
102610	LogEst aVal[] = { 33, 32, 30, 28, 26 };
102611	LogEst *a = pIdx->aiRowLogEst;
102612	int nCopy = MIN(ArraySize(aVal), pIdx->nKeyCol);
102613	int i;



102614
102615	/* Set the first entry (number of rows in the index) to the estimated
102616	** number of rows in the table, or half the number of rows in the table
102617	** for a partial index. But do not let the estimate drop below 10. */
102618	a[0] = pIdx->pTable->nRowLogEst;
	@@ -109798,10 +110040,13 @@
109798	VdbeComment((v, "%s", iField<0 ? "rowid" : pTab->aCol[iField].zName));
109799	}
109800	}
109801	sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn, aRegIdx[ix]);
109802	VdbeComment((v, "for %s", pIdx->zName));



109803
109804	/* In an UPDATE operation, if this index is the PRIMARY KEY index
109805	** of a WITHOUT ROWID table and there has been no change the
109806	** primary key, then no collision is possible. The collision detection
109807	** logic below can all be skipped. */
	@@ -109953,12 +110198,15 @@
109953
109954	/* Records with omitted columns are only allowed for schema format
109955	** version 2 and later (SQLite version 3.1.4, 2005-02-20). */
109956	if( pTab->pSchema->file_format<2 ) return;
109957
109958	for(i=pTab->nCol; i>1 && pTab->aCol[i-1].pDflt==0; i--){}
109959	sqlite3VdbeChangeP5(v, i);



109960	}
109961	#endif
109962
109963	/*
109964	** This routine generates code to finish the INSERT or UPDATE operation
	@@ -110244,11 +110492,11 @@
110244	}
110245	if( sqlite3TriggerList(pParse, pDest) ){
110246	return 0; /* tab1 must not have triggers */
110247	}
110248	#ifndef SQLITE_OMIT_VIRTUALTABLE
110249	if( pDest->tabFlags & TF_Virtual ){
110250	return 0; /* tab1 must not be a virtual table */
110251	}
110252	#endif
110253	if( onError==OE_Default ){
110254	if( pDest->iPKey>=0 ) onError = pDest->keyConf;
	@@ -110306,11 +110554,11 @@
110306	}
110307	if( HasRowid(pDest)!=HasRowid(pSrc) ){
110308	return 0; /* source and destination must both be WITHOUT ROWID or not */
110309	}
110310	#ifndef SQLITE_OMIT_VIRTUALTABLE
110311	if( pSrc->tabFlags & TF_Virtual ){
110312	return 0; /* tab2 must not be a virtual table */
110313	}
110314	#endif
110315	if( pSrc->pSelect ){
110316	return 0; /* tab2 may not be a view */
	@@ -110603,11 +110851,11 @@
110603	/* Invoke the callback function if required */
110604	if( xCallback && (SQLITE_ROW==rc \|\|
110605	(SQLITE_DONE==rc && !callbackIsInit
110606	&& db->flags&SQLITE_NullCallback)) ){
110607	if( !callbackIsInit ){
110608	azCols = sqlite3DbMallocZero(db, 2nColsizeof(const char*) + 1);
110609	if( azCols==0 ){
110610	goto exec_out;
110611	}
110612	for(i=0; i<nCol; i++){
110613	azCols[i] = (char *)sqlite3_column_name(pStmt, i);
	@@ -110624,10 +110872,11 @@
110624	if( !azVals[i] && sqlite3_column_type(pStmt, i)!=SQLITE_NULL ){
110625	sqlite3OomFault(db);
110626	goto exec_out;
110627	}
110628	}

110629	}
110630	if( xCallback(pArg, nCol, azVals, azCols) ){
110631	/* EVIDENCE-OF: R-38229-40159 If the callback function to
110632	** sqlite3_exec() returns non-zero, then sqlite3_exec() will
110633	** return SQLITE_ABORT. */
	@@ -112094,15 +112343,15 @@
112094	#define PragTyp_JOURNAL_SIZE_LIMIT 20
112095	#define PragTyp_LOCK_PROXY_FILE 21
112096	#define PragTyp_LOCKING_MODE 22
112097	#define PragTyp_PAGE_COUNT 23
112098	#define PragTyp_MMAP_SIZE 24
112099	#define PragTyp_PAGE_SIZE 25
112100	#define PragTyp_SECURE_DELETE 26
112101	#define PragTyp_SHRINK_MEMORY 27
112102	#define PragTyp_SOFT_HEAP_LIMIT 28
112103	#define PragTyp_STATS 29
112104	#define PragTyp_SYNCHRONOUS 30
112105	#define PragTyp_TABLE_INFO 31
112106	#define PragTyp_TEMP_STORE 32
112107	#define PragTyp_TEMP_STORE_DIRECTORY 33
112108	#define PragTyp_THREADS 34
	@@ -112112,10 +112361,11 @@
112112	#define PragTyp_HEXKEY 38
112113	#define PragTyp_KEY 39
112114	#define PragTyp_REKEY 40
112115	#define PragTyp_LOCK_STATUS 41
112116	#define PragTyp_PARSER_TRACE 42

112117
112118	/* Property flags associated with various pragma. */
112119	#define PragFlg_NeedSchema 0x01 /* Force schema load before running */
112120	#define PragFlg_NoColumns 0x02 /* OP_ResultRow called with zero columns */
112121	#define PragFlg_NoColumns1 0x04 /* zero columns if RHS argument is present */
	@@ -112135,51 +112385,52 @@
112135	/* 2 */ "name",
112136	/* 3 */ "type",
112137	/* 4 */ "notnull",
112138	/* 5 */ "dflt_value",
112139	/* 6 */ "pk",
112140	/* 7 / "table", / Used by: stats */
112141	/* 8 */ "index",
112142	/* 9 */ "width",
112143	/* 10 */ "height",
112144	/* 11 / "seqno", / Used by: index_info */
112145	/* 12 */ "cid",
112146	/* 13 */ "name",
112147	/* 14 / "seqno", / Used by: index_xinfo */
112148	/* 15 */ "cid",
112149	/* 16 */ "name",
112150	/* 17 */ "desc",
112151	/* 18 */ "coll",
112152	/* 19 */ "key",
112153	/* 20 / "seq", / Used by: index_list */
112154	/* 21 */ "name",
112155	/* 22 */ "unique",
112156	/* 23 */ "origin",
112157	/* 24 */ "partial",
112158	/* 25 / "seq", / Used by: database_list */
112159	/* 26 */ "name",
112160	/* 27 */ "file",
112161	/* 28 / "seq", / Used by: collation_list */
112162	/* 29 */ "name",
112163	/* 30 / "id", / Used by: foreign_key_list */
112164	/* 31 */ "seq",
112165	/* 32 */ "table",
112166	/* 33 */ "from",
112167	/* 34 */ "to",
112168	/* 35 */ "on_update",
112169	/* 36 */ "on_delete",
112170	/* 37 */ "match",
112171	/* 38 / "table", / Used by: foreign_key_check */
112172	/* 39 */ "rowid",
112173	/* 40 */ "parent",
112174	/* 41 */ "fkid",
112175	/* 42 / "busy", / Used by: wal_checkpoint */
112176	/* 43 */ "log",
112177	/* 44 */ "checkpointed",
112178	/* 45 / "timeout", / Used by: busy_timeout */
112179	/* 46 / "database", / Used by: lock_status */
112180	/* 47 */ "status",

112181	};
112182
112183	/* Definitions of all built-in pragmas */
112184	typedef struct PragmaName {
112185	const char const zName; / Name of pragma */
	@@ -112221,11 +112472,11 @@
112221	#endif
112222	#endif
112223	{/* zName: */ "busy_timeout",
112224	/* ePragTyp: */ PragTyp_BUSY_TIMEOUT,
112225	/* ePragFlg: */ PragFlg_Result0,
112226	/* ColNames: */ 45, 1,
112227	/* iArg: */ 0 },
112228	#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
112229	{/* zName: */ "cache_size",
112230	/* ePragTyp: */ PragTyp_CACHE_SIZE,
112231	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result0\|PragFlg_SchemaReq\|PragFlg_NoColumns1,
	@@ -112258,11 +112509,11 @@
112258	#endif
112259	#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
112260	{/* zName: */ "collation_list",
112261	/* ePragTyp: */ PragTyp_COLLATION_LIST,
112262	/* ePragFlg: */ PragFlg_Result0,
112263	/* ColNames: */ 28, 2,
112264	/* iArg: */ 0 },
112265	#endif
112266	#if !defined(SQLITE_OMIT_COMPILEOPTION_DIAGS)
112267	{/* zName: */ "compile_options",
112268	/* ePragTyp: */ PragTyp_COMPILE_OPTIONS,
	@@ -112293,11 +112544,11 @@
112293	#endif
112294	#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
112295	{/* zName: */ "database_list",
112296	/* ePragTyp: */ PragTyp_DATABASE_LIST,
112297	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result0,
112298	/* ColNames: */ 25, 3,
112299	/* iArg: */ 0 },
112300	#endif
112301	#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED)
112302	{/* zName: */ "default_cache_size",
112303	/* ePragTyp: */ PragTyp_DEFAULT_CACHE_SIZE,
	@@ -112330,18 +112581,18 @@
112330	#endif
112331	#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
112332	{/* zName: */ "foreign_key_check",
112333	/* ePragTyp: */ PragTyp_FOREIGN_KEY_CHECK,
112334	/* ePragFlg: */ PragFlg_NeedSchema,
112335	/* ColNames: */ 38, 4,
112336	/* iArg: */ 0 },
112337	#endif
112338	#if !defined(SQLITE_OMIT_FOREIGN_KEY)
112339	{/* zName: */ "foreign_key_list",
112340	/* ePragTyp: */ PragTyp_FOREIGN_KEY_LIST,
112341	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result1\|PragFlg_SchemaOpt,
112342	/* ColNames: */ 30, 8,
112343	/* iArg: */ 0 },
112344	#endif
112345	#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
112346	#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
112347	{/* zName: */ "foreign_keys",
	@@ -112400,21 +112651,21 @@
112400	#endif
112401	#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
112402	{/* zName: */ "index_info",
112403	/* ePragTyp: */ PragTyp_INDEX_INFO,
112404	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result1\|PragFlg_SchemaOpt,
112405	/* ColNames: */ 11, 3,
112406	/* iArg: */ 0 },
112407	{/* zName: */ "index_list",
112408	/* ePragTyp: */ PragTyp_INDEX_LIST,
112409	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result1\|PragFlg_SchemaOpt,
112410	/* ColNames: */ 20, 5,
112411	/* iArg: */ 0 },
112412	{/* zName: */ "index_xinfo",
112413	/* ePragTyp: */ PragTyp_INDEX_INFO,
112414	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result1\|PragFlg_SchemaOpt,
112415	/* ColNames: */ 14, 6,
112416	/* iArg: */ 1 },
112417	#endif
112418	#if !defined(SQLITE_OMIT_INTEGRITY_CHECK)
112419	{/* zName: */ "integrity_check",
112420	/* ePragTyp: */ PragTyp_INTEGRITY_CHECK,
	@@ -112457,11 +112708,11 @@
112457	#endif
112458	#if defined(SQLITE_DEBUG) \|\| defined(SQLITE_TEST)
112459	{/* zName: */ "lock_status",
112460	/* ePragTyp: */ PragTyp_LOCK_STATUS,
112461	/* ePragFlg: */ PragFlg_Result0,
112462	/* ColNames: */ 46, 2,
112463	/* iArg: */ 0 },
112464	#endif
112465	#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
112466	{/* zName: */ "locking_mode",
112467	/* ePragTyp: */ PragTyp_LOCKING_MODE,
	@@ -112476,10 +112727,17 @@
112476	{/* zName: */ "mmap_size",
112477	/* ePragTyp: */ PragTyp_MMAP_SIZE,
112478	/* ePragFlg: */ 0,
112479	/* ColNames: */ 0, 0,
112480	/* iArg: */ 0 },







112481	{/* zName: */ "page_count",
112482	/* ePragTyp: */ PragTyp_PAGE_COUNT,
112483	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result0\|PragFlg_SchemaReq,
112484	/* ColNames: */ 0, 0,
112485	/* iArg: */ 0 },
	@@ -112574,15 +112832,15 @@
112574	/* ePragFlg: */ PragFlg_Result0\|PragFlg_NoColumns1,
112575	/* ColNames: */ 0, 0,
112576	/* iArg: */ SQLITE_SqlTrace },
112577	#endif
112578	#endif
112579	#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
112580	{/* zName: */ "stats",
112581	/* ePragTyp: */ PragTyp_STATS,
112582	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result0\|PragFlg_SchemaReq,
112583	/* ColNames: */ 7, 4,
112584	/* iArg: */ 0 },
112585	#endif
112586	#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
112587	{/* zName: */ "synchronous",
112588	/* ePragTyp: */ PragTyp_SYNCHRONOUS,
	@@ -112657,11 +112915,11 @@
112657	/* ColNames: */ 0, 0,
112658	/* iArg: */ 0 },
112659	{/* zName: */ "wal_checkpoint",
112660	/* ePragTyp: */ PragTyp_WAL_CHECKPOINT,
112661	/* ePragFlg: */ PragFlg_NeedSchema,
112662	/* ColNames: */ 42, 3,
112663	/* iArg: */ 0 },
112664	#endif
112665	#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
112666	{/* zName: */ "writable_schema",
112667	/* ePragTyp: */ PragTyp_FLAG,
	@@ -112668,11 +112926,11 @@
112668	/* ePragFlg: */ PragFlg_Result0\|PragFlg_NoColumns1,
112669	/* ColNames: */ 0, 0,
112670	/* iArg: */ SQLITE_WriteSchema\|SQLITE_RecoveryMode },
112671	#endif
112672	};
112673	/* Number of pragmas: 60 on by default, 73 total. */
112674
112675	/************ End of pragma.h ********************************************/
112676	/************ Continuing where we left off in pragma.c *******************/
112677
112678	/*
	@@ -112937,10 +113195,26 @@
112937	lwr = mid + 1;
112938	}
112939	}
112940	return lwr>upr ? 0 : &aPragmaName[mid];
112941	}
















112942
112943	/*
112944	** Process a pragma statement.
112945	**
112946	** Pragmas are of this form:
	@@ -113741,33 +114015,37 @@
113741	}
113742	}
113743	}
113744	break;
113745

113746	case PragTyp_STATS: {
113747	Index *pIdx;
113748	HashElem *i;
113749	pParse->nMem = 4;
113750	sqlite3CodeVerifySchema(pParse, iDb);
113751	for(i=sqliteHashFirst(&pDb->pSchema->tblHash); i; i=sqliteHashNext(i)){
113752	Table *pTab = sqliteHashData(i);
113753	sqlite3VdbeMultiLoad(v, 1, "ssii",
113754	pTab->zName,
113755	0,
113756	pTab->szTabRow,
113757	pTab->nRowLogEst);
113758	sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 4);

113759	for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
113760	sqlite3VdbeMultiLoad(v, 2, "sii",
113761	pIdx->zName,
113762	pIdx->szIdxRow,
113763	pIdx->aiRowLogEst[0]);
113764	sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 4);

113765	}
113766	}
113767	}
113768	break;

113769
113770	case PragTyp_INDEX_INFO: if( zRight ){
113771	Index *pIdx;
113772	Table *pTab;
113773	pIdx = sqlite3FindIndex(db, zRight, zDb);
	@@ -114020,13 +114298,21 @@
114020	#ifndef SQLITE_INTEGRITY_CHECK_ERROR_MAX
114021	# define SQLITE_INTEGRITY_CHECK_ERROR_MAX 100
114022	#endif
114023
114024	#ifndef SQLITE_OMIT_INTEGRITY_CHECK
114025	/* Pragma "quick_check" is reduced version of







114026	** integrity_check designed to detect most database corruption
114027	** without most of the overhead of a full integrity-check.

114028	*/
114029	case PragTyp_INTEGRITY_CHECK: {
114030	int i, j, addr, mxErr;
114031
114032	int isQuick = (sqlite3Tolower(zLeft[0])=='q');
	@@ -114053,11 +114339,11 @@
114053	sqlite3GetInt32(zRight, &mxErr);
114054	if( mxErr<=0 ){
114055	mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX;
114056	}
114057	}
114058	sqlite3VdbeAddOp2(v, OP_Integer, mxErr, 1); /* reg[1] holds errors left */
114059
114060	/* Do an integrity check on each database file */
114061	for(i=0; i<db->nDb; i++){
114062	HashElem *x;
114063	Hash *pTbls;
	@@ -114068,14 +114354,10 @@
114068
114069	if( OMIT_TEMPDB && i==1 ) continue;
114070	if( iDb>=0 && i!=iDb ) continue;
114071
114072	sqlite3CodeVerifySchema(pParse, i);
114073	addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Halt if out of errors */
114074	VdbeCoverage(v);
114075	sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
114076	sqlite3VdbeJumpHere(v, addr);
114077
114078	/* Do an integrity check of the B-Tree
114079	**
114080	** Begin by finding the root pages numbers
114081	** for all tables and indices in the database.
	@@ -114111,29 +114393,30 @@
114111	sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
114112	sqlite3MPrintf(db, "* in database %s *\n", db->aDb[i].zDbSName),
114113	P4_DYNAMIC);
114114	sqlite3VdbeAddOp3(v, OP_Move, 2, 4, 1);
114115	sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 2);
114116	sqlite3VdbeAddOp2(v, OP_ResultRow, 2, 1);
114117	sqlite3VdbeJumpHere(v, addr);
114118
114119	/* Make sure all the indices are constructed correctly.
114120	*/
114121	for(x=sqliteHashFirst(pTbls); x && !isQuick; x=sqliteHashNext(x)){
114122	Table *pTab = sqliteHashData(x);
114123	Index pIdx, pPk;
114124	Index *pPrior = 0;
114125	int loopTop;
114126	int iDataCur, iIdxCur;
114127	int r1 = -1;
114128
114129	if( pTab->pIndex==0 ) continue;





114130	pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
114131	addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Stop if out of errors */
114132	VdbeCoverage(v);
114133	sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
114134	sqlite3VdbeJumpHere(v, addr);
114135	sqlite3ExprCacheClear(pParse);
114136	sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenRead, 0,
114137	1, 0, &iDataCur, &iIdxCur);
114138	sqlite3VdbeAddOp2(v, OP_Integer, 0, 7);
114139	for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
	@@ -114144,28 +114427,46 @@
114144	sqlite3VdbeAddOp2(v, OP_Rewind, iDataCur, 0); VdbeCoverage(v);
114145	loopTop = sqlite3VdbeAddOp2(v, OP_AddImm, 7, 1);
114146	/* Verify that all NOT NULL columns really are NOT NULL */
114147	for(j=0; j<pTab->nCol; j++){
114148	char *zErr;
114149	int jmp2, jmp3;
114150	if( j==pTab->iPKey ) continue;
114151	if( pTab->aCol[j].notNull==0 ) continue;
114152	sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, j, 3);
114153	sqlite3VdbeChangeP5(v, OPFLAG_TYPEOFARG);
114154	jmp2 = sqlite3VdbeAddOp1(v, OP_NotNull, 3); VdbeCoverage(v);
114155	sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1); /* Decrement error limit */
114156	zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName,
114157	pTab->aCol[j].zName);
114158	sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
114159	sqlite3VdbeAddOp2(v, OP_ResultRow, 3, 1);
114160	jmp3 = sqlite3VdbeAddOp1(v, OP_IfPos, 1); VdbeCoverage(v);
114161	sqlite3VdbeAddOp0(v, OP_Halt);
114162	sqlite3VdbeJumpHere(v, jmp2);
114163	sqlite3VdbeJumpHere(v, jmp3);





















114164	}
114165	/* Validate index entries for the current row */
114166	for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
114167	int jmp2, jmp3, jmp4, jmp5;
114168	int ckUniq = sqlite3VdbeMakeLabel(v);
114169	if( pPk==pIdx ) continue;
114170	r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 0, &jmp3,
114171	pPrior, r1);
	@@ -114172,20 +114473,17 @@
114172	pPrior = pIdx;
114173	sqlite3VdbeAddOp2(v, OP_AddImm, 8+j, 1); /* increment entry count */
114174	/* Verify that an index entry exists for the current table row */
114175	jmp2 = sqlite3VdbeAddOp4Int(v, OP_Found, iIdxCur+j, ckUniq, r1,
114176	pIdx->nColumn); VdbeCoverage(v);
114177	sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1); /* Decrement error limit */
114178	sqlite3VdbeLoadString(v, 3, "row ");
114179	sqlite3VdbeAddOp3(v, OP_Concat, 7, 3, 3);
114180	sqlite3VdbeLoadString(v, 4, " missing from index ");
114181	sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3);
114182	jmp5 = sqlite3VdbeLoadString(v, 4, pIdx->zName);
114183	sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3);
114184	sqlite3VdbeAddOp2(v, OP_ResultRow, 3, 1);
114185	jmp4 = sqlite3VdbeAddOp1(v, OP_IfPos, 1); VdbeCoverage(v);
114186	sqlite3VdbeAddOp0(v, OP_Halt);
114187	sqlite3VdbeJumpHere(v, jmp2);
114188	/* For UNIQUE indexes, verify that only one entry exists with the
114189	** current key. The entry is unique if (1) any column is NULL
114190	** or (2) the next entry has a different key */
114191	if( IsUniqueIndex(pIdx) ){
	@@ -114202,11 +114500,10 @@
114202	jmp6 = sqlite3VdbeAddOp1(v, OP_Next, iIdxCur+j); VdbeCoverage(v);
114203	sqlite3VdbeGoto(v, uniqOk);
114204	sqlite3VdbeJumpHere(v, jmp6);
114205	sqlite3VdbeAddOp4Int(v, OP_IdxGT, iIdxCur+j, uniqOk, r1,
114206	pIdx->nKeyCol); VdbeCoverage(v);
114207	sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1); /* Decrement error limit */
114208	sqlite3VdbeLoadString(v, 3, "non-unique entry in index ");
114209	sqlite3VdbeGoto(v, jmp5);
114210	sqlite3VdbeResolveLabel(v, uniqOk);
114211	}
114212	sqlite3VdbeJumpHere(v, jmp4);
	@@ -114213,40 +114510,39 @@
114213	sqlite3ResolvePartIdxLabel(pParse, jmp3);
114214	}
114215	sqlite3VdbeAddOp2(v, OP_Next, iDataCur, loopTop); VdbeCoverage(v);
114216	sqlite3VdbeJumpHere(v, loopTop-1);
114217	#ifndef SQLITE_OMIT_BTREECOUNT
114218	sqlite3VdbeLoadString(v, 2, "wrong # of entries in index ");
114219	for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
114220	if( pPk==pIdx ) continue;
114221	addr = sqlite3VdbeCurrentAddr(v);
114222	sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr+2); VdbeCoverage(v);
114223	sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
114224	sqlite3VdbeAddOp2(v, OP_Count, iIdxCur+j, 3);
114225	sqlite3VdbeAddOp3(v, OP_Eq, 8+j, addr+8, 3); VdbeCoverage(v);
114226	sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
114227	sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1);
114228	sqlite3VdbeLoadString(v, 3, pIdx->zName);
114229	sqlite3VdbeAddOp3(v, OP_Concat, 3, 2, 7);
114230	sqlite3VdbeAddOp2(v, OP_ResultRow, 7, 1);
114231	}
114232	#endif /* SQLITE_OMIT_BTREECOUNT */
114233	}
114234	}
114235	{
114236	static const int iLn = VDBE_OFFSET_LINENO(2);
114237	static const VdbeOpList endCode[] = {
114238	{ OP_AddImm, 1, 0, 0}, /* 0 */
114239	{ OP_If, 1, 4, 0}, /* 1 */
114240	{ OP_String8, 0, 3, 0}, /* 2 */
114241	{ OP_ResultRow, 3, 1, 0}, /* 3 */
114242	};
114243	VdbeOp *aOp;
114244
114245	aOp = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode, iLn);
114246	if( aOp ){
114247	aOp[0].p2 = -mxErr;
114248	aOp[2].p4type = P4_STATIC;
114249	aOp[2].p4.z = "ok";
114250	}
114251	}
114252	}
	@@ -114466,10 +114762,122 @@
114466	*/
114467	case PragTyp_SHRINK_MEMORY: {
114468	sqlite3_db_release_memory(db);
114469	break;
114470	}
















































































































114471
114472	/*
114473	** PRAGMA busy_timeout
114474	** PRAGMA busy_timeout = N
114475	**
	@@ -123782,12 +124190,29 @@
123782	** transient would cause the database file to appear to be deleted
123783	** following reboot.
123784	*/
123785	SQLITE_PRIVATE void sqlite3Vacuum(Parse pParse, Token pNm){
123786	Vdbe *v = sqlite3GetVdbe(pParse);
123787	int iDb = pNm ? sqlite3TwoPartName(pParse, pNm, pNm, &pNm) : 0;
123788	if( v && (iDb>=2 \|\| iDb==0) ){

















123789	sqlite3VdbeAddOp1(v, OP_Vacuum, iDb);
123790	sqlite3VdbeUsesBtree(v, iDb);
123791	}
123792	return;
123793	}
	@@ -124377,12 +124802,11 @@
124377
124378	db = pParse->db;
124379	iDb = sqlite3SchemaToIndex(db, pTable->pSchema);
124380	assert( iDb>=0 );
124381
124382	pTable->tabFlags \|= TF_Virtual;
124383	pTable->nModuleArg = 0;
124384	addModuleArgument(db, pTable, sqlite3NameFromToken(db, pModuleName));
124385	addModuleArgument(db, pTable, 0);
124386	addModuleArgument(db, pTable, sqlite3DbStrDup(db, pTable->zName));
124387	assert( (pParse->sNameToken.z==pName2->z && pName2->z!=0)
124388	\|\| (pParse->sNameToken.z==pName1->z && pName2->z==0)
	@@ -124666,11 +125090,11 @@
124666	const char *zMod;
124667	Module *pMod;
124668	int rc;
124669
124670	assert( pTab );
124671	if( (pTab->tabFlags & TF_Virtual)==0 \|\| sqlite3GetVTable(db, pTab) ){
124672	return SQLITE_OK;
124673	}
124674
124675	/* Locate the required virtual table module */
124676	zMod = pTab->azModuleArg[0];
	@@ -124736,11 +125160,11 @@
124736	Table *pTab;
124737	Module *pMod;
124738	const char *zMod;
124739
124740	pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
124741	assert( pTab && (pTab->tabFlags & TF_Virtual)!=0 && !pTab->pVTable );
124742
124743	/* Locate the required virtual table module */
124744	zMod = pTab->azModuleArg[0];
124745	pMod = (Module*)sqlite3HashFind(&db->aModule, zMod);
124746
	@@ -124790,11 +125214,11 @@
124790	sqlite3Error(db, SQLITE_MISUSE);
124791	sqlite3_mutex_leave(db->mutex);
124792	return SQLITE_MISUSE_BKPT;
124793	}
124794	pTab = pCtx->pTab;
124795	assert( (pTab->tabFlags & TF_Virtual)!=0 );
124796
124797	pParse = sqlite3StackAllocZero(db, sizeof(*pParse));
124798	if( pParse==0 ){
124799	rc = SQLITE_NOMEM_BKPT;
124800	}else{
	@@ -124804,11 +125228,11 @@
124804
124805	if( SQLITE_OK==sqlite3RunParser(pParse, zCreateTable, &zErr)
124806	&& pParse->pNewTable
124807	&& !db->mallocFailed
124808	&& !pParse->pNewTable->pSelect
124809	&& (pParse->pNewTable->tabFlags & TF_Virtual)==0
124810	){
124811	if( !pTab->aCol ){
124812	Table *pNew = pParse->pNewTable;
124813	Index *pIdx;
124814	pTab->aCol = pNew->aCol;
	@@ -125093,11 +125517,11 @@
125093	/* Check to see the left operand is a column in a virtual table */
125094	if( NEVER(pExpr==0) ) return pDef;
125095	if( pExpr->op!=TK_COLUMN ) return pDef;
125096	pTab = pExpr->pTab;
125097	if( NEVER(pTab==0) ) return pDef;
125098	if( (pTab->tabFlags & TF_Virtual)==0 ) return pDef;
125099	pVtab = sqlite3GetVTable(db, pTab)->pVtab;
125100	assert( pVtab!=0 );
125101	assert( pVtab->pModule!=0 );
125102	pMod = (sqlite3_module *)pVtab->pModule;
125103	if( pMod->xFindFunction==0 ) return pDef;
	@@ -125188,12 +125612,11 @@
125188	return 0;
125189	}
125190	pMod->pEpoTab = pTab;
125191	pTab->nTabRef = 1;
125192	pTab->pSchema = db->aDb[0].pSchema;
125193	pTab->tabFlags \|= TF_Virtual;
125194	pTab->nModuleArg = 0;
125195	pTab->iPKey = -1;
125196	addModuleArgument(db, pTab, sqlite3DbStrDup(db, pTab->zName));
125197	addModuleArgument(db, pTab, 0);
125198	addModuleArgument(db, pTab, sqlite3DbStrDup(db, pTab->zName));
125199	rc = vtabCallConstructor(db, pTab, pMod, pModule->xConnect, &zErr);
	@@ -125260,11 +125683,11 @@
125260	case SQLITE_VTAB_CONSTRAINT_SUPPORT: {
125261	VtabCtx *p = db->pVtabCtx;
125262	if( !p ){
125263	rc = SQLITE_MISUSE_BKPT;
125264	}else{
125265	assert( p->pTab==0 \|\| (p->pTab->tabFlags & TF_Virtual)!=0 );
125266	p->pVTable->bConstraint = (u8)va_arg(ap, int);
125267	}
125268	break;
125269	}
125270	default:
	@@ -125699,12 +126122,17 @@
125699	WhereOrSet pOrSet; / Record best loops here, if not NULL */
125700	#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
125701	UnpackedRecord pRec; / Probe for stat4 (if required) */
125702	int nRecValid; /* Number of valid fields currently in pRec */
125703	#endif

125704	};
125705




125706	/*
125707	** The WHERE clause processing routine has two halves. The
125708	** first part does the start of the WHERE loop and the second
125709	** half does the tail of the WHERE loop. An instance of
125710	** this structure is returned by the first half and passed
	@@ -125715,11 +126143,11 @@
125715	*/
125716	struct WhereInfo {
125717	Parse pParse; / Parsing and code generating context */
125718	SrcList pTabList; / List of tables in the join */
125719	ExprList pOrderBy; / The ORDER BY clause or NULL */
125720	ExprList pDistinctSet; / DISTINCT over all these values */
125721	LogEst iLimit; /* LIMIT if wctrlFlags has WHERE_USE_LIMIT */
125722	int aiCurOnePass[2]; /* OP_OpenWrite cursors for the ONEPASS opt */
125723	int iContinue; /* Jump here to continue with next record */
125724	int iBreak; /* Jump here to break out of the loop */
125725	int savedNQueryLoop; /* pParse->nQueryLoop outside the WHERE loop */
	@@ -126899,10 +127327,11 @@
126899	Parse pParse; / Parsing context */
126900	sqlite3 db; / Database connection */
126901	Vdbe v; / The prepared stmt under constructions */
126902	struct SrcList_item pTabItem; / FROM clause term being coded */
126903	int addrBrk; /* Jump here to break out of the loop */

126904	int addrCont; /* Jump here to continue with next cycle */
126905	int iRowidReg = 0; /* Rowid is stored in this register, if not zero */
126906	int iReleaseReg = 0; /* Temp register to free before returning */
126907
126908	pParse = pWInfo->pParse;
	@@ -126939,10 +127368,15 @@
126939	if( pLevel->iFrom>0 && (pTabItem[0].fg.jointype & JT_LEFT)!=0 ){
126940	pLevel->iLeftJoin = ++pParse->nMem;
126941	sqlite3VdbeAddOp2(v, OP_Integer, 0, pLevel->iLeftJoin);
126942	VdbeComment((v, "init LEFT JOIN no-match flag"));
126943	}





126944
126945	/* Special case of a FROM clause subquery implemented as a co-routine */
126946	if( pTabItem->fg.viaCoroutine ){
126947	int regYield = pTabItem->regReturn;
126948	sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pTabItem->addrFillSub);
	@@ -127124,11 +127558,11 @@
127124	VdbeCoverageIf(v, pX->op==TK_LT);
127125	VdbeCoverageIf(v, pX->op==TK_GE);
127126	sqlite3ExprCacheAffinityChange(pParse, r1, 1);
127127	sqlite3ReleaseTempReg(pParse, rTemp);
127128	}else{
127129	sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iCur, addrBrk);
127130	VdbeCoverageIf(v, bRev==0);
127131	VdbeCoverageIf(v, bRev!=0);
127132	}
127133	if( pEnd ){
127134	Expr *pX;
	@@ -127770,11 +128204,11 @@
127770	pLevel->op = OP_Noop;
127771	}else{
127772	codeCursorHint(pTabItem, pWInfo, pLevel, 0);
127773	pLevel->op = aStep[bRev];
127774	pLevel->p1 = iCur;
127775	pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrBrk);
127776	VdbeCoverageIf(v, bRev==0);
127777	VdbeCoverageIf(v, bRev!=0);
127778	pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP;
127779	}
127780	}
	@@ -128095,19 +128529,10 @@
128095	#ifdef SQLITE_EBCDIC
128096	if( *pnoCase ) return 0;
128097	#endif
128098	pList = pExpr->x.pList;
128099	pLeft = pList->a[1].pExpr;
128100	if( pLeft->op!=TK_COLUMN
128101	\|\| sqlite3ExprAffinity(pLeft)!=SQLITE_AFF_TEXT
128102	\|\| IsVirtual(pLeft->pTab) /* Value might be numeric */
128103	){
128104	/* IMP: R-02065-49465 The left-hand side of the LIKE or GLOB operator must
128105	** be the name of an indexed column with TEXT affinity. */
128106	return 0;
128107	}
128108	assert( pLeft->iColumn!=(-1) ); /* Because IPK never has AFF_TEXT */
128109
128110	pRight = sqlite3ExprSkipCollate(pList->a[0].pExpr);
128111	op = pRight->op;
128112	if( op==TK_VARIABLE ){
128113	Vdbe *pReprepare = pParse->pReprepare;
	@@ -128120,10 +128545,27 @@
128120	assert( pRight->op==TK_VARIABLE \|\| pRight->op==TK_REGISTER );
128121	}else if( op==TK_STRING ){
128122	z = pRight->u.zToken;
128123	}
128124	if( z ){

















128125	cnt = 0;
128126	while( (c=z[cnt])!=0 && c!=wc[0] && c!=wc[1] && c!=wc[2] ){
128127	cnt++;
128128	}
128129	if( cnt!=0 && 255!=(u8)z[cnt-1] ){
	@@ -128748,11 +129190,11 @@
128748	iCur = pFrom->a[i].iCursor;
128749	for(pIdx=pFrom->a[i].pTab->pIndex; pIdx; pIdx=pIdx->pNext){
128750	if( pIdx->aColExpr==0 ) continue;
128751	for(i=0; i<pIdx->nKeyCol; i++){
128752	if( pIdx->aiColumn[i]!=XN_EXPR ) continue;
128753	if( sqlite3ExprCompare(pExpr, pIdx->aColExpr->a[i].pExpr, iCur)==0 ){
128754	*piCur = iCur;
128755	*piColumn = XN_EXPR;
128756	return 1;
128757	}
128758	}
	@@ -129539,11 +129981,12 @@
129539	do{
129540	for(pTerm=pWC->a+k; k<pWC->nTerm; k++, pTerm++){
129541	if( pTerm->leftCursor==iCur
129542	&& pTerm->u.leftColumn==iColumn
129543	&& (iColumn!=XN_EXPR
129544	\|\| sqlite3ExprCompare(pTerm->pExpr->pLeft,pScan->pIdxExpr,iCur)==0)

129545	&& (pScan->iEquiv<=1 \|\| !ExprHasProperty(pTerm->pExpr, EP_FromJoin))
129546	){
129547	if( (pTerm->eOperator & WO_EQUIV)!=0
129548	&& pScan->nEquiv<ArraySize(pScan->aiCur)
129549	&& (pX = sqlite3ExprSkipCollate(pTerm->pExpr->pRight))->op==TK_COLUMN
	@@ -131716,10 +132159,15 @@
131716	testcase( eOp & WO_IS );
131717	testcase( eOp & WO_ISNULL );
131718	continue;
131719	}
131720





131721	pNew->wsFlags = saved_wsFlags;
131722	pNew->u.btree.nEq = saved_nEq;
131723	pNew->u.btree.nBtm = saved_nBtm;
131724	pNew->u.btree.nTop = saved_nTop;
131725	pNew->nLTerm = saved_nLTerm;
	@@ -132263,11 +132711,19 @@
132263	pNew->nOut = rSize;
132264	if( rc ) break;
132265	}
132266	}
132267

132268	rc = whereLoopAddBtreeIndex(pBuilder, pSrc, pProbe, 0);







132269	#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
132270	sqlite3Stat4ProbeFree(pBuilder->pRec);
132271	pBuilder->nRecValid = 0;
132272	pBuilder->pRec = 0;
132273	#endif
	@@ -133443,13 +133899,13 @@
133443	&& (pWInfo->wctrlFlags & WHERE_DISTINCTBY)==0
133444	&& pWInfo->eDistinct==WHERE_DISTINCT_NOOP
133445	&& nRowEst
133446	){
133447	Bitmask notUsed;
133448	int rc = wherePathSatisfiesOrderBy(pWInfo, pWInfo->pDistinctSet, pFrom,
133449	WHERE_DISTINCTBY, nLoop-1, pFrom->aLoop[nLoop-1], &notUsed);
133450	if( rc==pWInfo->pDistinctSet->nExpr ){
133451	pWInfo->eDistinct = WHERE_DISTINCT_ORDERED;
133452	}
133453	}
133454	if( pWInfo->pOrderBy ){
133455	if( pWInfo->wctrlFlags & WHERE_DISTINCTBY ){
	@@ -133682,11 +134138,11 @@
133682	SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
133683	Parse pParse, / The parser context */
133684	SrcList pTabList, / FROM clause: A list of all tables to be scanned */
133685	Expr pWhere, / The WHERE clause */
133686	ExprList pOrderBy, / An ORDER BY (or GROUP BY) clause, or NULL */
133687	ExprList pDistinctSet, / Try not to output two rows that duplicate these */
133688	u16 wctrlFlags, /* The WHERE_* flags defined in sqliteInt.h */
133689	int iAuxArg /* If WHERE_OR_SUBCLAUSE is set, index cursor number
133690	** If WHERE_USE_LIMIT, then the limit amount */
133691	){
133692	int nByteWInfo; /* Num. bytes allocated for WhereInfo struct */
	@@ -133758,11 +134214,11 @@
133758	goto whereBeginError;
133759	}
133760	pWInfo->pParse = pParse;
133761	pWInfo->pTabList = pTabList;
133762	pWInfo->pOrderBy = pOrderBy;
133763	pWInfo->pDistinctSet = pDistinctSet;
133764	pWInfo->aiCurOnePass[0] = pWInfo->aiCurOnePass[1] = -1;
133765	pWInfo->nLevel = nTabList;
133766	pWInfo->iBreak = pWInfo->iContinue = sqlite3VdbeMakeLabel(v);
133767	pWInfo->wctrlFlags = wctrlFlags;
133768	pWInfo->iLimit = iAuxArg;
	@@ -133836,17 +134292,17 @@
133836	/* Analyze all of the subexpressions. */
133837	sqlite3WhereExprAnalyze(pTabList, &pWInfo->sWC);
133838	if( db->mallocFailed ) goto whereBeginError;
133839
133840	if( wctrlFlags & WHERE_WANT_DISTINCT ){
133841	if( isDistinctRedundant(pParse, pTabList, &pWInfo->sWC, pDistinctSet) ){
133842	/* The DISTINCT marking is pointless. Ignore it. */
133843	pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE;
133844	}else if( pOrderBy==0 ){
133845	/* Try to ORDER BY the result set to make distinct processing easier */
133846	pWInfo->wctrlFlags \|= WHERE_DISTINCTBY;
133847	pWInfo->pOrderBy = pDistinctSet;
133848	}
133849	}
133850
133851	/* Construct the WhereLoop objects */
133852	#if defined(WHERETRACE_ENABLED)
	@@ -133918,14 +134374,14 @@
133918	}
133919	}
133920	#endif
133921	/* Attempt to omit tables from the join that do not effect the result */
133922	if( pWInfo->nLevel>=2
133923	&& pDistinctSet!=0
133924	&& OptimizationEnabled(db, SQLITE_OmitNoopJoin)
133925	){
133926	Bitmask tabUsed = sqlite3WhereExprListUsage(pMaskSet, pDistinctSet);
133927	if( sWLB.pOrderBy ){
133928	tabUsed \|= sqlite3WhereExprListUsage(pMaskSet, sWLB.pOrderBy);
133929	}
133930	while( pWInfo->nLevel>=2 ){
133931	WhereTerm pTerm, pEnd;
	@@ -134704,166 +135160,166 @@
134704	**
134705	********* Begin parsing tables ********************************************/
134706	#define YY_ACTTAB_COUNT (1567)
134707	static const YYACTIONTYPE yy_action[] = {
134708	/* 0 */ 325, 832, 351, 825, 5, 203, 203, 819, 99, 100,
134709	/* 10 */ 90, 842, 842, 854, 857, 846, 846, 97, 97, 98,
134710	/* 20 */ 98, 98, 98, 301, 96, 96, 96, 96, 95, 95,
134711	/* 30 */ 94, 94, 94, 93, 351, 325, 977, 977, 824, 824,
134712	/* 40 */ 826, 947, 354, 99, 100, 90, 842, 842, 854, 857,
134713	/* 50 */ 846, 846, 97, 97, 98, 98, 98, 98, 338, 96,
134714	/* 60 */ 96, 96, 96, 95, 95, 94, 94, 94, 93, 351,
134715	/* 70 */ 95, 95, 94, 94, 94, 93, 351, 791, 977, 977,
134716	/* 80 */ 325, 94, 94, 94, 93, 351, 792, 75, 99, 100,
134717	/* 90 */ 90, 842, 842, 854, 857, 846, 846, 97, 97, 98,
134718	/* 100 */ 98, 98, 98, 450, 96, 96, 96, 96, 95, 95,
134719	/* 110 */ 94, 94, 94, 93, 351, 1333, 155, 155, 2, 325,
134720	/* 120 */ 275, 146, 132, 52, 52, 93, 351, 99, 100, 90,
134721	/* 130 */ 842, 842, 854, 857, 846, 846, 97, 97, 98, 98,
134722	/* 140 */ 98, 98, 101, 96, 96, 96, 96, 95, 95, 94,
134723	/* 150 */ 94, 94, 93, 351, 958, 958, 325, 268, 428, 413,
134724	/* 160 */ 411, 61, 752, 752, 99, 100, 90, 842, 842, 854,
134725	/* 170 */ 857, 846, 846, 97, 97, 98, 98, 98, 98, 60,
134726	/* 180 */ 96, 96, 96, 96, 95, 95, 94, 94, 94, 93,
134727	/* 190 */ 351, 325, 270, 329, 273, 277, 959, 960, 250, 99,
134728	/* 200 */ 100, 90, 842, 842, 854, 857, 846, 846, 97, 97,
134729	/* 210 */ 98, 98, 98, 98, 301, 96, 96, 96, 96, 95,
134730	/* 220 */ 95, 94, 94, 94, 93, 351, 325, 938, 1326, 698,
134731	/* 230 */ 706, 1326, 242, 412, 99, 100, 90, 842, 842, 854,
134732	/* 240 */ 857, 846, 846, 97, 97, 98, 98, 98, 98, 347,
134733	/* 250 */ 96, 96, 96, 96, 95, 95, 94, 94, 94, 93,
134734	/* 260 */ 351, 325, 938, 1327, 384, 699, 1327, 381, 379, 99,
134735	/* 270 */ 100, 90, 842, 842, 854, 857, 846, 846, 97, 97,
134736	/* 280 */ 98, 98, 98, 98, 701, 96, 96, 96, 96, 95,
134737	/* 290 */ 95, 94, 94, 94, 93, 351, 325, 92, 89, 178,
134738	/* 300 */ 833, 936, 373, 700, 99, 100, 90, 842, 842, 854,
134739	/* 310 */ 857, 846, 846, 97, 97, 98, 98, 98, 98, 375,
134740	/* 320 */ 96, 96, 96, 96, 95, 95, 94, 94, 94, 93,
134741	/* 330 */ 351, 325, 1276, 947, 354, 818, 936, 739, 739, 99,
134742	/* 340 */ 100, 90, 842, 842, 854, 857, 846, 846, 97, 97,
134743	/* 350 */ 98, 98, 98, 98, 230, 96, 96, 96, 96, 95,
134744	/* 360 */ 95, 94, 94, 94, 93, 351, 325, 969, 227, 92,
134745	/* 370 */ 89, 178, 373, 300, 99, 100, 90, 842, 842, 854,
134746	/* 380 */ 857, 846, 846, 97, 97, 98, 98, 98, 98, 921,
134747	/* 390 */ 96, 96, 96, 96, 95, 95, 94, 94, 94, 93,
134748	/* 400 */ 351, 325, 449, 447, 447, 447, 147, 737, 737, 99,
134749	/* 410 */ 100, 90, 842, 842, 854, 857, 846, 846, 97, 97,
134750	/* 420 */ 98, 98, 98, 98, 296, 96, 96, 96, 96, 95,
134751	/* 430 */ 95, 94, 94, 94, 93, 351, 325, 419, 231, 958,
134752	/* 440 */ 958, 158, 25, 422, 99, 100, 90, 842, 842, 854,
134753	/* 450 */ 857, 846, 846, 97, 97, 98, 98, 98, 98, 450,
134754	/* 460 */ 96, 96, 96, 96, 95, 95, 94, 94, 94, 93,
134755	/* 470 */ 351, 443, 224, 224, 420, 958, 958, 962, 325, 52,
134756	/* 480 */ 52, 959, 960, 176, 415, 78, 99, 100, 90, 842,
134757	/* 490 */ 842, 854, 857, 846, 846, 97, 97, 98, 98, 98,
134758	/* 500 */ 98, 379, 96, 96, 96, 96, 95, 95, 94, 94,
134759	/* 510 */ 94, 93, 351, 325, 428, 418, 298, 959, 960, 962,
134760	/* 520 */ 81, 99, 88, 90, 842, 842, 854, 857, 846, 846,
134761	/* 530 */ 97, 97, 98, 98, 98, 98, 717, 96, 96, 96,
134762	/* 540 */ 96, 95, 95, 94, 94, 94, 93, 351, 325, 843,
134763	/* 550 */ 843, 855, 858, 996, 318, 343, 379, 100, 90, 842,
134764	/* 560 */ 842, 854, 857, 846, 846, 97, 97, 98, 98, 98,
134765	/* 570 */ 98, 450, 96, 96, 96, 96, 95, 95, 94, 94,
134766	/* 580 */ 94, 93, 351, 325, 350, 350, 350, 260, 377, 340,
134767	/* 590 */ 929, 52, 52, 90, 842, 842, 854, 857, 846, 846,
134768	/* 600 */ 97, 97, 98, 98, 98, 98, 361, 96, 96, 96,
134769	/* 610 */ 96, 95, 95, 94, 94, 94, 93, 351, 86, 445,
134770	/* 620 */ 847, 3, 1203, 361, 360, 378, 344, 813, 958, 958,
134771	/* 630 */ 1300, 86, 445, 729, 3, 212, 169, 287, 405, 282,
134772	/* 640 */ 404, 199, 232, 450, 300, 760, 83, 84, 280, 245,
134773	/* 650 */ 262, 365, 251, 85, 352, 352, 92, 89, 178, 83,
134774	/* 660 */ 84, 242, 412, 52, 52, 448, 85, 352, 352, 246,
134775	/* 670 */ 959, 960, 194, 455, 670, 402, 399, 398, 448, 243,
134776	/* 680 */ 221, 114, 434, 776, 361, 450, 397, 268, 747, 224,
134777	/* 690 */ 224, 132, 132, 198, 832, 434, 452, 451, 428, 427,
134778	/* 700 */ 819, 415, 734, 713, 132, 52, 52, 832, 268, 452,
134779	/* 710 */ 451, 734, 194, 819, 363, 402, 399, 398, 450, 1271,
134780	/* 720 */ 1271, 23, 958, 958, 86, 445, 397, 3, 228, 429,
134781	/* 730 */ 895, 824, 824, 826, 827, 19, 203, 720, 52, 52,
134782	/* 740 */ 428, 408, 439, 249, 824, 824, 826, 827, 19, 229,
134783	/* 750 */ 403, 153, 83, 84, 761, 177, 241, 450, 721, 85,
134784	/* 760 */ 352, 352, 120, 157, 959, 960, 58, 977, 409, 355,
134785	/* 770 */ 330, 448, 268, 428, 430, 320, 790, 32, 32, 86,
134786	/* 780 */ 445, 776, 3, 341, 98, 98, 98, 98, 434, 96,
134787	/* 790 */ 96, 96, 96, 95, 95, 94, 94, 94, 93, 351,
134788	/* 800 */ 832, 120, 452, 451, 813, 887, 819, 83, 84, 977,
134789	/* 810 */ 813, 132, 410, 920, 85, 352, 352, 132, 407, 789,
134790	/* 820 */ 958, 958, 92, 89, 178, 917, 448, 262, 370, 261,
134791	/* 830 */ 82, 914, 80, 262, 370, 261, 776, 824, 824, 826,
134792	/* 840 */ 827, 19, 934, 434, 96, 96, 96, 96, 95, 95,
134793	/* 850 */ 94, 94, 94, 93, 351, 832, 74, 452, 451, 958,
134794	/* 860 */ 958, 819, 959, 960, 120, 92, 89, 178, 945, 2,
134795	/* 870 */ 918, 965, 268, 1, 976, 76, 445, 762, 3, 708,
134796	/* 880 */ 901, 901, 387, 958, 958, 757, 919, 371, 740, 778,
134797	/* 890 */ 756, 257, 824, 824, 826, 827, 19, 417, 741, 450,
134798	/* 900 */ 24, 959, 960, 83, 84, 369, 958, 958, 177, 226,
134799	/* 910 */ 85, 352, 352, 885, 315, 314, 313, 215, 311, 10,
134800	/* 920 */ 10, 683, 448, 349, 348, 959, 960, 909, 777, 157,
134801	/* 930 */ 120, 958, 958, 337, 776, 416, 711, 310, 450, 434,
134802	/* 940 */ 450, 321, 450, 791, 103, 200, 175, 450, 959, 960,
134803	/* 950 */ 908, 832, 792, 452, 451, 9, 9, 819, 10, 10,
134804	/* 960 */ 52, 52, 51, 51, 180, 716, 248, 10, 10, 171,
134805	/* 970 */ 170, 167, 339, 959, 960, 247, 984, 702, 702, 450,
134806	/* 980 */ 715, 233, 686, 982, 889, 983, 182, 914, 824, 824,
134807	/* 990 */ 826, 827, 19, 183, 256, 423, 132, 181, 394, 10,
134808	/* 1000 */ 10, 889, 891, 749, 958, 958, 917, 268, 985, 198,
134809	/* 1010 */ 985, 349, 348, 425, 415, 299, 817, 832, 326, 825,
134810	/* 1020 */ 120, 332, 133, 819, 268, 98, 98, 98, 98, 91,
134811	/* 1030 */ 96, 96, 96, 96, 95, 95, 94, 94, 94, 93,
134812	/* 1040 */ 351, 157, 810, 371, 382, 359, 959, 960, 358, 268,
134813	/* 1050 */ 450, 918, 368, 324, 824, 824, 826, 450, 709, 450,
134814	/* 1060 */ 264, 380, 889, 450, 877, 746, 253, 919, 255, 433,
134815	/* 1070 */ 36, 36, 234, 450, 234, 120, 269, 37, 37, 12,
134816	/* 1080 */ 12, 334, 272, 27, 27, 450, 330, 118, 450, 162,
134817	/* 1090 */ 742, 280, 450, 38, 38, 450, 985, 356, 985, 450,
134818	/* 1100 */ 709, 1210, 450, 132, 450, 39, 39, 450, 40, 40,
134819	/* 1110 */ 450, 362, 41, 41, 450, 42, 42, 450, 254, 28,
134820	/* 1120 */ 28, 450, 29, 29, 31, 31, 450, 43, 43, 450,
134821	/* 1130 */ 44, 44, 450, 714, 45, 45, 450, 11, 11, 767,
134822	/* 1140 */ 450, 46, 46, 450, 268, 450, 105, 105, 450, 47,
134823	/* 1150 */ 47, 450, 48, 48, 450, 237, 33, 33, 450, 172,
134824	/* 1160 */ 49, 49, 450, 50, 50, 34, 34, 274, 122, 122,
134825	/* 1170 */ 450, 123, 123, 450, 124, 124, 450, 898, 56, 56,
134826	/* 1180 */ 450, 897, 35, 35, 450, 267, 450, 817, 450, 817,
134827	/* 1190 */ 106, 106, 450, 53, 53, 385, 107, 107, 450, 817,
134828	/* 1200 */ 108, 108, 817, 450, 104, 104, 121, 121, 119, 119,
134829	/* 1210 */ 450, 117, 112, 112, 450, 276, 450, 225, 111, 111,
134830	/* 1220 */ 450, 730, 450, 109, 109, 450, 673, 674, 675, 912,
134831	/* 1230 */ 110, 110, 317, 998, 55, 55, 57, 57, 692, 331,
134832	/* 1240 */ 54, 54, 26, 26, 696, 30, 30, 317, 937, 197,
134833	/* 1250 */ 196, 195, 335, 281, 336, 446, 331, 745, 689, 436,
134834	/* 1260 */ 440, 444, 120, 72, 386, 223, 175, 345, 757, 933,
134835	/* 1270 */ 20, 286, 319, 756, 815, 372, 374, 202, 202, 202,
134836	/* 1280 */ 263, 395, 285, 74, 208, 21, 696, 719, 718, 884,
134837	/* 1290 */ 120, 120, 120, 120, 120, 754, 278, 828, 77, 74,
134838	/* 1300 */ 726, 727, 785, 783, 880, 202, 999, 208, 894, 893,
134839	/* 1310 */ 894, 893, 694, 816, 763, 116, 774, 1290, 431, 432,
134840	/* 1320 */ 302, 999, 390, 303, 823, 697, 691, 680, 159, 289,
134841	/* 1330 */ 679, 884, 681, 952, 291, 218, 293, 7, 316, 828,
134842	/* 1340 */ 173, 805, 259, 364, 252, 911, 376, 713, 295, 435,
134843	/* 1350 */ 308, 168, 955, 993, 135, 400, 990, 284, 882, 881,
134844	/* 1360 */ 205, 928, 926, 59, 333, 62, 144, 156, 130, 72,
134845	/* 1370 */ 802, 366, 367, 393, 137, 185, 189, 160, 139, 383,
134846	/* 1380 */ 67, 896, 140, 141, 142, 148, 389, 812, 775, 266,
134847	/* 1390 */ 219, 190, 154, 391, 913, 876, 271, 406, 191, 322,
134848	/* 1400 */ 682, 733, 192, 342, 732, 724, 731, 711, 723, 421,
134849	/* 1410 */ 705, 71, 323, 6, 204, 771, 288, 79, 297, 346,
134850	/* 1420 */ 772, 704, 290, 283, 703, 770, 292, 294, 967, 239,
134851	/* 1430 */ 769, 102, 862, 438, 426, 240, 424, 442, 73, 213,
134852	/* 1440 */ 688, 238, 22, 453, 953, 214, 217, 216, 454, 677,
134853	/* 1450 */ 676, 671, 753, 125, 115, 235, 126, 669, 353, 166,
134854	/* 1460 */ 127, 244, 179, 357, 306, 304, 305, 307, 113, 892,
134855	/* 1470 */ 327, 890, 811, 328, 134, 128, 136, 138, 743, 258,
134856	/* 1480 */ 907, 184, 143, 129, 910, 186, 63, 64, 145, 187,
134857	/* 1490 */ 906, 65, 8, 66, 13, 188, 202, 899, 265, 149,
134858	/* 1500 */ 987, 388, 150, 685, 161, 392, 285, 193, 279, 396,
134859	/* 1510 */ 151, 401, 68, 14, 15, 722, 69, 236, 831, 131,
134860	/* 1520 */ 830, 860, 70, 751, 16, 414, 755, 4, 174, 220,
134861	/* 1530 */ 222, 784, 201, 152, 779, 77, 74, 17, 18, 875,
134862	/* 1540 */ 861, 859, 916, 864, 915, 207, 206, 942, 163, 437,
134863	/* 1550 */ 948, 943, 164, 209, 1002, 441, 863, 165, 210, 829,
134864	/* 1560 */ 695, 87, 312, 211, 1292, 1291, 309,
134865	};
134866	static const YYCODETYPE yy_lookahead[] = {
134867	/* 0 */ 19, 95, 53, 97, 22, 24, 24, 101, 27, 28,
134868	/* 10 */ 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
134869	/* 20 */ 39, 40, 41, 152, 43, 44, 45, 46, 47, 48,
	@@ -135112,55 +135568,55 @@
135112	/* 300 */ 1256, 1200, 1206, 1260, 1247, 1261, 1263, 1262, 1266, 1278,
135113	/* 310 */ 1282, 1292, 1294, 1297, 1298, 1299, 1300, 1221, 1224, 1228,
135114	/* 320 */ 1288, 1291, 1276, 1277, 1295,
135115	};
135116	static const YYACTIONTYPE yy_default[] = {
135117	/* 0 */ 1281, 1271, 1271, 1271, 1203, 1203, 1203, 1203, 1271, 1096,
135118	/* 10 */ 1125, 1125, 1255, 1332, 1332, 1332, 1332, 1332, 1332, 1202,
135119	/* 20 */ 1332, 1332, 1332, 1332, 1271, 1100, 1131, 1332, 1332, 1332,
135120	/* 30 */ 1332, 1204, 1205, 1332, 1332, 1332, 1254, 1256, 1141, 1140,
135121	/* 40 */ 1139, 1138, 1237, 1112, 1136, 1129, 1133, 1204, 1198, 1199,
135122	/* 50 */ 1197, 1201, 1205, 1332, 1132, 1167, 1182, 1166, 1332, 1332,
135123	/* 60 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135124	/* 70 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135125	/* 80 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135126	/* 90 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135127	/* 100 */ 1332, 1332, 1332, 1332, 1176, 1181, 1188, 1180, 1177, 1169,
135128	/* 110 */ 1168, 1170, 1171, 1332, 1019, 1067, 1332, 1332, 1332, 1172,
135129	/* 120 */ 1332, 1173, 1185, 1184, 1183, 1262, 1289, 1288, 1332, 1332,
135130	/* 130 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135131	/* 140 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135132	/* 150 */ 1332, 1332, 1332, 1332, 1332, 1281, 1271, 1025, 1025, 1332,
135133	/* 160 */ 1271, 1271, 1271, 1271, 1271, 1271, 1267, 1100, 1091, 1332,
135134	/* 170 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135135	/* 180 */ 1259, 1257, 1332, 1218, 1332, 1332, 1332, 1332, 1332, 1332,
135136	/* 190 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135137	/* 200 */ 1332, 1332, 1332, 1332, 1096, 1332, 1332, 1332, 1332, 1332,
135138	/* 210 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1283, 1332, 1232,
135139	/* 220 */ 1096, 1096, 1096, 1098, 1080, 1090, 1004, 1135, 1114, 1114,
135140	/* 230 */ 1321, 1135, 1321, 1042, 1303, 1039, 1125, 1114, 1200, 1125,
135141	/* 240 */ 1125, 1097, 1090, 1332, 1324, 1105, 1105, 1323, 1323, 1105,
135142	/* 250 */ 1146, 1070, 1135, 1076, 1076, 1076, 1076, 1105, 1016, 1135,
135143	/* 260 */ 1146, 1070, 1070, 1135, 1105, 1016, 1236, 1318, 1105, 1105,
135144	/* 270 */ 1016, 1211, 1105, 1016, 1105, 1016, 1211, 1068, 1068, 1068,
135145	/* 280 */ 1057, 1211, 1068, 1042, 1068, 1057, 1068, 1068, 1118, 1113,
135146	/* 290 */ 1118, 1113, 1118, 1113, 1118, 1113, 1105, 1206, 1105, 1332,
135147	/* 300 */ 1211, 1215, 1215, 1211, 1130, 1119, 1128, 1126, 1135, 1022,
135148	/* 310 */ 1060, 1286, 1286, 1282, 1282, 1282, 1282, 1329, 1329, 1267,
135149	/* 320 */ 1298, 1298, 1044, 1044, 1298, 1332, 1332, 1332, 1332, 1332,
135150	/* 330 */ 1332, 1293, 1332, 1220, 1332, 1332, 1332, 1332, 1332, 1332,
135151	/* 340 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135152	/* 350 */ 1332, 1332, 1152, 1332, 1000, 1264, 1332, 1332, 1263, 1332,
135153	/* 360 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135154	/* 370 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1320,
135155	/* 380 */ 1332, 1332, 1332, 1332, 1332, 1332, 1235, 1234, 1332, 1332,
135156	/* 390 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135157	/* 400 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135158	/* 410 */ 1332, 1082, 1332, 1332, 1332, 1307, 1332, 1332, 1332, 1332,
135159	/* 420 */ 1332, 1332, 1332, 1127, 1332, 1120, 1332, 1332, 1311, 1332,
135160	/* 430 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1273,
135161	/* 440 */ 1332, 1332, 1332, 1272, 1332, 1332, 1332, 1332, 1332, 1154,
135162	/* 450 */ 1332, 1153, 1157, 1332, 1010, 1332,
135163	};
135164	/******** End of lemon-generated parsing tables ***************************/
135165
135166	/* The next table maps tokens (terminal symbols) into fallback tokens.
	@@ -135602,147 +136058,147 @@
135602	/* 169 */ "expr ::= expr EQ\|NE expr",
135603	/* 170 */ "expr ::= expr BITAND\|BITOR\|LSHIFT\|RSHIFT expr",
135604	/* 171 */ "expr ::= expr PLUS\|MINUS expr",
135605	/* 172 */ "expr ::= expr STAR\|SLASH\|REM expr",
135606	/* 173 */ "expr ::= expr CONCAT expr",
135607	/* 174 */ "likeop ::= LIKE_KW\|MATCH",
135608	/* 175 */ "likeop ::= NOT LIKE_KW\|MATCH",
135609	/* 176 */ "expr ::= expr likeop expr",
135610	/* 177 */ "expr ::= expr likeop expr ESCAPE expr",
135611	/* 178 */ "expr ::= expr ISNULL\|NOTNULL",
135612	/* 179 */ "expr ::= expr NOT NULL",
135613	/* 180 */ "expr ::= expr IS expr",
135614	/* 181 */ "expr ::= expr IS NOT expr",
135615	/* 182 */ "expr ::= NOT expr",
135616	/* 183 */ "expr ::= BITNOT expr",
135617	/* 184 */ "expr ::= MINUS expr",
135618	/* 185 */ "expr ::= PLUS expr",
135619	/* 186 */ "between_op ::= BETWEEN",
135620	/* 187 */ "between_op ::= NOT BETWEEN",
135621	/* 188 */ "expr ::= expr between_op expr AND expr",
135622	/* 189 */ "in_op ::= IN",
135623	/* 190 */ "in_op ::= NOT IN",
135624	/* 191 */ "expr ::= expr in_op LP exprlist RP",
135625	/* 192 */ "expr ::= LP select RP",
135626	/* 193 */ "expr ::= expr in_op LP select RP",
135627	/* 194 */ "expr ::= expr in_op nm dbnm paren_exprlist",
135628	/* 195 */ "expr ::= EXISTS LP select RP",
135629	/* 196 */ "expr ::= CASE case_operand case_exprlist case_else END",
135630	/* 197 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
135631	/* 198 */ "case_exprlist ::= WHEN expr THEN expr",
135632	/* 199 */ "case_else ::= ELSE expr",
135633	/* 200 */ "case_else ::=",
135634	/* 201 */ "case_operand ::= expr",
135635	/* 202 */ "case_operand ::=",
135636	/* 203 */ "exprlist ::=",
135637	/* 204 */ "nexprlist ::= nexprlist COMMA expr",
135638	/* 205 */ "nexprlist ::= expr",
135639	/* 206 */ "paren_exprlist ::=",
135640	/* 207 */ "paren_exprlist ::= LP exprlist RP",
135641	/* 208 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt",
135642	/* 209 */ "uniqueflag ::= UNIQUE",
135643	/* 210 */ "uniqueflag ::=",
135644	/* 211 */ "eidlist_opt ::=",
135645	/* 212 */ "eidlist_opt ::= LP eidlist RP",
135646	/* 213 */ "eidlist ::= eidlist COMMA nm collate sortorder",
135647	/* 214 */ "eidlist ::= nm collate sortorder",
135648	/* 215 */ "collate ::=",
135649	/* 216 */ "collate ::= COLLATE ID\|STRING",
135650	/* 217 */ "cmd ::= DROP INDEX ifexists fullname",
135651	/* 218 */ "cmd ::= VACUUM",
135652	/* 219 */ "cmd ::= VACUUM nm",
135653	/* 220 */ "cmd ::= PRAGMA nm dbnm",
135654	/* 221 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
135655	/* 222 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
135656	/* 223 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
135657	/* 224 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
135658	/* 225 */ "plus_num ::= PLUS INTEGER\|FLOAT",
135659	/* 226 */ "minus_num ::= MINUS INTEGER\|FLOAT",
135660	/* 227 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
135661	/* 228 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
135662	/* 229 */ "trigger_time ::= BEFORE",
135663	/* 230 */ "trigger_time ::= AFTER",
135664	/* 231 */ "trigger_time ::= INSTEAD OF",
135665	/* 232 */ "trigger_time ::=",
135666	/* 233 */ "trigger_event ::= DELETE\|INSERT",
135667	/* 234 */ "trigger_event ::= UPDATE",
135668	/* 235 */ "trigger_event ::= UPDATE OF idlist",
135669	/* 236 */ "when_clause ::=",
135670	/* 237 */ "when_clause ::= WHEN expr",
135671	/* 238 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
135672	/* 239 */ "trigger_cmd_list ::= trigger_cmd SEMI",
135673	/* 240 */ "trnm ::= nm DOT nm",
135674	/* 241 */ "tridxby ::= INDEXED BY nm",
135675	/* 242 */ "tridxby ::= NOT INDEXED",
135676	/* 243 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt",
135677	/* 244 */ "trigger_cmd ::= insert_cmd INTO trnm idlist_opt select",
135678	/* 245 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt",
135679	/* 246 */ "trigger_cmd ::= select",
135680	/* 247 */ "expr ::= RAISE LP IGNORE RP",
135681	/* 248 */ "expr ::= RAISE LP raisetype COMMA nm RP",
135682	/* 249 */ "raisetype ::= ROLLBACK",
135683	/* 250 */ "raisetype ::= ABORT",
135684	/* 251 */ "raisetype ::= FAIL",
135685	/* 252 */ "cmd ::= DROP TRIGGER ifexists fullname",
135686	/* 253 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
135687	/* 254 */ "cmd ::= DETACH database_kw_opt expr",
135688	/* 255 */ "key_opt ::=",
135689	/* 256 */ "key_opt ::= KEY expr",
135690	/* 257 */ "cmd ::= REINDEX",
135691	/* 258 */ "cmd ::= REINDEX nm dbnm",
135692	/* 259 */ "cmd ::= ANALYZE",
135693	/* 260 */ "cmd ::= ANALYZE nm dbnm",
135694	/* 261 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
135695	/* 262 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist",
135696	/* 263 */ "add_column_fullname ::= fullname",
135697	/* 264 */ "cmd ::= create_vtab",
135698	/* 265 */ "cmd ::= create_vtab LP vtabarglist RP",
135699	/* 266 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm",
135700	/* 267 */ "vtabarg ::=",
135701	/* 268 */ "vtabargtoken ::= ANY",
135702	/* 269 */ "vtabargtoken ::= lp anylist RP",
135703	/* 270 */ "lp ::= LP",
135704	/* 271 */ "with ::=",
135705	/* 272 */ "with ::= WITH wqlist",
135706	/* 273 */ "with ::= WITH RECURSIVE wqlist",
135707	/* 274 */ "wqlist ::= nm eidlist_opt AS LP select RP",
135708	/* 275 */ "wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP",
135709	/* 276 */ "input ::= cmdlist",
135710	/* 277 */ "cmdlist ::= cmdlist ecmd",
135711	/* 278 */ "cmdlist ::= ecmd",
135712	/* 279 */ "ecmd ::= SEMI",
135713	/* 280 */ "ecmd ::= explain cmdx SEMI",
135714	/* 281 */ "explain ::=",
135715	/* 282 */ "trans_opt ::=",
135716	/* 283 */ "trans_opt ::= TRANSACTION",
135717	/* 284 */ "trans_opt ::= TRANSACTION nm",
135718	/* 285 */ "savepoint_opt ::= SAVEPOINT",
135719	/* 286 */ "savepoint_opt ::=",
135720	/* 287 */ "cmd ::= create_table create_table_args",
135721	/* 288 */ "columnlist ::= columnlist COMMA columnname carglist",
135722	/* 289 */ "columnlist ::= columnname carglist",
135723	/* 290 */ "nm ::= ID\|INDEXED",
135724	/* 291 */ "nm ::= STRING",
135725	/* 292 */ "nm ::= JOIN_KW",
135726	/* 293 */ "typetoken ::= typename",
135727	/* 294 */ "typename ::= ID\|STRING",
135728	/* 295 */ "signed ::= plus_num",
135729	/* 296 */ "signed ::= minus_num",
135730	/* 297 */ "carglist ::= carglist ccons",
135731	/* 298 */ "carglist ::=",
135732	/* 299 */ "ccons ::= NULL onconf",
135733	/* 300 */ "conslist_opt ::= COMMA conslist",
135734	/* 301 */ "conslist ::= conslist tconscomma tcons",
135735	/* 302 */ "conslist ::= tcons",
135736	/* 303 */ "tconscomma ::=",
135737	/* 304 */ "defer_subclause_opt ::= defer_subclause",
135738	/* 305 */ "resolvetype ::= raisetype",
135739	/* 306 */ "selectnowith ::= oneselect",
135740	/* 307 */ "oneselect ::= values",
135741	/* 308 */ "sclp ::= selcollist COMMA",
135742	/* 309 */ "as ::= ID\|STRING",
135743	/* 310 */ "expr ::= term",
135744	/* 311 */ "exprlist ::= nexprlist",
135745	/* 312 */ "nmnum ::= plus_num",
135746	/* 313 */ "nmnum ::= nm",
135747	/* 314 */ "nmnum ::= ON",
135748	/* 315 */ "nmnum ::= DELETE",
	@@ -136375,11 +136831,10 @@
136375	{ 173, 3 },
136376	{ 173, 3 },
136377	{ 173, 3 },
136378	{ 173, 3 },
136379	{ 173, 3 },
136380	{ 221, 1 },
136381	{ 221, 2 },
136382	{ 173, 3 },
136383	{ 173, 5 },
136384	{ 173, 2 },
136385	{ 173, 3 },
	@@ -136512,10 +136967,11 @@
136512	{ 194, 1 },
136513	{ 195, 1 },
136514	{ 209, 2 },
136515	{ 210, 1 },
136516	{ 173, 1 },

136517	{ 208, 1 },
136518	{ 230, 1 },
136519	{ 230, 1 },
136520	{ 230, 1 },
136521	{ 230, 1 },
	@@ -136654,11 +137110,11 @@
136654	case 42: /* autoinc ::= */ yytestcase(yyruleno==42);
136655	case 57: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==57);
136656	case 67: /* defer_subclause_opt ::= */ yytestcase(yyruleno==67);
136657	case 76: /* ifexists ::= */ yytestcase(yyruleno==76);
136658	case 90: /* distinct ::= */ yytestcase(yyruleno==90);
136659	case 215: /* collate ::= */ yytestcase(yyruleno==215);
136660	{yymsp[1].minor.yy194 = 0;}
136661	break;
136662	case 17: /* ifnotexists ::= IF NOT EXISTS */
136663	{yymsp[-2].minor.yy194 = 1;}
136664	break;
	@@ -136798,13 +137254,13 @@
136798	case 144: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==144);
136799	{yymsp[-1].minor.yy194 = yymsp[0].minor.yy194;}
136800	break;
136801	case 58: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */
136802	case 75: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==75);
136803	case 187: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==187);
136804	case 190: /* in_op ::= NOT IN */ yytestcase(yyruleno==190);
136805	case 216: /* collate ::= COLLATE ID\|STRING */ yytestcase(yyruleno==216);
136806	{yymsp[-1].minor.yy194 = 1;}
136807	break;
136808	case 59: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
136809	{yymsp[-1].minor.yy194 = 0;}
136810	break;
	@@ -136964,13 +137420,13 @@
136964	{yymsp[0].minor.yy194 = SF_All;}
136965	break;
136966	case 91: /* sclp ::= */
136967	case 119: /* orderby_opt ::= */ yytestcase(yyruleno==119);
136968	case 126: /* groupby_opt ::= */ yytestcase(yyruleno==126);
136969	case 203: /* exprlist ::= */ yytestcase(yyruleno==203);
136970	case 206: /* paren_exprlist ::= */ yytestcase(yyruleno==206);
136971	case 211: /* eidlist_opt ::= */ yytestcase(yyruleno==211);
136972	{yymsp[1].minor.yy148 = 0;}
136973	break;
136974	case 92: /* selcollist ::= sclp expr as */
136975	{
136976	yymsp[-2].minor.yy148 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy148, yymsp[-1].minor.yy190.pExpr);
	@@ -136992,12 +137448,12 @@
136992	yymsp[-3].minor.yy148 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy148, pDot);
136993	}
136994	break;
136995	case 95: /* as ::= AS nm */
136996	case 106: /* dbnm ::= DOT nm */ yytestcase(yyruleno==106);
136997	case 225: /* plus_num ::= PLUS INTEGER\|FLOAT */ yytestcase(yyruleno==225);
136998	case 226: /* minus_num ::= MINUS INTEGER\|FLOAT */ yytestcase(yyruleno==226);
136999	{yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;}
137000	break;
137001	case 97: /* from ::= */
137002	{yymsp[1].minor.yy185 = sqlite3DbMallocZero(pParse->db, sizeof(*yymsp[1].minor.yy185));}
137003	break;
	@@ -137076,18 +137532,18 @@
137076	{yymsp[-3].minor.yy194 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/X-overwrites-A/}
137077	break;
137078	case 112: /* on_opt ::= ON expr */
137079	case 129: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==129);
137080	case 136: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==136);
137081	case 199: /* case_else ::= ELSE expr */ yytestcase(yyruleno==199);
137082	{yymsp[-1].minor.yy72 = yymsp[0].minor.yy190.pExpr;}
137083	break;
137084	case 113: /* on_opt ::= */
137085	case 128: /* having_opt ::= */ yytestcase(yyruleno==128);
137086	case 135: /* where_opt ::= */ yytestcase(yyruleno==135);
137087	case 200: /* case_else ::= */ yytestcase(yyruleno==200);
137088	case 202: /* case_operand ::= */ yytestcase(yyruleno==202);
137089	{yymsp[1].minor.yy72 = 0;}
137090	break;
137091	case 115: /* indexed_opt ::= INDEXED BY nm */
137092	{yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;}
137093	break;
	@@ -137230,11 +137686,11 @@
137230	case 158: /* term ::= INTEGER */
137231	{
137232	yylhsminor.yy190.pExpr = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1);
137233	yylhsminor.yy190.zStart = yymsp[0].minor.yy0.z;
137234	yylhsminor.yy190.zEnd = yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n;
137235	if( yylhsminor.yy190.pExpr ) yylhsminor.yy190.pExpr->flags \|= EP_Leaf;
137236	}
137237	yymsp[0].minor.yy190 = yylhsminor.yy190;
137238	break;
137239	case 159: /* expr ::= VARIABLE */
137240	{
	@@ -137320,17 +137776,14 @@
137320	case 171: /* expr ::= expr PLUS\|MINUS expr */ yytestcase(yyruleno==171);
137321	case 172: /* expr ::= expr STAR\|SLASH\|REM expr */ yytestcase(yyruleno==172);
137322	case 173: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==173);
137323	{spanBinaryExpr(pParse,yymsp[-1].major,&yymsp[-2].minor.yy190,&yymsp[0].minor.yy190);}
137324	break;
137325	case 174: /* likeop ::= LIKE_KW\|MATCH */
137326	{yymsp[0].minor.yy0=yymsp[0].minor.yy0;/A-overwrites-X/}
137327	break;
137328	case 175: /* likeop ::= NOT LIKE_KW\|MATCH */
137329	{yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n\|=0x80000000; /yymsp[-1].minor.yy0-overwrite-yymsp[0].minor.yy0/}
137330	break;
137331	case 176: /* expr ::= expr likeop expr */
137332	{
137333	ExprList *pList;
137334	int bNot = yymsp[-1].minor.yy0.n & 0x80000000;
137335	yymsp[-1].minor.yy0.n &= 0x7fffffff;
137336	pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy190.pExpr);
	@@ -137339,11 +137792,11 @@
137339	exprNot(pParse, bNot, &yymsp[-2].minor.yy190);
137340	yymsp[-2].minor.yy190.zEnd = yymsp[0].minor.yy190.zEnd;
137341	if( yymsp[-2].minor.yy190.pExpr ) yymsp[-2].minor.yy190.pExpr->flags \|= EP_InfixFunc;
137342	}
137343	break;
137344	case 177: /* expr ::= expr likeop expr ESCAPE expr */
137345	{
137346	ExprList *pList;
137347	int bNot = yymsp[-3].minor.yy0.n & 0x80000000;
137348	yymsp[-3].minor.yy0.n &= 0x7fffffff;
137349	pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy190.pExpr);
	@@ -137353,43 +137806,43 @@
137353	exprNot(pParse, bNot, &yymsp[-4].minor.yy190);
137354	yymsp[-4].minor.yy190.zEnd = yymsp[0].minor.yy190.zEnd;
137355	if( yymsp[-4].minor.yy190.pExpr ) yymsp[-4].minor.yy190.pExpr->flags \|= EP_InfixFunc;
137356	}
137357	break;
137358	case 178: /* expr ::= expr ISNULL\|NOTNULL */
137359	{spanUnaryPostfix(pParse,yymsp[0].major,&yymsp[-1].minor.yy190,&yymsp[0].minor.yy0);}
137360	break;
137361	case 179: /* expr ::= expr NOT NULL */
137362	{spanUnaryPostfix(pParse,TK_NOTNULL,&yymsp[-2].minor.yy190,&yymsp[0].minor.yy0);}
137363	break;
137364	case 180: /* expr ::= expr IS expr */
137365	{
137366	spanBinaryExpr(pParse,TK_IS,&yymsp[-2].minor.yy190,&yymsp[0].minor.yy190);
137367	binaryToUnaryIfNull(pParse, yymsp[0].minor.yy190.pExpr, yymsp[-2].minor.yy190.pExpr, TK_ISNULL);
137368	}
137369	break;
137370	case 181: /* expr ::= expr IS NOT expr */
137371	{
137372	spanBinaryExpr(pParse,TK_ISNOT,&yymsp[-3].minor.yy190,&yymsp[0].minor.yy190);
137373	binaryToUnaryIfNull(pParse, yymsp[0].minor.yy190.pExpr, yymsp[-3].minor.yy190.pExpr, TK_NOTNULL);
137374	}
137375	break;
137376	case 182: /* expr ::= NOT expr */
137377	case 183: /* expr ::= BITNOT expr */ yytestcase(yyruleno==183);
137378	{spanUnaryPrefix(&yymsp[-1].minor.yy190,pParse,yymsp[-1].major,&yymsp[0].minor.yy190,&yymsp[-1].minor.yy0);/A-overwrites-B/}
137379	break;
137380	case 184: /* expr ::= MINUS expr */
137381	{spanUnaryPrefix(&yymsp[-1].minor.yy190,pParse,TK_UMINUS,&yymsp[0].minor.yy190,&yymsp[-1].minor.yy0);/A-overwrites-B/}
137382	break;
137383	case 185: /* expr ::= PLUS expr */
137384	{spanUnaryPrefix(&yymsp[-1].minor.yy190,pParse,TK_UPLUS,&yymsp[0].minor.yy190,&yymsp[-1].minor.yy0);/A-overwrites-B/}
137385	break;
137386	case 186: /* between_op ::= BETWEEN */
137387	case 189: /* in_op ::= IN */ yytestcase(yyruleno==189);
137388	{yymsp[0].minor.yy194 = 0;}
137389	break;
137390	case 188: /* expr ::= expr between_op expr AND expr */
137391	{
137392	ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy190.pExpr);
137393	pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy190.pExpr);
137394	yymsp[-4].minor.yy190.pExpr = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy190.pExpr, 0);
137395	if( yymsp[-4].minor.yy190.pExpr ){
	@@ -137399,11 +137852,11 @@
137399	}
137400	exprNot(pParse, yymsp[-3].minor.yy194, &yymsp[-4].minor.yy190);
137401	yymsp[-4].minor.yy190.zEnd = yymsp[0].minor.yy190.zEnd;
137402	}
137403	break;
137404	case 191: /* expr ::= expr in_op LP exprlist RP */
137405	{
137406	if( yymsp[-1].minor.yy148==0 ){
137407	/* Expressions of the form
137408	**
137409	** expr1 IN ()
	@@ -137452,26 +137905,26 @@
137452	exprNot(pParse, yymsp[-3].minor.yy194, &yymsp[-4].minor.yy190);
137453	}
137454	yymsp[-4].minor.yy190.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
137455	}
137456	break;
137457	case 192: /* expr ::= LP select RP */
137458	{
137459	spanSet(&yymsp[-2].minor.yy190,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /A-overwrites-B/
137460	yymsp[-2].minor.yy190.pExpr = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
137461	sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy190.pExpr, yymsp[-1].minor.yy243);
137462	}
137463	break;
137464	case 193: /* expr ::= expr in_op LP select RP */
137465	{
137466	yymsp[-4].minor.yy190.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy190.pExpr, 0);
137467	sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy190.pExpr, yymsp[-1].minor.yy243);
137468	exprNot(pParse, yymsp[-3].minor.yy194, &yymsp[-4].minor.yy190);
137469	yymsp[-4].minor.yy190.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
137470	}
137471	break;
137472	case 194: /* expr ::= expr in_op nm dbnm paren_exprlist */
137473	{
137474	SrcList *pSrc = sqlite3SrcListAppend(pParse->db, 0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);
137475	Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);
137476	if( yymsp[0].minor.yy148 ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy148);
137477	yymsp[-4].minor.yy190.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy190.pExpr, 0);
	@@ -137478,19 +137931,19 @@
137478	sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy190.pExpr, pSelect);
137479	exprNot(pParse, yymsp[-3].minor.yy194, &yymsp[-4].minor.yy190);
137480	yymsp[-4].minor.yy190.zEnd = yymsp[-1].minor.yy0.z ? &yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n] : &yymsp[-2].minor.yy0.z[yymsp[-2].minor.yy0.n];
137481	}
137482	break;
137483	case 195: /* expr ::= EXISTS LP select RP */
137484	{
137485	Expr *p;
137486	spanSet(&yymsp[-3].minor.yy190,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0); /A-overwrites-B/
137487	p = yymsp[-3].minor.yy190.pExpr = sqlite3PExpr(pParse, TK_EXISTS, 0, 0);
137488	sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy243);
137489	}
137490	break;
137491	case 196: /* expr ::= CASE case_operand case_exprlist case_else END */
137492	{
137493	spanSet(&yymsp[-4].minor.yy190,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0); /A-overwrites-C/
137494	yymsp[-4].minor.yy190.pExpr = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy72, 0);
137495	if( yymsp[-4].minor.yy190.pExpr ){
137496	yymsp[-4].minor.yy190.pExpr->x.pList = yymsp[-1].minor.yy72 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy148,yymsp[-1].minor.yy72) : yymsp[-2].minor.yy148;
	@@ -137499,313 +137952,314 @@
137499	sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy148);
137500	sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy72);
137501	}
137502	}
137503	break;
137504	case 197: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
137505	{
137506	yymsp[-4].minor.yy148 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy148, yymsp[-2].minor.yy190.pExpr);
137507	yymsp[-4].minor.yy148 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy148, yymsp[0].minor.yy190.pExpr);
137508	}
137509	break;
137510	case 198: /* case_exprlist ::= WHEN expr THEN expr */
137511	{
137512	yymsp[-3].minor.yy148 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy190.pExpr);
137513	yymsp[-3].minor.yy148 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy148, yymsp[0].minor.yy190.pExpr);
137514	}
137515	break;
137516	case 201: /* case_operand ::= expr */
137517	{yymsp[0].minor.yy72 = yymsp[0].minor.yy190.pExpr; /A-overwrites-X/}
137518	break;
137519	case 204: /* nexprlist ::= nexprlist COMMA expr */
137520	{yymsp[-2].minor.yy148 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy148,yymsp[0].minor.yy190.pExpr);}
137521	break;
137522	case 205: /* nexprlist ::= expr */
137523	{yymsp[0].minor.yy148 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy190.pExpr); /A-overwrites-Y/}
137524	break;
137525	case 207: /* paren_exprlist ::= LP exprlist RP */
137526	case 212: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==212);
137527	{yymsp[-2].minor.yy148 = yymsp[-1].minor.yy148;}
137528	break;
137529	case 208: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
137530	{
137531	sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0,
137532	sqlite3SrcListAppend(pParse->db,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy148, yymsp[-10].minor.yy194,
137533	&yymsp[-11].minor.yy0, yymsp[0].minor.yy72, SQLITE_SO_ASC, yymsp[-8].minor.yy194, SQLITE_IDXTYPE_APPDEF);
137534	}
137535	break;
137536	case 209: /* uniqueflag ::= UNIQUE */
137537	case 250: /* raisetype ::= ABORT */ yytestcase(yyruleno==250);
137538	{yymsp[0].minor.yy194 = OE_Abort;}
137539	break;
137540	case 210: /* uniqueflag ::= */
137541	{yymsp[1].minor.yy194 = OE_None;}
137542	break;
137543	case 213: /* eidlist ::= eidlist COMMA nm collate sortorder */
137544	{
137545	yymsp[-4].minor.yy148 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy148, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy194, yymsp[0].minor.yy194);
137546	}
137547	break;
137548	case 214: /* eidlist ::= nm collate sortorder */
137549	{
137550	yymsp[-2].minor.yy148 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy194, yymsp[0].minor.yy194); /A-overwrites-Y/
137551	}
137552	break;
137553	case 217: /* cmd ::= DROP INDEX ifexists fullname */
137554	{sqlite3DropIndex(pParse, yymsp[0].minor.yy185, yymsp[-1].minor.yy194);}
137555	break;
137556	case 218: /* cmd ::= VACUUM */
137557	{sqlite3Vacuum(pParse,0);}
137558	break;
137559	case 219: /* cmd ::= VACUUM nm */
137560	{sqlite3Vacuum(pParse,&yymsp[0].minor.yy0);}
137561	break;
137562	case 220: /* cmd ::= PRAGMA nm dbnm */
137563	{sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
137564	break;
137565	case 221: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
137566	{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);}
137567	break;
137568	case 222: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
137569	{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);}
137570	break;
137571	case 223: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
137572	{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);}
137573	break;
137574	case 224: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
137575	{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);}
137576	break;
137577	case 227: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
137578	{
137579	Token all;
137580	all.z = yymsp[-3].minor.yy0.z;
137581	all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
137582	sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy145, &all);
137583	}
137584	break;
137585	case 228: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
137586	{
137587	sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy194, yymsp[-4].minor.yy332.a, yymsp[-4].minor.yy332.b, yymsp[-2].minor.yy185, yymsp[0].minor.yy72, yymsp[-10].minor.yy194, yymsp[-8].minor.yy194);
137588	yymsp[-10].minor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0); /A-overwrites-T/
137589	}
137590	break;
137591	case 229: /* trigger_time ::= BEFORE */
137592	{ yymsp[0].minor.yy194 = TK_BEFORE; }
137593	break;
137594	case 230: /* trigger_time ::= AFTER */
137595	{ yymsp[0].minor.yy194 = TK_AFTER; }
137596	break;
137597	case 231: /* trigger_time ::= INSTEAD OF */
137598	{ yymsp[-1].minor.yy194 = TK_INSTEAD;}
137599	break;
137600	case 232: /* trigger_time ::= */
137601	{ yymsp[1].minor.yy194 = TK_BEFORE; }
137602	break;
137603	case 233: /* trigger_event ::= DELETE\|INSERT */
137604	case 234: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==234);
137605	{yymsp[0].minor.yy332.a = yymsp[0].major; /A-overwrites-X/ yymsp[0].minor.yy332.b = 0;}
137606	break;
137607	case 235: /* trigger_event ::= UPDATE OF idlist */
137608	{yymsp[-2].minor.yy332.a = TK_UPDATE; yymsp[-2].minor.yy332.b = yymsp[0].minor.yy254;}
137609	break;
137610	case 236: /* when_clause ::= */
137611	case 255: /* key_opt ::= */ yytestcase(yyruleno==255);
137612	{ yymsp[1].minor.yy72 = 0; }
137613	break;
137614	case 237: /* when_clause ::= WHEN expr */
137615	case 256: /* key_opt ::= KEY expr */ yytestcase(yyruleno==256);
137616	{ yymsp[-1].minor.yy72 = yymsp[0].minor.yy190.pExpr; }
137617	break;
137618	case 238: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
137619	{
137620	assert( yymsp[-2].minor.yy145!=0 );
137621	yymsp[-2].minor.yy145->pLast->pNext = yymsp[-1].minor.yy145;
137622	yymsp[-2].minor.yy145->pLast = yymsp[-1].minor.yy145;
137623	}
137624	break;
137625	case 239: /* trigger_cmd_list ::= trigger_cmd SEMI */
137626	{
137627	assert( yymsp[-1].minor.yy145!=0 );
137628	yymsp[-1].minor.yy145->pLast = yymsp[-1].minor.yy145;
137629	}
137630	break;
137631	case 240: /* trnm ::= nm DOT nm */
137632	{
137633	yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;
137634	sqlite3ErrorMsg(pParse,
137635	"qualified table names are not allowed on INSERT, UPDATE, and DELETE "
137636	"statements within triggers");
137637	}
137638	break;
137639	case 241: /* tridxby ::= INDEXED BY nm */
137640	{
137641	sqlite3ErrorMsg(pParse,
137642	"the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
137643	"within triggers");
137644	}
137645	break;
137646	case 242: /* tridxby ::= NOT INDEXED */
137647	{
137648	sqlite3ErrorMsg(pParse,
137649	"the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
137650	"within triggers");
137651	}
137652	break;
137653	case 243: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt */
137654	{yymsp[-6].minor.yy145 = sqlite3TriggerUpdateStep(pParse->db, &yymsp[-4].minor.yy0, yymsp[-1].minor.yy148, yymsp[0].minor.yy72, yymsp[-5].minor.yy194);}
137655	break;
137656	case 244: /* trigger_cmd ::= insert_cmd INTO trnm idlist_opt select */
137657	{yymsp[-4].minor.yy145 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy254, yymsp[0].minor.yy243, yymsp[-4].minor.yy194);/A-overwrites-R/}
137658	break;
137659	case 245: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt */
137660	{yymsp[-4].minor.yy145 = sqlite3TriggerDeleteStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[0].minor.yy72);}
137661	break;
137662	case 246: /* trigger_cmd ::= select */
137663	{yymsp[0].minor.yy145 = sqlite3TriggerSelectStep(pParse->db, yymsp[0].minor.yy243); /A-overwrites-X/}
137664	break;
137665	case 247: /* expr ::= RAISE LP IGNORE RP */
137666	{
137667	spanSet(&yymsp[-3].minor.yy190,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0); /A-overwrites-X/
137668	yymsp[-3].minor.yy190.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0);
137669	if( yymsp[-3].minor.yy190.pExpr ){
137670	yymsp[-3].minor.yy190.pExpr->affinity = OE_Ignore;
137671	}
137672	}
137673	break;
137674	case 248: /* expr ::= RAISE LP raisetype COMMA nm RP */
137675	{
137676	spanSet(&yymsp[-5].minor.yy190,&yymsp[-5].minor.yy0,&yymsp[0].minor.yy0); /A-overwrites-X/
137677	yymsp[-5].minor.yy190.pExpr = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1);
137678	if( yymsp[-5].minor.yy190.pExpr ) {
137679	yymsp[-5].minor.yy190.pExpr->affinity = (char)yymsp[-3].minor.yy194;
137680	}
137681	}
137682	break;
137683	case 249: /* raisetype ::= ROLLBACK */
137684	{yymsp[0].minor.yy194 = OE_Rollback;}
137685	break;
137686	case 251: /* raisetype ::= FAIL */
137687	{yymsp[0].minor.yy194 = OE_Fail;}
137688	break;
137689	case 252: /* cmd ::= DROP TRIGGER ifexists fullname */
137690	{
137691	sqlite3DropTrigger(pParse,yymsp[0].minor.yy185,yymsp[-1].minor.yy194);
137692	}
137693	break;
137694	case 253: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
137695	{
137696	sqlite3Attach(pParse, yymsp[-3].minor.yy190.pExpr, yymsp[-1].minor.yy190.pExpr, yymsp[0].minor.yy72);
137697	}
137698	break;
137699	case 254: /* cmd ::= DETACH database_kw_opt expr */
137700	{
137701	sqlite3Detach(pParse, yymsp[0].minor.yy190.pExpr);
137702	}
137703	break;
137704	case 257: /* cmd ::= REINDEX */
137705	{sqlite3Reindex(pParse, 0, 0);}
137706	break;
137707	case 258: /* cmd ::= REINDEX nm dbnm */
137708	{sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
137709	break;
137710	case 259: /* cmd ::= ANALYZE */
137711	{sqlite3Analyze(pParse, 0, 0);}
137712	break;
137713	case 260: /* cmd ::= ANALYZE nm dbnm */
137714	{sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
137715	break;
137716	case 261: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
137717	{
137718	sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy185,&yymsp[0].minor.yy0);
137719	}
137720	break;
137721	case 262: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
137722	{
137723	yymsp[-1].minor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-1].minor.yy0.z) + pParse->sLastToken.n;
137724	sqlite3AlterFinishAddColumn(pParse, &yymsp[-1].minor.yy0);
137725	}
137726	break;
137727	case 263: /* add_column_fullname ::= fullname */
137728	{
137729	disableLookaside(pParse);
137730	sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy185);
137731	}
137732	break;
137733	case 264: /* cmd ::= create_vtab */
137734	{sqlite3VtabFinishParse(pParse,0);}
137735	break;
137736	case 265: /* cmd ::= create_vtab LP vtabarglist RP */
137737	{sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
137738	break;
137739	case 266: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
137740	{
137741	sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy194);
137742	}
137743	break;
137744	case 267: /* vtabarg ::= */
137745	{sqlite3VtabArgInit(pParse);}
137746	break;
137747	case 268: /* vtabargtoken ::= ANY */
137748	case 269: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==269);
137749	case 270: /* lp ::= LP */ yytestcase(yyruleno==270);
137750	{sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
137751	break;
137752	case 271: /* with ::= */
137753	{yymsp[1].minor.yy285 = 0;}
137754	break;
137755	case 272: /* with ::= WITH wqlist */
137756	{ yymsp[-1].minor.yy285 = yymsp[0].minor.yy285; }
137757	break;
137758	case 273: /* with ::= WITH RECURSIVE wqlist */
137759	{ yymsp[-2].minor.yy285 = yymsp[0].minor.yy285; }
137760	break;
137761	case 274: /* wqlist ::= nm eidlist_opt AS LP select RP */
137762	{
137763	yymsp[-5].minor.yy285 = sqlite3WithAdd(pParse, 0, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy148, yymsp[-1].minor.yy243); /A-overwrites-X/
137764	}
137765	break;
137766	case 275: /* wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */
137767	{
137768	yymsp[-7].minor.yy285 = sqlite3WithAdd(pParse, yymsp[-7].minor.yy285, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy148, yymsp[-1].minor.yy243);
137769	}
137770	break;
137771	default:
137772	/* (276) input ::= cmdlist */ yytestcase(yyruleno==276);
137773	/* (277) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==277);
137774	/* (278) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=278);
137775	/* (279) ecmd ::= SEMI */ yytestcase(yyruleno==279);
137776	/* (280) ecmd ::= explain cmdx SEMI */ yytestcase(yyruleno==280);
137777	/* (281) explain ::= */ yytestcase(yyruleno==281);
137778	/* (282) trans_opt ::= */ yytestcase(yyruleno==282);
137779	/* (283) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==283);
137780	/* (284) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==284);
137781	/* (285) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==285);
137782	/* (286) savepoint_opt ::= */ yytestcase(yyruleno==286);
137783	/* (287) cmd ::= create_table create_table_args */ yytestcase(yyruleno==287);
137784	/* (288) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==288);
137785	/* (289) columnlist ::= columnname carglist */ yytestcase(yyruleno==289);
137786	/* (290) nm ::= ID\|INDEXED */ yytestcase(yyruleno==290);
137787	/* (291) nm ::= STRING */ yytestcase(yyruleno==291);
137788	/* (292) nm ::= JOIN_KW */ yytestcase(yyruleno==292);
137789	/* (293) typetoken ::= typename */ yytestcase(yyruleno==293);
137790	/* (294) typename ::= ID\|STRING */ yytestcase(yyruleno==294);
137791	/* (295) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=295);
137792	/* (296) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=296);
137793	/* (297) carglist ::= carglist ccons */ yytestcase(yyruleno==297);
137794	/* (298) carglist ::= */ yytestcase(yyruleno==298);
137795	/* (299) ccons ::= NULL onconf */ yytestcase(yyruleno==299);
137796	/* (300) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==300);
137797	/* (301) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==301);
137798	/* (302) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=302);
137799	/* (303) tconscomma ::= */ yytestcase(yyruleno==303);
137800	/* (304) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=304);
137801	/* (305) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=305);
137802	/* (306) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=306);
137803	/* (307) oneselect ::= values */ yytestcase(yyruleno==307);
137804	/* (308) sclp ::= selcollist COMMA */ yytestcase(yyruleno==308);
137805	/* (309) as ::= ID\|STRING */ yytestcase(yyruleno==309);
137806	/* (310) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=310);

137807	/* (311) exprlist ::= nexprlist */ yytestcase(yyruleno==311);
137808	/* (312) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=312);
137809	/* (313) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=313);
137810	/* (314) nmnum ::= ON */ yytestcase(yyruleno==314);
137811	/* (315) nmnum ::= DELETE */ yytestcase(yyruleno==315);
	@@ -138854,12 +139308,12 @@
138854	** memory obtained from sqlite3_malloc() and to make *pzErrMsg point to that
138855	** error message.
138856	*/
138857	SQLITE_PRIVATE int sqlite3RunParser(Parse pParse, const char zSql, char **pzErrMsg){
138858	int nErr = 0; /* Number of errors encountered */
138859	int i; /* Loop counter */
138860	void pEngine; / The LEMON-generated LALR(1) parser */

138861	int tokenType; /* type of the next token */
138862	int lastTokenParsed = -1; /* type of the previous token */
138863	sqlite3 db = pParse->db; / The database connection */
138864	int mxSqlLen; /* Max length of an SQL string */
138865	#ifdef sqlite3Parser_ENGINEALWAYSONSTACK
	@@ -138871,11 +139325,10 @@
138871	if( db->nVdbeActive==0 ){
138872	db->u1.isInterrupted = 0;
138873	}
138874	pParse->rc = SQLITE_OK;
138875	pParse->zTail = zSql;
138876	i = 0;
138877	assert( pzErrMsg!=0 );
138878	/* sqlite3ParserTrace(stdout, "parser: "); */
138879	#ifdef sqlite3Parser_ENGINEALWAYSONSTACK
138880	pEngine = zSpace;
138881	sqlite3ParserInit(pEngine);
	@@ -138889,16 +139342,14 @@
138889	assert( pParse->pNewTable==0 );
138890	assert( pParse->pNewTrigger==0 );
138891	assert( pParse->nVar==0 );
138892	assert( pParse->pVList==0 );
138893	while( 1 ){
138894	assert( i>=0 );
138895	if( zSql[i]!=0 ){
138896	pParse->sLastToken.z = &zSql[i];
138897	pParse->sLastToken.n = sqlite3GetToken((u8*)&zSql[i],&tokenType);
138898	i += pParse->sLastToken.n;
138899	if( i>mxSqlLen ){
138900	pParse->rc = SQLITE_TOOBIG;
138901	break;
138902	}
138903	}else{
138904	/* Upon reaching the end of input, call the parser two more times
	@@ -138908,30 +139359,34 @@
138908	}else if( lastTokenParsed==0 ){
138909	break;
138910	}else{
138911	tokenType = TK_SEMI;
138912	}

138913	}
138914	if( tokenType>=TK_SPACE ){
138915	assert( tokenType==TK_SPACE \|\| tokenType==TK_ILLEGAL );
138916	if( db->u1.isInterrupted ){
138917	pParse->rc = SQLITE_INTERRUPT;
138918	break;
138919	}
138920	if( tokenType==TK_ILLEGAL ){
138921	sqlite3ErrorMsg(pParse, "unrecognized token: \"%T\"",
138922	&pParse->sLastToken);
138923	break;
138924	}

138925	}else{


138926	sqlite3Parser(pEngine, tokenType, pParse->sLastToken, pParse);
138927	lastTokenParsed = tokenType;

138928	if( pParse->rc!=SQLITE_OK \|\| db->mallocFailed ) break;
138929	}
138930	}
138931	assert( nErr==0 );
138932	pParse->zTail = &zSql[i];
138933	#ifdef YYTRACKMAXSTACKDEPTH
138934	sqlite3_mutex_enter(sqlite3MallocMutex());
138935	sqlite3StatusHighwater(SQLITE_STATUS_PARSER_STACK,
138936	sqlite3ParserStackPeak(pEngine)
138937	);
	@@ -140301,10 +140756,25 @@
140301	return 0;
140302	}
140303	#endif
140304	return db->lastRowid;
140305	}















140306
140307	/*
140308	** Return the number of changes in the most recent call to sqlite3_exec().
140309	*/
140310	SQLITE_API int sqlite3_changes(sqlite3 *db){
	@@ -148111,12 +148581,14 @@
148111	** segments.
148112	*/
148113	const u32 nMinMerge = 64; /* Minimum amount of incr-merge work to do */
148114
148115	Fts3Table p = (Fts3Table)pVtab;
148116	int rc = sqlite3Fts3PendingTermsFlush(p);

148117

148118	if( rc==SQLITE_OK
148119	&& p->nLeafAdd>(nMinMerge/16)
148120	&& p->nAutoincrmerge && p->nAutoincrmerge!=0xff
148121	){
148122	int mxLevel = 0; /* Maximum relative level value in db */
	@@ -148127,10 +148599,11 @@
148127	A = p->nLeafAdd * mxLevel;
148128	A += (A/2);
148129	if( A>(int)nMinMerge ) rc = sqlite3Fts3Incrmerge(p, A, p->nAutoincrmerge);
148130	}
148131	sqlite3Fts3SegmentsClose(p);

148132	return rc;
148133	}
148134
148135	/*
148136	** If it is currently unknown whether or not the FTS table has an %_stat
	@@ -168462,10 +168935,11 @@
168462	int nStep; /* Rows processed for current object */
168463	int nProgress; /* Rows processed for all objects */
168464	RbuObjIter objiter; /* Iterator for skipping through tbl/idx */
168465	const char zVfsName; / Name of automatically created rbu vfs */
168466	rbu_file pTargetFd; / File handle open on target db */

168467	i64 iOalSz;
168468	i64 nPhaseOneStep;
168469
168470	/* The following state variables are used as part of the incremental
168471	** checkpoint stage (eStage==RBU_STAGE_CKPT). See comments surrounding
	@@ -170726,10 +171200,27 @@
170726
170727	if( p->rc==SQLITE_OK ){
170728	if( p->nFrame==0 \|\| (pState && pState->iWalCksum!=p->iWalCksum) ){
170729	p->rc = SQLITE_DONE;
170730	p->eStage = RBU_STAGE_DONE;

















170731	}
170732	}
170733	}
170734
170735	/*
	@@ -171381,13 +171872,30 @@
171381	if( p->rc==SQLITE_OK ){
171382	p->eStage = RBU_STAGE_DONE;
171383	p->rc = SQLITE_DONE;
171384	}
171385	}else{
171386	RbuFrame *pFrame = &p->aFrame[p->nStep];
171387	rbuCheckpointFrame(p, pFrame);
171388	p->nStep++;

















171389	}
171390	p->nProgress++;
171391	}
171392	break;
171393	}
	@@ -171823,10 +172331,16 @@
171823
171824	/* Commit the transaction to the -oal file. /
171825	if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_OAL ){
171826	p->rc = sqlite3_exec(p->dbMain, "COMMIT", 0, 0, &p->zErrmsg);
171827	}






171828
171829	rbuSaveState(p, p->eStage);
171830
171831	if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_OAL ){
171832	p->rc = sqlite3_exec(p->dbRbu, "COMMIT", 0, 0, &p->zErrmsg);
	@@ -171947,10 +172461,16 @@
171947	assert( p->eStage>=RBU_STAGE_OAL && p->eStage<=RBU_STAGE_DONE );
171948	if( p->eStage==RBU_STAGE_OAL ){
171949	assert( rc!=SQLITE_DONE );
171950	if( rc==SQLITE_OK ) rc = sqlite3_exec(p->dbMain, "COMMIT", 0, 0, 0);
171951	}






171952
171953	p->rc = rc;
171954	rbuSaveState(p, p->eStage);
171955	rc = p->rc;
171956
	@@ -181079,11 +181599,13 @@
181079	typedef unsigned short u16;
181080	typedef short i16;
181081	typedef sqlite3_int64 i64;
181082	typedef sqlite3_uint64 u64;
181083
181084	#define ArraySize(x) ((int)(sizeof(x) / sizeof(x[0])))


181085
181086	#define testcase(x)
181087	#define ALWAYS(x) 1
181088	#define NEVER(x) 0
181089
	@@ -186302,11 +186824,14 @@
186302	if( p1->bEof==0 ){
186303	if( (p1->iRowid==iLast)
186304	\|\| (bFromValid && fts5RowidCmp(pExpr, p1->iRowid, iFrom)<0)
186305	){
186306	int rc = fts5ExprNodeNext(pExpr, p1, bFromValid, iFrom);
186307	if( rc!=SQLITE_OK ) return rc;



186308	}
186309	}
186310	}
186311
186312	fts5ExprNodeTest_OR(pExpr, pNode);
	@@ -186333,11 +186858,14 @@
186333	Fts5ExprNode *pChild = pAnd->apChild[iChild];
186334	int cmp = fts5RowidCmp(pExpr, iLast, pChild->iRowid);
186335	if( cmp>0 ){
186336	/* Advance pChild until it points to iLast or laster */
186337	rc = fts5ExprNodeNext(pExpr, pChild, 1, iLast);
186338	if( rc!=SQLITE_OK ) return rc;



186339	}
186340
186341	/* If the child node is now at EOF, so is the parent AND node. Otherwise,
186342	** the child node is guaranteed to have advanced at least as far as
186343	** rowid iLast. So if it is not at exactly iLast, pChild->iRowid is the
	@@ -186372,10 +186900,12 @@
186372	i64 iFrom
186373	){
186374	int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
186375	if( rc==SQLITE_OK ){
186376	rc = fts5ExprNodeTest_AND(pExpr, pNode);


186377	}
186378	return rc;
186379	}
186380
186381	static int fts5ExprNodeTest_NOT(
	@@ -186414,10 +186944,13 @@
186414	){
186415	int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
186416	if( rc==SQLITE_OK ){
186417	rc = fts5ExprNodeTest_NOT(pExpr, pNode);
186418	}



186419	return rc;
186420	}
186421
186422	/*
186423	** If pNode currently points to a match, this function returns SQLITE_OK
	@@ -197534,11 +198067,11 @@
197534	int nArg, /* Number of args */
197535	sqlite3_value *apUnused / Function arguments */
197536	){
197537	assert( nArg==0 );
197538	UNUSED_PARAM2(nArg, apUnused);
197539	sqlite3_result_text(pCtx, "fts5: 2017-02-13 16:02:40 ada05cfa86ad7f5645450ac7a2a21c9aa6e57d2c", -1, SQLITE_TRANSIENT);
197540	}
197541
197542	static int fts5Init(sqlite3 *db){
197543	static const sqlite3_module fts5Mod = {
197544	/* iVersion */ 2,
	@@ -198197,15 +198730,10 @@
198197	sqlite3_step(pDel);
198198	rc = sqlite3_reset(pDel);
198199	}
198200	}
198201
198202	/* Write the averages record */
198203	if( rc==SQLITE_OK ){
198204	rc = fts5StorageSaveTotals(p);
198205	}
198206
198207	return rc;
198208	}
198209
198210	/*
198211	** Delete all entries in the FTS5 index.
	@@ -198405,15 +198933,10 @@
198405	if( rc==SQLITE_OK ){
198406	rc = fts5StorageInsertDocsize(p, iRowid, &buf);
198407	}
198408	sqlite3_free(buf.p);
198409
198410	/* Write the averages record */
198411	if( rc==SQLITE_OK ){
198412	rc = fts5StorageSaveTotals(p);
198413	}
198414
198415	return rc;
198416	}
198417
198418	static int fts5StorageCount(Fts5Storage p, const char zSuffix, i64 *pnRow){
198419	Fts5Config *pConfig = p->pConfig;
	@@ -198744,16 +199267,21 @@
198744
198745	/*
198746	** Flush any data currently held in-memory to disk.
198747	*/
198748	static int sqlite3Fts5StorageSync(Fts5Storage *p, int bCommit){
198749	if( bCommit && p->bTotalsValid ){
198750	int rc = fts5StorageSaveTotals(p);
198751	p->bTotalsValid = 0;
198752	if( rc!=SQLITE_OK ) return rc;

198753	}
198754	return sqlite3Fts5IndexSync(p->pIndex, bCommit);




198755	}
198756
198757	static int sqlite3Fts5StorageRollback(Fts5Storage *p){
198758	p->bTotalsValid = 0;
198759	return sqlite3Fts5IndexRollback(p->pIndex);
198760

	--- src/sqlite3.c
	+++ src/sqlite3.c
	@@ -1,8 +1,8 @@
1	/******************************************************************************
2	** This file is an amalgamation of many separate C source files from SQLite
3	** version 3.18.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.
	@@ -396,13 +396,13 @@
396	**
397	** See also: [sqlite3_libversion()],
398	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
399	** [sqlite_version()] and [sqlite_source_id()].
400	*/
401	#define SQLITE_VERSION "3.18.0"
402	#define SQLITE_VERSION_NUMBER 3018000
403	#define SQLITE_SOURCE_ID "2017-03-10 17:03:11 f8560c60d10c0365b33342ab05b5a953987b0471"
404
405	/*
406	** CAPI3REF: Run-Time Library Version Numbers
407	** KEYWORDS: sqlite3_version sqlite3_sourceid
408	**
	@@ -2315,24 +2315,34 @@
2315	** as an undeclared column named ROWID, OID, or _ROWID_ as long as those
2316	** names are not also used by explicitly declared columns. ^If
2317	** the table has a column of type [INTEGER PRIMARY KEY] then that column
2318	** is another alias for the rowid.
2319	**
2320	** ^The sqlite3_last_insert_rowid(D) interface usually returns the [rowid] of
2321	** the most recent successful [INSERT] into a rowid table or [virtual table]
2322	** on database connection D. ^Inserts into [WITHOUT ROWID] tables are not
2323	** recorded. ^If no successful [INSERT]s into rowid tables have ever occurred
2324	** on the database connection D, then sqlite3_last_insert_rowid(D) returns
2325	** zero.

2326	**
2327	** As well as being set automatically as rows are inserted into database
2328	** tables, the value returned by this function may be set explicitly by
2329	** [sqlite3_set_last_insert_rowid()]
2330	**
2331	** Some virtual table implementations may INSERT rows into rowid tables as
2332	** part of committing a transaction (e.g. to flush data accumulated in memory
2333	** to disk). In this case subsequent calls to this function return the rowid
2334	** associated with these internal INSERT operations, which leads to
2335	** unintuitive results. Virtual table implementations that do write to rowid
2336	** tables in this way can avoid this problem by restoring the original
2337	** rowid value using [sqlite3_set_last_insert_rowid()] before returning
2338	** control to the user.
2339	**
2340	** ^(If an [INSERT] occurs within a trigger then this routine will
2341	** return the [rowid] of the inserted row as long as the trigger is
2342	** running. Once the trigger program ends, the value returned
2343	** by this routine reverts to what it was before the trigger was fired.)^
2344	**
2345	** ^An [INSERT] that fails due to a constraint violation is not a
2346	** successful [INSERT] and does not change the value returned by this
2347	** routine. ^Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK,
2348	** and INSERT OR ABORT make no changes to the return value of this
	@@ -2355,10 +2365,20 @@
2365	** unpredictable and might not equal either the old or the new
2366	** last insert [rowid].
2367	*/
2368	SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);
2369
2370	/*
2371	** CAPI3REF: Set the Last Insert Rowid value.
2372	** METHOD: sqlite3
2373	**
2374	** The sqlite3_set_last_insert_rowid(D, R) method allows the application to
2375	** set the value returned by calling sqlite3_last_insert_rowid(D) to R
2376	** without inserting a row into the database.
2377	*/
2378	SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3*,sqlite3_int64);
2379
2380	/*
2381	** CAPI3REF: Count The Number Of Rows Modified
2382	** METHOD: sqlite3
2383	**
2384	** ^This function returns the number of rows modified, inserted or
	@@ -12457,10 +12477,11 @@
12477	SQLITE_PRIVATE const void sqlite3BtreePayloadFetch(BtCursor, u32 *pAmt);
12478	SQLITE_PRIVATE u32 sqlite3BtreePayloadSize(BtCursor*);
12479
12480	SQLITE_PRIVATE char sqlite3BtreeIntegrityCheck(Btree, int aRoot, int nRoot, int, int);
12481	SQLITE_PRIVATE struct Pager sqlite3BtreePager(Btree);
12482	SQLITE_PRIVATE i64 sqlite3BtreeRowCountEst(BtCursor*);
12483
12484	#ifndef SQLITE_OMIT_INCRBLOB
12485	SQLITE_PRIVATE int sqlite3BtreePayloadChecked(BtCursor, u32 offset, u32 amt, void);
12486	SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor, u32 offset, u32 amt, void);
12487	SQLITE_PRIVATE void sqlite3BtreeIncrblobCursor(BtCursor *);
	@@ -12757,117 +12778,119 @@
12778	#define OP_Divide 50 /* same as TK_SLASH, synopsis: r[P3]=r[P2]/r[P1] */
12779	#define OP_Remainder 51 /* same as TK_REM, synopsis: r[P3]=r[P2]%r[P1] */
12780	#define OP_Concat 52 /* same as TK_CONCAT, synopsis: r[P3]=r[P2]+r[P1] */
12781	#define OP_Last 53
12782	#define OP_BitNot 54 /* same as TK_BITNOT, synopsis: r[P1]= ~r[P1] */
12783	#define OP_IfSmaller 55
12784	#define OP_SorterSort 56
12785	#define OP_Sort 57
12786	#define OP_Rewind 58
12787	#define OP_IdxLE 59 /* synopsis: key=r[P3@P4] */
12788	#define OP_IdxGT 60 /* synopsis: key=r[P3@P4] */
12789	#define OP_IdxLT 61 /* synopsis: key=r[P3@P4] */
12790	#define OP_IdxGE 62 /* synopsis: key=r[P3@P4] */
12791	#define OP_RowSetRead 63 /* synopsis: r[P3]=rowset(P1) */
12792	#define OP_RowSetTest 64 /* synopsis: if r[P3] in rowset(P1) goto P2 */
12793	#define OP_Program 65
12794	#define OP_FkIfZero 66 /* synopsis: if fkctr[P1]==0 goto P2 */
12795	#define OP_IfPos 67 /* synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 */
12796	#define OP_IfNotZero 68 /* synopsis: if r[P1]!=0 then r[P1]--, goto P2 */
12797	#define OP_DecrJumpZero 69 /* synopsis: if (--r[P1])==0 goto P2 */
12798	#define OP_IncrVacuum 70
12799	#define OP_VNext 71
12800	#define OP_Init 72 /* synopsis: Start at P2 */
12801	#define OP_Return 73
12802	#define OP_EndCoroutine 74
12803	#define OP_HaltIfNull 75 /* synopsis: if r[P3]=null halt */
12804	#define OP_Halt 76
12805	#define OP_Integer 77 /* synopsis: r[P2]=P1 */
12806	#define OP_Int64 78 /* synopsis: r[P2]=P4 */
12807	#define OP_String 79 /* synopsis: r[P2]='P4' (len=P1) */
12808	#define OP_Null 80 /* synopsis: r[P2..P3]=NULL */
12809	#define OP_SoftNull 81 /* synopsis: r[P1]=NULL */
12810	#define OP_Blob 82 /* synopsis: r[P2]=P4 (len=P1) */
12811	#define OP_Variable 83 /* synopsis: r[P2]=parameter(P1,P4) */
12812	#define OP_Move 84 /* synopsis: r[P2@P3]=r[P1@P3] */
12813	#define OP_Copy 85 /* synopsis: r[P2@P3+1]=r[P1@P3+1] */
12814	#define OP_SCopy 86 /* synopsis: r[P2]=r[P1] */
12815	#define OP_IntCopy 87 /* synopsis: r[P2]=r[P1] */
12816	#define OP_ResultRow 88 /* synopsis: output=r[P1@P2] */
12817	#define OP_CollSeq 89
12818	#define OP_Function0 90 /* synopsis: r[P3]=func(r[P2@P5]) */
12819	#define OP_Function 91 /* synopsis: r[P3]=func(r[P2@P5]) */
12820	#define OP_AddImm 92 /* synopsis: r[P1]=r[P1]+P2 */
12821	#define OP_RealAffinity 93
12822	#define OP_Cast 94 /* synopsis: affinity(r[P1]) */
12823	#define OP_Permutation 95
12824	#define OP_Compare 96 /* synopsis: r[P1@P3] <-> r[P2@P3] */
12825	#define OP_String8 97 /* same as TK_STRING, synopsis: r[P2]='P4' */
12826	#define OP_Column 98 /* synopsis: r[P3]=PX */
12827	#define OP_Affinity 99 /* synopsis: affinity(r[P1@P2]) */
12828	#define OP_MakeRecord 100 /* synopsis: r[P3]=mkrec(r[P1@P2]) */
12829	#define OP_Count 101 /* synopsis: r[P2]=count() */
12830	#define OP_ReadCookie 102
12831	#define OP_SetCookie 103
12832	#define OP_ReopenIdx 104 /* synopsis: root=P2 iDb=P3 */
12833	#define OP_OpenRead 105 /* synopsis: root=P2 iDb=P3 */
12834	#define OP_OpenWrite 106 /* synopsis: root=P2 iDb=P3 */
12835	#define OP_OpenAutoindex 107 /* synopsis: nColumn=P2 */
12836	#define OP_OpenEphemeral 108 /* synopsis: nColumn=P2 */
12837	#define OP_SorterOpen 109
12838	#define OP_SequenceTest 110 /* synopsis: if( cursor[P1].ctr++ ) pc = P2 */
12839	#define OP_OpenPseudo 111 /* synopsis: P3 columns in r[P2] */
12840	#define OP_Close 112
12841	#define OP_ColumnsUsed 113
12842	#define OP_Sequence 114 /* synopsis: r[P2]=cursor[P1].ctr++ */
12843	#define OP_NewRowid 115 /* synopsis: r[P2]=rowid */
12844	#define OP_Insert 116 /* synopsis: intkey=r[P3] data=r[P2] */
12845	#define OP_InsertInt 117 /* synopsis: intkey=P3 data=r[P2] */
12846	#define OP_Delete 118
12847	#define OP_ResetCount 119
12848	#define OP_SorterCompare 120 /* synopsis: if key(P1)!=trim(r[P3],P4) goto P2 */
12849	#define OP_SorterData 121 /* synopsis: r[P2]=data */
12850	#define OP_RowData 122 /* synopsis: r[P2]=data */
12851	#define OP_Rowid 123 /* synopsis: r[P2]=rowid */
12852	#define OP_NullRow 124
12853	#define OP_SorterInsert 125 /* synopsis: key=r[P2] */
12854	#define OP_IdxInsert 126 /* synopsis: key=r[P2] */
12855	#define OP_IdxDelete 127 /* synopsis: key=r[P2@P3] */
12856	#define OP_Seek 128 /* synopsis: Move P3 to P1.rowid */
12857	#define OP_IdxRowid 129 /* synopsis: r[P2]=rowid */
12858	#define OP_Destroy 130
12859	#define OP_Clear 131
12860	#define OP_Real 132 /* same as TK_FLOAT, synopsis: r[P2]=P4 */
12861	#define OP_ResetSorter 133
12862	#define OP_CreateIndex 134 /* synopsis: r[P2]=root iDb=P1 */
12863	#define OP_CreateTable 135 /* synopsis: r[P2]=root iDb=P1 */
12864	#define OP_SqlExec 136
12865	#define OP_ParseSchema 137
12866	#define OP_LoadAnalysis 138
12867	#define OP_DropTable 139
12868	#define OP_DropIndex 140
12869	#define OP_DropTrigger 141
12870	#define OP_IntegrityCk 142
12871	#define OP_RowSetAdd 143 /* synopsis: rowset(P1)=r[P2] */
12872	#define OP_Param 144
12873	#define OP_FkCounter 145 /* synopsis: fkctr[P1]+=P2 */
12874	#define OP_MemMax 146 /* synopsis: r[P1]=max(r[P1],r[P2]) */
12875	#define OP_OffsetLimit 147 /* synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1) */
12876	#define OP_AggStep0 148 /* synopsis: accum=r[P3] step(r[P2@P5]) */
12877	#define OP_AggStep 149 /* synopsis: accum=r[P3] step(r[P2@P5]) */
12878	#define OP_AggFinal 150 /* synopsis: accum=r[P1] N=P2 */
12879	#define OP_Expire 151
12880	#define OP_TableLock 152 /* synopsis: iDb=P1 root=P2 write=P3 */
12881	#define OP_VBegin 153
12882	#define OP_VCreate 154
12883	#define OP_VDestroy 155
12884	#define OP_VOpen 156
12885	#define OP_VColumn 157 /* synopsis: r[P3]=vcolumn(P2) */
12886	#define OP_VRename 158
12887	#define OP_Pagecount 159
12888	#define OP_MaxPgcnt 160
12889	#define OP_CursorHint 161
12890	#define OP_Noop 162
12891	#define OP_Explain 163
12892
12893	/* Properties such as "out2" or "jump" that are specified in
12894	** comments following the "case" for each opcode in the vdbe.c
12895	** are encoded into bitvectors as follows:
12896	*/
	@@ -12883,32 +12906,32 @@
12906	/* 16 */ 0x03, 0x03, 0x01, 0x12, 0x01, 0x03, 0x03, 0x09,\
12907	/* 24 */ 0x09, 0x09, 0x09, 0x26, 0x26, 0x09, 0x09, 0x09,\
12908	/* 32 */ 0x09, 0x09, 0x03, 0x03, 0x0b, 0x0b, 0x0b, 0x0b,\
12909	/* 40 */ 0x0b, 0x0b, 0x01, 0x26, 0x26, 0x26, 0x26, 0x26,\
12910	/* 48 */ 0x26, 0x26, 0x26, 0x26, 0x26, 0x01, 0x12, 0x01,\
12911	/* 56 */ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x23,\
12912	/* 64 */ 0x0b, 0x01, 0x01, 0x03, 0x03, 0x03, 0x01, 0x01,\
12913	/* 72 */ 0x01, 0x02, 0x02, 0x08, 0x00, 0x10, 0x10, 0x10,\
12914	/* 80 */ 0x10, 0x00, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10,\
12915	/* 88 */ 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x00,\
12916	/* 96 */ 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00,\
12917	/* 104 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
12918	/* 112 */ 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,\
12919	/* 120 */ 0x00, 0x00, 0x00, 0x10, 0x00, 0x04, 0x04, 0x00,\
12920	/* 128 */ 0x00, 0x10, 0x10, 0x00, 0x10, 0x00, 0x10, 0x10,\
12921	/* 136 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,\
12922	/* 144 */ 0x10, 0x00, 0x04, 0x1a, 0x00, 0x00, 0x00, 0x00,\
12923	/* 152 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,\
12924	/* 160 */ 0x10, 0x00, 0x00, 0x00,}
12925
12926	/* The sqlite3P2Values() routine is able to run faster if it knows
12927	** the value of the largest JUMP opcode. The smaller the maximum
12928	** JUMP opcode the better, so the mkopcodeh.tcl script that
12929	** generated this include file strives to group all JUMP opcodes
12930	** together near the beginning of the list.
12931	*/
12932	#define SQLITE_MX_JUMP_OPCODE 72 /* Maximum JUMP opcode */
12933
12934	/************ End of opcodes.h *******************************************/
12935	/************ Continuing where we left off in vdbe.h *********************/
12936
12937	/*
	@@ -14074,10 +14097,11 @@
14097	u8 suppressErr; /* Do not issue error messages if true */
14098	u8 vtabOnConflict; /* Value to return for s3_vtab_on_conflict() */
14099	u8 isTransactionSavepoint; /* True if the outermost savepoint is a TS */
14100	u8 mTrace; /* zero or more SQLITE_TRACE flags */
14101	u8 skipBtreeMutex; /* True if no shared-cache backends */
14102	u8 nSqlExec; /* Number of pending OP_SqlExec opcodes */
14103	int nextPagesize; /* Pagesize after VACUUM if >0 */
14104	u32 magic; /* Magic number for detect library misuse */
14105	int nChange; /* Value returned by sqlite3_changes() */
14106	int nTotalChange; /* Value returned by sqlite3_total_changes() */
14107	int aLimit[SQLITE_N_LIMIT]; /* Limits */
	@@ -14589,18 +14613,18 @@
14613	char zColAff; / String defining the affinity of each column */
14614	ExprList pCheck; / All CHECK constraints */
14615	/* ... also used as column name list in a VIEW */
14616	int tnum; /* Root BTree page for this table */
14617	u32 nTabRef; /* Number of pointers to this Table */
14618	u32 tabFlags; /* Mask of TF_* values */
14619	i16 iPKey; /* If not negative, use aCol[iPKey] as the rowid */
14620	i16 nCol; /* Number of columns in this table */
14621	LogEst nRowLogEst; /* Estimated rows in table - from sqlite_stat1 table */
14622	LogEst szTabRow; /* Estimated size of each table row in bytes */
14623	#ifdef SQLITE_ENABLE_COSTMULT
14624	LogEst costMult; /* Cost multiplier for using this table */
14625	#endif

14626	u8 keyConf; /* What to do in case of uniqueness conflict on iPKey */
14627	#ifndef SQLITE_OMIT_ALTERTABLE
14628	int addColOffset; /* Offset in CREATE TABLE stmt to add a new column */
14629	#endif
14630	#ifndef SQLITE_OMIT_VIRTUALTABLE
	@@ -14620,27 +14644,29 @@
14644	** followed by non-hidden columns. Example: "CREATE VIRTUAL TABLE x USING
14645	** vtab1(a HIDDEN, b);". Since "b" is a non-hidden column but "a" is hidden,
14646	** the TF_OOOHidden attribute would apply in this case. Such tables require
14647	** special handling during INSERT processing.
14648	*/
14649	#define TF_Readonly 0x0001 /* Read-only system table */
14650	#define TF_Ephemeral 0x0002 /* An ephemeral table */
14651	#define TF_HasPrimaryKey 0x0004 /* Table has a primary key */
14652	#define TF_Autoincrement 0x0008 /* Integer primary key is autoincrement */
14653	#define TF_HasStat1 0x0010 /* nRowLogEst set from sqlite_stat1 */
14654	#define TF_WithoutRowid 0x0020 /* No rowid. PRIMARY KEY is the key */
14655	#define TF_NoVisibleRowid 0x0040 /* No user-visible "rowid" column */
14656	#define TF_OOOHidden 0x0080 /* Out-of-Order hidden columns */
14657	#define TF_StatsUsed 0x0100 /* Query planner decisions affected by
14658	** Index.aiRowLogEst[] values */
14659	#define TF_HasNotNull 0x0200 /* Contains NOT NULL constraints */
14660
14661	/*
14662	** Test to see whether or not a table is a virtual table. This is
14663	** done as a macro so that it will be optimized out when virtual
14664	** table support is omitted from the build.
14665	*/
14666	#ifndef SQLITE_OMIT_VIRTUALTABLE
14667	# define IsVirtual(X) ((X)->nModuleArg)
14668	#else
14669	# define IsVirtual(X) 0
14670	#endif
14671
14672	/*
	@@ -14871,10 +14897,11 @@
14897	unsigned bUnordered:1; /* Use this index for == or IN queries only */
14898	unsigned uniqNotNull:1; /* True if UNIQUE and NOT NULL for all columns */
14899	unsigned isResized:1; /* True if resizeIndexObject() has been called */
14900	unsigned isCovering:1; /* True if this is a covering index */
14901	unsigned noSkipScan:1; /* Do not try to use skip-scan if true */
14902	unsigned hasStat1:1; /* aiRowLogEst values come from sqlite_stat1 */
14903	#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
14904	int nSample; /* Number of elements in aSample[] */
14905	int nSampleCol; /* Size of IndexSample.anEq[] and so on */
14906	tRowcnt aAvgEq; / Average nEq values for keys not in aSample */
14907	IndexSample aSample; / Samples of the left-most key */
	@@ -15181,11 +15208,11 @@
15208	** form is used for name resolution with nested FROM clauses.
15209	*/
15210	struct ExprList {
15211	int nExpr; /* Number of expressions on the list */
15212	struct ExprList_item { /* For each expression in the list */
15213	Expr pExpr; / The parse tree for this expression */
15214	char zName; / Token associated with this expression */
15215	char zSpan; / Original text of the expression */
15216	u8 sortOrder; /* 1 for DESC or 0 for ASC */
15217	unsigned done :1; /* A flag to indicate when processing is finished */
15218	unsigned bSpanIsTab :1; /* zSpan holds DB.TABLE.COLUMN */
	@@ -16504,10 +16531,11 @@
16531	SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3,int,const char);
16532	SQLITE_PRIVATE void sqlite3Vacuum(Parse,Token);
16533	SQLITE_PRIVATE int sqlite3RunVacuum(char*, sqlite3, int);
16534	SQLITE_PRIVATE char sqlite3NameFromToken(sqlite3, Token*);
16535	SQLITE_PRIVATE int sqlite3ExprCompare(Expr, Expr, int);
16536	SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr, Expr, int);
16537	SQLITE_PRIVATE int sqlite3ExprListCompare(ExprList, ExprList, int);
16538	SQLITE_PRIVATE int sqlite3ExprImpliesExpr(Expr, Expr, int);
16539	SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext, Expr);
16540	SQLITE_PRIVATE void sqlite3ExprAnalyzeAggList(NameContext,ExprList);
16541	SQLITE_PRIVATE int sqlite3ExprCoveredByIndex(Expr, int iCur, Index pIdx);
	@@ -17450,11 +17478,11 @@
17478	"COMPILER=gcc-" __VERSION__,
17479	#endif
17480	#if SQLITE_COVERAGE_TEST
17481	"COVERAGE_TEST",
17482	#endif
17483	#ifdef SQLITE_DEBUG
17484	"DEBUG",
17485	#endif
17486	#if SQLITE_DEFAULT_LOCKING_MODE
17487	"DEFAULT_LOCKING_MODE=" CTIMEOPT_VAL(SQLITE_DEFAULT_LOCKING_MODE),
17488	#endif
	@@ -19505,22 +19533,23 @@
19533	**
19534	** Move the date backwards to the beginning of the current day,
19535	** or month or year.
19536	*/
19537	if( sqlite3_strnicmp(z, "start of ", 9)!=0 ) break;
19538	if( !p->validJD && !p->validYMD && !p->validHMS ) break;
19539	z += 9;
19540	computeYMD(p);
19541	p->validHMS = 1;
19542	p->h = p->m = 0;
19543	p->s = 0.0;
19544	p->rawS = 0;
19545	p->validTZ = 0;
19546	p->validJD = 0;
19547	if( sqlite3_stricmp(z,"month")==0 ){
19548	p->D = 1;
19549	rc = 0;
19550	}else if( sqlite3_stricmp(z,"year")==0 ){

19551	p->M = 1;
19552	p->D = 1;
19553	rc = 0;
19554	}else if( sqlite3_stricmp(z,"day")==0 ){
19555	rc = 0;
	@@ -24050,12 +24079,12 @@
24079	#ifdef SQLITE_DEBUG
24080	assert( p->nRef>0 \|\| p->owner==0 );
24081	p->owner = tid;
24082	p->nRef++;
24083	if( p->trace ){
24084	OSTRACE(("ENTER-MUTEX tid=%lu, mutex(%d)=%p (%d), nRef=%d\n",
24085	tid, p->id, p, p->trace, p->nRef));
24086	}
24087	#endif
24088	}
24089
24090	static int winMutexTry(sqlite3_mutex *p){
	@@ -24093,12 +24122,12 @@
24122	#else
24123	UNUSED_PARAMETER(p);
24124	#endif
24125	#ifdef SQLITE_DEBUG
24126	if( p->trace ){
24127	OSTRACE(("TRY-MUTEX tid=%lu, mutex(%d)=%p (%d), owner=%lu, nRef=%d, rc=%s\n",
24128	tid, p->id, p, p->trace, p->owner, p->nRef, sqlite3ErrName(rc)));
24129	}
24130	#endif
24131	return rc;
24132	}
24133
	@@ -24122,12 +24151,12 @@
24151	#endif
24152	assert( winMutex_isInit==1 );
24153	LeaveCriticalSection(&p->mutex);
24154	#ifdef SQLITE_DEBUG
24155	if( p->trace ){
24156	OSTRACE(("LEAVE-MUTEX tid=%lu, mutex(%d)=%p (%d), nRef=%d\n",
24157	tid, p->id, p, p->trace, p->nRef));
24158	}
24159	#endif
24160	}
24161
24162	SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){
	@@ -24383,10 +24412,17 @@
24412	** implementation of malloc_good_size(), which must be called in debug
24413	** mode and specifically when the DMD "Dark Matter Detector" is enabled
24414	** or else a crash results. Hence, do not attempt to optimize out the
24415	** following xRoundup() call. */
24416	nFull = sqlite3GlobalConfig.m.xRoundup(n);
24417
24418	#ifdef SQLITE_MAX_MEMORY
24419	if( sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED)+nFull>SQLITE_MAX_MEMORY ){
24420	*pp = 0;
24421	return;
24422	}
24423	#endif
24424
24425	sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, n);
24426	if( mem0.alarmThreshold>0 ){
24427	sqlite3_int64 nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
24428	if( nUsed >= mem0.alarmThreshold - nFull ){
	@@ -24572,11 +24608,11 @@
24608	return sqlite3GlobalConfig.m.xSize(p);
24609	}
24610	SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3 db, void p){
24611	assert( p!=0 );
24612	if( db==0 \|\| !isLookaside(db,p) ){
24613	#ifdef SQLITE_DEBUG
24614	if( db==0 ){
24615	assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
24616	assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
24617	}else{
24618	assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE\|MEMTYPE_HEAP)) );
	@@ -24633,11 +24669,11 @@
24669	measureAllocationSize(db, p);
24670	return;
24671	}
24672	if( isLookaside(db, p) ){
24673	LookasideSlot pBuf = (LookasideSlot)p;
24674	#ifdef SQLITE_DEBUG
24675	/* Trash all content in the buffer being freed */
24676	memset(p, 0xaa, db->lookaside.sz);
24677	#endif
24678	pBuf->pNext = db->lookaside.pFree;
24679	db->lookaside.pFree = pBuf;
	@@ -25002,11 +25038,11 @@
25038
25039	/*
25040	** Conversion types fall into various categories as defined by the
25041	** following enumeration.
25042	*/
25043	#define etRADIX 0 /* non-decimal integer types. %x %o */
25044	#define etFLOAT 1 /* Floating point. %f */
25045	#define etEXP 2 /* Exponentional notation. %e and %E */
25046	#define etGENERIC 3 /* Floating or exponential, depending on exponent. %g */
25047	#define etSIZE 4 /* Return number of characters processed so far. %n */
25048	#define etSTRING 5 /* Strings. %s */
	@@ -25020,12 +25056,13 @@
25056	#define etTOKEN 11 /* a pointer to a Token structure */
25057	#define etSRCLIST 12 /* a pointer to a SrcList */
25058	#define etPOINTER 13 /* The %p conversion */
25059	#define etSQLESCAPE3 14 /* %w -> Strings with '\"' doubled */
25060	#define etORDINAL 15 /* %r -> 1st, 2nd, 3rd, 4th, etc. English only */
25061	#define etDECIMAL 16 /* %d or %u, but not %x, %o */
25062
25063	#define etINVALID 17 /* Any unrecognized conversion type */
25064
25065
25066	/*
25067	** An "etByte" is an 8-bit unsigned value.
25068	*/
	@@ -25045,40 +25082,40 @@
25082	} et_info;
25083
25084	/*
25085	** Allowed values for et_info.flags
25086	*/
25087	#define FLAG_SIGNED 1 /* True if the value to convert is signed */
25088	#define FLAG_STRING 4 /* Allow infinite precision */
25089
25090
25091	/*
25092	** The following table is searched linearly, so it is good to put the
25093	** most frequently used conversion types first.
25094	*/
25095	static const char aDigits[] = "0123456789ABCDEF0123456789abcdef";
25096	static const char aPrefix[] = "-x0\000X0";
25097	static const et_info fmtinfo[] = {
25098	{ 'd', 10, 1, etDECIMAL, 0, 0 },
25099	{ 's', 0, 4, etSTRING, 0, 0 },
25100	{ 'g', 0, 1, etGENERIC, 30, 0 },
25101	{ 'z', 0, 4, etDYNSTRING, 0, 0 },
25102	{ 'q', 0, 4, etSQLESCAPE, 0, 0 },
25103	{ 'Q', 0, 4, etSQLESCAPE2, 0, 0 },
25104	{ 'w', 0, 4, etSQLESCAPE3, 0, 0 },
25105	{ 'c', 0, 0, etCHARX, 0, 0 },
25106	{ 'o', 8, 0, etRADIX, 0, 2 },
25107	{ 'u', 10, 0, etDECIMAL, 0, 0 },
25108	{ 'x', 16, 0, etRADIX, 16, 1 },
25109	{ 'X', 16, 0, etRADIX, 0, 4 },
25110	#ifndef SQLITE_OMIT_FLOATING_POINT
25111	{ 'f', 0, 1, etFLOAT, 0, 0 },
25112	{ 'e', 0, 1, etEXP, 30, 0 },
25113	{ 'E', 0, 1, etEXP, 14, 0 },
25114	{ 'G', 0, 1, etGENERIC, 14, 0 },
25115	#endif
25116	{ 'i', 10, 1, etDECIMAL, 0, 0 },
25117	{ 'n', 0, 0, etSIZE, 0, 0 },
25118	{ '%', 0, 0, etPERCENT, 0, 0 },
25119	{ 'p', 16, 0, etPOINTER, 0, 1 },
25120
25121	/* All the rest are undocumented and are for internal use only */
	@@ -25166,18 +25203,17 @@
25203	int precision; /* Precision of the current field */
25204	int length; /* Length of the field */
25205	int idx; /* A general purpose loop counter */
25206	int width; /* Width of the current field */
25207	etByte flag_leftjustify; /* True if "-" flag is present */
25208	etByte flag_prefix; /* '+' or ' ' or 0 for prefix */

25209	etByte flag_alternateform; /* True if "#" flag is present */
25210	etByte flag_altform2; /* True if "!" flag is present */
25211	etByte flag_zeropad; /* True if field width constant starts with zero */
25212	etByte flag_long; /* 1 for the "l" flag, 2 for "ll", 0 by default */

25213	etByte done; /* Loop termination flag */
25214	etByte cThousand; /* Thousands separator for %d and %u */
25215	etByte xtype = etINVALID; /* Conversion paradigm */
25216	u8 bArgList; /* True for SQLITE_PRINTF_SQLFUNC */
25217	char prefix; /* Prefix character. "+" or "-" or " " or '\0'. */
25218	sqlite_uint64 longvalue; /* Value for integer types */
25219	LONGDOUBLE_TYPE realvalue; /* Value for real types */
	@@ -25216,21 +25252,22 @@
25252	if( (c=(*++fmt))==0 ){
25253	sqlite3StrAccumAppend(pAccum, "%", 1);
25254	break;
25255	}
25256	/* Find out what flags are present */
25257	flag_leftjustify = flag_prefix = cThousand =
25258	flag_alternateform = flag_altform2 = flag_zeropad = 0;
25259	done = 0;
25260	do{
25261	switch( c ){
25262	case '-': flag_leftjustify = 1; break;
25263	case '+': flag_prefix = '+'; break;
25264	case ' ': flag_prefix = ' '; break;
25265	case '#': flag_alternateform = 1; break;
25266	case '!': flag_altform2 = 1; break;
25267	case '0': flag_zeropad = 1; break;
25268	case ',': cThousand = ','; break;
25269	default: done = 1; break;
25270	}
25271	}while( !done && (c=(*++fmt))!=0 );
25272	/* Get the field width */
25273	if( c=='*' ){
	@@ -25296,17 +25333,15 @@
25333	/* Get the conversion type modifier */
25334	if( c=='l' ){
25335	flag_long = 1;
25336	c = *++fmt;
25337	if( c=='l' ){
25338	flag_long = 2;
25339	c = *++fmt;


25340	}
25341	}else{
25342	flag_long = 0;
25343	}
25344	/* Fetch the info entry for the field */
25345	infop = &fmtinfo[0];
25346	xtype = etINVALID;
25347	for(idx=0; idx<ArraySize(fmtinfo); idx++){
	@@ -25320,41 +25355,42 @@
25355	/*
25356	** At this point, variables are initialized as follows:
25357	**
25358	** flag_alternateform TRUE if a '#' is present.
25359	** flag_altform2 TRUE if a '!' is present.
25360	** flag_prefix '+' or ' ' or zero
25361	** flag_leftjustify TRUE if a '-' is present or if the
25362	** field width was negative.
25363	** flag_zeropad TRUE if the width began with 0.
25364	** flag_long 1 for "l", 2 for "ll"




25365	** width The specified field width. This is
25366	** always non-negative. Zero is the default.
25367	** precision The specified precision. The default
25368	** is -1.
25369	** xtype The class of the conversion.
25370	** infop Pointer to the appropriate info struct.
25371	*/
25372	switch( xtype ){
25373	case etPOINTER:
25374	flag_long = sizeof(char*)==sizeof(i64) ? 2 :
25375	sizeof(char*)==sizeof(long int) ? 1 : 0;
25376	/* Fall through into the next case */
25377	case etORDINAL:
25378	case etRADIX:
25379	cThousand = 0;
25380	/* Fall through into the next case */
25381	case etDECIMAL:
25382	if( infop->flags & FLAG_SIGNED ){
25383	i64 v;
25384	if( bArgList ){
25385	v = getIntArg(pArgList);


25386	}else if( flag_long ){
25387	if( flag_long==2 ){
25388	v = va_arg(ap,i64) ;
25389	}else{
25390	v = va_arg(ap,long int);
25391	}
25392	}else{
25393	v = va_arg(ap,int);
25394	}
25395	if( v<0 ){
25396	if( v==SMALLEST_INT64 ){
	@@ -25363,35 +25399,35 @@
25399	longvalue = -v;
25400	}
25401	prefix = '-';
25402	}else{
25403	longvalue = v;
25404	prefix = flag_prefix;


25405	}
25406	}else{
25407	if( bArgList ){
25408	longvalue = (u64)getIntArg(pArgList);


25409	}else if( flag_long ){
25410	if( flag_long==2 ){
25411	longvalue = va_arg(ap,u64);
25412	}else{
25413	longvalue = va_arg(ap,unsigned long int);
25414	}
25415	}else{
25416	longvalue = va_arg(ap,unsigned int);
25417	}
25418	prefix = 0;
25419	}
25420	if( longvalue==0 ) flag_alternateform = 0;
25421	if( flag_zeropad && precision<width-(prefix!=0) ){
25422	precision = width-(prefix!=0);
25423	}
25424	if( precision<etBUFSIZE-10-etBUFSIZE/3 ){
25425	nOut = etBUFSIZE;
25426	zOut = buf;
25427	}else{
25428	nOut = precision + 10 + precision/3;
25429	zOut = zExtra = sqlite3Malloc( nOut );
25430	if( zOut==0 ){
25431	setStrAccumError(pAccum, STRACCUM_NOMEM);
25432	return;
25433	}
	@@ -25413,12 +25449,27 @@
25449	*(--bufpt) = cset[longvalue%base];
25450	longvalue = longvalue/base;
25451	}while( longvalue>0 );
25452	}
25453	length = (int)(&zOut[nOut-1]-bufpt);
25454	while( precision>length ){
25455	(--bufpt) = '0'; / Zero pad */
25456	length++;
25457	}
25458	if( cThousand ){
25459	int nn = (length - 1)/3; /* Number of "," to insert */
25460	int ix = (length - 1)%3 + 1;
25461	bufpt -= nn;
25462	for(idx=0; nn>0; idx++){
25463	bufpt[idx] = bufpt[idx+nn];
25464	ix--;
25465	if( ix==0 ){
25466	bufpt[++idx] = cThousand;
25467	nn--;
25468	ix = 3;
25469	}
25470	}
25471	}
25472	if( prefix ) (--bufpt) = prefix; / Add sign */
25473	if( flag_alternateform && infop->prefix ){ /* Add "0" or "0x" */
25474	const char *pre;
25475	char x;
	@@ -25441,13 +25492,11 @@
25492	if( precision<0 ) precision = 6; /* Set default precision */
25493	if( realvalue<0.0 ){
25494	realvalue = -realvalue;
25495	prefix = '-';
25496	}else{
25497	prefix = flag_prefix;


25498	}
25499	if( xtype==etGENERIC && precision>0 ) precision--;
25500	testcase( precision>0xfff );
25501	for(idx=precision&0xfff, rounder=0.5; idx>0; idx--, rounder*=0.1){}
25502	if( xtype==etFLOAT ) realvalue += rounder;
	@@ -29464,117 +29513,119 @@
29513	/* 50 */ "Divide" OpHelp("r[P3]=r[P2]/r[P1]"),
29514	/* 51 */ "Remainder" OpHelp("r[P3]=r[P2]%r[P1]"),
29515	/* 52 */ "Concat" OpHelp("r[P3]=r[P2]+r[P1]"),
29516	/* 53 */ "Last" OpHelp(""),
29517	/* 54 */ "BitNot" OpHelp("r[P1]= ~r[P1]"),
29518	/* 55 */ "IfSmaller" OpHelp(""),
29519	/* 56 */ "SorterSort" OpHelp(""),
29520	/* 57 */ "Sort" OpHelp(""),
29521	/* 58 */ "Rewind" OpHelp(""),
29522	/* 59 */ "IdxLE" OpHelp("key=r[P3@P4]"),
29523	/* 60 */ "IdxGT" OpHelp("key=r[P3@P4]"),
29524	/* 61 */ "IdxLT" OpHelp("key=r[P3@P4]"),
29525	/* 62 */ "IdxGE" OpHelp("key=r[P3@P4]"),
29526	/* 63 */ "RowSetRead" OpHelp("r[P3]=rowset(P1)"),
29527	/* 64 */ "RowSetTest" OpHelp("if r[P3] in rowset(P1) goto P2"),
29528	/* 65 */ "Program" OpHelp(""),
29529	/* 66 */ "FkIfZero" OpHelp("if fkctr[P1]==0 goto P2"),
29530	/* 67 */ "IfPos" OpHelp("if r[P1]>0 then r[P1]-=P3, goto P2"),
29531	/* 68 */ "IfNotZero" OpHelp("if r[P1]!=0 then r[P1]--, goto P2"),
29532	/* 69 */ "DecrJumpZero" OpHelp("if (--r[P1])==0 goto P2"),
29533	/* 70 */ "IncrVacuum" OpHelp(""),
29534	/* 71 */ "VNext" OpHelp(""),
29535	/* 72 */ "Init" OpHelp("Start at P2"),
29536	/* 73 */ "Return" OpHelp(""),
29537	/* 74 */ "EndCoroutine" OpHelp(""),
29538	/* 75 */ "HaltIfNull" OpHelp("if r[P3]=null halt"),
29539	/* 76 */ "Halt" OpHelp(""),
29540	/* 77 */ "Integer" OpHelp("r[P2]=P1"),
29541	/* 78 */ "Int64" OpHelp("r[P2]=P4"),
29542	/* 79 */ "String" OpHelp("r[P2]='P4' (len=P1)"),
29543	/* 80 */ "Null" OpHelp("r[P2..P3]=NULL"),
29544	/* 81 */ "SoftNull" OpHelp("r[P1]=NULL"),
29545	/* 82 */ "Blob" OpHelp("r[P2]=P4 (len=P1)"),
29546	/* 83 */ "Variable" OpHelp("r[P2]=parameter(P1,P4)"),
29547	/* 84 */ "Move" OpHelp("r[P2@P3]=r[P1@P3]"),
29548	/* 85 */ "Copy" OpHelp("r[P2@P3+1]=r[P1@P3+1]"),
29549	/* 86 */ "SCopy" OpHelp("r[P2]=r[P1]"),
29550	/* 87 */ "IntCopy" OpHelp("r[P2]=r[P1]"),
29551	/* 88 */ "ResultRow" OpHelp("output=r[P1@P2]"),
29552	/* 89 */ "CollSeq" OpHelp(""),
29553	/* 90 */ "Function0" OpHelp("r[P3]=func(r[P2@P5])"),
29554	/* 91 */ "Function" OpHelp("r[P3]=func(r[P2@P5])"),
29555	/* 92 */ "AddImm" OpHelp("r[P1]=r[P1]+P2"),
29556	/* 93 */ "RealAffinity" OpHelp(""),
29557	/* 94 */ "Cast" OpHelp("affinity(r[P1])"),
29558	/* 95 */ "Permutation" OpHelp(""),
29559	/* 96 */ "Compare" OpHelp("r[P1@P3] <-> r[P2@P3]"),
29560	/* 97 */ "String8" OpHelp("r[P2]='P4'"),
29561	/* 98 */ "Column" OpHelp("r[P3]=PX"),
29562	/* 99 */ "Affinity" OpHelp("affinity(r[P1@P2])"),
29563	/* 100 */ "MakeRecord" OpHelp("r[P3]=mkrec(r[P1@P2])"),
29564	/* 101 */ "Count" OpHelp("r[P2]=count()"),
29565	/* 102 */ "ReadCookie" OpHelp(""),
29566	/* 103 */ "SetCookie" OpHelp(""),
29567	/* 104 */ "ReopenIdx" OpHelp("root=P2 iDb=P3"),
29568	/* 105 */ "OpenRead" OpHelp("root=P2 iDb=P3"),
29569	/* 106 */ "OpenWrite" OpHelp("root=P2 iDb=P3"),
29570	/* 107 */ "OpenAutoindex" OpHelp("nColumn=P2"),
29571	/* 108 */ "OpenEphemeral" OpHelp("nColumn=P2"),
29572	/* 109 */ "SorterOpen" OpHelp(""),
29573	/* 110 */ "SequenceTest" OpHelp("if( cursor[P1].ctr++ ) pc = P2"),
29574	/* 111 */ "OpenPseudo" OpHelp("P3 columns in r[P2]"),
29575	/* 112 */ "Close" OpHelp(""),
29576	/* 113 */ "ColumnsUsed" OpHelp(""),
29577	/* 114 */ "Sequence" OpHelp("r[P2]=cursor[P1].ctr++"),
29578	/* 115 */ "NewRowid" OpHelp("r[P2]=rowid"),
29579	/* 116 */ "Insert" OpHelp("intkey=r[P3] data=r[P2]"),
29580	/* 117 */ "InsertInt" OpHelp("intkey=P3 data=r[P2]"),
29581	/* 118 */ "Delete" OpHelp(""),
29582	/* 119 */ "ResetCount" OpHelp(""),
29583	/* 120 */ "SorterCompare" OpHelp("if key(P1)!=trim(r[P3],P4) goto P2"),
29584	/* 121 */ "SorterData" OpHelp("r[P2]=data"),
29585	/* 122 */ "RowData" OpHelp("r[P2]=data"),
29586	/* 123 */ "Rowid" OpHelp("r[P2]=rowid"),
29587	/* 124 */ "NullRow" OpHelp(""),
29588	/* 125 */ "SorterInsert" OpHelp("key=r[P2]"),
29589	/* 126 */ "IdxInsert" OpHelp("key=r[P2]"),
29590	/* 127 */ "IdxDelete" OpHelp("key=r[P2@P3]"),
29591	/* 128 */ "Seek" OpHelp("Move P3 to P1.rowid"),
29592	/* 129 */ "IdxRowid" OpHelp("r[P2]=rowid"),
29593	/* 130 */ "Destroy" OpHelp(""),
29594	/* 131 */ "Clear" OpHelp(""),
29595	/* 132 */ "Real" OpHelp("r[P2]=P4"),
29596	/* 133 */ "ResetSorter" OpHelp(""),
29597	/* 134 */ "CreateIndex" OpHelp("r[P2]=root iDb=P1"),
29598	/* 135 */ "CreateTable" OpHelp("r[P2]=root iDb=P1"),
29599	/* 136 */ "SqlExec" OpHelp(""),
29600	/* 137 */ "ParseSchema" OpHelp(""),
29601	/* 138 */ "LoadAnalysis" OpHelp(""),
29602	/* 139 */ "DropTable" OpHelp(""),
29603	/* 140 */ "DropIndex" OpHelp(""),
29604	/* 141 */ "DropTrigger" OpHelp(""),
29605	/* 142 */ "IntegrityCk" OpHelp(""),
29606	/* 143 */ "RowSetAdd" OpHelp("rowset(P1)=r[P2]"),
29607	/* 144 */ "Param" OpHelp(""),
29608	/* 145 */ "FkCounter" OpHelp("fkctr[P1]+=P2"),
29609	/* 146 */ "MemMax" OpHelp("r[P1]=max(r[P1],r[P2])"),
29610	/* 147 */ "OffsetLimit" OpHelp("if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)"),
29611	/* 148 */ "AggStep0" OpHelp("accum=r[P3] step(r[P2@P5])"),
29612	/* 149 */ "AggStep" OpHelp("accum=r[P3] step(r[P2@P5])"),
29613	/* 150 */ "AggFinal" OpHelp("accum=r[P1] N=P2"),
29614	/* 151 */ "Expire" OpHelp(""),
29615	/* 152 */ "TableLock" OpHelp("iDb=P1 root=P2 write=P3"),
29616	/* 153 */ "VBegin" OpHelp(""),
29617	/* 154 */ "VCreate" OpHelp(""),
29618	/* 155 */ "VDestroy" OpHelp(""),
29619	/* 156 */ "VOpen" OpHelp(""),
29620	/* 157 */ "VColumn" OpHelp("r[P3]=vcolumn(P2)"),
29621	/* 158 */ "VRename" OpHelp(""),
29622	/* 159 */ "Pagecount" OpHelp(""),
29623	/* 160 */ "MaxPgcnt" OpHelp(""),
29624	/* 161 */ "CursorHint" OpHelp(""),
29625	/* 162 */ "Noop" OpHelp(""),
29626	/* 163 */ "Explain" OpHelp(""),
29627	};
29628	return azName[i];
29629	}
29630	#endif
29631
	@@ -37952,46 +38003,84 @@
38003	* be freed immediately and any attempt to access any of that freed
38004	* data will almost certainly result in an immediate access violation.
38005	******************************************************************************
38006	*/
38007	#ifndef SQLITE_WIN32_HEAP_CREATE
38008	# define SQLITE_WIN32_HEAP_CREATE (TRUE)
38009	#endif
38010
38011	/*
38012	* This is the maximum possible initial size of the Win32-specific heap, in
38013	* bytes.
38014	*/
38015	#ifndef SQLITE_WIN32_HEAP_MAX_INIT_SIZE
38016	# define SQLITE_WIN32_HEAP_MAX_INIT_SIZE (4294967295U)
38017	#endif
38018
38019	/*
38020	* This is the extra space for the initial size of the Win32-specific heap,
38021	* in bytes. This value may be zero.
38022	*/
38023	#ifndef SQLITE_WIN32_HEAP_INIT_EXTRA
38024	# define SQLITE_WIN32_HEAP_INIT_EXTRA (4194304)
38025	#endif
38026
38027	/*
38028	* Calculate the maximum legal cache size, in pages, based on the maximum
38029	* possible initial heap size and the default page size, setting aside the
38030	* needed extra space.
38031	*/
38032	#ifndef SQLITE_WIN32_MAX_CACHE_SIZE
38033	# define SQLITE_WIN32_MAX_CACHE_SIZE (((SQLITE_WIN32_HEAP_MAX_INIT_SIZE) - \
38034	(SQLITE_WIN32_HEAP_INIT_EXTRA)) / \
38035	(SQLITE_DEFAULT_PAGE_SIZE))
38036	#endif
38037
38038	/*
38039	* This is cache size used in the calculation of the initial size of the
38040	* Win32-specific heap. It cannot be negative.
38041	*/
38042	#ifndef SQLITE_WIN32_CACHE_SIZE
38043	# if SQLITE_DEFAULT_CACHE_SIZE>=0
38044	# define SQLITE_WIN32_CACHE_SIZE (SQLITE_DEFAULT_CACHE_SIZE)
38045	# else
38046	# define SQLITE_WIN32_CACHE_SIZE (-(SQLITE_DEFAULT_CACHE_SIZE))
38047	# endif
38048	#endif
38049
38050	/*
38051	* Make sure that the calculated cache size, in pages, cannot cause the
38052	* initial size of the Win32-specific heap to exceed the maximum amount
38053	* of memory that can be specified in the call to HeapCreate.
38054	*/
38055	#if SQLITE_WIN32_CACHE_SIZE>SQLITE_WIN32_MAX_CACHE_SIZE
38056	# undef SQLITE_WIN32_CACHE_SIZE
38057	# define SQLITE_WIN32_CACHE_SIZE (2000)
38058	#endif
38059
38060	/*
38061	* The initial size of the Win32-specific heap. This value may be zero.
38062	*/
38063	#ifndef SQLITE_WIN32_HEAP_INIT_SIZE
38064	# define SQLITE_WIN32_HEAP_INIT_SIZE ((SQLITE_WIN32_CACHE_SIZE) * \
38065	(SQLITE_DEFAULT_PAGE_SIZE) + \
38066	(SQLITE_WIN32_HEAP_INIT_EXTRA))
38067	#endif
38068
38069	/*
38070	* The maximum size of the Win32-specific heap. This value may be zero.
38071	*/
38072	#ifndef SQLITE_WIN32_HEAP_MAX_SIZE
38073	# define SQLITE_WIN32_HEAP_MAX_SIZE (0)
38074	#endif
38075
38076	/*
38077	* The extra flags to use in calls to the Win32 heap APIs. This value may be
38078	* zero for the default behavior.
38079	*/
38080	#ifndef SQLITE_WIN32_HEAP_FLAGS
38081	# define SQLITE_WIN32_HEAP_FLAGS (0)
38082	#endif
38083
38084
38085	/*
38086	** The winMemData structure stores information required by the Win32-specific
	@@ -44084,11 +44173,11 @@
44173	** This routine is for use inside of assert() statements only. For
44174	** example:
44175	**
44176	** assert( sqlite3PcachePageSanity(pPg) );
44177	*/
44178	#ifdef SQLITE_DEBUG
44179	SQLITE_PRIVATE int sqlite3PcachePageSanity(PgHdr *pPg){
44180	PCache *pCache;
44181	assert( pPg!=0 );
44182	assert( pPg->pgno>0 \|\| pPg->pPager==0 ); /* Page number is 1 or more */
44183	pCache = pPg->pCache;
	@@ -60177,21 +60266,22 @@
60266	}
60267	#endif
60268
60269
60270	/*
60271	** Defragment the page given. This routine reorganizes cells within the
60272	** page so that there are no free-blocks on the free-block list.
60273	**
60274	** Parameter nMaxFrag is the maximum amount of fragmented space that may be
60275	** present in the page after this routine returns.
60276	**
60277	** EVIDENCE-OF: R-44582-60138 SQLite may from time to time reorganize a
60278	** b-tree page so that there are no freeblocks or fragment bytes, all
60279	** unused bytes are contained in the unallocated space region, and all
60280	** cells are packed tightly at the end of the page.
60281	*/
60282	static int defragmentPage(MemPage *pPage, int nMaxFrag){
60283	int i; /* Loop counter */
60284	int pc; /* Address of the i-th cell */
60285	int hdr; /* Offset to the page header */
60286	int size; /* Size of a cell */
60287	int usableSize; /* Number of usable bytes on a page */
	@@ -60202,11 +60292,10 @@
60292	unsigned char temp; / Temp area for cell content */
60293	unsigned char src; / Source of content */
60294	int iCellFirst; /* First allowable cell index */
60295	int iCellLast; /* Last possible cell index */
60296

60297	assert( sqlite3PagerIswriteable(pPage->pDbPage) );
60298	assert( pPage->pBt!=0 );
60299	assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE );
60300	assert( pPage->nOverflow==0 );
60301	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
	@@ -60214,13 +60303,60 @@
60303	src = data = pPage->aData;
60304	hdr = pPage->hdrOffset;
60305	cellOffset = pPage->cellOffset;
60306	nCell = pPage->nCell;
60307	assert( nCell==get2byte(&data[hdr+3]) );
60308	iCellFirst = cellOffset + 2*nCell;
60309	usableSize = pPage->pBt->usableSize;
60310
60311	/* This block handles pages with two or fewer free blocks and nMaxFrag
60312	** or fewer fragmented bytes. In this case it is faster to move the
60313	** two (or one) blocks of cells using memmove() and add the required
60314	** offsets to each pointer in the cell-pointer array than it is to
60315	** reconstruct the entire page. */
60316	if( (int)data[hdr+7]<=nMaxFrag ){
60317	int iFree = get2byte(&data[hdr+1]);
60318	if( iFree ){
60319	int iFree2 = get2byte(&data[iFree]);
60320
60321	/* pageFindSlot() has already verified that free blocks are sorted
60322	** in order of offset within the page, and that no block extends
60323	** past the end of the page. Provided the two free slots do not
60324	** overlap, this guarantees that the memmove() calls below will not
60325	** overwrite the usableSize byte buffer, even if the database page
60326	** is corrupt. */
60327	assert( iFree2==0 \|\| iFree2>iFree );
60328	assert( iFree+get2byte(&data[iFree+2]) <= usableSize );
60329	assert( iFree2==0 \|\| iFree2+get2byte(&data[iFree2+2]) <= usableSize );
60330
60331	if( 0==iFree2 \|\| (data[iFree2]==0 && data[iFree2+1]==0) ){
60332	u8 pEnd = &data[cellOffset + nCell2];
60333	u8 *pAddr;
60334	int sz2 = 0;
60335	int sz = get2byte(&data[iFree+2]);
60336	int top = get2byte(&data[hdr+5]);
60337	if( iFree2 ){
60338	if( iFree+sz>iFree2 ) return SQLITE_CORRUPT_BKPT;
60339	sz2 = get2byte(&data[iFree2+2]);
60340	assert( iFree+sz+sz2+iFree2-(iFree+sz) <= usableSize );
60341	memmove(&data[iFree+sz+sz2], &data[iFree+sz], iFree2-(iFree+sz));
60342	sz += sz2;
60343	}
60344	cbrk = top+sz;
60345	assert( cbrk+(iFree-top) <= usableSize );
60346	memmove(&data[cbrk], &data[top], iFree-top);
60347	for(pAddr=&data[cellOffset]; pAddr<pEnd; pAddr+=2){
60348	pc = get2byte(pAddr);
60349	if( pc<iFree ){ put2byte(pAddr, pc+sz); }
60350	else if( pc<iFree2 ){ put2byte(pAddr, pc+sz2); }
60351	}
60352	goto defragment_out;
60353	}
60354	}
60355	}
60356
60357	cbrk = usableSize;

60358	iCellLast = usableSize - 4;
60359	for(i=0; i<nCell; i++){
60360	u8 pAddr; / The i-th cell pointer */
60361	pAddr = &data[cellOffset + i*2];
60362	pc = get2byte(pAddr);
	@@ -60250,20 +60386,22 @@
60386	memcpy(&temp[x], &data[x], (cbrk+size) - x);
60387	src = temp;
60388	}
60389	memcpy(&data[cbrk], &src[pc], size);
60390	}
60391	data[hdr+7] = 0;
60392
60393	defragment_out:
60394	if( data[hdr+7]+cbrk-iCellFirst!=pPage->nFree ){
60395	return SQLITE_CORRUPT_BKPT;
60396	}
60397	assert( cbrk>=iCellFirst );
60398	put2byte(&data[hdr+5], cbrk);
60399	data[hdr+1] = 0;
60400	data[hdr+2] = 0;

60401	memset(&data[iCellFirst], 0, cbrk-iCellFirst);
60402	assert( sqlite3PagerIswriteable(pPage->pDbPage) );



60403	return SQLITE_OK;
60404	}
60405
60406	/*
60407	** Search the free-list on page pPg for space to store a cell nByte bytes in
	@@ -60397,14 +60535,14 @@
60535	** to see if defragmentation is necessary.
60536	*/
60537	testcase( gap+2+nByte==top );
60538	if( gap+2+nByte>top ){
60539	assert( pPage->nCell>0 \|\| CORRUPT_DB );
60540	rc = defragmentPage(pPage, MIN(4, pPage->nFree - (2+nByte)));
60541	if( rc ) return rc;
60542	top = get2byteNotZero(&data[hdr+5]);
60543	assert( gap+2+nByte<=top );
60544	}
60545
60546
60547	/* Allocate memory from the gap in between the cell pointer array
60548	** and the cell content area. The btreeInitPage() call has already
	@@ -63636,11 +63774,11 @@
63774	pCur->aiIdx[pCur->iPage] = 0;
63775	return getAndInitPage(pBt, newPgno, &pCur->apPage[pCur->iPage],
63776	pCur, pCur->curPagerFlags);
63777	}
63778
63779	#ifdef SQLITE_DEBUG
63780	/*
63781	** Page pParent is an internal (non-leaf) tree page. This function
63782	** asserts that page number iChild is the left-child if the iIdx'th
63783	** cell in page pParent. Or, if iIdx is equal to the total number of
63784	** cells in pParent, that page number iChild is the right-child of
	@@ -64178,10 +64316,34 @@
64316	** have been deleted? This API will need to change to return an error code
64317	** as well as the boolean result value.
64318	*/
64319	return (CURSOR_VALID!=pCur->eState);
64320	}
64321
64322	/*
64323	** Return an estimate for the number of rows in the table that pCur is
64324	** pointing to. Return a negative number if no estimate is currently
64325	** available.
64326	*/
64327	SQLITE_PRIVATE i64 sqlite3BtreeRowCountEst(BtCursor *pCur){
64328	i64 n;
64329	u8 i;
64330
64331	assert( cursorOwnsBtShared(pCur) );
64332	assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
64333
64334	/* Currently this interface is only called by the OP_IfSmaller
64335	** opcode, and it that case the cursor will always be valid and
64336	** will always point to a leaf node. */
64337	if( NEVER(pCur->eState!=CURSOR_VALID) ) return -1;
64338	if( NEVER(pCur->apPage[pCur->iPage]->leaf==0) ) return -1;
64339
64340	for(n=1, i=0; i<=pCur->iPage; i++){
64341	n *= pCur->apPage[i]->nCell;
64342	}
64343	return n;
64344	}
64345
64346	/*
64347	** Advance the cursor to the next entry in the database. If
64348	** successful then set *pRes=0. If the cursor
64349	** was already pointing to the last entry in the database before
	@@ -65023,11 +65185,11 @@
65185	** pPrior Where to write the pgno of the first overflow page
65186	**
65187	** Use a call to btreeParseCellPtr() to verify that the values above
65188	** were computed correctly.
65189	*/
65190	#ifdef SQLITE_DEBUG
65191	{
65192	CellInfo info;
65193	pPage->xParseCell(pPage, pCell, &info);
65194	assert( nHeader==(int)(info.pPayload - pCell) );
65195	assert( info.nKey==pX->nKey );
	@@ -66549,11 +66711,11 @@
66711	** copied into the parent, because if the parent is page 1 then it will
66712	** by smaller than the child due to the database header, and so all the
66713	** free space needs to be up front.
66714	*/
66715	assert( nNew==1 \|\| CORRUPT_DB );
66716	rc = defragmentPage(apNew[0], -1);
66717	testcase( rc!=SQLITE_OK );
66718	assert( apNew[0]->nFree ==
66719	(get2byte(&apNew[0]->aData[5])-apNew[0]->cellOffset-apNew[0]->nCell*2)
66720	\|\| rc!=SQLITE_OK
66721	);
	@@ -71201,10 +71363,11 @@
71363	** Remember the SQL string for a prepared statement.
71364	*/
71365	SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe p, const char z, int n, int isPrepareV2){
71366	assert( isPrepareV2==1 \|\| isPrepareV2==0 );
71367	if( p==0 ) return;
71368	if( !isPrepareV2 ) p->expmask = 0;
71369	#if defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_ENABLE_SQLLOG)
71370	if( !isPrepareV2 ) return;
71371	#endif
71372	assert( p->zSql==0 );
71373	p->zSql = sqlite3DbStrNDup(p->db, z, n);
	@@ -71229,10 +71392,11 @@
71392	pB->pPrev = pTmp;
71393	zTmp = pA->zSql;
71394	pA->zSql = pB->zSql;
71395	pB->zSql = zTmp;
71396	pB->isPrepareV2 = pA->isPrepareV2;
71397	pB->expmask = pA->expmask;
71398	}
71399
71400	/*
71401	** Resize the Vdbe.aOp array so that it is at least nOp elements larger
71402	** than its current size. nOp is guaranteed to be less than or equal
	@@ -73753,17 +73917,17 @@
73917	** Then the internal cache might have been left in an inconsistent
73918	** state. We need to rollback the statement transaction, if there is
73919	** one, or the complete transaction if there is no statement transaction.
73920	*/
73921
73922	if( p->magic!=VDBE_MAGIC_RUN ){
73923	return SQLITE_OK;
73924	}
73925	if( db->mallocFailed ){
73926	p->rc = SQLITE_NOMEM_BKPT;
73927	}
73928	closeAllCursors(p);



73929	checkActiveVdbeCnt(db);
73930
73931	/* No commit or rollback needed if the program never started or if the
73932	** SQL statement does not read or write a database file. */
73933	if( p->pc>=0 && p->bIsReader ){
	@@ -74706,11 +74870,11 @@
74870	}
74871	assert( u<=pKeyInfo->nField + 1 );
74872	p->nField = u;
74873	}
74874
74875	#ifdef SQLITE_DEBUG
74876	/*
74877	** This function compares two index or table record keys in the same way
74878	** as the sqlite3VdbeRecordCompare() routine. Unlike VdbeRecordCompare(),
74879	** this function deserializes and compares values using the
74880	** sqlite3VdbeSerialGet() and sqlite3MemCompare() functions. It is used
	@@ -74811,11 +74975,11 @@
74975	if( pKeyInfo->db->mallocFailed ) return 1;
74976	return 0;
74977	}
74978	#endif
74979
74980	#ifdef SQLITE_DEBUG
74981	/*
74982	** Count the number of fields (a.k.a. columns) in the record given by
74983	** pKey,nKey. The verify that this count is less than or equal to the
74984	** limit given by pKeyInfo->nField + pKeyInfo->nXField.
74985	**
	@@ -75694,12 +75858,12 @@
75858	** to sqlite3_reoptimize() that re-preparing the statement may result
75859	** in a better query plan.
75860	*/
75861	SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe *v, int iVar){
75862	assert( iVar>0 );
75863	if( iVar>=32 ){
75864	v->expmask \|= 0x80000000;
75865	}else{
75866	v->expmask \|= ((u32)1 << (iVar-1));
75867	}
75868	}
75869
	@@ -75965,11 +76129,12 @@
76129	sqlite3_mutex_enter(mutex);
76130	for(i=0; i<p->nVar; i++){
76131	sqlite3VdbeMemRelease(&p->aVar[i]);
76132	p->aVar[i].flags = MEM_Null;
76133	}
76134	assert( p->isPrepareV2 \|\| p->expmask==0 );
76135	if( p->expmask ){
76136	p->expired = 1;
76137	}
76138	sqlite3_mutex_leave(mutex);
76139	return rc;
76140	}
	@@ -77069,13 +77234,12 @@
77234	** parameter in the WHERE clause might influence the choice of query plan
77235	** for a statement, then the statement will be automatically recompiled,
77236	** as if there had been a schema change, on the first sqlite3_step() call
77237	** following any change to the bindings of that parameter.
77238	*/
77239	assert( p->isPrepareV2 \|\| p->expmask==0 );
77240	if( p->expmask!=0 && (p->expmask & (i>=31 ? 0x80000000 : (u32)1<<i))!=0 ){

77241	p->expired = 1;
77242	}
77243	return SQLITE_OK;
77244	}
77245
	@@ -77334,14 +77498,16 @@
77498	Vdbe pFrom = (Vdbe)pFromStmt;
77499	Vdbe pTo = (Vdbe)pToStmt;
77500	if( pFrom->nVar!=pTo->nVar ){
77501	return SQLITE_ERROR;
77502	}
77503	assert( pTo->isPrepareV2 \|\| pTo->expmask==0 );
77504	if( pTo->expmask ){
77505	pTo->expired = 1;
77506	}
77507	assert( pFrom->isPrepareV2 \|\| pFrom->expmask==0 );
77508	if( pFrom->expmask ){
77509	pFrom->expired = 1;
77510	}
77511	return sqlite3TransferBindings(pFromStmt, pToStmt);
77512	}
77513	#endif
	@@ -79658,39 +79824,39 @@
79824	if( pCtx->pOut != pOut ){
79825	pCtx->pOut = pOut;
79826	for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
79827	}
79828
79829	memAboutToChange(p, pOut);
79830	#ifdef SQLITE_DEBUG
79831	for(i=0; i<pCtx->argc; i++){
79832	assert( memIsValid(pCtx->argv[i]) );
79833	REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
79834	}
79835	#endif
79836	MemSetTypeFlag(pOut, MEM_Null);
79837	pCtx->fErrorOrAux = 0;
79838	(pCtx->pFunc->xSFunc)(pCtx, pCtx->argc, pCtx->argv);/ IMP: R-24505-23230 */
79839
79840	/* If the function returned an error, throw an exception */
79841	if( pCtx->fErrorOrAux ){
79842	if( pCtx->isError ){
79843	sqlite3VdbeError(p, "%s", sqlite3_value_text(pOut));
79844	rc = pCtx->isError;
79845	}
79846	sqlite3VdbeDeleteAuxData(db, &p->pAuxData, pCtx->iOp, pOp->p1);
79847	if( rc ) goto abort_due_to_error;
79848	}
79849
79850	/* Copy the result of the function into register P3 */
79851	if( pOut->flags & (MEM_Str\|MEM_Blob) ){
79852	sqlite3VdbeChangeEncoding(pOut, encoding);
79853	if( sqlite3VdbeMemTooBig(pOut) ) goto too_big;
79854	}
79855
79856	REGISTER_TRACE(pOp->p3, pOut);
79857	UPDATE_MAX_BLOBSIZE(pOut);
79858	break;
79859	}
79860
79861	/* Opcode: BitAnd P1 P2 P3 * *
79862	** Synopsis: r[P3]=r[P1]&r[P2]
	@@ -80187,11 +80353,11 @@
80353	pKeyInfo = pOp->p4.pKeyInfo;
80354	assert( n>0 );
80355	assert( pKeyInfo!=0 );
80356	p1 = pOp->p1;
80357	p2 = pOp->p2;
80358	#ifdef SQLITE_DEBUG
80359	if( aPermute ){
80360	int k, mx = 0;
80361	for(k=0; k<n; k++) if( aPermute[k]>mx ) mx = aPermute[k];
80362	assert( p1>0 && p1+mx<=(p->nMem+1 - p->nCursor)+1 );
80363	assert( p2>0 && p2+mx<=(p->nMem+1 - p->nCursor)+1 );
	@@ -82836,10 +83002,37 @@
83002	assert( pOp->p2==0 );
83003	}
83004	break;
83005	}
83006
83007	/* Opcode: IfSmaller P1 P2 P3 * *
83008	**
83009	** Estimate the number of rows in the table P1. Jump to P2 if that
83010	estimate is less than approximately 2(0.1*P3).
83011	*/
83012	case OP_IfSmaller: { /* jump */
83013	VdbeCursor *pC;
83014	BtCursor *pCrsr;
83015	int res;
83016	i64 sz;
83017
83018	assert( pOp->p1>=0 && pOp->p1<p->nCursor );
83019	pC = p->apCsr[pOp->p1];
83020	assert( pC!=0 );
83021	pCrsr = pC->uc.pCursor;
83022	assert( pCrsr );
83023	rc = sqlite3BtreeFirst(pCrsr, &res);
83024	if( rc ) goto abort_due_to_error;
83025	if( res==0 ){
83026	sz = sqlite3BtreeRowCountEst(pCrsr);
83027	if( ALWAYS(sz>=0) && sqlite3LogEst((u64)sz)<pOp->p3 ) res = 1;
83028	}
83029	VdbeBranchTaken(res!=0,2);
83030	if( res ) goto jump_to_p2;
83031	break;
83032	}
83033
83034
83035	/* Opcode: SorterSort P1 P2 * * *
83036	**
83037	** After all records have been inserted into the Sorter object
83038	** identified by P1, invoke this opcode to actually do the sorting.
	@@ -83479,10 +83672,22 @@
83672	rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, flags);
83673	if( rc ) goto abort_due_to_error;
83674	pOut->u.i = pgno;
83675	break;
83676	}
83677
83678	/* Opcode: SqlExec * * * P4 *
83679	**
83680	** Run the SQL statement or statements specified in the P4 string.
83681	*/
83682	case OP_SqlExec: {
83683	db->nSqlExec++;
83684	rc = sqlite3_exec(db, pOp->p4.z, 0, 0, 0);
83685	db->nSqlExec--;
83686	if( rc ) goto abort_due_to_error;
83687	break;
83688	}
83689
83690	/* Opcode: ParseSchema P1 * * P4 *
83691	**
83692	** Read and parse all entries from the SQLITE_MASTER table of database P1
83693	** that match the WHERE clause P4.
	@@ -83600,11 +83805,11 @@
83805	**
83806	** Do an analysis of the currently open database. Store in
83807	** register P1 the text of an error message describing any problems.
83808	** If no problems are found, store a NULL in register P1.
83809	**
83810	** The register P3 contains one less than the maximum number of allowed errors.
83811	** At most reg(P3) errors will be reported.
83812	** In other words, the analysis stops as soon as reg(P1) errors are
83813	** seen. Reg(P1) is updated with the number of errors remaining.
83814	**
83815	** The root page numbers of all tables in the database are integers
	@@ -83633,18 +83838,18 @@
83838	assert( (pnErr->flags & (MEM_Str\|MEM_Blob))==0 );
83839	pIn1 = &aMem[pOp->p1];
83840	assert( pOp->p5<db->nDb );
83841	assert( DbMaskTest(p->btreeMask, pOp->p5) );
83842	z = sqlite3BtreeIntegrityCheck(db->aDb[pOp->p5].pBt, aRoot, nRoot,
83843	(int)pnErr->u.i+1, &nErr);

83844	sqlite3VdbeMemSetNull(pIn1);
83845	if( nErr==0 ){
83846	assert( z==0 );
83847	}else if( z==0 ){
83848	goto no_mem;
83849	}else{
83850	pnErr->u.i -= nErr-1;
83851	sqlite3VdbeMemSetStr(pIn1, z, -1, SQLITE_UTF8, sqlite3_free);
83852	}
83853	UPDATE_MAX_BLOBSIZE(pIn1);
83854	sqlite3VdbeChangeEncoding(pIn1, encoding);
83855	break;
	@@ -88787,15 +88992,15 @@
88992	** The return value from the callback should be one of the WRC_*
88993	** constants to specify how to proceed with the walk.
88994	**
88995	** WRC_Continue Continue descending down the tree.
88996	**
88997	** WRC_Prune Do not descend into child nodes, but allow
88998	** the walk to continue with sibling nodes.
88999	**
89000	** WRC_Abort Do no more callbacks. Unwind the stack and
89001	** return from the top-level walk call.
89002	**
89003	** The return value from this routine is WRC_Abort to abandon the tree walk
89004	** and WRC_Continue to continue.
89005	*/
89006	static SQLITE_NOINLINE int walkExpr(Walker pWalker, Expr pExpr){
	@@ -89153,11 +89358,12 @@
89358	}
89359	}
89360	}
89361
89362	/* Start at the inner-most context and move outward until a match is found */
89363	assert( pNC && cnt==0 );
89364	do{
89365	ExprList *pEList;
89366	SrcList *pSrcList = pNC->pSrcList;
89367
89368	if( pSrcList ){
89369	for(i=0, pItem=pSrcList->a; i<pSrcList->nSrc; i++, pItem++){
	@@ -89338,15 +89544,15 @@
89544	}
89545
89546	/* Advance to the next name context. The loop will exit when either
89547	** we have a match (cnt>0) or when we run out of name contexts.
89548	*/
89549	if( cnt ) break;
89550	pNC = pNC->pNext;
89551	nSubquery++;
89552	}while( pNC );
89553
89554
89555	/*
89556	** If X and Y are NULL (in other words if only the column name Z is
89557	** supplied) and the value of Z is enclosed in double-quotes, then
89558	** Z is a string literal if it doesn't match any column names. In that
	@@ -89532,37 +89738,42 @@
89738	break;
89739	}
89740	#endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT)
89741	&& !defined(SQLITE_OMIT_SUBQUERY) */
89742
89743	/* A column name: ID
89744	** Or table name and column name: ID.ID





89745	** Or a database, table and column: ID.ID.ID
89746	**
89747	** The TK_ID and TK_OUT cases are combined so that there will only
89748	** be one call to lookupName(). Then the compiler will in-line
89749	** lookupName() for a size reduction and performance increase.
89750	*/
89751	case TK_ID:
89752	case TK_DOT: {
89753	const char *zColumn;
89754	const char *zTable;
89755	const char *zDb;
89756	Expr *pRight;
89757
89758	if( pExpr->op==TK_ID ){



89759	zDb = 0;
89760	zTable = 0;
89761	zColumn = pExpr->u.zToken;
89762	}else{
89763	notValid(pParse, pNC, "the \".\" operator", NC_IdxExpr);
89764	pRight = pExpr->pRight;
89765	if( pRight->op==TK_ID ){
89766	zDb = 0;
89767	zTable = pExpr->pLeft->u.zToken;
89768	zColumn = pRight->u.zToken;
89769	}else{
89770	assert( pRight->op==TK_DOT );
89771	zDb = pExpr->pLeft->u.zToken;
89772	zTable = pRight->pLeft->u.zToken;
89773	zColumn = pRight->pRight->u.zToken;
89774	}
89775	}
89776	return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr);
89777	}
89778
89779	/* Resolve function names
	@@ -92833,11 +93044,11 @@
93044	int nVal = sqlite3ExprVectorSize(pLeft);
93045	Select *pSelect = (pExpr->flags & EP_xIsSelect) ? pExpr->x.pSelect : 0;
93046	char *zRet;
93047
93048	assert( pExpr->op==TK_IN );
93049	zRet = sqlite3DbMallocRaw(pParse->db, nVal+1);
93050	if( zRet ){
93051	int i;
93052	for(i=0; i<nVal; i++){
93053	Expr *pA = sqlite3VectorFieldSubexpr(pLeft, i);
93054	char a = sqlite3ExprAffinity(pA);
	@@ -93738,11 +93949,11 @@
93949	** Clear all column cache entries.
93950	*/
93951	SQLITE_PRIVATE void sqlite3ExprCacheClear(Parse *pParse){
93952	int i;
93953
93954	#ifdef SQLITE_DEBUG
93955	if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
93956	printf("CLEAR\n");
93957	}
93958	#endif
93959	for(i=0; i<pParse->nColCache; i++){
	@@ -95145,10 +95356,21 @@
95356	if( pA->a[i].sortOrder!=pB->a[i].sortOrder ) return 1;
95357	if( sqlite3ExprCompare(pExprA, pExprB, iTab) ) return 1;
95358	}
95359	return 0;
95360	}
95361
95362	/*
95363	** Like sqlite3ExprCompare() except COLLATE operators at the top-level
95364	** are ignored.
95365	*/
95366	SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr pA, Expr pB, int iTab){
95367	return sqlite3ExprCompare(
95368	sqlite3ExprSkipCollate(pA),
95369	sqlite3ExprSkipCollate(pB),
95370	iTab);
95371	}
95372
95373	/*
95374	** Return true if we can prove the pE2 will always be true if pE1 is
95375	** true. Return false if we cannot complete the proof or if pE2 might
95376	** be false. Examples:
	@@ -96698,10 +96920,11 @@
96920	Stat4Sample current; /* Current row as a Stat4Sample */
96921	u32 iPrn; /* Pseudo-random number used for sampling */
96922	Stat4Sample aBest; / Array of nCol best samples */
96923	int iMin; /* Index in a[] of entry with minimum score */
96924	int nSample; /* Current number of samples */
96925	int nMaxEqZero; /* Max leading 0 in anEq[] for any a[] entry */
96926	int iGet; /* Index of current sample accessed by stat_get() */
96927	Stat4Sample a; / Array of mxSample Stat4Sample objects */
96928	sqlite3 db; / Database connection, for malloc() */
96929	};
96930
	@@ -96962,10 +97185,17 @@
97185	int i;
97186
97187	assert( IsStat4 \|\| nEqZero==0 );
97188
97189	#ifdef SQLITE_ENABLE_STAT4
97190	/* Stat4Accum.nMaxEqZero is set to the maximum number of leading 0
97191	** values in the anEq[] array of any sample in Stat4Accum.a[]. In
97192	** other words, if nMaxEqZero is n, then it is guaranteed that there
97193	** are no samples with Stat4Sample.anEq[m]==0 for (m>=n). */
97194	if( nEqZero>p->nMaxEqZero ){
97195	p->nMaxEqZero = nEqZero;
97196	}
97197	if( pNew->isPSample==0 ){
97198	Stat4Sample *pUpgrade = 0;
97199	assert( pNew->anEq[pNew->iCol]>0 );
97200
97201	/* This sample is being added because the prefix that ends in column
	@@ -97059,16 +97289,26 @@
97289	if( p->nSample<p->mxSample \|\| sampleIsBetter(p, pBest, &p->a[p->iMin]) ){
97290	sampleInsert(p, pBest, i);
97291	}
97292	}
97293
97294	/* Check that no sample contains an anEq[] entry with an index of
97295	** p->nMaxEqZero or greater set to zero. */
97296	for(i=p->nSample-1; i>=0; i--){
97297	int j;
97298	for(j=p->nMaxEqZero; j<p->nCol; j++) assert( p->a[i].anEq[j]>0 );
97299	}
97300
97301	/* Update the anEq[] fields of any samples already collected. */
97302	if( iChng<p->nMaxEqZero ){
97303	for(i=p->nSample-1; i>=0; i--){
97304	int j;
97305	for(j=iChng; j<p->nCol; j++){
97306	if( p->a[i].anEq[j]==0 ) p->a[i].anEq[j] = p->current.anEq[j];
97307	}
97308	}
97309	p->nMaxEqZero = iChng;
97310	}
97311	#endif
97312
97313	#if defined(SQLITE_ENABLE_STAT3) && !defined(SQLITE_ENABLE_STAT4)
97314	if( iChng==0 ){
	@@ -97778,44 +98018,32 @@
98018	/* Form 1: Analyze everything */
98019	for(i=0; i<db->nDb; i++){
98020	if( i==1 ) continue; /* Do not analyze the TEMP database */
98021	analyzeDatabase(pParse, i);
98022	}
98023	}else if( pName2->n==0 && (iDb = sqlite3FindDb(db, pName1))>=0 ){
98024	/* Analyze the schema named as the argument */
98025	analyzeDatabase(pParse, iDb);
98026	}else{
98027	/* Form 3: Analyze the table or index named as an argument */













98028	iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName);
98029	if( iDb>=0 ){
98030	zDb = pName2->n ? db->aDb[iDb].zDbSName : 0;
98031	z = sqlite3NameFromToken(db, pTableName);
98032	if( z ){
98033	if( (pIdx = sqlite3FindIndex(db, z, zDb))!=0 ){
98034	analyzeTable(pParse, pIdx->pTable, pIdx);
98035	}else if( (pTab = sqlite3LocateTable(pParse, 0, z, zDb))!=0 ){
98036	analyzeTable(pParse, pTab, 0);
98037	}
98038	sqlite3DbFree(db, z);
98039	}
98040	}
98041	}
98042	if( db->nSqlExec==0 && (v = sqlite3GetVdbe(pParse))!=0 ){
98043	sqlite3VdbeAddOp0(v, OP_Expire);
98044	}
98045	}
98046
98047	/*
98048	** Used to pass information from the analyzer reader through to the
98049	** callback routine.
	@@ -97940,19 +98168,24 @@
98168	}
98169	aiRowEst = pIndex->aiRowEst;
98170	#endif
98171	pIndex->bUnordered = 0;
98172	decodeIntArray((char*)z, nCol, aiRowEst, pIndex->aiRowLogEst, pIndex);
98173	pIndex->hasStat1 = 1;
98174	if( pIndex->pPartIdxWhere==0 ){
98175	pTable->nRowLogEst = pIndex->aiRowLogEst[0];
98176	pTable->tabFlags \|= TF_HasStat1;
98177	}
98178	}else{
98179	Index fakeIdx;
98180	fakeIdx.szIdxRow = pTable->szTabRow;
98181	#ifdef SQLITE_ENABLE_COSTMULT
98182	fakeIdx.pTable = pTable;
98183	#endif
98184	decodeIntArray((char*)z, 1, 0, &pTable->nRowLogEst, &fakeIdx);
98185	pTable->szTabRow = fakeIdx.szIdxRow;
98186	pTable->tabFlags \|= TF_HasStat1;
98187	}
98188
98189	return 0;
98190	}
98191
	@@ -98243,19 +98476,24 @@
98476	SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
98477	analysisInfo sInfo;
98478	HashElem *i;
98479	char *zSql;
98480	int rc = SQLITE_OK;
98481	Schema *pSchema = db->aDb[iDb].pSchema;
98482
98483	assert( iDb>=0 && iDb<db->nDb );
98484	assert( db->aDb[iDb].pBt!=0 );
98485
98486	/* Clear any prior statistics */
98487	assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
98488	for(i=sqliteHashFirst(&pSchema->tblHash); i; i=sqliteHashNext(i)){
98489	Table *pTab = sqliteHashData(i);
98490	pTab->tabFlags &= ~TF_HasStat1;
98491	}
98492	for(i=sqliteHashFirst(&pSchema->idxHash); i; i=sqliteHashNext(i)){
98493	Index *pIdx = sqliteHashData(i);
98494	pIdx->hasStat1 = 0;
98495	#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
98496	sqlite3DeleteIndexSamples(db, pIdx);
98497	pIdx->aSample = 0;
98498	#endif
98499	}
	@@ -98274,23 +98512,23 @@
98512	}
98513	}
98514
98515	/* Set appropriate defaults on all indexes not in the sqlite_stat1 table */
98516	assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
98517	for(i=sqliteHashFirst(&pSchema->idxHash); i; i=sqliteHashNext(i)){
98518	Index *pIdx = sqliteHashData(i);
98519	if( !pIdx->hasStat1 ) sqlite3DefaultRowEst(pIdx);
98520	}
98521
98522	/* Load the statistics from the sqlite_stat4 table. */
98523	#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
98524	if( rc==SQLITE_OK && OptimizationEnabled(db, SQLITE_Stat34) ){
98525	db->lookaside.bDisable++;
98526	rc = loadStat4(db, sInfo.zDatabase);
98527	db->lookaside.bDisable--;
98528	}
98529	for(i=sqliteHashFirst(&pSchema->idxHash); i; i=sqliteHashNext(i)){
98530	Index *pIdx = sqliteHashData(i);
98531	sqlite3_free(pIdx->aiRowEst);
98532	pIdx->aiRowEst = 0;
98533	}
98534	#endif
	@@ -100271,10 +100509,11 @@
100509	SQLITE_PRIVATE void sqlite3AddNotNull(Parse *pParse, int onError){
100510	Table *p;
100511	p = pParse->pNewTable;
100512	if( p==0 \|\| NEVER(p->nCol<1) ) return;
100513	p->aCol[p->nCol-1].notNull = (u8)onError;
100514	p->tabFlags \|= TF_HasNotNull;
100515	}
100516
100517	/*
100518	** Scan the column type name zType (length nType) and return the
100519	** associated affinity type.
	@@ -102609,10 +102848,13 @@
102848	/* 10, 9, 8, 7, 6 */
102849	LogEst aVal[] = { 33, 32, 30, 28, 26 };
102850	LogEst *a = pIdx->aiRowLogEst;
102851	int nCopy = MIN(ArraySize(aVal), pIdx->nKeyCol);
102852	int i;
102853
102854	/* Indexes with default row estimates should not have stat1 data */
102855	assert( !pIdx->hasStat1 );
102856
102857	/* Set the first entry (number of rows in the index) to the estimated
102858	** number of rows in the table, or half the number of rows in the table
102859	** for a partial index. But do not let the estimate drop below 10. */
102860	a[0] = pIdx->pTable->nRowLogEst;
	@@ -109798,10 +110040,13 @@
110040	VdbeComment((v, "%s", iField<0 ? "rowid" : pTab->aCol[iField].zName));
110041	}
110042	}
110043	sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn, aRegIdx[ix]);
110044	VdbeComment((v, "for %s", pIdx->zName));
110045	#ifdef SQLITE_ENABLE_NULL_TRIM
110046	if( pIdx->idxType==2 ) sqlite3SetMakeRecordP5(v, pIdx->pTable);
110047	#endif
110048
110049	/* In an UPDATE operation, if this index is the PRIMARY KEY index
110050	** of a WITHOUT ROWID table and there has been no change the
110051	** primary key, then no collision is possible. The collision detection
110052	** logic below can all be skipped. */
	@@ -109953,12 +110198,15 @@
110198
110199	/* Records with omitted columns are only allowed for schema format
110200	** version 2 and later (SQLite version 3.1.4, 2005-02-20). */
110201	if( pTab->pSchema->file_format<2 ) return;
110202
110203	for(i=pTab->nCol-1; i>0; i--){
110204	if( pTab->aCol[i].pDflt!=0 ) break;
110205	if( pTab->aCol[i].colFlags & COLFLAG_PRIMKEY ) break;
110206	}
110207	sqlite3VdbeChangeP5(v, i+1);
110208	}
110209	#endif
110210
110211	/*
110212	** This routine generates code to finish the INSERT or UPDATE operation
	@@ -110244,11 +110492,11 @@
110492	}
110493	if( sqlite3TriggerList(pParse, pDest) ){
110494	return 0; /* tab1 must not have triggers */
110495	}
110496	#ifndef SQLITE_OMIT_VIRTUALTABLE
110497	if( IsVirtual(pDest) ){
110498	return 0; /* tab1 must not be a virtual table */
110499	}
110500	#endif
110501	if( onError==OE_Default ){
110502	if( pDest->iPKey>=0 ) onError = pDest->keyConf;
	@@ -110306,11 +110554,11 @@
110554	}
110555	if( HasRowid(pDest)!=HasRowid(pSrc) ){
110556	return 0; /* source and destination must both be WITHOUT ROWID or not */
110557	}
110558	#ifndef SQLITE_OMIT_VIRTUALTABLE
110559	if( IsVirtual(pSrc) ){
110560	return 0; /* tab2 must not be a virtual table */
110561	}
110562	#endif
110563	if( pSrc->pSelect ){
110564	return 0; /* tab2 may not be a view */
	@@ -110603,11 +110851,11 @@
110851	/* Invoke the callback function if required */
110852	if( xCallback && (SQLITE_ROW==rc \|\|
110853	(SQLITE_DONE==rc && !callbackIsInit
110854	&& db->flags&SQLITE_NullCallback)) ){
110855	if( !callbackIsInit ){
110856	azCols = sqlite3DbMallocRaw(db, (2nCol+1)sizeof(const char*));
110857	if( azCols==0 ){
110858	goto exec_out;
110859	}
110860	for(i=0; i<nCol; i++){
110861	azCols[i] = (char *)sqlite3_column_name(pStmt, i);
	@@ -110624,10 +110872,11 @@
110872	if( !azVals[i] && sqlite3_column_type(pStmt, i)!=SQLITE_NULL ){
110873	sqlite3OomFault(db);
110874	goto exec_out;
110875	}
110876	}
110877	azVals[i] = 0;
110878	}
110879	if( xCallback(pArg, nCol, azVals, azCols) ){
110880	/* EVIDENCE-OF: R-38229-40159 If the callback function to
110881	** sqlite3_exec() returns non-zero, then sqlite3_exec() will
110882	** return SQLITE_ABORT. */
	@@ -112094,15 +112343,15 @@
112343	#define PragTyp_JOURNAL_SIZE_LIMIT 20
112344	#define PragTyp_LOCK_PROXY_FILE 21
112345	#define PragTyp_LOCKING_MODE 22
112346	#define PragTyp_PAGE_COUNT 23
112347	#define PragTyp_MMAP_SIZE 24
112348	#define PragTyp_OPTIMIZE 25
112349	#define PragTyp_PAGE_SIZE 26
112350	#define PragTyp_SECURE_DELETE 27
112351	#define PragTyp_SHRINK_MEMORY 28
112352	#define PragTyp_SOFT_HEAP_LIMIT 29
112353	#define PragTyp_SYNCHRONOUS 30
112354	#define PragTyp_TABLE_INFO 31
112355	#define PragTyp_TEMP_STORE 32
112356	#define PragTyp_TEMP_STORE_DIRECTORY 33
112357	#define PragTyp_THREADS 34
	@@ -112112,10 +112361,11 @@
112361	#define PragTyp_HEXKEY 38
112362	#define PragTyp_KEY 39
112363	#define PragTyp_REKEY 40
112364	#define PragTyp_LOCK_STATUS 41
112365	#define PragTyp_PARSER_TRACE 42
112366	#define PragTyp_STATS 43
112367
112368	/* Property flags associated with various pragma. */
112369	#define PragFlg_NeedSchema 0x01 /* Force schema load before running */
112370	#define PragFlg_NoColumns 0x02 /* OP_ResultRow called with zero columns */
112371	#define PragFlg_NoColumns1 0x04 /* zero columns if RHS argument is present */
	@@ -112135,51 +112385,52 @@
112385	/* 2 */ "name",
112386	/* 3 */ "type",
112387	/* 4 */ "notnull",
112388	/* 5 */ "dflt_value",
112389	/* 6 */ "pk",
112390	/* 7 / "tbl", / Used by: stats */
112391	/* 8 */ "idx",
112392	/* 9 */ "wdth",
112393	/* 10 */ "hght",
112394	/* 11 */ "flgs",
112395	/* 12 / "seqno", / Used by: index_info */
112396	/* 13 */ "cid",
112397	/* 14 */ "name",
112398	/* 15 / "seqno", / Used by: index_xinfo */
112399	/* 16 */ "cid",
112400	/* 17 */ "name",
112401	/* 18 */ "desc",
112402	/* 19 */ "coll",
112403	/* 20 */ "key",
112404	/* 21 / "seq", / Used by: index_list */
112405	/* 22 */ "name",
112406	/* 23 */ "unique",
112407	/* 24 */ "origin",
112408	/* 25 */ "partial",
112409	/* 26 / "seq", / Used by: database_list */
112410	/* 27 */ "name",
112411	/* 28 */ "file",
112412	/* 29 / "seq", / Used by: collation_list */
112413	/* 30 */ "name",
112414	/* 31 / "id", / Used by: foreign_key_list */
112415	/* 32 */ "seq",
112416	/* 33 */ "table",
112417	/* 34 */ "from",
112418	/* 35 */ "to",
112419	/* 36 */ "on_update",
112420	/* 37 */ "on_delete",
112421	/* 38 */ "match",
112422	/* 39 / "table", / Used by: foreign_key_check */
112423	/* 40 */ "rowid",
112424	/* 41 */ "parent",
112425	/* 42 */ "fkid",
112426	/* 43 / "busy", / Used by: wal_checkpoint */
112427	/* 44 */ "log",
112428	/* 45 */ "checkpointed",
112429	/* 46 / "timeout", / Used by: busy_timeout */
112430	/* 47 / "database", / Used by: lock_status */
112431	/* 48 */ "status",
112432	};
112433
112434	/* Definitions of all built-in pragmas */
112435	typedef struct PragmaName {
112436	const char const zName; / Name of pragma */
	@@ -112221,11 +112472,11 @@
112472	#endif
112473	#endif
112474	{/* zName: */ "busy_timeout",
112475	/* ePragTyp: */ PragTyp_BUSY_TIMEOUT,
112476	/* ePragFlg: */ PragFlg_Result0,
112477	/* ColNames: */ 46, 1,
112478	/* iArg: */ 0 },
112479	#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
112480	{/* zName: */ "cache_size",
112481	/* ePragTyp: */ PragTyp_CACHE_SIZE,
112482	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result0\|PragFlg_SchemaReq\|PragFlg_NoColumns1,
	@@ -112258,11 +112509,11 @@
112509	#endif
112510	#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
112511	{/* zName: */ "collation_list",
112512	/* ePragTyp: */ PragTyp_COLLATION_LIST,
112513	/* ePragFlg: */ PragFlg_Result0,
112514	/* ColNames: */ 29, 2,
112515	/* iArg: */ 0 },
112516	#endif
112517	#if !defined(SQLITE_OMIT_COMPILEOPTION_DIAGS)
112518	{/* zName: */ "compile_options",
112519	/* ePragTyp: */ PragTyp_COMPILE_OPTIONS,
	@@ -112293,11 +112544,11 @@
112544	#endif
112545	#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
112546	{/* zName: */ "database_list",
112547	/* ePragTyp: */ PragTyp_DATABASE_LIST,
112548	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result0,
112549	/* ColNames: */ 26, 3,
112550	/* iArg: */ 0 },
112551	#endif
112552	#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED)
112553	{/* zName: */ "default_cache_size",
112554	/* ePragTyp: */ PragTyp_DEFAULT_CACHE_SIZE,
	@@ -112330,18 +112581,18 @@
112581	#endif
112582	#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
112583	{/* zName: */ "foreign_key_check",
112584	/* ePragTyp: */ PragTyp_FOREIGN_KEY_CHECK,
112585	/* ePragFlg: */ PragFlg_NeedSchema,
112586	/* ColNames: */ 39, 4,
112587	/* iArg: */ 0 },
112588	#endif
112589	#if !defined(SQLITE_OMIT_FOREIGN_KEY)
112590	{/* zName: */ "foreign_key_list",
112591	/* ePragTyp: */ PragTyp_FOREIGN_KEY_LIST,
112592	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result1\|PragFlg_SchemaOpt,
112593	/* ColNames: */ 31, 8,
112594	/* iArg: */ 0 },
112595	#endif
112596	#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
112597	#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
112598	{/* zName: */ "foreign_keys",
	@@ -112400,21 +112651,21 @@
112651	#endif
112652	#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
112653	{/* zName: */ "index_info",
112654	/* ePragTyp: */ PragTyp_INDEX_INFO,
112655	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result1\|PragFlg_SchemaOpt,
112656	/* ColNames: */ 12, 3,
112657	/* iArg: */ 0 },
112658	{/* zName: */ "index_list",
112659	/* ePragTyp: */ PragTyp_INDEX_LIST,
112660	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result1\|PragFlg_SchemaOpt,
112661	/* ColNames: */ 21, 5,
112662	/* iArg: */ 0 },
112663	{/* zName: */ "index_xinfo",
112664	/* ePragTyp: */ PragTyp_INDEX_INFO,
112665	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result1\|PragFlg_SchemaOpt,
112666	/* ColNames: */ 15, 6,
112667	/* iArg: */ 1 },
112668	#endif
112669	#if !defined(SQLITE_OMIT_INTEGRITY_CHECK)
112670	{/* zName: */ "integrity_check",
112671	/* ePragTyp: */ PragTyp_INTEGRITY_CHECK,
	@@ -112457,11 +112708,11 @@
112708	#endif
112709	#if defined(SQLITE_DEBUG) \|\| defined(SQLITE_TEST)
112710	{/* zName: */ "lock_status",
112711	/* ePragTyp: */ PragTyp_LOCK_STATUS,
112712	/* ePragFlg: */ PragFlg_Result0,
112713	/* ColNames: */ 47, 2,
112714	/* iArg: */ 0 },
112715	#endif
112716	#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
112717	{/* zName: */ "locking_mode",
112718	/* ePragTyp: */ PragTyp_LOCKING_MODE,
	@@ -112476,10 +112727,17 @@
112727	{/* zName: */ "mmap_size",
112728	/* ePragTyp: */ PragTyp_MMAP_SIZE,
112729	/* ePragFlg: */ 0,
112730	/* ColNames: */ 0, 0,
112731	/* iArg: */ 0 },
112732	#endif
112733	{/* zName: */ "optimize",
112734	/* ePragTyp: */ PragTyp_OPTIMIZE,
112735	/* ePragFlg: */ PragFlg_Result1,
112736	/* ColNames: */ 0, 0,
112737	/* iArg: */ 0 },
112738	#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
112739	{/* zName: */ "page_count",
112740	/* ePragTyp: */ PragTyp_PAGE_COUNT,
112741	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result0\|PragFlg_SchemaReq,
112742	/* ColNames: */ 0, 0,
112743	/* iArg: */ 0 },
	@@ -112574,15 +112832,15 @@
112832	/* ePragFlg: */ PragFlg_Result0\|PragFlg_NoColumns1,
112833	/* ColNames: */ 0, 0,
112834	/* iArg: */ SQLITE_SqlTrace },
112835	#endif
112836	#endif
112837	#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) && defined(SQLITE_DEBUG)
112838	{/* zName: */ "stats",
112839	/* ePragTyp: */ PragTyp_STATS,
112840	/* ePragFlg: */ PragFlg_NeedSchema\|PragFlg_Result0\|PragFlg_SchemaReq,
112841	/* ColNames: */ 7, 5,
112842	/* iArg: */ 0 },
112843	#endif
112844	#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
112845	{/* zName: */ "synchronous",
112846	/* ePragTyp: */ PragTyp_SYNCHRONOUS,
	@@ -112657,11 +112915,11 @@
112915	/* ColNames: */ 0, 0,
112916	/* iArg: */ 0 },
112917	{/* zName: */ "wal_checkpoint",
112918	/* ePragTyp: */ PragTyp_WAL_CHECKPOINT,
112919	/* ePragFlg: */ PragFlg_NeedSchema,
112920	/* ColNames: */ 43, 3,
112921	/* iArg: */ 0 },
112922	#endif
112923	#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
112924	{/* zName: */ "writable_schema",
112925	/* ePragTyp: */ PragTyp_FLAG,
	@@ -112668,11 +112926,11 @@
112926	/* ePragFlg: */ PragFlg_Result0\|PragFlg_NoColumns1,
112927	/* ColNames: */ 0, 0,
112928	/* iArg: */ SQLITE_WriteSchema\|SQLITE_RecoveryMode },
112929	#endif
112930	};
112931	/* Number of pragmas: 60 on by default, 74 total. */
112932
112933	/************ End of pragma.h ********************************************/
112934	/************ Continuing where we left off in pragma.c *******************/
112935
112936	/*
	@@ -112937,10 +113195,26 @@
113195	lwr = mid + 1;
113196	}
113197	}
113198	return lwr>upr ? 0 : &aPragmaName[mid];
113199	}
113200
113201	/*
113202	** Helper subroutine for PRAGMA integrity_check:
113203	**
113204	** Generate code to output a single-column result row with the result
113205	** held in register regResult. Decrement the result count and halt if
113206	** the maximum number of result rows have been issued.
113207	*/
113208	static int integrityCheckResultRow(Vdbe *v, int regResult){
113209	int addr;
113210	sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, 1);
113211	addr = sqlite3VdbeAddOp3(v, OP_IfPos, 1, sqlite3VdbeCurrentAddr(v)+2, 1);
113212	VdbeCoverage(v);
113213	sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
113214	return addr;
113215	}
113216
113217	/*
113218	** Process a pragma statement.
113219	**
113220	** Pragmas are of this form:
	@@ -113741,33 +114015,37 @@
114015	}
114016	}
114017	}
114018	break;
114019
114020	#ifdef SQLITE_DEBUG
114021	case PragTyp_STATS: {
114022	Index *pIdx;
114023	HashElem *i;
114024	pParse->nMem = 5;
114025	sqlite3CodeVerifySchema(pParse, iDb);
114026	for(i=sqliteHashFirst(&pDb->pSchema->tblHash); i; i=sqliteHashNext(i)){
114027	Table *pTab = sqliteHashData(i);
114028	sqlite3VdbeMultiLoad(v, 1, "ssiii",
114029	pTab->zName,
114030	0,
114031	pTab->szTabRow,
114032	pTab->nRowLogEst,
114033	pTab->tabFlags);
114034	sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 5);
114035	for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
114036	sqlite3VdbeMultiLoad(v, 2, "siii",
114037	pIdx->zName,
114038	pIdx->szIdxRow,
114039	pIdx->aiRowLogEst[0],
114040	pIdx->hasStat1);
114041	sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 5);
114042	}
114043	}
114044	}
114045	break;
114046	#endif
114047
114048	case PragTyp_INDEX_INFO: if( zRight ){
114049	Index *pIdx;
114050	Table *pTab;
114051	pIdx = sqlite3FindIndex(db, zRight, zDb);
	@@ -114020,13 +114298,21 @@
114298	#ifndef SQLITE_INTEGRITY_CHECK_ERROR_MAX
114299	# define SQLITE_INTEGRITY_CHECK_ERROR_MAX 100
114300	#endif
114301
114302	#ifndef SQLITE_OMIT_INTEGRITY_CHECK
114303	/* PRAGMA integrity_check
114304	** PRAGMA integrity_check(N)
114305	** PRAGMA quick_check
114306	** PRAGMA quick_check(N)
114307	**
114308	** Verify the integrity of the database.
114309	**
114310	** The "quick_check" is reduced version of
114311	** integrity_check designed to detect most database corruption
114312	** without the overhead of cross-checking indexes. Quick_check
114313	** is linear time wherease integrity_check is O(NlogN).
114314	*/
114315	case PragTyp_INTEGRITY_CHECK: {
114316	int i, j, addr, mxErr;
114317
114318	int isQuick = (sqlite3Tolower(zLeft[0])=='q');
	@@ -114053,11 +114339,11 @@
114339	sqlite3GetInt32(zRight, &mxErr);
114340	if( mxErr<=0 ){
114341	mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX;
114342	}
114343	}
114344	sqlite3VdbeAddOp2(v, OP_Integer, mxErr-1, 1); /* reg[1] holds errors left */
114345
114346	/* Do an integrity check on each database file */
114347	for(i=0; i<db->nDb; i++){
114348	HashElem *x;
114349	Hash *pTbls;
	@@ -114068,14 +114354,10 @@
114354
114355	if( OMIT_TEMPDB && i==1 ) continue;
114356	if( iDb>=0 && i!=iDb ) continue;
114357
114358	sqlite3CodeVerifySchema(pParse, i);




114359
114360	/* Do an integrity check of the B-Tree
114361	**
114362	** Begin by finding the root pages numbers
114363	** for all tables and indices in the database.
	@@ -114111,29 +114393,30 @@
114393	sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
114394	sqlite3MPrintf(db, "* in database %s *\n", db->aDb[i].zDbSName),
114395	P4_DYNAMIC);
114396	sqlite3VdbeAddOp3(v, OP_Move, 2, 4, 1);
114397	sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 2);
114398	integrityCheckResultRow(v, 2);
114399	sqlite3VdbeJumpHere(v, addr);
114400
114401	/* Make sure all the indices are constructed correctly.
114402	*/
114403	for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){
114404	Table *pTab = sqliteHashData(x);
114405	Index pIdx, pPk;
114406	Index *pPrior = 0;
114407	int loopTop;
114408	int iDataCur, iIdxCur;
114409	int r1 = -1;
114410
114411	if( pTab->pCheck==0
114412	&& (pTab->tabFlags & TF_HasNotNull)==0
114413	&& (pTab->pIndex==0 \|\| isQuick)
114414	){
114415	continue; /* No additional checks needed for this table */
114416	}
114417	pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);




114418	sqlite3ExprCacheClear(pParse);
114419	sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenRead, 0,
114420	1, 0, &iDataCur, &iIdxCur);
114421	sqlite3VdbeAddOp2(v, OP_Integer, 0, 7);
114422	for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
	@@ -114144,28 +114427,46 @@
114427	sqlite3VdbeAddOp2(v, OP_Rewind, iDataCur, 0); VdbeCoverage(v);
114428	loopTop = sqlite3VdbeAddOp2(v, OP_AddImm, 7, 1);
114429	/* Verify that all NOT NULL columns really are NOT NULL */
114430	for(j=0; j<pTab->nCol; j++){
114431	char *zErr;
114432	int jmp2;
114433	if( j==pTab->iPKey ) continue;
114434	if( pTab->aCol[j].notNull==0 ) continue;
114435	sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, j, 3);
114436	sqlite3VdbeChangeP5(v, OPFLAG_TYPEOFARG);
114437	jmp2 = sqlite3VdbeAddOp1(v, OP_NotNull, 3); VdbeCoverage(v);

114438	zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName,
114439	pTab->aCol[j].zName);
114440	sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
114441	integrityCheckResultRow(v, 3);


114442	sqlite3VdbeJumpHere(v, jmp2);
114443	}
114444	/* Verify CHECK constraints */
114445	if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){
114446	int addrCkFault = sqlite3VdbeMakeLabel(v);
114447	int addrCkOk = sqlite3VdbeMakeLabel(v);
114448	ExprList *pCheck = pTab->pCheck;
114449	char *zErr;
114450	int k;
114451	pParse->iSelfTab = iDataCur;
114452	sqlite3ExprCachePush(pParse);
114453	for(k=pCheck->nExpr-1; k>0; k--){
114454	sqlite3ExprIfFalse(pParse, pCheck->a[k].pExpr, addrCkFault, 0);
114455	}
114456	sqlite3ExprIfTrue(pParse, pCheck->a[0].pExpr, addrCkOk,
114457	SQLITE_JUMPIFNULL);
114458	sqlite3VdbeResolveLabel(v, addrCkFault);
114459	zErr = sqlite3MPrintf(db, "CHECK constraint failed in %s",
114460	pTab->zName);
114461	sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
114462	integrityCheckResultRow(v, 3);
114463	sqlite3VdbeResolveLabel(v, addrCkOk);
114464	sqlite3ExprCachePop(pParse);
114465	}
114466	/* Validate index entries for the current row */
114467	for(j=0, pIdx=pTab->pIndex; pIdx && !isQuick; pIdx=pIdx->pNext, j++){
114468	int jmp2, jmp3, jmp4, jmp5;
114469	int ckUniq = sqlite3VdbeMakeLabel(v);
114470	if( pPk==pIdx ) continue;
114471	r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 0, &jmp3,
114472	pPrior, r1);
	@@ -114172,20 +114473,17 @@
114473	pPrior = pIdx;
114474	sqlite3VdbeAddOp2(v, OP_AddImm, 8+j, 1); /* increment entry count */
114475	/* Verify that an index entry exists for the current table row */
114476	jmp2 = sqlite3VdbeAddOp4Int(v, OP_Found, iIdxCur+j, ckUniq, r1,
114477	pIdx->nColumn); VdbeCoverage(v);

114478	sqlite3VdbeLoadString(v, 3, "row ");
114479	sqlite3VdbeAddOp3(v, OP_Concat, 7, 3, 3);
114480	sqlite3VdbeLoadString(v, 4, " missing from index ");
114481	sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3);
114482	jmp5 = sqlite3VdbeLoadString(v, 4, pIdx->zName);
114483	sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3);
114484	jmp4 = integrityCheckResultRow(v, 3);


114485	sqlite3VdbeJumpHere(v, jmp2);
114486	/* For UNIQUE indexes, verify that only one entry exists with the
114487	** current key. The entry is unique if (1) any column is NULL
114488	** or (2) the next entry has a different key */
114489	if( IsUniqueIndex(pIdx) ){
	@@ -114202,11 +114500,10 @@
114500	jmp6 = sqlite3VdbeAddOp1(v, OP_Next, iIdxCur+j); VdbeCoverage(v);
114501	sqlite3VdbeGoto(v, uniqOk);
114502	sqlite3VdbeJumpHere(v, jmp6);
114503	sqlite3VdbeAddOp4Int(v, OP_IdxGT, iIdxCur+j, uniqOk, r1,
114504	pIdx->nKeyCol); VdbeCoverage(v);

114505	sqlite3VdbeLoadString(v, 3, "non-unique entry in index ");
114506	sqlite3VdbeGoto(v, jmp5);
114507	sqlite3VdbeResolveLabel(v, uniqOk);
114508	}
114509	sqlite3VdbeJumpHere(v, jmp4);
	@@ -114213,40 +114510,39 @@
114510	sqlite3ResolvePartIdxLabel(pParse, jmp3);
114511	}
114512	sqlite3VdbeAddOp2(v, OP_Next, iDataCur, loopTop); VdbeCoverage(v);
114513	sqlite3VdbeJumpHere(v, loopTop-1);
114514	#ifndef SQLITE_OMIT_BTREECOUNT
114515	if( !isQuick ){
114516	sqlite3VdbeLoadString(v, 2, "wrong # of entries in index ");
114517	for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
114518	if( pPk==pIdx ) continue;
114519	sqlite3VdbeAddOp2(v, OP_Count, iIdxCur+j, 3);
114520	addr = sqlite3VdbeAddOp3(v, OP_Eq, 8+j, 0, 3); VdbeCoverage(v);
114521	sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
114522	sqlite3VdbeLoadString(v, 3, pIdx->zName);
114523	sqlite3VdbeAddOp3(v, OP_Concat, 3, 2, 7);
114524	integrityCheckResultRow(v, 7);
114525	sqlite3VdbeJumpHere(v, addr);
114526	}

114527	}
114528	#endif /* SQLITE_OMIT_BTREECOUNT */
114529	}
114530	}
114531	{
114532	static const int iLn = VDBE_OFFSET_LINENO(2);
114533	static const VdbeOpList endCode[] = {
114534	{ OP_AddImm, 1, 0, 0}, /* 0 */
114535	{ OP_IfNotZero, 1, 4, 0}, /* 1 */
114536	{ OP_String8, 0, 3, 0}, /* 2 */
114537	{ OP_ResultRow, 3, 1, 0}, /* 3 */
114538	};
114539	VdbeOp *aOp;
114540
114541	aOp = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode, iLn);
114542	if( aOp ){
114543	aOp[0].p2 = 1-mxErr;
114544	aOp[2].p4type = P4_STATIC;
114545	aOp[2].p4.z = "ok";
114546	}
114547	}
114548	}
	@@ -114466,10 +114762,122 @@
114762	*/
114763	case PragTyp_SHRINK_MEMORY: {
114764	sqlite3_db_release_memory(db);
114765	break;
114766	}
114767
114768	/*
114769	** PRAGMA optimize
114770	** PRAGMA optimize(MASK)
114771	** PRAGMA schema.optimize
114772	** PRAGMA schema.optimize(MASK)
114773	**
114774	** Attempt to optimize the database. All schemas are optimized in the first
114775	** two forms, and only the specified schema is optimized in the latter two.
114776	**
114777	** The details of optimizations performed by this pragma are expected
114778	** to change and improve over time. Applications should anticipate that
114779	** this pragma will perform new optimizations in future releases.
114780	**
114781	** The optional argument is a bitmask of optimizations to perform:
114782	**
114783	** 0x0001 Debugging mode. Do not actually perform any optimizations
114784	** but instead return one line of text for each optimization
114785	** that would have been done. Off by default.
114786	**
114787	** 0x0002 Run ANALYZE on tables that might benefit. On by default.
114788	** See below for additional information.
114789	**
114790	** 0x0004 (Not yet implemented) Record usage and performance
114791	** information from the current session in the
114792	** database file so that it will be available to "optimize"
114793	** pragmas run by future database connections.
114794	**
114795	** 0x0008 (Not yet implemented) Create indexes that might have
114796	** been helpful to recent queries
114797	**
114798	The default MASK is and always shall be 0xfffe. 0xfffe means perform all of the optimizations listed above except Debug Mode, including new
114799	** optimizations that have not yet been invented. If new optimizations are
114800	** ever added that should be off by default, those off-by-default
114801	** optimizations will have bitmasks of 0x10000 or larger.
114802	**
114803	** DETERMINATION OF WHEN TO RUN ANALYZE
114804	**
114805	** In the current implementation, a table is analyzed if only if all of
114806	** the following are true:
114807	**
114808	** (1) MASK bit 0x02 is set.
114809	**
114810	** (2) The query planner used sqlite_stat1-style statistics for one or
114811	** more indexes of the table at some point during the lifetime of
114812	** the current connection.
114813	**
114814	** (3) One or more indexes of the table are currently unanalyzed OR
114815	** the number of rows in the table has increased by 25 times or more
114816	** since the last time ANALYZE was run.
114817	**
114818	** The rules for when tables are analyzed are likely to change in
114819	** future releases.
114820	*/
114821	case PragTyp_OPTIMIZE: {
114822	int iDbLast; /* Loop termination point for the schema loop */
114823	int iTabCur; /* Cursor for a table whose size needs checking */
114824	HashElem k; / Loop over tables of a schema */
114825	Schema pSchema; / The current schema */
114826	Table pTab; / A table in the schema */
114827	Index pIdx; / An index of the table */
114828	LogEst szThreshold; /* Size threshold above which reanalysis is needd */
114829	char zSubSql; / SQL statement for the OP_SqlExec opcode */
114830	u32 opMask; /* Mask of operations to perform */
114831
114832	if( zRight ){
114833	opMask = (u32)sqlite3Atoi(zRight);
114834	if( (opMask & 0x02)==0 ) break;
114835	}else{
114836	opMask = 0xfffe;
114837	}
114838	iTabCur = pParse->nTab++;
114839	for(iDbLast = zDb?iDb:db->nDb-1; iDb<=iDbLast; iDb++){
114840	if( iDb==1 ) continue;
114841	sqlite3CodeVerifySchema(pParse, iDb);
114842	pSchema = db->aDb[iDb].pSchema;
114843	for(k=sqliteHashFirst(&pSchema->tblHash); k; k=sqliteHashNext(k)){
114844	pTab = (Table*)sqliteHashData(k);
114845
114846	/* If table pTab has not been used in a way that would benefit from
114847	** having analysis statistics during the current session, then skip it.
114848	** This also has the effect of skipping virtual tables and views */
114849	if( (pTab->tabFlags & TF_StatsUsed)==0 ) continue;
114850
114851	/* Reanalyze if the table is 25 times larger than the last analysis */
114852	szThreshold = pTab->nRowLogEst + 46; assert( sqlite3LogEst(25)==46 );
114853	for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
114854	if( !pIdx->hasStat1 ){
114855	szThreshold = 0; /* Always analyze if any index lacks statistics */
114856	break;
114857	}
114858	}
114859	if( szThreshold ){
114860	sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
114861	sqlite3VdbeAddOp3(v, OP_IfSmaller, iTabCur,
114862	sqlite3VdbeCurrentAddr(v)+2+(opMask&1), szThreshold);
114863	VdbeCoverage(v);
114864	}
114865	zSubSql = sqlite3MPrintf(db, "ANALYZE \"%w\".\"%w\"",
114866	db->aDb[iDb].zDbSName, pTab->zName);
114867	if( opMask & 0x01 ){
114868	int r1 = sqlite3GetTempReg(pParse);
114869	sqlite3VdbeAddOp4(v, OP_String8, 0, r1, 0, zSubSql, P4_DYNAMIC);
114870	sqlite3VdbeAddOp2(v, OP_ResultRow, r1, 1);
114871	}else{
114872	sqlite3VdbeAddOp4(v, OP_SqlExec, 0, 0, 0, zSubSql, P4_DYNAMIC);
114873	}
114874	}
114875	}
114876	sqlite3VdbeAddOp0(v, OP_Expire);
114877	break;
114878	}
114879
114880	/*
114881	** PRAGMA busy_timeout
114882	** PRAGMA busy_timeout = N
114883	**
	@@ -123782,12 +124190,29 @@
124190	** transient would cause the database file to appear to be deleted
124191	** following reboot.
124192	*/
124193	SQLITE_PRIVATE void sqlite3Vacuum(Parse pParse, Token pNm){
124194	Vdbe *v = sqlite3GetVdbe(pParse);
124195	int iDb = 0;
124196	if( v==0 ) return;
124197	if( pNm ){
124198	#ifndef SQLITE_BUG_COMPATIBLE_20160819
124199	/* Default behavior: Report an error if the argument to VACUUM is
124200	** not recognized */
124201	iDb = sqlite3TwoPartName(pParse, pNm, pNm, &pNm);
124202	if( iDb<0 ) return;
124203	#else
124204	/* When SQLITE_BUG_COMPATIBLE_20160819 is defined, unrecognized arguments
124205	** to VACUUM are silently ignored. This is a back-out of a bug fix that
124206	** occurred on 2016-08-19 (https://www.sqlite.org/src/info/083f9e6270).
124207	** The buggy behavior is required for binary compatibility with some
124208	** legacy applications. */
124209	iDb = sqlite3FindDb(pParse->db, pNm);
124210	if( iDb<0 ) iDb = 0;
124211	#endif
124212	}
124213	if( iDb!=1 ){
124214	sqlite3VdbeAddOp1(v, OP_Vacuum, iDb);
124215	sqlite3VdbeUsesBtree(v, iDb);
124216	}
124217	return;
124218	}
	@@ -124377,12 +124802,11 @@
124802
124803	db = pParse->db;
124804	iDb = sqlite3SchemaToIndex(db, pTable->pSchema);
124805	assert( iDb>=0 );
124806
124807	assert( pTable->nModuleArg==0 );

124808	addModuleArgument(db, pTable, sqlite3NameFromToken(db, pModuleName));
124809	addModuleArgument(db, pTable, 0);
124810	addModuleArgument(db, pTable, sqlite3DbStrDup(db, pTable->zName));
124811	assert( (pParse->sNameToken.z==pName2->z && pName2->z!=0)
124812	\|\| (pParse->sNameToken.z==pName1->z && pName2->z==0)
	@@ -124666,11 +125090,11 @@
125090	const char *zMod;
125091	Module *pMod;
125092	int rc;
125093
125094	assert( pTab );
125095	if( !IsVirtual(pTab) \|\| sqlite3GetVTable(db, pTab) ){
125096	return SQLITE_OK;
125097	}
125098
125099	/* Locate the required virtual table module */
125100	zMod = pTab->azModuleArg[0];
	@@ -124736,11 +125160,11 @@
125160	Table *pTab;
125161	Module *pMod;
125162	const char *zMod;
125163
125164	pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
125165	assert( pTab && IsVirtual(pTab) && !pTab->pVTable );
125166
125167	/* Locate the required virtual table module */
125168	zMod = pTab->azModuleArg[0];
125169	pMod = (Module*)sqlite3HashFind(&db->aModule, zMod);
125170
	@@ -124790,11 +125214,11 @@
125214	sqlite3Error(db, SQLITE_MISUSE);
125215	sqlite3_mutex_leave(db->mutex);
125216	return SQLITE_MISUSE_BKPT;
125217	}
125218	pTab = pCtx->pTab;
125219	assert( IsVirtual(pTab) );
125220
125221	pParse = sqlite3StackAllocZero(db, sizeof(*pParse));
125222	if( pParse==0 ){
125223	rc = SQLITE_NOMEM_BKPT;
125224	}else{
	@@ -124804,11 +125228,11 @@
125228
125229	if( SQLITE_OK==sqlite3RunParser(pParse, zCreateTable, &zErr)
125230	&& pParse->pNewTable
125231	&& !db->mallocFailed
125232	&& !pParse->pNewTable->pSelect
125233	&& !IsVirtual(pParse->pNewTable)
125234	){
125235	if( !pTab->aCol ){
125236	Table *pNew = pParse->pNewTable;
125237	Index *pIdx;
125238	pTab->aCol = pNew->aCol;
	@@ -125093,11 +125517,11 @@
125517	/* Check to see the left operand is a column in a virtual table */
125518	if( NEVER(pExpr==0) ) return pDef;
125519	if( pExpr->op!=TK_COLUMN ) return pDef;
125520	pTab = pExpr->pTab;
125521	if( NEVER(pTab==0) ) return pDef;
125522	if( !IsVirtual(pTab) ) return pDef;
125523	pVtab = sqlite3GetVTable(db, pTab)->pVtab;
125524	assert( pVtab!=0 );
125525	assert( pVtab->pModule!=0 );
125526	pMod = (sqlite3_module *)pVtab->pModule;
125527	if( pMod->xFindFunction==0 ) return pDef;
	@@ -125188,12 +125612,11 @@
125612	return 0;
125613	}
125614	pMod->pEpoTab = pTab;
125615	pTab->nTabRef = 1;
125616	pTab->pSchema = db->aDb[0].pSchema;
125617	assert( pTab->nModuleArg==0 );

125618	pTab->iPKey = -1;
125619	addModuleArgument(db, pTab, sqlite3DbStrDup(db, pTab->zName));
125620	addModuleArgument(db, pTab, 0);
125621	addModuleArgument(db, pTab, sqlite3DbStrDup(db, pTab->zName));
125622	rc = vtabCallConstructor(db, pTab, pMod, pModule->xConnect, &zErr);
	@@ -125260,11 +125683,11 @@
125683	case SQLITE_VTAB_CONSTRAINT_SUPPORT: {
125684	VtabCtx *p = db->pVtabCtx;
125685	if( !p ){
125686	rc = SQLITE_MISUSE_BKPT;
125687	}else{
125688	assert( p->pTab==0 \|\| IsVirtual(p->pTab) );
125689	p->pVTable->bConstraint = (u8)va_arg(ap, int);
125690	}
125691	break;
125692	}
125693	default:
	@@ -125699,12 +126122,17 @@
126122	WhereOrSet pOrSet; / Record best loops here, if not NULL */
126123	#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
126124	UnpackedRecord pRec; / Probe for stat4 (if required) */
126125	int nRecValid; /* Number of valid fields currently in pRec */
126126	#endif
126127	unsigned int bldFlags; /* SQLITE_BLDF_* flags */
126128	};
126129
126130	/* Allowed values for WhereLoopBuider.bldFlags */
126131	#define SQLITE_BLDF_INDEXED 0x0001 /* An index is used */
126132	#define SQLITE_BLDF_UNIQUE 0x0002 /* All keys of a UNIQUE index used */
126133
126134	/*
126135	** The WHERE clause processing routine has two halves. The
126136	** first part does the start of the WHERE loop and the second
126137	** half does the tail of the WHERE loop. An instance of
126138	** this structure is returned by the first half and passed
	@@ -125715,11 +126143,11 @@
126143	*/
126144	struct WhereInfo {
126145	Parse pParse; / Parsing and code generating context */
126146	SrcList pTabList; / List of tables in the join */
126147	ExprList pOrderBy; / The ORDER BY clause or NULL */
126148	ExprList pResultSet; / Result set of the query */
126149	LogEst iLimit; /* LIMIT if wctrlFlags has WHERE_USE_LIMIT */
126150	int aiCurOnePass[2]; /* OP_OpenWrite cursors for the ONEPASS opt */
126151	int iContinue; /* Jump here to continue with next record */
126152	int iBreak; /* Jump here to break out of the loop */
126153	int savedNQueryLoop; /* pParse->nQueryLoop outside the WHERE loop */
	@@ -126899,10 +127327,11 @@
127327	Parse pParse; / Parsing context */
127328	sqlite3 db; / Database connection */
127329	Vdbe v; / The prepared stmt under constructions */
127330	struct SrcList_item pTabItem; / FROM clause term being coded */
127331	int addrBrk; /* Jump here to break out of the loop */
127332	int addrHalt; /* addrBrk for the outermost loop */
127333	int addrCont; /* Jump here to continue with next cycle */
127334	int iRowidReg = 0; /* Rowid is stored in this register, if not zero */
127335	int iReleaseReg = 0; /* Temp register to free before returning */
127336
127337	pParse = pWInfo->pParse;
	@@ -126939,10 +127368,15 @@
127368	if( pLevel->iFrom>0 && (pTabItem[0].fg.jointype & JT_LEFT)!=0 ){
127369	pLevel->iLeftJoin = ++pParse->nMem;
127370	sqlite3VdbeAddOp2(v, OP_Integer, 0, pLevel->iLeftJoin);
127371	VdbeComment((v, "init LEFT JOIN no-match flag"));
127372	}
127373
127374	/* Compute a safe address to jump to if we discover that the table for
127375	** this loop is empty and can never contribute content. */
127376	for(j=iLevel; j>0 && pWInfo->a[j].iLeftJoin==0; j--){}
127377	addrHalt = pWInfo->a[j].addrBrk;
127378
127379	/* Special case of a FROM clause subquery implemented as a co-routine */
127380	if( pTabItem->fg.viaCoroutine ){
127381	int regYield = pTabItem->regReturn;
127382	sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pTabItem->addrFillSub);
	@@ -127124,11 +127558,11 @@
127558	VdbeCoverageIf(v, pX->op==TK_LT);
127559	VdbeCoverageIf(v, pX->op==TK_GE);
127560	sqlite3ExprCacheAffinityChange(pParse, r1, 1);
127561	sqlite3ReleaseTempReg(pParse, rTemp);
127562	}else{
127563	sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iCur, addrHalt);
127564	VdbeCoverageIf(v, bRev==0);
127565	VdbeCoverageIf(v, bRev!=0);
127566	}
127567	if( pEnd ){
127568	Expr *pX;
	@@ -127770,11 +128204,11 @@
128204	pLevel->op = OP_Noop;
128205	}else{
128206	codeCursorHint(pTabItem, pWInfo, pLevel, 0);
128207	pLevel->op = aStep[bRev];
128208	pLevel->p1 = iCur;
128209	pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrHalt);
128210	VdbeCoverageIf(v, bRev==0);
128211	VdbeCoverageIf(v, bRev!=0);
128212	pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP;
128213	}
128214	}
	@@ -128095,19 +128529,10 @@
128529	#ifdef SQLITE_EBCDIC
128530	if( *pnoCase ) return 0;
128531	#endif
128532	pList = pExpr->x.pList;
128533	pLeft = pList->a[1].pExpr;









128534
128535	pRight = sqlite3ExprSkipCollate(pList->a[0].pExpr);
128536	op = pRight->op;
128537	if( op==TK_VARIABLE ){
128538	Vdbe *pReprepare = pParse->pReprepare;
	@@ -128120,10 +128545,27 @@
128545	assert( pRight->op==TK_VARIABLE \|\| pRight->op==TK_REGISTER );
128546	}else if( op==TK_STRING ){
128547	z = pRight->u.zToken;
128548	}
128549	if( z ){
128550
128551	/* If the RHS begins with a digit or a minus sign, then the LHS must
128552	** be an ordinary column (not a virtual table column) with TEXT affinity.
128553	** Otherwise the LHS might be numeric and "lhs >= rhs" would be false
128554	** even though "lhs LIKE rhs" is true. But if the RHS does not start
128555	** with a digit or '-', then "lhs LIKE rhs" will always be false if
128556	** the LHS is numeric and so the optimization still works.
128557	*/
128558	if( sqlite3Isdigit(z[0]) \|\| z[0]=='-' ){
128559	if( pLeft->op!=TK_COLUMN
128560	\|\| sqlite3ExprAffinity(pLeft)!=SQLITE_AFF_TEXT
128561	\|\| IsVirtual(pLeft->pTab) /* Value might be numeric */
128562	){
128563	sqlite3ValueFree(pVal);
128564	return 0;
128565	}
128566	}
128567	cnt = 0;
128568	while( (c=z[cnt])!=0 && c!=wc[0] && c!=wc[1] && c!=wc[2] ){
128569	cnt++;
128570	}
128571	if( cnt!=0 && 255!=(u8)z[cnt-1] ){
	@@ -128748,11 +129190,11 @@
129190	iCur = pFrom->a[i].iCursor;
129191	for(pIdx=pFrom->a[i].pTab->pIndex; pIdx; pIdx=pIdx->pNext){
129192	if( pIdx->aColExpr==0 ) continue;
129193	for(i=0; i<pIdx->nKeyCol; i++){
129194	if( pIdx->aiColumn[i]!=XN_EXPR ) continue;
129195	if( sqlite3ExprCompareSkip(pExpr, pIdx->aColExpr->a[i].pExpr, iCur)==0 ){
129196	*piCur = iCur;
129197	*piColumn = XN_EXPR;
129198	return 1;
129199	}
129200	}
	@@ -129539,11 +129981,12 @@
129981	do{
129982	for(pTerm=pWC->a+k; k<pWC->nTerm; k++, pTerm++){
129983	if( pTerm->leftCursor==iCur
129984	&& pTerm->u.leftColumn==iColumn
129985	&& (iColumn!=XN_EXPR
129986	\|\| sqlite3ExprCompareSkip(pTerm->pExpr->pLeft,
129987	pScan->pIdxExpr,iCur)==0)
129988	&& (pScan->iEquiv<=1 \|\| !ExprHasProperty(pTerm->pExpr, EP_FromJoin))
129989	){
129990	if( (pTerm->eOperator & WO_EQUIV)!=0
129991	&& pScan->nEquiv<ArraySize(pScan->aiCur)
129992	&& (pX = sqlite3ExprSkipCollate(pTerm->pExpr->pRight))->op==TK_COLUMN
	@@ -131716,10 +132159,15 @@
132159	testcase( eOp & WO_IS );
132160	testcase( eOp & WO_ISNULL );
132161	continue;
132162	}
132163
132164	if( IsUniqueIndex(pProbe) && saved_nEq==pProbe->nKeyCol-1 ){
132165	pBuilder->bldFlags \|= SQLITE_BLDF_UNIQUE;
132166	}else{
132167	pBuilder->bldFlags \|= SQLITE_BLDF_INDEXED;
132168	}
132169	pNew->wsFlags = saved_wsFlags;
132170	pNew->u.btree.nEq = saved_nEq;
132171	pNew->u.btree.nBtm = saved_nBtm;
132172	pNew->u.btree.nTop = saved_nTop;
132173	pNew->nLTerm = saved_nLTerm;
	@@ -132263,11 +132711,19 @@
132711	pNew->nOut = rSize;
132712	if( rc ) break;
132713	}
132714	}
132715
132716	pBuilder->bldFlags = 0;
132717	rc = whereLoopAddBtreeIndex(pBuilder, pSrc, pProbe, 0);
132718	if( pBuilder->bldFlags==SQLITE_BLDF_INDEXED ){
132719	/* If a non-unique index is used, or if a prefix of the key for
132720	** unique index is used (making the index functionally non-unique)
132721	** then the sqlite_stat1 data becomes important for scoring the
132722	** plan */
132723	pTab->tabFlags \|= TF_StatsUsed;
132724	}
132725	#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
132726	sqlite3Stat4ProbeFree(pBuilder->pRec);
132727	pBuilder->nRecValid = 0;
132728	pBuilder->pRec = 0;
132729	#endif
	@@ -133443,13 +133899,13 @@
133899	&& (pWInfo->wctrlFlags & WHERE_DISTINCTBY)==0
133900	&& pWInfo->eDistinct==WHERE_DISTINCT_NOOP
133901	&& nRowEst
133902	){
133903	Bitmask notUsed;
133904	int rc = wherePathSatisfiesOrderBy(pWInfo, pWInfo->pResultSet, pFrom,
133905	WHERE_DISTINCTBY, nLoop-1, pFrom->aLoop[nLoop-1], &notUsed);
133906	if( rc==pWInfo->pResultSet->nExpr ){
133907	pWInfo->eDistinct = WHERE_DISTINCT_ORDERED;
133908	}
133909	}
133910	if( pWInfo->pOrderBy ){
133911	if( pWInfo->wctrlFlags & WHERE_DISTINCTBY ){
	@@ -133682,11 +134138,11 @@
134138	SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
134139	Parse pParse, / The parser context */
134140	SrcList pTabList, / FROM clause: A list of all tables to be scanned */
134141	Expr pWhere, / The WHERE clause */
134142	ExprList pOrderBy, / An ORDER BY (or GROUP BY) clause, or NULL */
134143	ExprList pResultSet, / Query result set. Req'd for DISTINCT */
134144	u16 wctrlFlags, /* The WHERE_* flags defined in sqliteInt.h */
134145	int iAuxArg /* If WHERE_OR_SUBCLAUSE is set, index cursor number
134146	** If WHERE_USE_LIMIT, then the limit amount */
134147	){
134148	int nByteWInfo; /* Num. bytes allocated for WhereInfo struct */
	@@ -133758,11 +134214,11 @@
134214	goto whereBeginError;
134215	}
134216	pWInfo->pParse = pParse;
134217	pWInfo->pTabList = pTabList;
134218	pWInfo->pOrderBy = pOrderBy;
134219	pWInfo->pResultSet = pResultSet;
134220	pWInfo->aiCurOnePass[0] = pWInfo->aiCurOnePass[1] = -1;
134221	pWInfo->nLevel = nTabList;
134222	pWInfo->iBreak = pWInfo->iContinue = sqlite3VdbeMakeLabel(v);
134223	pWInfo->wctrlFlags = wctrlFlags;
134224	pWInfo->iLimit = iAuxArg;
	@@ -133836,17 +134292,17 @@
134292	/* Analyze all of the subexpressions. */
134293	sqlite3WhereExprAnalyze(pTabList, &pWInfo->sWC);
134294	if( db->mallocFailed ) goto whereBeginError;
134295
134296	if( wctrlFlags & WHERE_WANT_DISTINCT ){
134297	if( isDistinctRedundant(pParse, pTabList, &pWInfo->sWC, pResultSet) ){
134298	/* The DISTINCT marking is pointless. Ignore it. */
134299	pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE;
134300	}else if( pOrderBy==0 ){
134301	/* Try to ORDER BY the result set to make distinct processing easier */
134302	pWInfo->wctrlFlags \|= WHERE_DISTINCTBY;
134303	pWInfo->pOrderBy = pResultSet;
134304	}
134305	}
134306
134307	/* Construct the WhereLoop objects */
134308	#if defined(WHERETRACE_ENABLED)
	@@ -133918,14 +134374,14 @@
134374	}
134375	}
134376	#endif
134377	/* Attempt to omit tables from the join that do not effect the result */
134378	if( pWInfo->nLevel>=2
134379	&& pResultSet!=0
134380	&& OptimizationEnabled(db, SQLITE_OmitNoopJoin)
134381	){
134382	Bitmask tabUsed = sqlite3WhereExprListUsage(pMaskSet, pResultSet);
134383	if( sWLB.pOrderBy ){
134384	tabUsed \|= sqlite3WhereExprListUsage(pMaskSet, sWLB.pOrderBy);
134385	}
134386	while( pWInfo->nLevel>=2 ){
134387	WhereTerm pTerm, pEnd;
	@@ -134704,166 +135160,166 @@
135160	**
135161	********* Begin parsing tables ********************************************/
135162	#define YY_ACTTAB_COUNT (1567)
135163	static const YYACTIONTYPE yy_action[] = {
135164	/* 0 */ 325, 832, 351, 825, 5, 203, 203, 819, 99, 100,
135165	/* 10 */ 90, 978, 978, 853, 856, 845, 845, 97, 97, 98,
135166	/* 20 */ 98, 98, 98, 301, 96, 96, 96, 96, 95, 95,
135167	/* 30 */ 94, 94, 94, 93, 351, 325, 976, 976, 824, 824,
135168	/* 40 */ 826, 946, 354, 99, 100, 90, 978, 978, 853, 856,
135169	/* 50 */ 845, 845, 97, 97, 98, 98, 98, 98, 338, 96,
135170	/* 60 */ 96, 96, 96, 95, 95, 94, 94, 94, 93, 351,
135171	/* 70 */ 95, 95, 94, 94, 94, 93, 351, 791, 976, 976,
135172	/* 80 */ 325, 94, 94, 94, 93, 351, 792, 75, 99, 100,
135173	/* 90 */ 90, 978, 978, 853, 856, 845, 845, 97, 97, 98,
135174	/* 100 */ 98, 98, 98, 450, 96, 96, 96, 96, 95, 95,
135175	/* 110 */ 94, 94, 94, 93, 351, 1333, 155, 155, 2, 325,
135176	/* 120 */ 275, 146, 132, 52, 52, 93, 351, 99, 100, 90,
135177	/* 130 */ 978, 978, 853, 856, 845, 845, 97, 97, 98, 98,
135178	/* 140 */ 98, 98, 101, 96, 96, 96, 96, 95, 95, 94,
135179	/* 150 */ 94, 94, 93, 351, 957, 957, 325, 268, 428, 413,
135180	/* 160 */ 411, 61, 752, 752, 99, 100, 90, 978, 978, 853,
135181	/* 170 */ 856, 845, 845, 97, 97, 98, 98, 98, 98, 60,
135182	/* 180 */ 96, 96, 96, 96, 95, 95, 94, 94, 94, 93,
135183	/* 190 */ 351, 325, 270, 329, 273, 277, 958, 959, 250, 99,
135184	/* 200 */ 100, 90, 978, 978, 853, 856, 845, 845, 97, 97,
135185	/* 210 */ 98, 98, 98, 98, 301, 96, 96, 96, 96, 95,
135186	/* 220 */ 95, 94, 94, 94, 93, 351, 325, 937, 1326, 698,
135187	/* 230 */ 706, 1326, 242, 412, 99, 100, 90, 978, 978, 853,
135188	/* 240 */ 856, 845, 845, 97, 97, 98, 98, 98, 98, 347,
135189	/* 250 */ 96, 96, 96, 96, 95, 95, 94, 94, 94, 93,
135190	/* 260 */ 351, 325, 937, 1327, 384, 699, 1327, 381, 379, 99,
135191	/* 270 */ 100, 90, 978, 978, 853, 856, 845, 845, 97, 97,
135192	/* 280 */ 98, 98, 98, 98, 701, 96, 96, 96, 96, 95,
135193	/* 290 */ 95, 94, 94, 94, 93, 351, 325, 92, 89, 178,
135194	/* 300 */ 833, 935, 373, 700, 99, 100, 90, 978, 978, 853,
135195	/* 310 */ 856, 845, 845, 97, 97, 98, 98, 98, 98, 375,
135196	/* 320 */ 96, 96, 96, 96, 95, 95, 94, 94, 94, 93,
135197	/* 330 */ 351, 325, 1275, 946, 354, 818, 935, 739, 739, 99,
135198	/* 340 */ 100, 90, 978, 978, 853, 856, 845, 845, 97, 97,
135199	/* 350 */ 98, 98, 98, 98, 230, 96, 96, 96, 96, 95,
135200	/* 360 */ 95, 94, 94, 94, 93, 351, 325, 968, 227, 92,
135201	/* 370 */ 89, 178, 373, 300, 99, 100, 90, 978, 978, 853,
135202	/* 380 */ 856, 845, 845, 97, 97, 98, 98, 98, 98, 920,
135203	/* 390 */ 96, 96, 96, 96, 95, 95, 94, 94, 94, 93,
135204	/* 400 */ 351, 325, 449, 447, 447, 447, 147, 737, 737, 99,
135205	/* 410 */ 100, 90, 978, 978, 853, 856, 845, 845, 97, 97,
135206	/* 420 */ 98, 98, 98, 98, 296, 96, 96, 96, 96, 95,
135207	/* 430 */ 95, 94, 94, 94, 93, 351, 325, 419, 231, 957,
135208	/* 440 */ 957, 158, 25, 422, 99, 100, 90, 978, 978, 853,
135209	/* 450 */ 856, 845, 845, 97, 97, 98, 98, 98, 98, 450,
135210	/* 460 */ 96, 96, 96, 96, 95, 95, 94, 94, 94, 93,
135211	/* 470 */ 351, 443, 224, 224, 420, 957, 957, 961, 325, 52,
135212	/* 480 */ 52, 958, 959, 176, 415, 78, 99, 100, 90, 978,
135213	/* 490 */ 978, 853, 856, 845, 845, 97, 97, 98, 98, 98,
135214	/* 500 */ 98, 379, 96, 96, 96, 96, 95, 95, 94, 94,
135215	/* 510 */ 94, 93, 351, 325, 428, 418, 298, 958, 959, 961,
135216	/* 520 */ 81, 99, 88, 90, 978, 978, 853, 856, 845, 845,
135217	/* 530 */ 97, 97, 98, 98, 98, 98, 717, 96, 96, 96,
135218	/* 540 */ 96, 95, 95, 94, 94, 94, 93, 351, 325, 842,
135219	/* 550 */ 842, 854, 857, 996, 318, 343, 379, 100, 90, 978,
135220	/* 560 */ 978, 853, 856, 845, 845, 97, 97, 98, 98, 98,
135221	/* 570 */ 98, 450, 96, 96, 96, 96, 95, 95, 94, 94,
135222	/* 580 */ 94, 93, 351, 325, 350, 350, 350, 260, 377, 340,
135223	/* 590 */ 928, 52, 52, 90, 978, 978, 853, 856, 845, 845,
135224	/* 600 */ 97, 97, 98, 98, 98, 98, 361, 96, 96, 96,
135225	/* 610 */ 96, 95, 95, 94, 94, 94, 93, 351, 86, 445,
135226	/* 620 */ 846, 3, 1202, 361, 360, 378, 344, 813, 957, 957,
135227	/* 630 */ 1299, 86, 445, 729, 3, 212, 169, 287, 405, 282,
135228	/* 640 */ 404, 199, 232, 450, 300, 760, 83, 84, 280, 245,
135229	/* 650 */ 262, 365, 251, 85, 352, 352, 92, 89, 178, 83,
135230	/* 660 */ 84, 242, 412, 52, 52, 448, 85, 352, 352, 246,
135231	/* 670 */ 958, 959, 194, 455, 670, 402, 399, 398, 448, 243,
135232	/* 680 */ 221, 114, 434, 776, 361, 450, 397, 268, 747, 224,
135233	/* 690 */ 224, 132, 132, 198, 832, 434, 452, 451, 428, 427,
135234	/* 700 */ 819, 415, 734, 713, 132, 52, 52, 832, 268, 452,
135235	/* 710 */ 451, 734, 194, 819, 363, 402, 399, 398, 450, 1270,
135236	/* 720 */ 1270, 23, 957, 957, 86, 445, 397, 3, 228, 429,
135237	/* 730 */ 894, 824, 824, 826, 827, 19, 203, 720, 52, 52,
135238	/* 740 */ 428, 408, 439, 249, 824, 824, 826, 827, 19, 229,
135239	/* 750 */ 403, 153, 83, 84, 761, 177, 241, 450, 721, 85,
135240	/* 760 */ 352, 352, 120, 157, 958, 959, 58, 976, 409, 355,
135241	/* 770 */ 330, 448, 268, 428, 430, 320, 790, 32, 32, 86,
135242	/* 780 */ 445, 776, 3, 341, 98, 98, 98, 98, 434, 96,
135243	/* 790 */ 96, 96, 96, 95, 95, 94, 94, 94, 93, 351,
135244	/* 800 */ 832, 120, 452, 451, 813, 886, 819, 83, 84, 976,
135245	/* 810 */ 813, 132, 410, 919, 85, 352, 352, 132, 407, 789,
135246	/* 820 */ 957, 957, 92, 89, 178, 916, 448, 262, 370, 261,
135247	/* 830 */ 82, 913, 80, 262, 370, 261, 776, 824, 824, 826,
135248	/* 840 */ 827, 19, 933, 434, 96, 96, 96, 96, 95, 95,
135249	/* 850 */ 94, 94, 94, 93, 351, 832, 74, 452, 451, 957,
135250	/* 860 */ 957, 819, 958, 959, 120, 92, 89, 178, 944, 2,
135251	/* 870 */ 917, 964, 268, 1, 975, 76, 445, 762, 3, 708,
135252	/* 880 */ 900, 900, 387, 957, 957, 757, 918, 371, 740, 778,
135253	/* 890 */ 756, 257, 824, 824, 826, 827, 19, 417, 741, 450,
135254	/* 900 */ 24, 958, 959, 83, 84, 369, 957, 957, 177, 226,
135255	/* 910 */ 85, 352, 352, 884, 315, 314, 313, 215, 311, 10,
135256	/* 920 */ 10, 683, 448, 349, 348, 958, 959, 908, 777, 157,
135257	/* 930 */ 120, 957, 957, 337, 776, 416, 711, 310, 450, 434,
135258	/* 940 */ 450, 321, 450, 791, 103, 200, 175, 450, 958, 959,
135259	/* 950 */ 907, 832, 792, 452, 451, 9, 9, 819, 10, 10,
135260	/* 960 */ 52, 52, 51, 51, 180, 716, 248, 10, 10, 171,
135261	/* 970 */ 170, 167, 339, 958, 959, 247, 984, 702, 702, 450,
135262	/* 980 */ 715, 233, 686, 982, 888, 983, 182, 913, 824, 824,
135263	/* 990 */ 826, 827, 19, 183, 256, 423, 132, 181, 394, 10,
135264	/* 1000 */ 10, 888, 890, 749, 957, 957, 916, 268, 985, 198,
135265	/* 1010 */ 985, 349, 348, 425, 415, 299, 817, 832, 326, 825,
135266	/* 1020 */ 120, 332, 133, 819, 268, 98, 98, 98, 98, 91,
135267	/* 1030 */ 96, 96, 96, 96, 95, 95, 94, 94, 94, 93,
135268	/* 1040 */ 351, 157, 810, 371, 382, 359, 958, 959, 358, 268,
135269	/* 1050 */ 450, 917, 368, 324, 824, 824, 826, 450, 709, 450,
135270	/* 1060 */ 264, 380, 888, 450, 876, 746, 253, 918, 255, 433,
135271	/* 1070 */ 36, 36, 234, 450, 234, 120, 269, 37, 37, 12,
135272	/* 1080 */ 12, 334, 272, 27, 27, 450, 330, 118, 450, 162,
135273	/* 1090 */ 742, 280, 450, 38, 38, 450, 985, 356, 985, 450,
135274	/* 1100 */ 709, 1209, 450, 132, 450, 39, 39, 450, 40, 40,
135275	/* 1110 */ 450, 362, 41, 41, 450, 42, 42, 450, 254, 28,
135276	/* 1120 */ 28, 450, 29, 29, 31, 31, 450, 43, 43, 450,
135277	/* 1130 */ 44, 44, 450, 714, 45, 45, 450, 11, 11, 767,
135278	/* 1140 */ 450, 46, 46, 450, 268, 450, 105, 105, 450, 47,
135279	/* 1150 */ 47, 450, 48, 48, 450, 237, 33, 33, 450, 172,
135280	/* 1160 */ 49, 49, 450, 50, 50, 34, 34, 274, 122, 122,
135281	/* 1170 */ 450, 123, 123, 450, 124, 124, 450, 897, 56, 56,
135282	/* 1180 */ 450, 896, 35, 35, 450, 267, 450, 817, 450, 817,
135283	/* 1190 */ 106, 106, 450, 53, 53, 385, 107, 107, 450, 817,
135284	/* 1200 */ 108, 108, 817, 450, 104, 104, 121, 121, 119, 119,
135285	/* 1210 */ 450, 117, 112, 112, 450, 276, 450, 225, 111, 111,
135286	/* 1220 */ 450, 730, 450, 109, 109, 450, 673, 674, 675, 911,
135287	/* 1230 */ 110, 110, 317, 998, 55, 55, 57, 57, 692, 331,
135288	/* 1240 */ 54, 54, 26, 26, 696, 30, 30, 317, 936, 197,
135289	/* 1250 */ 196, 195, 335, 281, 336, 446, 331, 745, 689, 436,
135290	/* 1260 */ 440, 444, 120, 72, 386, 223, 175, 345, 757, 932,
135291	/* 1270 */ 20, 286, 319, 756, 815, 372, 374, 202, 202, 202,
135292	/* 1280 */ 263, 395, 285, 74, 208, 21, 696, 719, 718, 883,
135293	/* 1290 */ 120, 120, 120, 120, 120, 754, 278, 828, 77, 74,
135294	/* 1300 */ 726, 727, 785, 783, 879, 202, 999, 208, 893, 892,
135295	/* 1310 */ 893, 892, 694, 816, 763, 116, 774, 1289, 431, 432,
135296	/* 1320 */ 302, 999, 390, 303, 823, 697, 691, 680, 159, 289,
135297	/* 1330 */ 679, 883, 681, 951, 291, 218, 293, 7, 316, 828,
135298	/* 1340 */ 173, 805, 259, 364, 252, 910, 376, 713, 295, 435,
135299	/* 1350 */ 308, 168, 954, 993, 135, 400, 990, 284, 881, 880,
135300	/* 1360 */ 205, 927, 925, 59, 333, 62, 144, 156, 130, 72,
135301	/* 1370 */ 802, 366, 367, 393, 137, 185, 189, 160, 139, 383,
135302	/* 1380 */ 67, 895, 140, 141, 142, 148, 389, 812, 775, 266,
135303	/* 1390 */ 219, 190, 154, 391, 912, 875, 271, 406, 191, 322,
135304	/* 1400 */ 682, 733, 192, 342, 732, 724, 731, 711, 723, 421,
135305	/* 1410 */ 705, 71, 323, 6, 204, 771, 288, 79, 297, 346,
135306	/* 1420 */ 772, 704, 290, 283, 703, 770, 292, 294, 966, 239,
135307	/* 1430 */ 769, 102, 861, 438, 426, 240, 424, 442, 73, 213,
135308	/* 1440 */ 688, 238, 22, 453, 952, 214, 217, 216, 454, 677,
135309	/* 1450 */ 676, 671, 753, 125, 115, 235, 126, 669, 353, 166,
135310	/* 1460 */ 127, 244, 179, 357, 306, 304, 305, 307, 113, 891,
135311	/* 1470 */ 327, 889, 811, 328, 134, 128, 136, 138, 743, 258,
135312	/* 1480 */ 906, 184, 143, 129, 909, 186, 63, 64, 145, 187,
135313	/* 1490 */ 905, 65, 8, 66, 13, 188, 202, 898, 265, 149,
135314	/* 1500 */ 987, 388, 150, 685, 161, 392, 285, 193, 279, 396,
135315	/* 1510 */ 151, 401, 68, 14, 15, 722, 69, 236, 831, 131,
135316	/* 1520 */ 830, 859, 70, 751, 16, 414, 755, 4, 174, 220,
135317	/* 1530 */ 222, 784, 201, 152, 779, 77, 74, 17, 18, 874,
135318	/* 1540 */ 860, 858, 915, 863, 914, 207, 206, 941, 163, 437,
135319	/* 1550 */ 947, 942, 164, 209, 1002, 441, 862, 165, 210, 829,
135320	/* 1560 */ 695, 87, 312, 211, 1291, 1290, 309,
135321	};
135322	static const YYCODETYPE yy_lookahead[] = {
135323	/* 0 */ 19, 95, 53, 97, 22, 24, 24, 101, 27, 28,
135324	/* 10 */ 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
135325	/* 20 */ 39, 40, 41, 152, 43, 44, 45, 46, 47, 48,
	@@ -135112,55 +135568,55 @@
135568	/* 300 */ 1256, 1200, 1206, 1260, 1247, 1261, 1263, 1262, 1266, 1278,
135569	/* 310 */ 1282, 1292, 1294, 1297, 1298, 1299, 1300, 1221, 1224, 1228,
135570	/* 320 */ 1288, 1291, 1276, 1277, 1295,
135571	};
135572	static const YYACTIONTYPE yy_default[] = {
135573	/* 0 */ 1280, 1270, 1270, 1270, 1202, 1202, 1202, 1202, 1270, 1096,
135574	/* 10 */ 1125, 1125, 1254, 1332, 1332, 1332, 1332, 1332, 1332, 1201,
135575	/* 20 */ 1332, 1332, 1332, 1332, 1270, 1100, 1131, 1332, 1332, 1332,
135576	/* 30 */ 1332, 1203, 1204, 1332, 1332, 1332, 1253, 1255, 1141, 1140,
135577	/* 40 */ 1139, 1138, 1236, 1112, 1136, 1129, 1133, 1203, 1197, 1198,
135578	/* 50 */ 1196, 1200, 1204, 1332, 1132, 1167, 1181, 1166, 1332, 1332,
135579	/* 60 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135580	/* 70 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135581	/* 80 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135582	/* 90 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135583	/* 100 */ 1332, 1332, 1332, 1332, 1175, 1180, 1187, 1179, 1176, 1169,
135584	/* 110 */ 1168, 1170, 1171, 1332, 1019, 1067, 1332, 1332, 1332, 1172,
135585	/* 120 */ 1332, 1173, 1184, 1183, 1182, 1261, 1288, 1287, 1332, 1332,
135586	/* 130 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135587	/* 140 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135588	/* 150 */ 1332, 1332, 1332, 1332, 1332, 1280, 1270, 1025, 1025, 1332,
135589	/* 160 */ 1270, 1270, 1270, 1270, 1270, 1270, 1266, 1100, 1091, 1332,
135590	/* 170 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135591	/* 180 */ 1258, 1256, 1332, 1217, 1332, 1332, 1332, 1332, 1332, 1332,
135592	/* 190 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135593	/* 200 */ 1332, 1332, 1332, 1332, 1096, 1332, 1332, 1332, 1332, 1332,
135594	/* 210 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1282, 1332, 1231,
135595	/* 220 */ 1096, 1096, 1096, 1098, 1080, 1090, 1004, 1135, 1114, 1114,
135596	/* 230 */ 1321, 1135, 1321, 1042, 1302, 1039, 1125, 1114, 1199, 1125,
135597	/* 240 */ 1125, 1097, 1090, 1332, 1324, 1105, 1105, 1323, 1323, 1105,
135598	/* 250 */ 1146, 1070, 1135, 1076, 1076, 1076, 1076, 1105, 1016, 1135,
135599	/* 260 */ 1146, 1070, 1070, 1135, 1105, 1016, 1235, 1318, 1105, 1105,
135600	/* 270 */ 1016, 1210, 1105, 1016, 1105, 1016, 1210, 1068, 1068, 1068,
135601	/* 280 */ 1057, 1210, 1068, 1042, 1068, 1057, 1068, 1068, 1118, 1113,
135602	/* 290 */ 1118, 1113, 1118, 1113, 1118, 1113, 1105, 1205, 1105, 1332,
135603	/* 300 */ 1210, 1214, 1214, 1210, 1130, 1119, 1128, 1126, 1135, 1022,
135604	/* 310 */ 1060, 1285, 1285, 1281, 1281, 1281, 1281, 1329, 1329, 1266,
135605	/* 320 */ 1297, 1297, 1044, 1044, 1297, 1332, 1332, 1332, 1332, 1332,
135606	/* 330 */ 1332, 1292, 1332, 1219, 1332, 1332, 1332, 1332, 1332, 1332,
135607	/* 340 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135608	/* 350 */ 1332, 1332, 1152, 1332, 1000, 1263, 1332, 1332, 1262, 1332,
135609	/* 360 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135610	/* 370 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1320,
135611	/* 380 */ 1332, 1332, 1332, 1332, 1332, 1332, 1234, 1233, 1332, 1332,
135612	/* 390 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135613	/* 400 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
135614	/* 410 */ 1332, 1082, 1332, 1332, 1332, 1306, 1332, 1332, 1332, 1332,
135615	/* 420 */ 1332, 1332, 1332, 1127, 1332, 1120, 1332, 1332, 1311, 1332,
135616	/* 430 */ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1272,
135617	/* 440 */ 1332, 1332, 1332, 1271, 1332, 1332, 1332, 1332, 1332, 1154,
135618	/* 450 */ 1332, 1153, 1157, 1332, 1010, 1332,
135619	};
135620	/******** End of lemon-generated parsing tables ***************************/
135621
135622	/* The next table maps tokens (terminal symbols) into fallback tokens.
	@@ -135602,147 +136058,147 @@
136058	/* 169 */ "expr ::= expr EQ\|NE expr",
136059	/* 170 */ "expr ::= expr BITAND\|BITOR\|LSHIFT\|RSHIFT expr",
136060	/* 171 */ "expr ::= expr PLUS\|MINUS expr",
136061	/* 172 */ "expr ::= expr STAR\|SLASH\|REM expr",
136062	/* 173 */ "expr ::= expr CONCAT expr",
136063	/* 174 */ "likeop ::= NOT LIKE_KW\|MATCH",
136064	/* 175 */ "expr ::= expr likeop expr",
136065	/* 176 */ "expr ::= expr likeop expr ESCAPE expr",
136066	/* 177 */ "expr ::= expr ISNULL\|NOTNULL",
136067	/* 178 */ "expr ::= expr NOT NULL",
136068	/* 179 */ "expr ::= expr IS expr",
136069	/* 180 */ "expr ::= expr IS NOT expr",
136070	/* 181 */ "expr ::= NOT expr",
136071	/* 182 */ "expr ::= BITNOT expr",
136072	/* 183 */ "expr ::= MINUS expr",
136073	/* 184 */ "expr ::= PLUS expr",
136074	/* 185 */ "between_op ::= BETWEEN",
136075	/* 186 */ "between_op ::= NOT BETWEEN",
136076	/* 187 */ "expr ::= expr between_op expr AND expr",
136077	/* 188 */ "in_op ::= IN",
136078	/* 189 */ "in_op ::= NOT IN",
136079	/* 190 */ "expr ::= expr in_op LP exprlist RP",
136080	/* 191 */ "expr ::= LP select RP",
136081	/* 192 */ "expr ::= expr in_op LP select RP",
136082	/* 193 */ "expr ::= expr in_op nm dbnm paren_exprlist",
136083	/* 194 */ "expr ::= EXISTS LP select RP",
136084	/* 195 */ "expr ::= CASE case_operand case_exprlist case_else END",
136085	/* 196 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
136086	/* 197 */ "case_exprlist ::= WHEN expr THEN expr",
136087	/* 198 */ "case_else ::= ELSE expr",
136088	/* 199 */ "case_else ::=",
136089	/* 200 */ "case_operand ::= expr",
136090	/* 201 */ "case_operand ::=",
136091	/* 202 */ "exprlist ::=",
136092	/* 203 */ "nexprlist ::= nexprlist COMMA expr",
136093	/* 204 */ "nexprlist ::= expr",
136094	/* 205 */ "paren_exprlist ::=",
136095	/* 206 */ "paren_exprlist ::= LP exprlist RP",
136096	/* 207 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt",
136097	/* 208 */ "uniqueflag ::= UNIQUE",
136098	/* 209 */ "uniqueflag ::=",
136099	/* 210 */ "eidlist_opt ::=",
136100	/* 211 */ "eidlist_opt ::= LP eidlist RP",
136101	/* 212 */ "eidlist ::= eidlist COMMA nm collate sortorder",
136102	/* 213 */ "eidlist ::= nm collate sortorder",
136103	/* 214 */ "collate ::=",
136104	/* 215 */ "collate ::= COLLATE ID\|STRING",
136105	/* 216 */ "cmd ::= DROP INDEX ifexists fullname",
136106	/* 217 */ "cmd ::= VACUUM",
136107	/* 218 */ "cmd ::= VACUUM nm",
136108	/* 219 */ "cmd ::= PRAGMA nm dbnm",
136109	/* 220 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
136110	/* 221 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
136111	/* 222 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
136112	/* 223 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
136113	/* 224 */ "plus_num ::= PLUS INTEGER\|FLOAT",
136114	/* 225 */ "minus_num ::= MINUS INTEGER\|FLOAT",
136115	/* 226 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
136116	/* 227 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
136117	/* 228 */ "trigger_time ::= BEFORE",
136118	/* 229 */ "trigger_time ::= AFTER",
136119	/* 230 */ "trigger_time ::= INSTEAD OF",
136120	/* 231 */ "trigger_time ::=",
136121	/* 232 */ "trigger_event ::= DELETE\|INSERT",
136122	/* 233 */ "trigger_event ::= UPDATE",
136123	/* 234 */ "trigger_event ::= UPDATE OF idlist",
136124	/* 235 */ "when_clause ::=",
136125	/* 236 */ "when_clause ::= WHEN expr",
136126	/* 237 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
136127	/* 238 */ "trigger_cmd_list ::= trigger_cmd SEMI",
136128	/* 239 */ "trnm ::= nm DOT nm",
136129	/* 240 */ "tridxby ::= INDEXED BY nm",
136130	/* 241 */ "tridxby ::= NOT INDEXED",
136131	/* 242 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt",
136132	/* 243 */ "trigger_cmd ::= insert_cmd INTO trnm idlist_opt select",
136133	/* 244 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt",
136134	/* 245 */ "trigger_cmd ::= select",
136135	/* 246 */ "expr ::= RAISE LP IGNORE RP",
136136	/* 247 */ "expr ::= RAISE LP raisetype COMMA nm RP",
136137	/* 248 */ "raisetype ::= ROLLBACK",
136138	/* 249 */ "raisetype ::= ABORT",
136139	/* 250 */ "raisetype ::= FAIL",
136140	/* 251 */ "cmd ::= DROP TRIGGER ifexists fullname",
136141	/* 252 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
136142	/* 253 */ "cmd ::= DETACH database_kw_opt expr",
136143	/* 254 */ "key_opt ::=",
136144	/* 255 */ "key_opt ::= KEY expr",
136145	/* 256 */ "cmd ::= REINDEX",
136146	/* 257 */ "cmd ::= REINDEX nm dbnm",
136147	/* 258 */ "cmd ::= ANALYZE",
136148	/* 259 */ "cmd ::= ANALYZE nm dbnm",
136149	/* 260 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
136150	/* 261 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist",
136151	/* 262 */ "add_column_fullname ::= fullname",
136152	/* 263 */ "cmd ::= create_vtab",
136153	/* 264 */ "cmd ::= create_vtab LP vtabarglist RP",
136154	/* 265 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm",
136155	/* 266 */ "vtabarg ::=",
136156	/* 267 */ "vtabargtoken ::= ANY",
136157	/* 268 */ "vtabargtoken ::= lp anylist RP",
136158	/* 269 */ "lp ::= LP",
136159	/* 270 */ "with ::=",
136160	/* 271 */ "with ::= WITH wqlist",
136161	/* 272 */ "with ::= WITH RECURSIVE wqlist",
136162	/* 273 */ "wqlist ::= nm eidlist_opt AS LP select RP",
136163	/* 274 */ "wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP",
136164	/* 275 */ "input ::= cmdlist",
136165	/* 276 */ "cmdlist ::= cmdlist ecmd",
136166	/* 277 */ "cmdlist ::= ecmd",
136167	/* 278 */ "ecmd ::= SEMI",
136168	/* 279 */ "ecmd ::= explain cmdx SEMI",
136169	/* 280 */ "explain ::=",
136170	/* 281 */ "trans_opt ::=",
136171	/* 282 */ "trans_opt ::= TRANSACTION",
136172	/* 283 */ "trans_opt ::= TRANSACTION nm",
136173	/* 284 */ "savepoint_opt ::= SAVEPOINT",
136174	/* 285 */ "savepoint_opt ::=",
136175	/* 286 */ "cmd ::= create_table create_table_args",
136176	/* 287 */ "columnlist ::= columnlist COMMA columnname carglist",
136177	/* 288 */ "columnlist ::= columnname carglist",
136178	/* 289 */ "nm ::= ID\|INDEXED",
136179	/* 290 */ "nm ::= STRING",
136180	/* 291 */ "nm ::= JOIN_KW",
136181	/* 292 */ "typetoken ::= typename",
136182	/* 293 */ "typename ::= ID\|STRING",
136183	/* 294 */ "signed ::= plus_num",
136184	/* 295 */ "signed ::= minus_num",
136185	/* 296 */ "carglist ::= carglist ccons",
136186	/* 297 */ "carglist ::=",
136187	/* 298 */ "ccons ::= NULL onconf",
136188	/* 299 */ "conslist_opt ::= COMMA conslist",
136189	/* 300 */ "conslist ::= conslist tconscomma tcons",
136190	/* 301 */ "conslist ::= tcons",
136191	/* 302 */ "tconscomma ::=",
136192	/* 303 */ "defer_subclause_opt ::= defer_subclause",
136193	/* 304 */ "resolvetype ::= raisetype",
136194	/* 305 */ "selectnowith ::= oneselect",
136195	/* 306 */ "oneselect ::= values",
136196	/* 307 */ "sclp ::= selcollist COMMA",
136197	/* 308 */ "as ::= ID\|STRING",
136198	/* 309 */ "expr ::= term",
136199	/* 310 */ "likeop ::= LIKE_KW\|MATCH",
136200	/* 311 */ "exprlist ::= nexprlist",
136201	/* 312 */ "nmnum ::= plus_num",
136202	/* 313 */ "nmnum ::= nm",
136203	/* 314 */ "nmnum ::= ON",
136204	/* 315 */ "nmnum ::= DELETE",
	@@ -136375,11 +136831,10 @@
136831	{ 173, 3 },
136832	{ 173, 3 },
136833	{ 173, 3 },
136834	{ 173, 3 },
136835	{ 173, 3 },

136836	{ 221, 2 },
136837	{ 173, 3 },
136838	{ 173, 5 },
136839	{ 173, 2 },
136840	{ 173, 3 },
	@@ -136512,10 +136967,11 @@
136967	{ 194, 1 },
136968	{ 195, 1 },
136969	{ 209, 2 },
136970	{ 210, 1 },
136971	{ 173, 1 },
136972	{ 221, 1 },
136973	{ 208, 1 },
136974	{ 230, 1 },
136975	{ 230, 1 },
136976	{ 230, 1 },
136977	{ 230, 1 },
	@@ -136654,11 +137110,11 @@
137110	case 42: /* autoinc ::= */ yytestcase(yyruleno==42);
137111	case 57: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==57);
137112	case 67: /* defer_subclause_opt ::= */ yytestcase(yyruleno==67);
137113	case 76: /* ifexists ::= */ yytestcase(yyruleno==76);
137114	case 90: /* distinct ::= */ yytestcase(yyruleno==90);
137115	case 214: /* collate ::= */ yytestcase(yyruleno==214);
137116	{yymsp[1].minor.yy194 = 0;}
137117	break;
137118	case 17: /* ifnotexists ::= IF NOT EXISTS */
137119	{yymsp[-2].minor.yy194 = 1;}
137120	break;
	@@ -136798,13 +137254,13 @@
137254	case 144: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==144);
137255	{yymsp[-1].minor.yy194 = yymsp[0].minor.yy194;}
137256	break;
137257	case 58: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */
137258	case 75: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==75);
137259	case 186: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==186);
137260	case 189: /* in_op ::= NOT IN */ yytestcase(yyruleno==189);
137261	case 215: /* collate ::= COLLATE ID\|STRING */ yytestcase(yyruleno==215);
137262	{yymsp[-1].minor.yy194 = 1;}
137263	break;
137264	case 59: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
137265	{yymsp[-1].minor.yy194 = 0;}
137266	break;
	@@ -136964,13 +137420,13 @@
137420	{yymsp[0].minor.yy194 = SF_All;}
137421	break;
137422	case 91: /* sclp ::= */
137423	case 119: /* orderby_opt ::= */ yytestcase(yyruleno==119);
137424	case 126: /* groupby_opt ::= */ yytestcase(yyruleno==126);
137425	case 202: /* exprlist ::= */ yytestcase(yyruleno==202);
137426	case 205: /* paren_exprlist ::= */ yytestcase(yyruleno==205);
137427	case 210: /* eidlist_opt ::= */ yytestcase(yyruleno==210);
137428	{yymsp[1].minor.yy148 = 0;}
137429	break;
137430	case 92: /* selcollist ::= sclp expr as */
137431	{
137432	yymsp[-2].minor.yy148 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy148, yymsp[-1].minor.yy190.pExpr);
	@@ -136992,12 +137448,12 @@
137448	yymsp[-3].minor.yy148 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy148, pDot);
137449	}
137450	break;
137451	case 95: /* as ::= AS nm */
137452	case 106: /* dbnm ::= DOT nm */ yytestcase(yyruleno==106);
137453	case 224: /* plus_num ::= PLUS INTEGER\|FLOAT */ yytestcase(yyruleno==224);
137454	case 225: /* minus_num ::= MINUS INTEGER\|FLOAT */ yytestcase(yyruleno==225);
137455	{yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;}
137456	break;
137457	case 97: /* from ::= */
137458	{yymsp[1].minor.yy185 = sqlite3DbMallocZero(pParse->db, sizeof(*yymsp[1].minor.yy185));}
137459	break;
	@@ -137076,18 +137532,18 @@
137532	{yymsp[-3].minor.yy194 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/X-overwrites-A/}
137533	break;
137534	case 112: /* on_opt ::= ON expr */
137535	case 129: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==129);
137536	case 136: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==136);
137537	case 198: /* case_else ::= ELSE expr */ yytestcase(yyruleno==198);
137538	{yymsp[-1].minor.yy72 = yymsp[0].minor.yy190.pExpr;}
137539	break;
137540	case 113: /* on_opt ::= */
137541	case 128: /* having_opt ::= */ yytestcase(yyruleno==128);
137542	case 135: /* where_opt ::= */ yytestcase(yyruleno==135);
137543	case 199: /* case_else ::= */ yytestcase(yyruleno==199);
137544	case 201: /* case_operand ::= */ yytestcase(yyruleno==201);
137545	{yymsp[1].minor.yy72 = 0;}
137546	break;
137547	case 115: /* indexed_opt ::= INDEXED BY nm */
137548	{yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;}
137549	break;
	@@ -137230,11 +137686,11 @@
137686	case 158: /* term ::= INTEGER */
137687	{
137688	yylhsminor.yy190.pExpr = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1);
137689	yylhsminor.yy190.zStart = yymsp[0].minor.yy0.z;
137690	yylhsminor.yy190.zEnd = yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n;
137691	if( yylhsminor.yy190.pExpr ) yylhsminor.yy190.pExpr->flags \|= EP_Leaf\|EP_Resolved;
137692	}
137693	yymsp[0].minor.yy190 = yylhsminor.yy190;
137694	break;
137695	case 159: /* expr ::= VARIABLE */
137696	{
	@@ -137320,17 +137776,14 @@
137776	case 171: /* expr ::= expr PLUS\|MINUS expr */ yytestcase(yyruleno==171);
137777	case 172: /* expr ::= expr STAR\|SLASH\|REM expr */ yytestcase(yyruleno==172);
137778	case 173: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==173);
137779	{spanBinaryExpr(pParse,yymsp[-1].major,&yymsp[-2].minor.yy190,&yymsp[0].minor.yy190);}
137780	break;
137781	case 174: /* likeop ::= NOT LIKE_KW\|MATCH */



137782	{yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n\|=0x80000000; /yymsp[-1].minor.yy0-overwrite-yymsp[0].minor.yy0/}
137783	break;
137784	case 175: /* expr ::= expr likeop expr */
137785	{
137786	ExprList *pList;
137787	int bNot = yymsp[-1].minor.yy0.n & 0x80000000;
137788	yymsp[-1].minor.yy0.n &= 0x7fffffff;
137789	pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy190.pExpr);
	@@ -137339,11 +137792,11 @@
137792	exprNot(pParse, bNot, &yymsp[-2].minor.yy190);
137793	yymsp[-2].minor.yy190.zEnd = yymsp[0].minor.yy190.zEnd;
137794	if( yymsp[-2].minor.yy190.pExpr ) yymsp[-2].minor.yy190.pExpr->flags \|= EP_InfixFunc;
137795	}
137796	break;
137797	case 176: /* expr ::= expr likeop expr ESCAPE expr */
137798	{
137799	ExprList *pList;
137800	int bNot = yymsp[-3].minor.yy0.n & 0x80000000;
137801	yymsp[-3].minor.yy0.n &= 0x7fffffff;
137802	pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy190.pExpr);
	@@ -137353,43 +137806,43 @@
137806	exprNot(pParse, bNot, &yymsp[-4].minor.yy190);
137807	yymsp[-4].minor.yy190.zEnd = yymsp[0].minor.yy190.zEnd;
137808	if( yymsp[-4].minor.yy190.pExpr ) yymsp[-4].minor.yy190.pExpr->flags \|= EP_InfixFunc;
137809	}
137810	break;
137811	case 177: /* expr ::= expr ISNULL\|NOTNULL */
137812	{spanUnaryPostfix(pParse,yymsp[0].major,&yymsp[-1].minor.yy190,&yymsp[0].minor.yy0);}
137813	break;
137814	case 178: /* expr ::= expr NOT NULL */
137815	{spanUnaryPostfix(pParse,TK_NOTNULL,&yymsp[-2].minor.yy190,&yymsp[0].minor.yy0);}
137816	break;
137817	case 179: /* expr ::= expr IS expr */
137818	{
137819	spanBinaryExpr(pParse,TK_IS,&yymsp[-2].minor.yy190,&yymsp[0].minor.yy190);
137820	binaryToUnaryIfNull(pParse, yymsp[0].minor.yy190.pExpr, yymsp[-2].minor.yy190.pExpr, TK_ISNULL);
137821	}
137822	break;
137823	case 180: /* expr ::= expr IS NOT expr */
137824	{
137825	spanBinaryExpr(pParse,TK_ISNOT,&yymsp[-3].minor.yy190,&yymsp[0].minor.yy190);
137826	binaryToUnaryIfNull(pParse, yymsp[0].minor.yy190.pExpr, yymsp[-3].minor.yy190.pExpr, TK_NOTNULL);
137827	}
137828	break;
137829	case 181: /* expr ::= NOT expr */
137830	case 182: /* expr ::= BITNOT expr */ yytestcase(yyruleno==182);
137831	{spanUnaryPrefix(&yymsp[-1].minor.yy190,pParse,yymsp[-1].major,&yymsp[0].minor.yy190,&yymsp[-1].minor.yy0);/A-overwrites-B/}
137832	break;
137833	case 183: /* expr ::= MINUS expr */
137834	{spanUnaryPrefix(&yymsp[-1].minor.yy190,pParse,TK_UMINUS,&yymsp[0].minor.yy190,&yymsp[-1].minor.yy0);/A-overwrites-B/}
137835	break;
137836	case 184: /* expr ::= PLUS expr */
137837	{spanUnaryPrefix(&yymsp[-1].minor.yy190,pParse,TK_UPLUS,&yymsp[0].minor.yy190,&yymsp[-1].minor.yy0);/A-overwrites-B/}
137838	break;
137839	case 185: /* between_op ::= BETWEEN */
137840	case 188: /* in_op ::= IN */ yytestcase(yyruleno==188);
137841	{yymsp[0].minor.yy194 = 0;}
137842	break;
137843	case 187: /* expr ::= expr between_op expr AND expr */
137844	{
137845	ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy190.pExpr);
137846	pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy190.pExpr);
137847	yymsp[-4].minor.yy190.pExpr = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy190.pExpr, 0);
137848	if( yymsp[-4].minor.yy190.pExpr ){
	@@ -137399,11 +137852,11 @@
137852	}
137853	exprNot(pParse, yymsp[-3].minor.yy194, &yymsp[-4].minor.yy190);
137854	yymsp[-4].minor.yy190.zEnd = yymsp[0].minor.yy190.zEnd;
137855	}
137856	break;
137857	case 190: /* expr ::= expr in_op LP exprlist RP */
137858	{
137859	if( yymsp[-1].minor.yy148==0 ){
137860	/* Expressions of the form
137861	**
137862	** expr1 IN ()
	@@ -137452,26 +137905,26 @@
137905	exprNot(pParse, yymsp[-3].minor.yy194, &yymsp[-4].minor.yy190);
137906	}
137907	yymsp[-4].minor.yy190.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
137908	}
137909	break;
137910	case 191: /* expr ::= LP select RP */
137911	{
137912	spanSet(&yymsp[-2].minor.yy190,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /A-overwrites-B/
137913	yymsp[-2].minor.yy190.pExpr = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
137914	sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy190.pExpr, yymsp[-1].minor.yy243);
137915	}
137916	break;
137917	case 192: /* expr ::= expr in_op LP select RP */
137918	{
137919	yymsp[-4].minor.yy190.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy190.pExpr, 0);
137920	sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy190.pExpr, yymsp[-1].minor.yy243);
137921	exprNot(pParse, yymsp[-3].minor.yy194, &yymsp[-4].minor.yy190);
137922	yymsp[-4].minor.yy190.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
137923	}
137924	break;
137925	case 193: /* expr ::= expr in_op nm dbnm paren_exprlist */
137926	{
137927	SrcList *pSrc = sqlite3SrcListAppend(pParse->db, 0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);
137928	Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);
137929	if( yymsp[0].minor.yy148 ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy148);
137930	yymsp[-4].minor.yy190.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy190.pExpr, 0);
	@@ -137478,19 +137931,19 @@
137931	sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy190.pExpr, pSelect);
137932	exprNot(pParse, yymsp[-3].minor.yy194, &yymsp[-4].minor.yy190);
137933	yymsp[-4].minor.yy190.zEnd = yymsp[-1].minor.yy0.z ? &yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n] : &yymsp[-2].minor.yy0.z[yymsp[-2].minor.yy0.n];
137934	}
137935	break;
137936	case 194: /* expr ::= EXISTS LP select RP */
137937	{
137938	Expr *p;
137939	spanSet(&yymsp[-3].minor.yy190,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0); /A-overwrites-B/
137940	p = yymsp[-3].minor.yy190.pExpr = sqlite3PExpr(pParse, TK_EXISTS, 0, 0);
137941	sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy243);
137942	}
137943	break;
137944	case 195: /* expr ::= CASE case_operand case_exprlist case_else END */
137945	{
137946	spanSet(&yymsp[-4].minor.yy190,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0); /A-overwrites-C/
137947	yymsp[-4].minor.yy190.pExpr = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy72, 0);
137948	if( yymsp[-4].minor.yy190.pExpr ){
137949	yymsp[-4].minor.yy190.pExpr->x.pList = yymsp[-1].minor.yy72 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy148,yymsp[-1].minor.yy72) : yymsp[-2].minor.yy148;
	@@ -137499,313 +137952,314 @@
137952	sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy148);
137953	sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy72);
137954	}
137955	}
137956	break;
137957	case 196: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
137958	{
137959	yymsp[-4].minor.yy148 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy148, yymsp[-2].minor.yy190.pExpr);
137960	yymsp[-4].minor.yy148 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy148, yymsp[0].minor.yy190.pExpr);
137961	}
137962	break;
137963	case 197: /* case_exprlist ::= WHEN expr THEN expr */
137964	{
137965	yymsp[-3].minor.yy148 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy190.pExpr);
137966	yymsp[-3].minor.yy148 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy148, yymsp[0].minor.yy190.pExpr);
137967	}
137968	break;
137969	case 200: /* case_operand ::= expr */
137970	{yymsp[0].minor.yy72 = yymsp[0].minor.yy190.pExpr; /A-overwrites-X/}
137971	break;
137972	case 203: /* nexprlist ::= nexprlist COMMA expr */
137973	{yymsp[-2].minor.yy148 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy148,yymsp[0].minor.yy190.pExpr);}
137974	break;
137975	case 204: /* nexprlist ::= expr */
137976	{yymsp[0].minor.yy148 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy190.pExpr); /A-overwrites-Y/}
137977	break;
137978	case 206: /* paren_exprlist ::= LP exprlist RP */
137979	case 211: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==211);
137980	{yymsp[-2].minor.yy148 = yymsp[-1].minor.yy148;}
137981	break;
137982	case 207: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
137983	{
137984	sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0,
137985	sqlite3SrcListAppend(pParse->db,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy148, yymsp[-10].minor.yy194,
137986	&yymsp[-11].minor.yy0, yymsp[0].minor.yy72, SQLITE_SO_ASC, yymsp[-8].minor.yy194, SQLITE_IDXTYPE_APPDEF);
137987	}
137988	break;
137989	case 208: /* uniqueflag ::= UNIQUE */
137990	case 249: /* raisetype ::= ABORT */ yytestcase(yyruleno==249);
137991	{yymsp[0].minor.yy194 = OE_Abort;}
137992	break;
137993	case 209: /* uniqueflag ::= */
137994	{yymsp[1].minor.yy194 = OE_None;}
137995	break;
137996	case 212: /* eidlist ::= eidlist COMMA nm collate sortorder */
137997	{
137998	yymsp[-4].minor.yy148 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy148, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy194, yymsp[0].minor.yy194);
137999	}
138000	break;
138001	case 213: /* eidlist ::= nm collate sortorder */
138002	{
138003	yymsp[-2].minor.yy148 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy194, yymsp[0].minor.yy194); /A-overwrites-Y/
138004	}
138005	break;
138006	case 216: /* cmd ::= DROP INDEX ifexists fullname */
138007	{sqlite3DropIndex(pParse, yymsp[0].minor.yy185, yymsp[-1].minor.yy194);}
138008	break;
138009	case 217: /* cmd ::= VACUUM */
138010	{sqlite3Vacuum(pParse,0);}
138011	break;
138012	case 218: /* cmd ::= VACUUM nm */
138013	{sqlite3Vacuum(pParse,&yymsp[0].minor.yy0);}
138014	break;
138015	case 219: /* cmd ::= PRAGMA nm dbnm */
138016	{sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
138017	break;
138018	case 220: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
138019	{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);}
138020	break;
138021	case 221: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
138022	{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);}
138023	break;
138024	case 222: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
138025	{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);}
138026	break;
138027	case 223: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
138028	{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);}
138029	break;
138030	case 226: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
138031	{
138032	Token all;
138033	all.z = yymsp[-3].minor.yy0.z;
138034	all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
138035	sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy145, &all);
138036	}
138037	break;
138038	case 227: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
138039	{
138040	sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy194, yymsp[-4].minor.yy332.a, yymsp[-4].minor.yy332.b, yymsp[-2].minor.yy185, yymsp[0].minor.yy72, yymsp[-10].minor.yy194, yymsp[-8].minor.yy194);
138041	yymsp[-10].minor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0); /A-overwrites-T/
138042	}
138043	break;
138044	case 228: /* trigger_time ::= BEFORE */
138045	{ yymsp[0].minor.yy194 = TK_BEFORE; }
138046	break;
138047	case 229: /* trigger_time ::= AFTER */
138048	{ yymsp[0].minor.yy194 = TK_AFTER; }
138049	break;
138050	case 230: /* trigger_time ::= INSTEAD OF */
138051	{ yymsp[-1].minor.yy194 = TK_INSTEAD;}
138052	break;
138053	case 231: /* trigger_time ::= */
138054	{ yymsp[1].minor.yy194 = TK_BEFORE; }
138055	break;
138056	case 232: /* trigger_event ::= DELETE\|INSERT */
138057	case 233: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==233);
138058	{yymsp[0].minor.yy332.a = yymsp[0].major; /A-overwrites-X/ yymsp[0].minor.yy332.b = 0;}
138059	break;
138060	case 234: /* trigger_event ::= UPDATE OF idlist */
138061	{yymsp[-2].minor.yy332.a = TK_UPDATE; yymsp[-2].minor.yy332.b = yymsp[0].minor.yy254;}
138062	break;
138063	case 235: /* when_clause ::= */
138064	case 254: /* key_opt ::= */ yytestcase(yyruleno==254);
138065	{ yymsp[1].minor.yy72 = 0; }
138066	break;
138067	case 236: /* when_clause ::= WHEN expr */
138068	case 255: /* key_opt ::= KEY expr */ yytestcase(yyruleno==255);
138069	{ yymsp[-1].minor.yy72 = yymsp[0].minor.yy190.pExpr; }
138070	break;
138071	case 237: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
138072	{
138073	assert( yymsp[-2].minor.yy145!=0 );
138074	yymsp[-2].minor.yy145->pLast->pNext = yymsp[-1].minor.yy145;
138075	yymsp[-2].minor.yy145->pLast = yymsp[-1].minor.yy145;
138076	}
138077	break;
138078	case 238: /* trigger_cmd_list ::= trigger_cmd SEMI */
138079	{
138080	assert( yymsp[-1].minor.yy145!=0 );
138081	yymsp[-1].minor.yy145->pLast = yymsp[-1].minor.yy145;
138082	}
138083	break;
138084	case 239: /* trnm ::= nm DOT nm */
138085	{
138086	yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;
138087	sqlite3ErrorMsg(pParse,
138088	"qualified table names are not allowed on INSERT, UPDATE, and DELETE "
138089	"statements within triggers");
138090	}
138091	break;
138092	case 240: /* tridxby ::= INDEXED BY nm */
138093	{
138094	sqlite3ErrorMsg(pParse,
138095	"the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
138096	"within triggers");
138097	}
138098	break;
138099	case 241: /* tridxby ::= NOT INDEXED */
138100	{
138101	sqlite3ErrorMsg(pParse,
138102	"the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
138103	"within triggers");
138104	}
138105	break;
138106	case 242: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt */
138107	{yymsp[-6].minor.yy145 = sqlite3TriggerUpdateStep(pParse->db, &yymsp[-4].minor.yy0, yymsp[-1].minor.yy148, yymsp[0].minor.yy72, yymsp[-5].minor.yy194);}
138108	break;
138109	case 243: /* trigger_cmd ::= insert_cmd INTO trnm idlist_opt select */
138110	{yymsp[-4].minor.yy145 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy254, yymsp[0].minor.yy243, yymsp[-4].minor.yy194);/A-overwrites-R/}
138111	break;
138112	case 244: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt */
138113	{yymsp[-4].minor.yy145 = sqlite3TriggerDeleteStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[0].minor.yy72);}
138114	break;
138115	case 245: /* trigger_cmd ::= select */
138116	{yymsp[0].minor.yy145 = sqlite3TriggerSelectStep(pParse->db, yymsp[0].minor.yy243); /A-overwrites-X/}
138117	break;
138118	case 246: /* expr ::= RAISE LP IGNORE RP */
138119	{
138120	spanSet(&yymsp[-3].minor.yy190,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0); /A-overwrites-X/
138121	yymsp[-3].minor.yy190.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0);
138122	if( yymsp[-3].minor.yy190.pExpr ){
138123	yymsp[-3].minor.yy190.pExpr->affinity = OE_Ignore;
138124	}
138125	}
138126	break;
138127	case 247: /* expr ::= RAISE LP raisetype COMMA nm RP */
138128	{
138129	spanSet(&yymsp[-5].minor.yy190,&yymsp[-5].minor.yy0,&yymsp[0].minor.yy0); /A-overwrites-X/
138130	yymsp[-5].minor.yy190.pExpr = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1);
138131	if( yymsp[-5].minor.yy190.pExpr ) {
138132	yymsp[-5].minor.yy190.pExpr->affinity = (char)yymsp[-3].minor.yy194;
138133	}
138134	}
138135	break;
138136	case 248: /* raisetype ::= ROLLBACK */
138137	{yymsp[0].minor.yy194 = OE_Rollback;}
138138	break;
138139	case 250: /* raisetype ::= FAIL */
138140	{yymsp[0].minor.yy194 = OE_Fail;}
138141	break;
138142	case 251: /* cmd ::= DROP TRIGGER ifexists fullname */
138143	{
138144	sqlite3DropTrigger(pParse,yymsp[0].minor.yy185,yymsp[-1].minor.yy194);
138145	}
138146	break;
138147	case 252: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
138148	{
138149	sqlite3Attach(pParse, yymsp[-3].minor.yy190.pExpr, yymsp[-1].minor.yy190.pExpr, yymsp[0].minor.yy72);
138150	}
138151	break;
138152	case 253: /* cmd ::= DETACH database_kw_opt expr */
138153	{
138154	sqlite3Detach(pParse, yymsp[0].minor.yy190.pExpr);
138155	}
138156	break;
138157	case 256: /* cmd ::= REINDEX */
138158	{sqlite3Reindex(pParse, 0, 0);}
138159	break;
138160	case 257: /* cmd ::= REINDEX nm dbnm */
138161	{sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
138162	break;
138163	case 258: /* cmd ::= ANALYZE */
138164	{sqlite3Analyze(pParse, 0, 0);}
138165	break;
138166	case 259: /* cmd ::= ANALYZE nm dbnm */
138167	{sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
138168	break;
138169	case 260: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
138170	{
138171	sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy185,&yymsp[0].minor.yy0);
138172	}
138173	break;
138174	case 261: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
138175	{
138176	yymsp[-1].minor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-1].minor.yy0.z) + pParse->sLastToken.n;
138177	sqlite3AlterFinishAddColumn(pParse, &yymsp[-1].minor.yy0);
138178	}
138179	break;
138180	case 262: /* add_column_fullname ::= fullname */
138181	{
138182	disableLookaside(pParse);
138183	sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy185);
138184	}
138185	break;
138186	case 263: /* cmd ::= create_vtab */
138187	{sqlite3VtabFinishParse(pParse,0);}
138188	break;
138189	case 264: /* cmd ::= create_vtab LP vtabarglist RP */
138190	{sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
138191	break;
138192	case 265: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
138193	{
138194	sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy194);
138195	}
138196	break;
138197	case 266: /* vtabarg ::= */
138198	{sqlite3VtabArgInit(pParse);}
138199	break;
138200	case 267: /* vtabargtoken ::= ANY */
138201	case 268: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==268);
138202	case 269: /* lp ::= LP */ yytestcase(yyruleno==269);
138203	{sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
138204	break;
138205	case 270: /* with ::= */
138206	{yymsp[1].minor.yy285 = 0;}
138207	break;
138208	case 271: /* with ::= WITH wqlist */
138209	{ yymsp[-1].minor.yy285 = yymsp[0].minor.yy285; }
138210	break;
138211	case 272: /* with ::= WITH RECURSIVE wqlist */
138212	{ yymsp[-2].minor.yy285 = yymsp[0].minor.yy285; }
138213	break;
138214	case 273: /* wqlist ::= nm eidlist_opt AS LP select RP */
138215	{
138216	yymsp[-5].minor.yy285 = sqlite3WithAdd(pParse, 0, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy148, yymsp[-1].minor.yy243); /A-overwrites-X/
138217	}
138218	break;
138219	case 274: /* wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */
138220	{
138221	yymsp[-7].minor.yy285 = sqlite3WithAdd(pParse, yymsp[-7].minor.yy285, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy148, yymsp[-1].minor.yy243);
138222	}
138223	break;
138224	default:
138225	/* (275) input ::= cmdlist */ yytestcase(yyruleno==275);
138226	/* (276) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==276);
138227	/* (277) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=277);
138228	/* (278) ecmd ::= SEMI */ yytestcase(yyruleno==278);
138229	/* (279) ecmd ::= explain cmdx SEMI */ yytestcase(yyruleno==279);
138230	/* (280) explain ::= */ yytestcase(yyruleno==280);
138231	/* (281) trans_opt ::= */ yytestcase(yyruleno==281);
138232	/* (282) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==282);
138233	/* (283) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==283);
138234	/* (284) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==284);
138235	/* (285) savepoint_opt ::= */ yytestcase(yyruleno==285);
138236	/* (286) cmd ::= create_table create_table_args */ yytestcase(yyruleno==286);
138237	/* (287) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==287);
138238	/* (288) columnlist ::= columnname carglist */ yytestcase(yyruleno==288);
138239	/* (289) nm ::= ID\|INDEXED */ yytestcase(yyruleno==289);
138240	/* (290) nm ::= STRING */ yytestcase(yyruleno==290);
138241	/* (291) nm ::= JOIN_KW */ yytestcase(yyruleno==291);
138242	/* (292) typetoken ::= typename */ yytestcase(yyruleno==292);
138243	/* (293) typename ::= ID\|STRING */ yytestcase(yyruleno==293);
138244	/* (294) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=294);
138245	/* (295) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=295);
138246	/* (296) carglist ::= carglist ccons */ yytestcase(yyruleno==296);
138247	/* (297) carglist ::= */ yytestcase(yyruleno==297);
138248	/* (298) ccons ::= NULL onconf */ yytestcase(yyruleno==298);
138249	/* (299) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==299);
138250	/* (300) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==300);
138251	/* (301) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=301);
138252	/* (302) tconscomma ::= */ yytestcase(yyruleno==302);
138253	/* (303) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=303);
138254	/* (304) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=304);
138255	/* (305) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=305);
138256	/* (306) oneselect ::= values */ yytestcase(yyruleno==306);
138257	/* (307) sclp ::= selcollist COMMA */ yytestcase(yyruleno==307);
138258	/* (308) as ::= ID\|STRING */ yytestcase(yyruleno==308);
138259	/* (309) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=309);
138260	/* (310) likeop ::= LIKE_KW\|MATCH */ yytestcase(yyruleno==310);
138261	/* (311) exprlist ::= nexprlist */ yytestcase(yyruleno==311);
138262	/* (312) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=312);
138263	/* (313) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=313);
138264	/* (314) nmnum ::= ON */ yytestcase(yyruleno==314);
138265	/* (315) nmnum ::= DELETE */ yytestcase(yyruleno==315);
	@@ -138854,12 +139308,12 @@
139308	** memory obtained from sqlite3_malloc() and to make *pzErrMsg point to that
139309	** error message.
139310	*/
139311	SQLITE_PRIVATE int sqlite3RunParser(Parse pParse, const char zSql, char **pzErrMsg){
139312	int nErr = 0; /* Number of errors encountered */

139313	void pEngine; / The LEMON-generated LALR(1) parser */
139314	int n = 0; /* Length of the next token token */
139315	int tokenType; /* type of the next token */
139316	int lastTokenParsed = -1; /* type of the previous token */
139317	sqlite3 db = pParse->db; / The database connection */
139318	int mxSqlLen; /* Max length of an SQL string */
139319	#ifdef sqlite3Parser_ENGINEALWAYSONSTACK
	@@ -138871,11 +139325,10 @@
139325	if( db->nVdbeActive==0 ){
139326	db->u1.isInterrupted = 0;
139327	}
139328	pParse->rc = SQLITE_OK;
139329	pParse->zTail = zSql;

139330	assert( pzErrMsg!=0 );
139331	/* sqlite3ParserTrace(stdout, "parser: "); */
139332	#ifdef sqlite3Parser_ENGINEALWAYSONSTACK
139333	pEngine = zSpace;
139334	sqlite3ParserInit(pEngine);
	@@ -138889,16 +139342,14 @@
139342	assert( pParse->pNewTable==0 );
139343	assert( pParse->pNewTrigger==0 );
139344	assert( pParse->nVar==0 );
139345	assert( pParse->pVList==0 );
139346	while( 1 ){
139347	if( zSql[0]!=0 ){
139348	n = sqlite3GetToken((u8*)zSql, &tokenType);
139349	mxSqlLen -= n;
139350	if( mxSqlLen<0 ){


139351	pParse->rc = SQLITE_TOOBIG;
139352	break;
139353	}
139354	}else{
139355	/* Upon reaching the end of input, call the parser two more times
	@@ -138908,30 +139359,34 @@
139359	}else if( lastTokenParsed==0 ){
139360	break;
139361	}else{
139362	tokenType = TK_SEMI;
139363	}
139364	zSql -= n;
139365	}
139366	if( tokenType>=TK_SPACE ){
139367	assert( tokenType==TK_SPACE \|\| tokenType==TK_ILLEGAL );
139368	if( db->u1.isInterrupted ){
139369	pParse->rc = SQLITE_INTERRUPT;
139370	break;
139371	}
139372	if( tokenType==TK_ILLEGAL ){
139373	sqlite3ErrorMsg(pParse, "unrecognized token: \"%.*s\"", n, zSql);

139374	break;
139375	}
139376	zSql += n;
139377	}else{
139378	pParse->sLastToken.z = zSql;
139379	pParse->sLastToken.n = n;
139380	sqlite3Parser(pEngine, tokenType, pParse->sLastToken, pParse);
139381	lastTokenParsed = tokenType;
139382	zSql += n;
139383	if( pParse->rc!=SQLITE_OK \|\| db->mallocFailed ) break;
139384	}
139385	}
139386	assert( nErr==0 );
139387	pParse->zTail = zSql;
139388	#ifdef YYTRACKMAXSTACKDEPTH
139389	sqlite3_mutex_enter(sqlite3MallocMutex());
139390	sqlite3StatusHighwater(SQLITE_STATUS_PARSER_STACK,
139391	sqlite3ParserStackPeak(pEngine)
139392	);
	@@ -140301,10 +140756,25 @@
140756	return 0;
140757	}
140758	#endif
140759	return db->lastRowid;
140760	}
140761
140762	/*
140763	** Set the value returned by the sqlite3_last_insert_rowid() API function.
140764	*/
140765	SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3 *db, sqlite3_int64 iRowid){
140766	#ifdef SQLITE_ENABLE_API_ARMOR
140767	if( !sqlite3SafetyCheckOk(db) ){
140768	(void)SQLITE_MISUSE_BKPT;
140769	return;
140770	}
140771	#endif
140772	sqlite3_mutex_enter(db->mutex);
140773	db->lastRowid = iRowid;
140774	sqlite3_mutex_leave(db->mutex);
140775	}
140776
140777	/*
140778	** Return the number of changes in the most recent call to sqlite3_exec().
140779	*/
140780	SQLITE_API int sqlite3_changes(sqlite3 *db){
	@@ -148111,12 +148581,14 @@
148581	** segments.
148582	*/
148583	const u32 nMinMerge = 64; /* Minimum amount of incr-merge work to do */
148584
148585	Fts3Table p = (Fts3Table)pVtab;
148586	int rc;
148587	i64 iLastRowid = sqlite3_last_insert_rowid(p->db);
148588
148589	rc = sqlite3Fts3PendingTermsFlush(p);
148590	if( rc==SQLITE_OK
148591	&& p->nLeafAdd>(nMinMerge/16)
148592	&& p->nAutoincrmerge && p->nAutoincrmerge!=0xff
148593	){
148594	int mxLevel = 0; /* Maximum relative level value in db */
	@@ -148127,10 +148599,11 @@
148599	A = p->nLeafAdd * mxLevel;
148600	A += (A/2);
148601	if( A>(int)nMinMerge ) rc = sqlite3Fts3Incrmerge(p, A, p->nAutoincrmerge);
148602	}
148603	sqlite3Fts3SegmentsClose(p);
148604	sqlite3_set_last_insert_rowid(p->db, iLastRowid);
148605	return rc;
148606	}
148607
148608	/*
148609	** If it is currently unknown whether or not the FTS table has an %_stat
	@@ -168462,10 +168935,11 @@
168935	int nStep; /* Rows processed for current object */
168936	int nProgress; /* Rows processed for all objects */
168937	RbuObjIter objiter; /* Iterator for skipping through tbl/idx */
168938	const char zVfsName; / Name of automatically created rbu vfs */
168939	rbu_file pTargetFd; / File handle open on target db */
168940	int nPagePerSector; /* Pages per sector for pTargetFd */
168941	i64 iOalSz;
168942	i64 nPhaseOneStep;
168943
168944	/* The following state variables are used as part of the incremental
168945	** checkpoint stage (eStage==RBU_STAGE_CKPT). See comments surrounding
	@@ -170726,10 +171200,27 @@
171200
171201	if( p->rc==SQLITE_OK ){
171202	if( p->nFrame==0 \|\| (pState && pState->iWalCksum!=p->iWalCksum) ){
171203	p->rc = SQLITE_DONE;
171204	p->eStage = RBU_STAGE_DONE;
171205	}else{
171206	int nSectorSize;
171207	sqlite3_file *pDb = p->pTargetFd->pReal;
171208	sqlite3_file *pWal = p->pTargetFd->pWalFd->pReal;
171209	assert( p->nPagePerSector==0 );
171210	nSectorSize = pDb->pMethods->xSectorSize(pDb);
171211	if( nSectorSize>p->pgsz ){
171212	p->nPagePerSector = nSectorSize / p->pgsz;
171213	}else{
171214	p->nPagePerSector = 1;
171215	}
171216
171217	/* Call xSync() on the wal file. This causes SQLite to sync the
171218	** directory in which the target database and the wal file reside, in
171219	** case it has not been synced since the rename() call in
171220	** rbuMoveOalFile(). */
171221	p->rc = pWal->pMethods->xSync(pWal, SQLITE_SYNC_NORMAL);
171222	}
171223	}
171224	}
171225
171226	/*
	@@ -171381,13 +171872,30 @@
171872	if( p->rc==SQLITE_OK ){
171873	p->eStage = RBU_STAGE_DONE;
171874	p->rc = SQLITE_DONE;
171875	}
171876	}else{
171877	/* At one point the following block copied a single frame from the
171878	** wal file to the database file. So that one call to sqlite3rbu_step()
171879	** checkpointed a single frame.
171880	**
171881	** However, if the sector-size is larger than the page-size, and the
171882	** application calls sqlite3rbu_savestate() or close() immediately
171883	** after this step, then rbu_step() again, then a power failure occurs,
171884	** then the database page written here may be damaged. Work around
171885	** this by checkpointing frames until the next page in the aFrame[]
171886	** lies on a different disk sector to the current one. */
171887	u32 iSector;
171888	do{
171889	RbuFrame *pFrame = &p->aFrame[p->nStep];
171890	iSector = (pFrame->iDbPage-1) / p->nPagePerSector;
171891	rbuCheckpointFrame(p, pFrame);
171892	p->nStep++;
171893	}while( p->nStep<p->nFrame
171894	&& iSector==((p->aFrame[p->nStep].iDbPage-1) / p->nPagePerSector)
171895	&& p->rc==SQLITE_OK
171896	);
171897	}
171898	p->nProgress++;
171899	}
171900	break;
171901	}
	@@ -171823,10 +172331,16 @@
172331
172332	/* Commit the transaction to the -oal file. /
172333	if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_OAL ){
172334	p->rc = sqlite3_exec(p->dbMain, "COMMIT", 0, 0, &p->zErrmsg);
172335	}
172336
172337	/* Sync the db file if currently doing an incremental checkpoint */
172338	if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_CKPT ){
172339	sqlite3_file *pDb = p->pTargetFd->pReal;
172340	p->rc = pDb->pMethods->xSync(pDb, SQLITE_SYNC_NORMAL);
172341	}
172342
172343	rbuSaveState(p, p->eStage);
172344
172345	if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_OAL ){
172346	p->rc = sqlite3_exec(p->dbRbu, "COMMIT", 0, 0, &p->zErrmsg);
	@@ -171947,10 +172461,16 @@
172461	assert( p->eStage>=RBU_STAGE_OAL && p->eStage<=RBU_STAGE_DONE );
172462	if( p->eStage==RBU_STAGE_OAL ){
172463	assert( rc!=SQLITE_DONE );
172464	if( rc==SQLITE_OK ) rc = sqlite3_exec(p->dbMain, "COMMIT", 0, 0, 0);
172465	}
172466
172467	/* Sync the db file */
172468	if( rc==SQLITE_OK && p->eStage==RBU_STAGE_CKPT ){
172469	sqlite3_file *pDb = p->pTargetFd->pReal;
172470	rc = pDb->pMethods->xSync(pDb, SQLITE_SYNC_NORMAL);
172471	}
172472
172473	p->rc = rc;
172474	rbuSaveState(p, p->eStage);
172475	rc = p->rc;
172476
	@@ -181079,11 +181599,13 @@
181599	typedef unsigned short u16;
181600	typedef short i16;
181601	typedef sqlite3_int64 i64;
181602	typedef sqlite3_uint64 u64;
181603
181604	#ifndef ArraySize
181605	# define ArraySize(x) ((int)(sizeof(x) / sizeof(x[0])))
181606	#endif
181607
181608	#define testcase(x)
181609	#define ALWAYS(x) 1
181610	#define NEVER(x) 0
181611
	@@ -186302,11 +186824,14 @@
186824	if( p1->bEof==0 ){
186825	if( (p1->iRowid==iLast)
186826	\|\| (bFromValid && fts5RowidCmp(pExpr, p1->iRowid, iFrom)<0)
186827	){
186828	int rc = fts5ExprNodeNext(pExpr, p1, bFromValid, iFrom);
186829	if( rc!=SQLITE_OK ){
186830	pNode->bNomatch = 0;
186831	return rc;
186832	}
186833	}
186834	}
186835	}
186836
186837	fts5ExprNodeTest_OR(pExpr, pNode);
	@@ -186333,11 +186858,14 @@
186858	Fts5ExprNode *pChild = pAnd->apChild[iChild];
186859	int cmp = fts5RowidCmp(pExpr, iLast, pChild->iRowid);
186860	if( cmp>0 ){
186861	/* Advance pChild until it points to iLast or laster */
186862	rc = fts5ExprNodeNext(pExpr, pChild, 1, iLast);
186863	if( rc!=SQLITE_OK ){
186864	pAnd->bNomatch = 0;
186865	return rc;
186866	}
186867	}
186868
186869	/* If the child node is now at EOF, so is the parent AND node. Otherwise,
186870	** the child node is guaranteed to have advanced at least as far as
186871	** rowid iLast. So if it is not at exactly iLast, pChild->iRowid is the
	@@ -186372,10 +186900,12 @@
186900	i64 iFrom
186901	){
186902	int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
186903	if( rc==SQLITE_OK ){
186904	rc = fts5ExprNodeTest_AND(pExpr, pNode);
186905	}else{
186906	pNode->bNomatch = 0;
186907	}
186908	return rc;
186909	}
186910
186911	static int fts5ExprNodeTest_NOT(
	@@ -186414,10 +186944,13 @@
186944	){
186945	int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
186946	if( rc==SQLITE_OK ){
186947	rc = fts5ExprNodeTest_NOT(pExpr, pNode);
186948	}
186949	if( rc!=SQLITE_OK ){
186950	pNode->bNomatch = 0;
186951	}
186952	return rc;
186953	}
186954
186955	/*
186956	** If pNode currently points to a match, this function returns SQLITE_OK
	@@ -197534,11 +198067,11 @@
198067	int nArg, /* Number of args */
198068	sqlite3_value *apUnused / Function arguments */
198069	){
198070	assert( nArg==0 );
198071	UNUSED_PARAM2(nArg, apUnused);
198072	sqlite3_result_text(pCtx, "fts5: 2017-03-10 17:03:11 f8560c60d10c0365b33342ab05b5a953987b0471", -1, SQLITE_TRANSIENT);
198073	}
198074
198075	static int fts5Init(sqlite3 *db){
198076	static const sqlite3_module fts5Mod = {
198077	/* iVersion */ 2,
	@@ -198197,15 +198730,10 @@
198730	sqlite3_step(pDel);
198731	rc = sqlite3_reset(pDel);
198732	}
198733	}
198734





198735	return rc;
198736	}
198737
198738	/*
198739	** Delete all entries in the FTS5 index.
	@@ -198405,15 +198933,10 @@
198933	if( rc==SQLITE_OK ){
198934	rc = fts5StorageInsertDocsize(p, iRowid, &buf);
198935	}
198936	sqlite3_free(buf.p);
198937





198938	return rc;
198939	}
198940
198941	static int fts5StorageCount(Fts5Storage p, const char zSuffix, i64 *pnRow){
198942	Fts5Config *pConfig = p->pConfig;
	@@ -198744,16 +199267,21 @@
199267
199268	/*
199269	** Flush any data currently held in-memory to disk.
199270	*/
199271	static int sqlite3Fts5StorageSync(Fts5Storage *p, int bCommit){
199272	int rc = SQLITE_OK;
199273	i64 iLastRowid = sqlite3_last_insert_rowid(p->pConfig->db);
199274	if( p->bTotalsValid ){
199275	rc = fts5StorageSaveTotals(p);
199276	if( bCommit ) p->bTotalsValid = 0;
199277	}
199278	if( rc==SQLITE_OK ){
199279	rc = sqlite3Fts5IndexSync(p->pIndex, bCommit);
199280	}
199281	sqlite3_set_last_insert_rowid(p->pConfig->db, iLastRowid);
199282	return rc;
199283	}
199284
199285	static int sqlite3Fts5StorageRollback(Fts5Storage *p){
199286	p->bTotalsValid = 0;
199287	return sqlite3Fts5IndexRollback(p->pIndex);
199288

M src/sqlite3.h

+36 -16

		--- src/sqlite3.h
		+++ src/sqlite3.h
		@@ -119,13 +119,13 @@
119	119	**
120	120	** See also: [sqlite3_libversion()],
121	121	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
122	122	** [sqlite_version()] and [sqlite_source_id()].
123	123	*/
124		-#define SQLITE_VERSION "3.17.0"
125		-#define SQLITE_VERSION_NUMBER 3017000
126		-#define SQLITE_SOURCE_ID "2017-02-13 16:02:40 ada05cfa86ad7f5645450ac7a2a21c9aa6e57d2c"
	124	+#define SQLITE_VERSION "3.18.0"
	125	+#define SQLITE_VERSION_NUMBER 3018000
	126	+#define SQLITE_SOURCE_ID "2017-03-10 17:03:11 f8560c60d10c0365b33342ab05b5a953987b0471"
127	127
128	128	/*
129	129	** CAPI3REF: Run-Time Library Version Numbers
130	130	** KEYWORDS: sqlite3_version sqlite3_sourceid
131	131	**
		@@ -2038,24 +2038,34 @@
2038	2038	** as an undeclared column named ROWID, OID, or _ROWID_ as long as those
2039	2039	** names are not also used by explicitly declared columns. ^If
2040	2040	** the table has a column of type [INTEGER PRIMARY KEY] then that column
2041	2041	** is another alias for the rowid.
2042	2042	**
2043		-** ^The sqlite3_last_insert_rowid(D) interface returns the [rowid] of the
2044		-** most recent successful [INSERT] into a rowid table or [virtual table]
2045		-** on database connection D.
2046		-** ^Inserts into [WITHOUT ROWID] tables are not recorded.
2047		-** ^If no successful [INSERT]s into rowid tables
2048		-** have ever occurred on the database connection D,
2049		-** then sqlite3_last_insert_rowid(D) returns zero.
	2043	+** ^The sqlite3_last_insert_rowid(D) interface usually returns the [rowid] of
	2044	+** the most recent successful [INSERT] into a rowid table or [virtual table]
	2045	+** on database connection D. ^Inserts into [WITHOUT ROWID] tables are not
	2046	+** recorded. ^If no successful [INSERT]s into rowid tables have ever occurred
	2047	+** on the database connection D, then sqlite3_last_insert_rowid(D) returns
	2048	+** zero.
2050	2049	**
2051		-** ^(If an [INSERT] occurs within a trigger or within a [virtual table]
2052		-** method, then this routine will return the [rowid] of the inserted
2053		-** row as long as the trigger or virtual table method is running.
2054		-** But once the trigger or virtual table method ends, the value returned
2055		-** by this routine reverts to what it was before the trigger or virtual
2056		-** table method began.)^
	2050	+** As well as being set automatically as rows are inserted into database
	2051	+** tables, the value returned by this function may be set explicitly by
	2052	+** [sqlite3_set_last_insert_rowid()]
	2053	+**
	2054	+** Some virtual table implementations may INSERT rows into rowid tables as
	2055	+** part of committing a transaction (e.g. to flush data accumulated in memory
	2056	+** to disk). In this case subsequent calls to this function return the rowid
	2057	+** associated with these internal INSERT operations, which leads to
	2058	+** unintuitive results. Virtual table implementations that do write to rowid
	2059	+** tables in this way can avoid this problem by restoring the original
	2060	+** rowid value using [sqlite3_set_last_insert_rowid()] before returning
	2061	+** control to the user.
	2062	+**
	2063	+** ^(If an [INSERT] occurs within a trigger then this routine will
	2064	+** return the [rowid] of the inserted row as long as the trigger is
	2065	+** running. Once the trigger program ends, the value returned
	2066	+** by this routine reverts to what it was before the trigger was fired.)^
2057	2067	**
2058	2068	** ^An [INSERT] that fails due to a constraint violation is not a
2059	2069	** successful [INSERT] and does not change the value returned by this
2060	2070	** routine. ^Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK,
2061	2071	** and INSERT OR ABORT make no changes to the return value of this
		@@ -2078,10 +2088,20 @@
2078	2088	** unpredictable and might not equal either the old or the new
2079	2089	** last insert [rowid].
2080	2090	*/
2081	2091	SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);
2082	2092
	2093	+/*
	2094	+** CAPI3REF: Set the Last Insert Rowid value.
	2095	+** METHOD: sqlite3
	2096	+**
	2097	+** The sqlite3_set_last_insert_rowid(D, R) method allows the application to
	2098	+** set the value returned by calling sqlite3_last_insert_rowid(D) to R
	2099	+** without inserting a row into the database.
	2100	+*/
	2101	+SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3*,sqlite3_int64);
	2102	+
2083	2103	/*
2084	2104	** CAPI3REF: Count The Number Of Rows Modified
2085	2105	** METHOD: sqlite3
2086	2106	**
2087	2107	** ^This function returns the number of rows modified, inserted or
2088	2108

	--- src/sqlite3.h
	+++ src/sqlite3.h
	@@ -119,13 +119,13 @@
119	**
120	** See also: [sqlite3_libversion()],
121	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
122	** [sqlite_version()] and [sqlite_source_id()].
123	*/
124	#define SQLITE_VERSION "3.17.0"
125	#define SQLITE_VERSION_NUMBER 3017000
126	#define SQLITE_SOURCE_ID "2017-02-13 16:02:40 ada05cfa86ad7f5645450ac7a2a21c9aa6e57d2c"
127
128	/*
129	** CAPI3REF: Run-Time Library Version Numbers
130	** KEYWORDS: sqlite3_version sqlite3_sourceid
131	**
	@@ -2038,24 +2038,34 @@
2038	** as an undeclared column named ROWID, OID, or _ROWID_ as long as those
2039	** names are not also used by explicitly declared columns. ^If
2040	** the table has a column of type [INTEGER PRIMARY KEY] then that column
2041	** is another alias for the rowid.
2042	**
2043	** ^The sqlite3_last_insert_rowid(D) interface returns the [rowid] of the
2044	** most recent successful [INSERT] into a rowid table or [virtual table]
2045	** on database connection D.
2046	** ^Inserts into [WITHOUT ROWID] tables are not recorded.
2047	** ^If no successful [INSERT]s into rowid tables
2048	** have ever occurred on the database connection D,
2049	** then sqlite3_last_insert_rowid(D) returns zero.
2050	**
2051	** ^(If an [INSERT] occurs within a trigger or within a [virtual table]
2052	** method, then this routine will return the [rowid] of the inserted
2053	** row as long as the trigger or virtual table method is running.
2054	** But once the trigger or virtual table method ends, the value returned
2055	** by this routine reverts to what it was before the trigger or virtual
2056	** table method began.)^











2057	**
2058	** ^An [INSERT] that fails due to a constraint violation is not a
2059	** successful [INSERT] and does not change the value returned by this
2060	** routine. ^Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK,
2061	** and INSERT OR ABORT make no changes to the return value of this
	@@ -2078,10 +2088,20 @@
2078	** unpredictable and might not equal either the old or the new
2079	** last insert [rowid].
2080	*/
2081	SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);
2082










2083	/*
2084	** CAPI3REF: Count The Number Of Rows Modified
2085	** METHOD: sqlite3
2086	**
2087	** ^This function returns the number of rows modified, inserted or
2088

	--- src/sqlite3.h
	+++ src/sqlite3.h
	@@ -119,13 +119,13 @@
119	**
120	** See also: [sqlite3_libversion()],
121	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
122	** [sqlite_version()] and [sqlite_source_id()].
123	*/
124	#define SQLITE_VERSION "3.18.0"
125	#define SQLITE_VERSION_NUMBER 3018000
126	#define SQLITE_SOURCE_ID "2017-03-10 17:03:11 f8560c60d10c0365b33342ab05b5a953987b0471"
127
128	/*
129	** CAPI3REF: Run-Time Library Version Numbers
130	** KEYWORDS: sqlite3_version sqlite3_sourceid
131	**
	@@ -2038,24 +2038,34 @@
2038	** as an undeclared column named ROWID, OID, or _ROWID_ as long as those
2039	** names are not also used by explicitly declared columns. ^If
2040	** the table has a column of type [INTEGER PRIMARY KEY] then that column
2041	** is another alias for the rowid.
2042	**
2043	** ^The sqlite3_last_insert_rowid(D) interface usually returns the [rowid] of
2044	** the most recent successful [INSERT] into a rowid table or [virtual table]
2045	** on database connection D. ^Inserts into [WITHOUT ROWID] tables are not
2046	** recorded. ^If no successful [INSERT]s into rowid tables have ever occurred
2047	** on the database connection D, then sqlite3_last_insert_rowid(D) returns
2048	** zero.

2049	**
2050	** As well as being set automatically as rows are inserted into database
2051	** tables, the value returned by this function may be set explicitly by
2052	** [sqlite3_set_last_insert_rowid()]
2053	**
2054	** Some virtual table implementations may INSERT rows into rowid tables as
2055	** part of committing a transaction (e.g. to flush data accumulated in memory
2056	** to disk). In this case subsequent calls to this function return the rowid
2057	** associated with these internal INSERT operations, which leads to
2058	** unintuitive results. Virtual table implementations that do write to rowid
2059	** tables in this way can avoid this problem by restoring the original
2060	** rowid value using [sqlite3_set_last_insert_rowid()] before returning
2061	** control to the user.
2062	**
2063	** ^(If an [INSERT] occurs within a trigger then this routine will
2064	** return the [rowid] of the inserted row as long as the trigger is
2065	** running. Once the trigger program ends, the value returned
2066	** by this routine reverts to what it was before the trigger was fired.)^
2067	**
2068	** ^An [INSERT] that fails due to a constraint violation is not a
2069	** successful [INSERT] and does not change the value returned by this
2070	** routine. ^Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK,
2071	** and INSERT OR ABORT make no changes to the return value of this
	@@ -2078,10 +2088,20 @@
2088	** unpredictable and might not equal either the old or the new
2089	** last insert [rowid].
2090	*/
2091	SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);
2092
2093	/*
2094	** CAPI3REF: Set the Last Insert Rowid value.
2095	** METHOD: sqlite3
2096	**
2097	** The sqlite3_set_last_insert_rowid(D, R) method allows the application to
2098	** set the value returned by calling sqlite3_last_insert_rowid(D) to R
2099	** without inserting a row into the database.
2100	*/
2101	SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3*,sqlite3_int64);
2102
2103	/*
2104	** CAPI3REF: Count The Number Of Rows Modified
2105	** METHOD: sqlite3
2106	**
2107	** ^This function returns the number of rows modified, inserted or
2108

M src/stat.c

+64 -2

		--- src/stat.c
		+++ src/stat.c
		@@ -388,10 +388,12 @@
388	388	**
389	389	** Show the repository schema
390	390	*/
391	391	void repo_schema_page(void){
392	392	Stmt q;
	393	+ Blob sql;
	394	+ const char *zArg = P("n");
393	395	login_check_credentials();
394	396	if( !g.perm.Admin ){ login_needed(0); return; }
395	397
396	398	style_header("Repository Schema");
397	399	style_adunit_config(ADUNIT_RIGHT_OK);
		@@ -398,18 +400,78 @@
398	400	style_submenu_element("Stat", "stat");
399	401	style_submenu_element("URLs", "urllist");
400	402	if( sqlite3_compileoption_used("ENABLE_DBSTAT_VTAB") ){
401	403	style_submenu_element("Table Sizes", "repo-tabsize");
402	404	}
403		- db_prepare(&q,
404		- "SELECT sql FROM repository.sqlite_master WHERE sql IS NOT NULL");
	405	+ blob_init(&sql,
	406	+ "SELECT sql FROM repository.sqlite_master WHERE sql IS NOT NULL", -1);
	407	+ if( zArg ){
	408	+ style_submenu_element("All", "repo_schema");
	409	+ blob_appendf(&sql, " AND (tbl_name=%Q OR name=%Q)", zArg, zArg);
	410	+ }
	411	+ blob_appendf(&sql, " ORDER BY tbl_name, type<>'table', name");
	412	+ db_prepare(&q, "%s", blob_str(&sql)/safe-for-%s/);
	413	+ blob_reset(&sql);
405	414	@ <pre>
406	415	while( db_step(&q)==SQLITE_ROW ){
407	416	@ %h(db_column_text(&q, 0));
408	417	}
409	418	@ </pre>
410	419	db_finalize(&q);
	420	+ if( db_table_exists("repository","sqlite_stat1") ){
	421	+ if( zArg ){
	422	+ db_prepare(&q,
	423	+ "SELECT tbl, idx, stat FROM repository.sqlite_stat1"
	424	+ " WHERE tbl LIKE %Q OR idx LIKE %Q"
	425	+ " ORDER BY tbl, idx", zArg, zArg);
	426	+
	427	+ @ <hr>
	428	+ @ <pre>
	429	+ while( db_step(&q)==SQLITE_ROW ){
	430	+ const char *zTab = db_column_text(&q,0);
	431	+ const char *zIdx = db_column_text(&q,1);
	432	+ const char *zStat = db_column_text(&q,2);
	433	+ @ INSERT INTO sqlite_stat1 VALUES('%h(zTab)','%h(zIdx)','%h(zStat)');
	434	+ }
	435	+ @ </pre>
	436	+ db_finalize(&q);
	437	+ }else{
	438	+ style_submenu_element("Stat1","repo_stat1");
	439	+ }
	440	+ }
	441	+ style_footer();
	442	+}
	443	+
	444	+/*
	445	+** WEBPAGE: repo_stat1
	446	+**
	447	+** Show the sqlite_stat1 table for the repository schema
	448	+*/
	449	+void repo_stat1_page(void){
	450	+ login_check_credentials();
	451	+ if( !g.perm.Admin ){ login_needed(0); return; }
	452	+
	453	+ style_header("Repository STAT1 Table");
	454	+ style_adunit_config(ADUNIT_RIGHT_OK);
	455	+ style_submenu_element("Stat", "stat");
	456	+ style_submenu_element("Schema", "repo_schema");
	457	+ if( db_table_exists("repository","sqlite_stat1") ){
	458	+ Stmt q;
	459	+ db_prepare(&q,
	460	+ "SELECT tbl, idx, stat FROM repository.sqlite_stat1"
	461	+ " ORDER BY tbl, idx");
	462	+ @ <pre>
	463	+ while( db_step(&q)==SQLITE_ROW ){
	464	+ const char *zTab = db_column_text(&q,0);
	465	+ const char *zIdx = db_column_text(&q,1);
	466	+ const char *zStat = db_column_text(&q,2);
	467	+ char *zUrl = href("%R/repo_schema?n=%t",zTab);
	468	+ @ INSERT INTO sqlite_stat1 VALUES('%z(zUrl)%h(zTab)</a>','%h(zIdx)','%h(zStat)');
	469	+ }
	470	+ @ </pre>
	471	+ db_finalize(&q);
	472	+ }
411	473	style_footer();
412	474	}
413	475
414	476	/*
415	477	** WEBPAGE: repo-tabsize
416	478

	--- src/stat.c
	+++ src/stat.c
	@@ -388,10 +388,12 @@
388	**
389	** Show the repository schema
390	*/
391	void repo_schema_page(void){
392	Stmt q;


393	login_check_credentials();
394	if( !g.perm.Admin ){ login_needed(0); return; }
395
396	style_header("Repository Schema");
397	style_adunit_config(ADUNIT_RIGHT_OK);
	@@ -398,18 +400,78 @@
398	style_submenu_element("Stat", "stat");
399	style_submenu_element("URLs", "urllist");
400	if( sqlite3_compileoption_used("ENABLE_DBSTAT_VTAB") ){
401	style_submenu_element("Table Sizes", "repo-tabsize");
402	}
403	db_prepare(&q,
404	"SELECT sql FROM repository.sqlite_master WHERE sql IS NOT NULL");







405	@ <pre>
406	while( db_step(&q)==SQLITE_ROW ){
407	@ %h(db_column_text(&q, 0));
408	}
409	@ </pre>
410	db_finalize(&q);





















































411	style_footer();
412	}
413
414	/*
415	** WEBPAGE: repo-tabsize
416

	--- src/stat.c
	+++ src/stat.c
	@@ -388,10 +388,12 @@
388	**
389	** Show the repository schema
390	*/
391	void repo_schema_page(void){
392	Stmt q;
393	Blob sql;
394	const char *zArg = P("n");
395	login_check_credentials();
396	if( !g.perm.Admin ){ login_needed(0); return; }
397
398	style_header("Repository Schema");
399	style_adunit_config(ADUNIT_RIGHT_OK);
	@@ -398,18 +400,78 @@
400	style_submenu_element("Stat", "stat");
401	style_submenu_element("URLs", "urllist");
402	if( sqlite3_compileoption_used("ENABLE_DBSTAT_VTAB") ){
403	style_submenu_element("Table Sizes", "repo-tabsize");
404	}
405	blob_init(&sql,
406	"SELECT sql FROM repository.sqlite_master WHERE sql IS NOT NULL", -1);
407	if( zArg ){
408	style_submenu_element("All", "repo_schema");
409	blob_appendf(&sql, " AND (tbl_name=%Q OR name=%Q)", zArg, zArg);
410	}
411	blob_appendf(&sql, " ORDER BY tbl_name, type<>'table', name");
412	db_prepare(&q, "%s", blob_str(&sql)/safe-for-%s/);
413	blob_reset(&sql);
414	@ <pre>
415	while( db_step(&q)==SQLITE_ROW ){
416	@ %h(db_column_text(&q, 0));
417	}
418	@ </pre>
419	db_finalize(&q);
420	if( db_table_exists("repository","sqlite_stat1") ){
421	if( zArg ){
422	db_prepare(&q,
423	"SELECT tbl, idx, stat FROM repository.sqlite_stat1"
424	" WHERE tbl LIKE %Q OR idx LIKE %Q"
425	" ORDER BY tbl, idx", zArg, zArg);
426
427	@ <hr>
428	@ <pre>
429	while( db_step(&q)==SQLITE_ROW ){
430	const char *zTab = db_column_text(&q,0);
431	const char *zIdx = db_column_text(&q,1);
432	const char *zStat = db_column_text(&q,2);
433	@ INSERT INTO sqlite_stat1 VALUES('%h(zTab)','%h(zIdx)','%h(zStat)');
434	}
435	@ </pre>
436	db_finalize(&q);
437	}else{
438	style_submenu_element("Stat1","repo_stat1");
439	}
440	}
441	style_footer();
442	}
443
444	/*
445	** WEBPAGE: repo_stat1
446	**
447	** Show the sqlite_stat1 table for the repository schema
448	*/
449	void repo_stat1_page(void){
450	login_check_credentials();
451	if( !g.perm.Admin ){ login_needed(0); return; }
452
453	style_header("Repository STAT1 Table");
454	style_adunit_config(ADUNIT_RIGHT_OK);
455	style_submenu_element("Stat", "stat");
456	style_submenu_element("Schema", "repo_schema");
457	if( db_table_exists("repository","sqlite_stat1") ){
458	Stmt q;
459	db_prepare(&q,
460	"SELECT tbl, idx, stat FROM repository.sqlite_stat1"
461	" ORDER BY tbl, idx");
462	@ <pre>
463	while( db_step(&q)==SQLITE_ROW ){
464	const char *zTab = db_column_text(&q,0);
465	const char *zIdx = db_column_text(&q,1);
466	const char *zStat = db_column_text(&q,2);
467	char *zUrl = href("%R/repo_schema?n=%t",zTab);
468	@ INSERT INTO sqlite_stat1 VALUES('%z(zUrl)%h(zTab)</a>','%h(zIdx)','%h(zStat)');
469	}
470	@ </pre>
471	db_finalize(&q);
472	}
473	style_footer();
474	}
475
476	/*
477	** WEBPAGE: repo-tabsize
478

M www/build.wiki

+7 -12

		--- www/build.wiki
		+++ www/build.wiki
		@@ -1,16 +1,14 @@
1	1	<title>Compiling and Installing Fossil</title>
2	2
3	3	<h2>0.0 Using A Pre-compiled Binary</h2>
4	4
5		-<p>Released versions of fossil come with
6		-<a href="/uv/download.html">pre-compiled binaries and
7		-a source archive</a> for that release. You can thus skip the following if you
8		-want to run or build a release version of fossil. Just download
9		-the appropriate package from the <a href="/uv/download.html">downloads page</a>
	5	+<p>[/uv/download.html\|Pre-compiled binaries] are available for recent
	6	+releases. Just download
	7	+the appropriate executable for your platform
10	8	and put it on your $PATH.
11		-To uninstall, simply delete the binary.
	9	+To uninstall, simply delete the executable.
12	10	To upgrade from an older release, just overwrite the older binary with
13	11	the newer one.</p>
14	12
15	13	<h2>0.1 Executive Summary</h2>
16	14
		@@ -29,20 +27,17 @@
29	27
30	28	<p>Fossil is self-hosting, so you can obtain a ZIP archive or tarball
31	29	containing a snapshot of the <em>latest</em> version directly from
32	30	Fossil's own fossil repository. Additionally, source archives of
33	31	<em>released</em> versions of
34		-fossil are available from the <a href="/uv/download.html">downloads page</a>.
	32	+fossil are available from the [/uv/download.html\|downloads page].
35	33	To obtain a development version of fossil, follow these steps:</p>
36	34
37	35	<ol>
38		-<li><p>Point your web browser to
39		-<a href="http://www.fossil-scm.org/">
40		-http://www.fossil-scm.org/</a>.</p></li>
	36	+<li><p>Point your web browser to [https://www.fossil-scm.org/]</li>
41	37
42		-<li><p>Click on the
43		-<a href="http://www.fossil-scm.org/fossil/timeline">Timeline</a>
	38	+<li><p>Click on the [/timeline\|Timeline]
44	39	link at the top of the page.</p></li>
45	40
46	41	<li><p>Select a version of of Fossil you want to download. The latest
47	42	version on the trunk branch is usually a good choice. Click on its
48	43	link.</p></li>
49	44

	--- www/build.wiki
	+++ www/build.wiki
	@@ -1,16 +1,14 @@
1	<title>Compiling and Installing Fossil</title>
2
3	<h2>0.0 Using A Pre-compiled Binary</h2>
4
5	<p>Released versions of fossil come with
6	<a href="/uv/download.html">pre-compiled binaries and
7	a source archive</a> for that release. You can thus skip the following if you
8	want to run or build a release version of fossil. Just download
9	the appropriate package from the <a href="/uv/download.html">downloads page</a>
10	and put it on your $PATH.
11	To uninstall, simply delete the binary.
12	To upgrade from an older release, just overwrite the older binary with
13	the newer one.</p>
14
15	<h2>0.1 Executive Summary</h2>
16
	@@ -29,20 +27,17 @@
29
30	<p>Fossil is self-hosting, so you can obtain a ZIP archive or tarball
31	containing a snapshot of the <em>latest</em> version directly from
32	Fossil's own fossil repository. Additionally, source archives of
33	<em>released</em> versions of
34	fossil are available from the <a href="/uv/download.html">downloads page</a>.
35	To obtain a development version of fossil, follow these steps:</p>
36
37	<ol>
38	<li><p>Point your web browser to
39	<a href="http://www.fossil-scm.org/">
40	http://www.fossil-scm.org/</a>.</p></li>
41
42	<li><p>Click on the
43	<a href="http://www.fossil-scm.org/fossil/timeline">Timeline</a>
44	link at the top of the page.</p></li>
45
46	<li><p>Select a version of of Fossil you want to download. The latest
47	version on the trunk branch is usually a good choice. Click on its
48	link.</p></li>
49

	--- www/build.wiki
	+++ www/build.wiki
	@@ -1,16 +1,14 @@
1	<title>Compiling and Installing Fossil</title>
2
3	<h2>0.0 Using A Pre-compiled Binary</h2>
4
5	<p>[/uv/download.html\|Pre-compiled binaries] are available for recent
6	releases. Just download
7	the appropriate executable for your platform


8	and put it on your $PATH.
9	To uninstall, simply delete the executable.
10	To upgrade from an older release, just overwrite the older binary with
11	the newer one.</p>
12
13	<h2>0.1 Executive Summary</h2>
14
	@@ -29,20 +27,17 @@
27
28	<p>Fossil is self-hosting, so you can obtain a ZIP archive or tarball
29	containing a snapshot of the <em>latest</em> version directly from
30	Fossil's own fossil repository. Additionally, source archives of
31	<em>released</em> versions of
32	fossil are available from the [/uv/download.html\|downloads page].
33	To obtain a development version of fossil, follow these steps:</p>
34
35	<ol>
36	<li><p>Point your web browser to [https://www.fossil-scm.org/]</li>


37
38	<li><p>Click on the [/timeline\|Timeline]

39	link at the top of the page.</p></li>
40
41	<li><p>Select a version of of Fossil you want to download. The latest
42	version on the trunk branch is usually a good choice. Click on its
43	link.</p></li>
44

M www/changes.wiki

+1 -1

		--- www/changes.wiki
		+++ www/changes.wiki
		@@ -1,9 +1,9 @@
1	1	<title>Change Log</title>
2	2
3	3	<a name='v2_1'></a>
4		-<h2>Changes for Version 2.1 (2017-03-??)</h2>
	4	+<h2>Changes for Version 2.1 (2017-03-10)</h2>
5	5
6	6	* Add support for [./hashpolicy.wiki\|hash policies] that control which
7	7	of the Hardened-SHA1 or SHA3-256 algorithms is used to name new
8	8	artifacts.
9	9	* Add the "gshow" and "gcat" subcommands to [/help?cmd=stash\|fossil stash].
10	10

	--- www/changes.wiki
	+++ www/changes.wiki
	@@ -1,9 +1,9 @@
1	<title>Change Log</title>
2
3	<a name='v2_1'></a>
4	<h2>Changes for Version 2.1 (2017-03-??)</h2>
5
6	* Add support for [./hashpolicy.wiki\|hash policies] that control which
7	of the Hardened-SHA1 or SHA3-256 algorithms is used to name new
8	artifacts.
9	* Add the "gshow" and "gcat" subcommands to [/help?cmd=stash\|fossil stash].
10

	--- www/changes.wiki
	+++ www/changes.wiki
	@@ -1,9 +1,9 @@
1	<title>Change Log</title>
2
3	<a name='v2_1'></a>
4	<h2>Changes for Version 2.1 (2017-03-10)</h2>
5
6	* Add support for [./hashpolicy.wiki\|hash policies] that control which
7	of the Hardened-SHA1 or SHA3-256 algorithms is used to name new
8	artifacts.
9	* Add the "gshow" and "gcat" subcommands to [/help?cmd=stash\|fossil stash].
10

M www/fossil-v-git.wiki

+2 -2

		--- www/fossil-v-git.wiki
		+++ www/fossil-v-git.wiki
		@@ -118,11 +118,11 @@
118	118	closely supervised by an highly engaged architect and implemented by
119	119	a clique of developers.
120	120
121	121	Nota Bene: This is not to say that Git cannot be used for cathedral-style
122	122	development or that Fossil cannot be used for bazaar-style development.
123		-They can be. But those modes are not their design intent nor the their
	123	+They can be. But those modes are not their design intent nor their
124	124	low-friction path.
125	125
126	126	Git encourages a style in which individual developers work in relative
127	127	isolation, maintaining their
128	128	own branches and occasionally rebasing and pushing selected changes up
		@@ -145,11 +145,11 @@
145	145	Fossil was specifically designed to support the development of SQLite.
146	146
147	147	Both SQLite and Linux are important pieces of software.
148	148	SQLite is found on far more systems than Linux. (Almost every Linux
149	149	system uses SQLite, but there are many non-Linux systems such as
150		-iPhones, PlayStations, and Windows PC that use SQLite.) On the other
	150	+iPhones, PlayStations, and Windows PCs that use SQLite.) On the other
151	151	hand, for those systems that do use Linux, Linux is a far more important
152	152	component.
153	153
154	154	Linux uses a bazaar-style development model. There are thousands and
155	155	thousands of contributors, most of whom do not know each others names.
156	156

	--- www/fossil-v-git.wiki
	+++ www/fossil-v-git.wiki
	@@ -118,11 +118,11 @@
118	closely supervised by an highly engaged architect and implemented by
119	a clique of developers.
120
121	Nota Bene: This is not to say that Git cannot be used for cathedral-style
122	development or that Fossil cannot be used for bazaar-style development.
123	They can be. But those modes are not their design intent nor the their
124	low-friction path.
125
126	Git encourages a style in which individual developers work in relative
127	isolation, maintaining their
128	own branches and occasionally rebasing and pushing selected changes up
	@@ -145,11 +145,11 @@
145	Fossil was specifically designed to support the development of SQLite.
146
147	Both SQLite and Linux are important pieces of software.
148	SQLite is found on far more systems than Linux. (Almost every Linux
149	system uses SQLite, but there are many non-Linux systems such as
150	iPhones, PlayStations, and Windows PC that use SQLite.) On the other
151	hand, for those systems that do use Linux, Linux is a far more important
152	component.
153
154	Linux uses a bazaar-style development model. There are thousands and
155	thousands of contributors, most of whom do not know each others names.
156

	--- www/fossil-v-git.wiki
	+++ www/fossil-v-git.wiki
	@@ -118,11 +118,11 @@
118	closely supervised by an highly engaged architect and implemented by
119	a clique of developers.
120
121	Nota Bene: This is not to say that Git cannot be used for cathedral-style
122	development or that Fossil cannot be used for bazaar-style development.
123	They can be. But those modes are not their design intent nor their
124	low-friction path.
125
126	Git encourages a style in which individual developers work in relative
127	isolation, maintaining their
128	own branches and occasionally rebasing and pushing selected changes up
	@@ -145,11 +145,11 @@
145	Fossil was specifically designed to support the development of SQLite.
146
147	Both SQLite and Linux are important pieces of software.
148	SQLite is found on far more systems than Linux. (Almost every Linux
149	system uses SQLite, but there are many non-Linux systems such as
150	iPhones, PlayStations, and Windows PCs that use SQLite.) On the other
151	hand, for those systems that do use Linux, Linux is a far more important
152	component.
153
154	Linux uses a bazaar-style development model. There are thousands and
155	thousands of contributors, most of whom do not know each others names.
156

M www/selfcheck.wiki

+5 -4

		--- www/selfcheck.wiki
		+++ www/selfcheck.wiki
		@@ -78,15 +78,15 @@
78	78	Note that these added checks use a different hash algorithm (MD5)
79	79	in order to avoid common-mode failures in the hash
80	80	algorithm implementation.
81	81
82	82
83		-<h2>Checksums On Control Artifacts And Deltas</h2>
	83	+<h2>Checksums On Structural Artifacts And Deltas</h2>
84	84
85		-Every [./fileformat.wiki \| control artifact] in a fossil repository
	85	+Every [./fileformat.wiki \| structural artifact] in a fossil repository
86	86	contains a "Z-card" bearing an MD5 checksum over the rest of the
87		-artifact. Any mismatch causes the control artifact to be ignored.
	87	+artifact. Any mismatch causes the structural artifact to be ignored.
88	88
89	89	The [./delta_format.wiki \| file delta format] includes a 32-bit
90	90	checksum of the target file. Whenever a file is reconstructed from
91	91	a delta, that checksum is verified to make sure the reconstruction
92	92	was done correctly.
		@@ -103,6 +103,7 @@
103	103	reliability is more important than raw speed. The developers of
104	104	fossil see no merit in getting the wrong answer quickly.
105	105
106	106	Fossil may not be the fastest versioning system, but it is "fast enough".
107	107	Fossil runs quickly enough to stay out of the developers way.
108		-Most operations complete in under a second.
	108	+Most operations complete in milliseconds, faster that you can press
	109	+the "Enter" key.
109	110

	--- www/selfcheck.wiki
	+++ www/selfcheck.wiki
	@@ -78,15 +78,15 @@
78	Note that these added checks use a different hash algorithm (MD5)
79	in order to avoid common-mode failures in the hash
80	algorithm implementation.
81
82
83	<h2>Checksums On Control Artifacts And Deltas</h2>
84
85	Every [./fileformat.wiki \| control artifact] in a fossil repository
86	contains a "Z-card" bearing an MD5 checksum over the rest of the
87	artifact. Any mismatch causes the control artifact to be ignored.
88
89	The [./delta_format.wiki \| file delta format] includes a 32-bit
90	checksum of the target file. Whenever a file is reconstructed from
91	a delta, that checksum is verified to make sure the reconstruction
92	was done correctly.
	@@ -103,6 +103,7 @@
103	reliability is more important than raw speed. The developers of
104	fossil see no merit in getting the wrong answer quickly.
105
106	Fossil may not be the fastest versioning system, but it is "fast enough".
107	Fossil runs quickly enough to stay out of the developers way.
108	Most operations complete in under a second.

109

	--- www/selfcheck.wiki
	+++ www/selfcheck.wiki
	@@ -78,15 +78,15 @@
78	Note that these added checks use a different hash algorithm (MD5)
79	in order to avoid common-mode failures in the hash
80	algorithm implementation.
81
82
83	<h2>Checksums On Structural Artifacts And Deltas</h2>
84
85	Every [./fileformat.wiki \| structural artifact] in a fossil repository
86	contains a "Z-card" bearing an MD5 checksum over the rest of the
87	artifact. Any mismatch causes the structural artifact to be ignored.
88
89	The [./delta_format.wiki \| file delta format] includes a 32-bit
90	checksum of the target file. Whenever a file is reconstructed from
91	a delta, that checksum is verified to make sure the reconstruction
92	was done correctly.
	@@ -103,6 +103,7 @@
103	reliability is more important than raw speed. The developers of
104	fossil see no merit in getting the wrong answer quickly.
105
106	Fossil may not be the fastest versioning system, but it is "fast enough".
107	Fossil runs quickly enough to stay out of the developers way.
108	Most operations complete in milliseconds, faster that you can press
109	the "Enter" key.
110

M www/tech_overview.wiki

+2 -2

		--- www/tech_overview.wiki
		+++ www/tech_overview.wiki
		@@ -6,12 +6,12 @@
6	6	<h2>1.0 Introduction</h2>
7	7
8	8	At its lowest level, a Fossil repository consists of an unordered set
9	9	of immutable "artifacts". You might think of these artifacts as "files",
10	10	since in many cases the artifacts are exactly that.
11		-But other "control artifacts"
12		-are also included in the mix. These control artifacts define the relationships
	11	+But other "structural artifacts" are also included in the mix.
	12	+These structural artifacts define the relationships
13	13	between artifacts - which files go together to form a particular
14	14	version of the project, who checked in that version and when, what was
15	15	the check-in comment, what wiki pages are included with the project, what
16	16	are the edit histories of each wiki page, what bug reports or tickets are
17	17	included, who contributed to the evolution of each ticket, and so forth.
18	18

	--- www/tech_overview.wiki
	+++ www/tech_overview.wiki
	@@ -6,12 +6,12 @@
6	<h2>1.0 Introduction</h2>
7
8	At its lowest level, a Fossil repository consists of an unordered set
9	of immutable "artifacts". You might think of these artifacts as "files",
10	since in many cases the artifacts are exactly that.
11	But other "control artifacts"
12	are also included in the mix. These control artifacts define the relationships
13	between artifacts - which files go together to form a particular
14	version of the project, who checked in that version and when, what was
15	the check-in comment, what wiki pages are included with the project, what
16	are the edit histories of each wiki page, what bug reports or tickets are
17	included, who contributed to the evolution of each ticket, and so forth.
18

	--- www/tech_overview.wiki
	+++ www/tech_overview.wiki
	@@ -6,12 +6,12 @@
6	<h2>1.0 Introduction</h2>
7
8	At its lowest level, a Fossil repository consists of an unordered set
9	of immutable "artifacts". You might think of these artifacts as "files",
10	since in many cases the artifacts are exactly that.
11	But other "structural artifacts" are also included in the mix.
12	These structural artifacts define the relationships
13	between artifacts - which files go together to form a particular
14	version of the project, who checked in that version and when, what was
15	the check-in comment, what wiki pages are included with the project, what
16	are the edit histories of each wiki page, what bug reports or tickets are
17	included, who contributed to the evolution of each ticket, and so forth.
18

Fossil SCM

Keyboard Shortcuts