Fossil SCM

Update the built-in SQLite to the first check-in that supports the octet_length() SQL function so that we can use that function in the Fossil implementation.

drh 2023-06-23 11:43 trunk

Commit 9f8e9cbd174884ec9f40cd58e53389e6fe4d00769b4975b349a8b7051a9456ec

Parent bdde964e06128a0…

3 files changed +187 +408 -286 +1 -1

~ extsrc/shell.c ~ extsrc/sqlite3.c ~ extsrc/sqlite3.h

M extsrc/shell.c

+187

		--- extsrc/shell.c
		+++ extsrc/shell.c
		@@ -1798,10 +1798,192 @@
1798	1798	memtraceOut = 0;
1799	1799	return rc;
1800	1800	}
1801	1801
1802	1802	/*********************** End ../ext/misc/memtrace.c ******************/
	1803	+/*********************** Begin ../ext/misc/pcachetrace.c ****************/
	1804	+/*
	1805	+** 2023-06-21
	1806	+**
	1807	+** The author disclaims copyright to this source code. In place of
	1808	+** a legal notice, here is a blessing:
	1809	+**
	1810	+** May you do good and not evil.
	1811	+** May you find forgiveness for yourself and forgive others.
	1812	+** May you share freely, never taking more than you give.
	1813	+**
	1814	+*************************************************************************
	1815	+**
	1816	+** This file implements an extension that uses the SQLITE_CONFIG_PCACHE2
	1817	+** mechanism to add a tracing layer on top of pluggable page cache of
	1818	+** SQLite. If this extension is registered prior to sqlite3_initialize(),
	1819	+** it will cause all page cache activities to be logged on standard output,
	1820	+** or to some other FILE specified by the initializer.
	1821	+**
	1822	+** This file needs to be compiled into the application that uses it.
	1823	+**
	1824	+** This extension is used to implement the --pcachetrace option of the
	1825	+** command-line shell.
	1826	+*/
	1827	+#include <assert.h>
	1828	+#include <string.h>
	1829	+#include <stdio.h>
	1830	+
	1831	+/* The original page cache routines */
	1832	+static sqlite3_pcache_methods2 pcacheBase;
	1833	+static FILE *pcachetraceOut;
	1834	+
	1835	+/* Methods that trace pcache activity */
	1836	+static int pcachetraceInit(void *pArg){
	1837	+ int nRes;
	1838	+ if( pcachetraceOut ){
	1839	+ fprintf(pcachetraceOut, "PCACHETRACE: xInit(%p)\n", pArg);
	1840	+ }
	1841	+ nRes = pcacheBase.xInit(pArg);
	1842	+ if( pcachetraceOut ){
	1843	+ fprintf(pcachetraceOut, "PCACHETRACE: xInit(%p) -> %d\n", pArg, nRes);
	1844	+ }
	1845	+ return nRes;
	1846	+}
	1847	+static void pcachetraceShutdown(void *pArg){
	1848	+ if( pcachetraceOut ){
	1849	+ fprintf(pcachetraceOut, "PCACHETRACE: xShutdown(%p)\n", pArg);
	1850	+ }
	1851	+ pcacheBase.xShutdown(pArg);
	1852	+}
	1853	+static sqlite3_pcache *pcachetraceCreate(int szPage, int szExtra, int bPurge){
	1854	+ sqlite3_pcache *pRes;
	1855	+ if( pcachetraceOut ){
	1856	+ fprintf(pcachetraceOut, "PCACHETRACE: xCreate(%d,%d,%d)\n",
	1857	+ szPage, szExtra, bPurge);
	1858	+ }
	1859	+ pRes = pcacheBase.xCreate(szPage, szExtra, bPurge);
	1860	+ if( pcachetraceOut ){
	1861	+ fprintf(pcachetraceOut, "PCACHETRACE: xCreate(%d,%d,%d) -> %p\n",
	1862	+ szPage, szExtra, bPurge, pRes);
	1863	+ }
	1864	+ return pRes;
	1865	+}
	1866	+static void pcachetraceCachesize(sqlite3_pcache *p, int nCachesize){
	1867	+ if( pcachetraceOut ){
	1868	+ fprintf(pcachetraceOut, "PCACHETRACE: xCachesize(%p, %d)\n", p, nCachesize);
	1869	+ }
	1870	+ pcacheBase.xCachesize(p, nCachesize);
	1871	+}
	1872	+static int pcachetracePagecount(sqlite3_pcache *p){
	1873	+ int nRes;
	1874	+ if( pcachetraceOut ){
	1875	+ fprintf(pcachetraceOut, "PCACHETRACE: xPagecount(%p)\n", p);
	1876	+ }
	1877	+ nRes = pcacheBase.xPagecount(p);
	1878	+ if( pcachetraceOut ){
	1879	+ fprintf(pcachetraceOut, "PCACHETRACE: xPagecount(%p) -> %d\n", p, nRes);
	1880	+ }
	1881	+ return nRes;
	1882	+}
	1883	+static sqlite3_pcache_page *pcachetraceFetch(
	1884	+ sqlite3_pcache *p,
	1885	+ unsigned key,
	1886	+ int crFg
	1887	+){
	1888	+ sqlite3_pcache_page *pRes;
	1889	+ if( pcachetraceOut ){
	1890	+ fprintf(pcachetraceOut, "PCACHETRACE: xFetch(%p,%u,%d)\n", p, key, crFg);
	1891	+ }
	1892	+ pRes = pcacheBase.xFetch(p, key, crFg);
	1893	+ if( pcachetraceOut ){
	1894	+ fprintf(pcachetraceOut, "PCACHETRACE: xFetch(%p,%u,%d) -> %p\n",
	1895	+ p, key, crFg, pRes);
	1896	+ }
	1897	+ return pRes;
	1898	+}
	1899	+static void pcachetraceUnpin(
	1900	+ sqlite3_pcache *p,
	1901	+ sqlite3_pcache_page *pPg,
	1902	+ int bDiscard
	1903	+){
	1904	+ if( pcachetraceOut ){
	1905	+ fprintf(pcachetraceOut, "PCACHETRACE: xUnpin(%p, %p, %d)\n",
	1906	+ p, pPg, bDiscard);
	1907	+ }
	1908	+ pcacheBase.xUnpin(p, pPg, bDiscard);
	1909	+}
	1910	+static void pcachetraceRekey(
	1911	+ sqlite3_pcache *p,
	1912	+ sqlite3_pcache_page *pPg,
	1913	+ unsigned oldKey,
	1914	+ unsigned newKey
	1915	+){
	1916	+ if( pcachetraceOut ){
	1917	+ fprintf(pcachetraceOut, "PCACHETRACE: xRekey(%p, %p, %u, %u)\n",
	1918	+ p, pPg, oldKey, newKey);
	1919	+ }
	1920	+ pcacheBase.xRekey(p, pPg, oldKey, newKey);
	1921	+}
	1922	+static void pcachetraceTruncate(sqlite3_pcache *p, unsigned n){
	1923	+ if( pcachetraceOut ){
	1924	+ fprintf(pcachetraceOut, "PCACHETRACE: xTruncate(%p, %u)\n", p, n);
	1925	+ }
	1926	+ pcacheBase.xTruncate(p, n);
	1927	+}
	1928	+static void pcachetraceDestroy(sqlite3_pcache *p){
	1929	+ if( pcachetraceOut ){
	1930	+ fprintf(pcachetraceOut, "PCACHETRACE: xDestroy(%p)\n", p);
	1931	+ }
	1932	+ pcacheBase.xDestroy(p);
	1933	+}
	1934	+static void pcachetraceShrink(sqlite3_pcache *p){
	1935	+ if( pcachetraceOut ){
	1936	+ fprintf(pcachetraceOut, "PCACHETRACE: xShrink(%p)\n", p);
	1937	+ }
	1938	+ pcacheBase.xShrink(p);
	1939	+}
	1940	+
	1941	+/* The substitute pcache methods */
	1942	+static sqlite3_pcache_methods2 ersaztPcacheMethods = {
	1943	+ 0,
	1944	+ 0,
	1945	+ pcachetraceInit,
	1946	+ pcachetraceShutdown,
	1947	+ pcachetraceCreate,
	1948	+ pcachetraceCachesize,
	1949	+ pcachetracePagecount,
	1950	+ pcachetraceFetch,
	1951	+ pcachetraceUnpin,
	1952	+ pcachetraceRekey,
	1953	+ pcachetraceTruncate,
	1954	+ pcachetraceDestroy,
	1955	+ pcachetraceShrink
	1956	+};
	1957	+
	1958	+/* Begin tracing memory allocations to out. */
	1959	+int sqlite3PcacheTraceActivate(FILE *out){
	1960	+ int rc = SQLITE_OK;
	1961	+ if( pcacheBase.xFetch==0 ){
	1962	+ rc = sqlite3_config(SQLITE_CONFIG_GETPCACHE2, &pcacheBase);
	1963	+ if( rc==SQLITE_OK ){
	1964	+ rc = sqlite3_config(SQLITE_CONFIG_PCACHE2, &ersaztPcacheMethods);
	1965	+ }
	1966	+ }
	1967	+ pcachetraceOut = out;
	1968	+ return rc;
	1969	+}
	1970	+
	1971	+/* Deactivate memory tracing */
	1972	+int sqlite3PcacheTraceDeactivate(void){
	1973	+ int rc = SQLITE_OK;
	1974	+ if( pcacheBase.xFetch!=0 ){
	1975	+ rc = sqlite3_config(SQLITE_CONFIG_PCACHE2, &pcacheBase);
	1976	+ if( rc==SQLITE_OK ){
	1977	+ memset(&pcacheBase, 0, sizeof(pcacheBase));
	1978	+ }
	1979	+ }
	1980	+ pcachetraceOut = 0;
	1981	+ return rc;
	1982	+}
	1983	+
	1984	+/*********************** End ../ext/misc/pcachetrace.c ******************/
1803	1985	/*********************** Begin ../ext/misc/shathree.c ****************/
1804	1986	/*
1805	1987	** 2017-03-08
1806	1988	**
1807	1989	** The author disclaims copyright to this source code. In place of
		@@ -27151,10 +27333,11 @@
27151	27333	" -newline SEP set output row separator. Default: '\\n'\n"
27152	27334	" -nofollow refuse to open symbolic links to database files\n"
27153	27335	" -nonce STRING set the safe-mode escape nonce\n"
27154	27336	" -nullvalue TEXT set text string for NULL values. Default ''\n"
27155	27337	" -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n"
	27338	+ " -pcachetrace trace all page cache operations\n"
27156	27339	" -quote set output mode to 'quote'\n"
27157	27340	" -readonly open the database read-only\n"
27158	27341	" -safe enable safe-mode\n"
27159	27342	" -separator SEP set output column separator. Default: '\|'\n"
27160	27343	#ifdef SQLITE_ENABLE_SORTER_REFERENCES
		@@ -27537,10 +27720,12 @@
27537	27720	** command, so ignore them */
27538	27721	break;
27539	27722	#endif
27540	27723	}else if( cli_strcmp(z, "-memtrace")==0 ){
27541	27724	sqlite3MemTraceActivate(stderr);
	27725	+ }else if( cli_strcmp(z, "-pcachetrace")==0 ){
	27726	+ sqlite3PcacheTraceActivate(stderr);
27542	27727	}else if( cli_strcmp(z,"-bail")==0 ){
27543	27728	bail_on_error = 1;
27544	27729	}else if( cli_strcmp(z,"-nonce")==0 ){
27545	27730	free(data.zNonce);
27546	27731	data.zNonce = strdup(cmdline_option_value(argc, argv, ++i));
		@@ -27723,10 +27908,12 @@
27723	27908	}else if( cli_strcmp(z,"-nonce")==0 ){
27724	27909	i += 2;
27725	27910	}else if( cli_strcmp(z,"-mmap")==0 ){
27726	27911	i++;
27727	27912	}else if( cli_strcmp(z,"-memtrace")==0 ){
	27913	+ i++;
	27914	+ }else if( cli_strcmp(z,"-pcachetrace")==0 ){
27728	27915	i++;
27729	27916	#ifdef SQLITE_ENABLE_SORTER_REFERENCES
27730	27917	}else if( cli_strcmp(z,"-sorterref")==0 ){
27731	27918	i++;
27732	27919	#endif
27733	27920

	--- extsrc/shell.c
	+++ extsrc/shell.c
	@@ -1798,10 +1798,192 @@
1798	memtraceOut = 0;
1799	return rc;
1800	}
1801
1802	/*********************** End ../ext/misc/memtrace.c ******************/






















































































































































































1803	/*********************** Begin ../ext/misc/shathree.c ****************/
1804	/*
1805	** 2017-03-08
1806	**
1807	** The author disclaims copyright to this source code. In place of
	@@ -27151,10 +27333,11 @@
27151	" -newline SEP set output row separator. Default: '\\n'\n"
27152	" -nofollow refuse to open symbolic links to database files\n"
27153	" -nonce STRING set the safe-mode escape nonce\n"
27154	" -nullvalue TEXT set text string for NULL values. Default ''\n"
27155	" -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n"

27156	" -quote set output mode to 'quote'\n"
27157	" -readonly open the database read-only\n"
27158	" -safe enable safe-mode\n"
27159	" -separator SEP set output column separator. Default: '\|'\n"
27160	#ifdef SQLITE_ENABLE_SORTER_REFERENCES
	@@ -27537,10 +27720,12 @@
27537	** command, so ignore them */
27538	break;
27539	#endif
27540	}else if( cli_strcmp(z, "-memtrace")==0 ){
27541	sqlite3MemTraceActivate(stderr);


27542	}else if( cli_strcmp(z,"-bail")==0 ){
27543	bail_on_error = 1;
27544	}else if( cli_strcmp(z,"-nonce")==0 ){
27545	free(data.zNonce);
27546	data.zNonce = strdup(cmdline_option_value(argc, argv, ++i));
	@@ -27723,10 +27908,12 @@
27723	}else if( cli_strcmp(z,"-nonce")==0 ){
27724	i += 2;
27725	}else if( cli_strcmp(z,"-mmap")==0 ){
27726	i++;
27727	}else if( cli_strcmp(z,"-memtrace")==0 ){


27728	i++;
27729	#ifdef SQLITE_ENABLE_SORTER_REFERENCES
27730	}else if( cli_strcmp(z,"-sorterref")==0 ){
27731	i++;
27732	#endif
27733

	--- extsrc/shell.c
	+++ extsrc/shell.c
	@@ -1798,10 +1798,192 @@
1798	memtraceOut = 0;
1799	return rc;
1800	}
1801
1802	/*********************** End ../ext/misc/memtrace.c ******************/
1803	/*********************** Begin ../ext/misc/pcachetrace.c ****************/
1804	/*
1805	** 2023-06-21
1806	**
1807	** The author disclaims copyright to this source code. In place of
1808	** a legal notice, here is a blessing:
1809	**
1810	** May you do good and not evil.
1811	** May you find forgiveness for yourself and forgive others.
1812	** May you share freely, never taking more than you give.
1813	**
1814	*************************************************************************
1815	**
1816	** This file implements an extension that uses the SQLITE_CONFIG_PCACHE2
1817	** mechanism to add a tracing layer on top of pluggable page cache of
1818	** SQLite. If this extension is registered prior to sqlite3_initialize(),
1819	** it will cause all page cache activities to be logged on standard output,
1820	** or to some other FILE specified by the initializer.
1821	**
1822	** This file needs to be compiled into the application that uses it.
1823	**
1824	** This extension is used to implement the --pcachetrace option of the
1825	** command-line shell.
1826	*/
1827	#include <assert.h>
1828	#include <string.h>
1829	#include <stdio.h>
1830
1831	/* The original page cache routines */
1832	static sqlite3_pcache_methods2 pcacheBase;
1833	static FILE *pcachetraceOut;
1834
1835	/* Methods that trace pcache activity */
1836	static int pcachetraceInit(void *pArg){
1837	int nRes;
1838	if( pcachetraceOut ){
1839	fprintf(pcachetraceOut, "PCACHETRACE: xInit(%p)\n", pArg);
1840	}
1841	nRes = pcacheBase.xInit(pArg);
1842	if( pcachetraceOut ){
1843	fprintf(pcachetraceOut, "PCACHETRACE: xInit(%p) -> %d\n", pArg, nRes);
1844	}
1845	return nRes;
1846	}
1847	static void pcachetraceShutdown(void *pArg){
1848	if( pcachetraceOut ){
1849	fprintf(pcachetraceOut, "PCACHETRACE: xShutdown(%p)\n", pArg);
1850	}
1851	pcacheBase.xShutdown(pArg);
1852	}
1853	static sqlite3_pcache *pcachetraceCreate(int szPage, int szExtra, int bPurge){
1854	sqlite3_pcache *pRes;
1855	if( pcachetraceOut ){
1856	fprintf(pcachetraceOut, "PCACHETRACE: xCreate(%d,%d,%d)\n",
1857	szPage, szExtra, bPurge);
1858	}
1859	pRes = pcacheBase.xCreate(szPage, szExtra, bPurge);
1860	if( pcachetraceOut ){
1861	fprintf(pcachetraceOut, "PCACHETRACE: xCreate(%d,%d,%d) -> %p\n",
1862	szPage, szExtra, bPurge, pRes);
1863	}
1864	return pRes;
1865	}
1866	static void pcachetraceCachesize(sqlite3_pcache *p, int nCachesize){
1867	if( pcachetraceOut ){
1868	fprintf(pcachetraceOut, "PCACHETRACE: xCachesize(%p, %d)\n", p, nCachesize);
1869	}
1870	pcacheBase.xCachesize(p, nCachesize);
1871	}
1872	static int pcachetracePagecount(sqlite3_pcache *p){
1873	int nRes;
1874	if( pcachetraceOut ){
1875	fprintf(pcachetraceOut, "PCACHETRACE: xPagecount(%p)\n", p);
1876	}
1877	nRes = pcacheBase.xPagecount(p);
1878	if( pcachetraceOut ){
1879	fprintf(pcachetraceOut, "PCACHETRACE: xPagecount(%p) -> %d\n", p, nRes);
1880	}
1881	return nRes;
1882	}
1883	static sqlite3_pcache_page *pcachetraceFetch(
1884	sqlite3_pcache *p,
1885	unsigned key,
1886	int crFg
1887	){
1888	sqlite3_pcache_page *pRes;
1889	if( pcachetraceOut ){
1890	fprintf(pcachetraceOut, "PCACHETRACE: xFetch(%p,%u,%d)\n", p, key, crFg);
1891	}
1892	pRes = pcacheBase.xFetch(p, key, crFg);
1893	if( pcachetraceOut ){
1894	fprintf(pcachetraceOut, "PCACHETRACE: xFetch(%p,%u,%d) -> %p\n",
1895	p, key, crFg, pRes);
1896	}
1897	return pRes;
1898	}
1899	static void pcachetraceUnpin(
1900	sqlite3_pcache *p,
1901	sqlite3_pcache_page *pPg,
1902	int bDiscard
1903	){
1904	if( pcachetraceOut ){
1905	fprintf(pcachetraceOut, "PCACHETRACE: xUnpin(%p, %p, %d)\n",
1906	p, pPg, bDiscard);
1907	}
1908	pcacheBase.xUnpin(p, pPg, bDiscard);
1909	}
1910	static void pcachetraceRekey(
1911	sqlite3_pcache *p,
1912	sqlite3_pcache_page *pPg,
1913	unsigned oldKey,
1914	unsigned newKey
1915	){
1916	if( pcachetraceOut ){
1917	fprintf(pcachetraceOut, "PCACHETRACE: xRekey(%p, %p, %u, %u)\n",
1918	p, pPg, oldKey, newKey);
1919	}
1920	pcacheBase.xRekey(p, pPg, oldKey, newKey);
1921	}
1922	static void pcachetraceTruncate(sqlite3_pcache *p, unsigned n){
1923	if( pcachetraceOut ){
1924	fprintf(pcachetraceOut, "PCACHETRACE: xTruncate(%p, %u)\n", p, n);
1925	}
1926	pcacheBase.xTruncate(p, n);
1927	}
1928	static void pcachetraceDestroy(sqlite3_pcache *p){
1929	if( pcachetraceOut ){
1930	fprintf(pcachetraceOut, "PCACHETRACE: xDestroy(%p)\n", p);
1931	}
1932	pcacheBase.xDestroy(p);
1933	}
1934	static void pcachetraceShrink(sqlite3_pcache *p){
1935	if( pcachetraceOut ){
1936	fprintf(pcachetraceOut, "PCACHETRACE: xShrink(%p)\n", p);
1937	}
1938	pcacheBase.xShrink(p);
1939	}
1940
1941	/* The substitute pcache methods */
1942	static sqlite3_pcache_methods2 ersaztPcacheMethods = {
1943	0,
1944	0,
1945	pcachetraceInit,
1946	pcachetraceShutdown,
1947	pcachetraceCreate,
1948	pcachetraceCachesize,
1949	pcachetracePagecount,
1950	pcachetraceFetch,
1951	pcachetraceUnpin,
1952	pcachetraceRekey,
1953	pcachetraceTruncate,
1954	pcachetraceDestroy,
1955	pcachetraceShrink
1956	};
1957
1958	/* Begin tracing memory allocations to out. */
1959	int sqlite3PcacheTraceActivate(FILE *out){
1960	int rc = SQLITE_OK;
1961	if( pcacheBase.xFetch==0 ){
1962	rc = sqlite3_config(SQLITE_CONFIG_GETPCACHE2, &pcacheBase);
1963	if( rc==SQLITE_OK ){
1964	rc = sqlite3_config(SQLITE_CONFIG_PCACHE2, &ersaztPcacheMethods);
1965	}
1966	}
1967	pcachetraceOut = out;
1968	return rc;
1969	}
1970
1971	/* Deactivate memory tracing */
1972	int sqlite3PcacheTraceDeactivate(void){
1973	int rc = SQLITE_OK;
1974	if( pcacheBase.xFetch!=0 ){
1975	rc = sqlite3_config(SQLITE_CONFIG_PCACHE2, &pcacheBase);
1976	if( rc==SQLITE_OK ){
1977	memset(&pcacheBase, 0, sizeof(pcacheBase));
1978	}
1979	}
1980	pcachetraceOut = 0;
1981	return rc;
1982	}
1983
1984	/*********************** End ../ext/misc/pcachetrace.c ******************/
1985	/*********************** Begin ../ext/misc/shathree.c ****************/
1986	/*
1987	** 2017-03-08
1988	**
1989	** The author disclaims copyright to this source code. In place of
	@@ -27151,10 +27333,11 @@
27333	" -newline SEP set output row separator. Default: '\\n'\n"
27334	" -nofollow refuse to open symbolic links to database files\n"
27335	" -nonce STRING set the safe-mode escape nonce\n"
27336	" -nullvalue TEXT set text string for NULL values. Default ''\n"
27337	" -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n"
27338	" -pcachetrace trace all page cache operations\n"
27339	" -quote set output mode to 'quote'\n"
27340	" -readonly open the database read-only\n"
27341	" -safe enable safe-mode\n"
27342	" -separator SEP set output column separator. Default: '\|'\n"
27343	#ifdef SQLITE_ENABLE_SORTER_REFERENCES
	@@ -27537,10 +27720,12 @@
27720	** command, so ignore them */
27721	break;
27722	#endif
27723	}else if( cli_strcmp(z, "-memtrace")==0 ){
27724	sqlite3MemTraceActivate(stderr);
27725	}else if( cli_strcmp(z, "-pcachetrace")==0 ){
27726	sqlite3PcacheTraceActivate(stderr);
27727	}else if( cli_strcmp(z,"-bail")==0 ){
27728	bail_on_error = 1;
27729	}else if( cli_strcmp(z,"-nonce")==0 ){
27730	free(data.zNonce);
27731	data.zNonce = strdup(cmdline_option_value(argc, argv, ++i));
	@@ -27723,10 +27908,12 @@
27908	}else if( cli_strcmp(z,"-nonce")==0 ){
27909	i += 2;
27910	}else if( cli_strcmp(z,"-mmap")==0 ){
27911	i++;
27912	}else if( cli_strcmp(z,"-memtrace")==0 ){
27913	i++;
27914	}else if( cli_strcmp(z,"-pcachetrace")==0 ){
27915	i++;
27916	#ifdef SQLITE_ENABLE_SORTER_REFERENCES
27917	}else if( cli_strcmp(z,"-sorterref")==0 ){
27918	i++;
27919	#endif
27920

M extsrc/sqlite3.c

+408 -286

		--- extsrc/sqlite3.c
		+++ extsrc/sqlite3.c
		@@ -16,11 +16,11 @@
16	16	** if you want a wrapper to interface SQLite with your choice of programming
17	17	** language. The code for the "sqlite3" command-line shell is also in a
18	18	** separate file. This file contains only code for the core SQLite library.
19	19	**
20	20	** The content in this amalgamation comes from Fossil check-in
21		-** c94f87806a8b408d8204fc7deec16d01c08.
	21	+** a5f77862c0fe0189aa4246a1e55bb7c537c.
22	22	*/
23	23	#define SQLITE_CORE 1
24	24	#define SQLITE_AMALGAMATION 1
25	25	#ifndef SQLITE_PRIVATE
26	26	# define SQLITE_PRIVATE static
		@@ -459,11 +459,11 @@
459	459	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
460	460	** [sqlite_version()] and [sqlite_source_id()].
461	461	*/
462	462	#define SQLITE_VERSION "3.43.0"
463	463	#define SQLITE_VERSION_NUMBER 3043000
464		-#define SQLITE_SOURCE_ID "2023-06-19 13:09:16 3c94f87806a8b408d8204fc7deec16d01c085ee199ff21a1f20b6346ce816cfe"
	464	+#define SQLITE_SOURCE_ID "2023-06-23 11:10:13 fa5f77862c0fe0189aa4246a1e55bb7c537c28c436ec10b75f5fa141e5e4aff0"
465	465
466	466	/*
467	467	** CAPI3REF: Run-Time Library Version Numbers
468	468	** KEYWORDS: sqlite3_version sqlite3_sourceid
469	469	**
		@@ -17548,10 +17548,11 @@
17548	17548	** Value constraints (enforced via assert()):
17549	17549	** SQLITE_FUNC_MINMAX == NC_MinMaxAgg == SF_MinMaxAgg
17550	17550	** SQLITE_FUNC_ANYORDER == NC_OrderAgg == SF_OrderByReqd
17551	17551	** SQLITE_FUNC_LENGTH == OPFLAG_LENGTHARG
17552	17552	** SQLITE_FUNC_TYPEOF == OPFLAG_TYPEOFARG
	17553	+** SQLITE_FUNC_BYTELEN == OPFLAG_BYTELENARG
17553	17554	** SQLITE_FUNC_CONSTANT == SQLITE_DETERMINISTIC from the API
17554	17555	** SQLITE_FUNC_DIRECT == SQLITE_DIRECTONLY from the API
17555	17556	** SQLITE_FUNC_UNSAFE == SQLITE_INNOCUOUS -- opposite meanings!!!
17556	17557	** SQLITE_FUNC_ENCMASK depends on SQLITE_UTF* macros in the API
17557	17558	**
		@@ -17566,10 +17567,11 @@
17566	17567	#define SQLITE_FUNC_CASE 0x0008 /* Case-sensitive LIKE-type function */
17567	17568	#define SQLITE_FUNC_EPHEM 0x0010 /* Ephemeral. Delete with VDBE */
17568	17569	#define SQLITE_FUNC_NEEDCOLL 0x0020 /* sqlite3GetFuncCollSeq() might be called*/
17569	17570	#define SQLITE_FUNC_LENGTH 0x0040 /* Built-in length() function */
17570	17571	#define SQLITE_FUNC_TYPEOF 0x0080 /* Built-in typeof() function */
	17572	+#define SQLITE_FUNC_BYTELEN 0x00c0 /* Built-in octet_length() function */
17571	17573	#define SQLITE_FUNC_COUNT 0x0100 /* Built-in count() aggregate /
17572	17574	/* 0x0200 -- available for reuse */
17573	17575	#define SQLITE_FUNC_UNLIKELY 0x0400 /* Built-in unlikely() function */
17574	17576	#define SQLITE_FUNC_CONSTANT 0x0800 /* Constant inputs give a constant output */
17575	17577	#define SQLITE_FUNC_MINMAX 0x1000 /* True for min() and max() aggregates */
		@@ -19509,10 +19511,11 @@
19509	19511	#define OPFLAG_APPEND 0x08 /* This is likely to be an append */
19510	19512	#define OPFLAG_USESEEKRESULT 0x10 /* Try to avoid a seek in BtreeInsert() */
19511	19513	#define OPFLAG_ISNOOP 0x40 /* OP_Delete does pre-update-hook only */
19512	19514	#define OPFLAG_LENGTHARG 0x40 /* OP_Column only used for length() */
19513	19515	#define OPFLAG_TYPEOFARG 0x80 /* OP_Column only used for typeof() */
	19516	+#define OPFLAG_BYTELENARG 0xc0 /* OP_Column only for octet_length() */
19514	19517	#define OPFLAG_BULKCSR 0x01 /* OP_Open** used to open bulk cursor */
19515	19518	#define OPFLAG_SEEKEQ 0x02 /* OP_Open** cursor uses EQ seek only */
19516	19519	#define OPFLAG_FORDELETE 0x08 /* OP_Open should use BTREE_FORDELETE */
19517	19520	#define OPFLAG_P2ISREG 0x10 /* P2 to OP_Open** is a register number */
19518	19521	#define OPFLAG_PERMUTE 0x01 /* OP_Compare: use the permutation */
		@@ -19829,10 +19832,11 @@
19829	19832	const Token pName; / Name of the container - used for error messages */
19830	19833	};
19831	19834
19832	19835	/* Forward declarations */
19833	19836	SQLITE_PRIVATE int sqlite3WalkExpr(Walker, Expr);
	19837	+SQLITE_PRIVATE int sqlite3WalkExprNN(Walker, Expr);
19834	19838	SQLITE_PRIVATE int sqlite3WalkExprList(Walker, ExprList);
19835	19839	SQLITE_PRIVATE int sqlite3WalkSelect(Walker, Select);
19836	19840	SQLITE_PRIVATE int sqlite3WalkSelectExpr(Walker, Select);
19837	19841	SQLITE_PRIVATE int sqlite3WalkSelectFrom(Walker, Select);
19838	19842	SQLITE_PRIVATE int sqlite3ExprWalkNoop(Walker, Expr);
		@@ -71221,72 +71225,45 @@
71221	71225	return btreePagecount(p->pBt);
71222	71226	}
71223	71227
71224	71228	/*
71225	71229	** Get a page from the pager and initialize it.
71226		-**
71227		-** If pCur!=0 then the page is being fetched as part of a moveToChild()
71228		-** call. Do additional sanity checking on the page in this case.
71229		-** And if the fetch fails, this routine must decrement pCur->iPage.
71230		-**
71231		-** The page is fetched as read-write unless pCur is not NULL and is
71232		-** a read-only cursor.
71233		-**
71234		-** If an error occurs, then *ppPage is undefined. It
71235		-** may remain unchanged, or it may be set to an invalid value.
71236	71230	*/
71237	71231	static int getAndInitPage(
71238	71232	BtShared pBt, / The database file */
71239	71233	Pgno pgno, /* Number of the page to get */
71240	71234	MemPage *ppPage, / Write the page pointer here */
71241		- BtCursor pCur, / Cursor to receive the page, or NULL */
71242	71235	int bReadOnly /* True for a read-only page */
71243	71236	){
71244	71237	int rc;
71245	71238	DbPage *pDbPage;
	71239	+ MemPage *pPage;
71246	71240	assert( sqlite3_mutex_held(pBt->mutex) );
71247		- assert( pCur==0 \|\| ppPage==&pCur->pPage );
71248		- assert( pCur==0 \|\| bReadOnly==pCur->curPagerFlags );
71249		- assert( pCur==0 \|\| pCur->iPage>0 );
71250	71241
71251	71242	if( pgno>btreePagecount(pBt) ){
71252		- rc = SQLITE_CORRUPT_BKPT;
71253		- goto getAndInitPage_error1;
	71243	+ *ppPage = 0;
	71244	+ return SQLITE_CORRUPT_BKPT;
71254	71245	}
71255	71246	rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, bReadOnly);
71256	71247	if( rc ){
71257		- goto getAndInitPage_error1;
	71248	+ *ppPage = 0;
	71249	+ return rc;
71258	71250	}
71259		- ppPage = (MemPage)sqlite3PagerGetExtra(pDbPage);
71260		- if( (*ppPage)->isInit==0 ){
	71251	+ pPage = (MemPage*)sqlite3PagerGetExtra(pDbPage);
	71252	+ if( pPage->isInit==0 ){
71261	71253	btreePageFromDbPage(pDbPage, pgno, pBt);
71262		- rc = btreeInitPage(*ppPage);
	71254	+ rc = btreeInitPage(pPage);
71263	71255	if( rc!=SQLITE_OK ){
71264		- goto getAndInitPage_error2;
71265		- }
71266		- }
71267		- assert( (*ppPage)->pgno==pgno \|\| CORRUPT_DB );
71268		- assert( (*ppPage)->aData==sqlite3PagerGetData(pDbPage) );
71269		-
71270		- /* If obtaining a child page for a cursor, we must verify that the page is
71271		- ** compatible with the root page. */
71272		- if( pCur && ((ppPage)->nCell<1 \|\| (ppPage)->intKey!=pCur->curIntKey) ){
71273		- rc = SQLITE_CORRUPT_PGNO(pgno);
71274		- goto getAndInitPage_error2;
71275		- }
71276		- return SQLITE_OK;
71277		-
71278		-getAndInitPage_error2:
71279		- releasePage(*ppPage);
71280		-getAndInitPage_error1:
71281		- if( pCur ){
71282		- pCur->iPage--;
71283		- pCur->pPage = pCur->apPage[pCur->iPage];
71284		- }
71285		- testcase( pgno==0 );
71286		- assert( pgno!=0 \|\| rc!=SQLITE_OK );
71287		- return rc;
	71256	+ releasePage(pPage);
	71257	+ *ppPage = 0;
	71258	+ return rc;
	71259	+ }
	71260	+ }
	71261	+ assert( pPage->pgno==pgno \|\| CORRUPT_DB );
	71262	+ assert( pPage->aData==sqlite3PagerGetData(pDbPage) );
	71263	+ *ppPage = pPage;
	71264	+ return SQLITE_OK;
71288	71265	}
71289	71266
71290	71267	/*
71291	71268	** Release a MemPage. This should be called once for each prior
71292	71269	** call to btreeGetPage.
		@@ -74256,10 +74233,11 @@
74256	74233	** the new child page does not match the flags field of the parent (i.e.
74257	74234	** if an intkey page appears to be the parent of a non-intkey page, or
74258	74235	** vice-versa).
74259	74236	*/
74260	74237	static int moveToChild(BtCursor *pCur, u32 newPgno){
	74238	+ int rc;
74261	74239	assert( cursorOwnsBtShared(pCur) );
74262	74240	assert( pCur->eState==CURSOR_VALID );
74263	74241	assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
74264	74242	assert( pCur->iPage>=0 );
74265	74243	if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
		@@ -74269,12 +74247,21 @@
74269	74247	pCur->curFlags &= ~(BTCF_ValidNKey\|BTCF_ValidOvfl);
74270	74248	pCur->aiIdx[pCur->iPage] = pCur->ix;
74271	74249	pCur->apPage[pCur->iPage] = pCur->pPage;
74272	74250	pCur->ix = 0;
74273	74251	pCur->iPage++;
74274		- return getAndInitPage(pCur->pBt, newPgno, &pCur->pPage, pCur,
74275		- pCur->curPagerFlags);
	74252	+ rc = getAndInitPage(pCur->pBt, newPgno, &pCur->pPage, pCur->curPagerFlags);
	74253	+ if( rc==SQLITE_OK
	74254	+ && (pCur->pPage->nCell<1 \|\| pCur->pPage->intKey!=pCur->curIntKey)
	74255	+ ){
	74256	+ releasePage(pCur->pPage);
	74257	+ rc = SQLITE_CORRUPT_PGNO(newPgno);
	74258	+ }
	74259	+ if( rc ){
	74260	+ pCur->pPage = pCur->apPage[--pCur->iPage];
	74261	+ }
	74262	+ return rc;
74276	74263	}
74277	74264
74278	74265	#ifdef SQLITE_DEBUG
74279	74266	/*
74280	74267	** Page pParent is an internal (non-leaf) tree page. This function
		@@ -74377,11 +74364,11 @@
74377	74364	return pCur->skipNext;
74378	74365	}
74379	74366	sqlite3BtreeClearCursor(pCur);
74380	74367	}
74381	74368	rc = getAndInitPage(pCur->pBt, pCur->pgnoRoot, &pCur->pPage,
74382		- 0, pCur->curPagerFlags);
	74369	+ pCur->curPagerFlags);
74383	74370	if( rc!=SQLITE_OK ){
74384	74371	pCur->eState = CURSOR_INVALID;
74385	74372	return rc;
74386	74373	}
74387	74374	pCur->iPage = 0;
		@@ -74990,14 +74977,40 @@
74990	74977	if( lwr>=pPage->nCell ){
74991	74978	chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]);
74992	74979	}else{
74993	74980	chldPg = get4byte(findCell(pPage, lwr));
74994	74981	}
74995		- pCur->ix = (u16)lwr;
74996		- rc = moveToChild(pCur, chldPg);
74997		- if( rc ) break;
74998		- }
	74982	+
	74983	+ /* This block is similar to an in-lined version of:
	74984	+ **
	74985	+ ** pCur->ix = (u16)lwr;
	74986	+ ** rc = moveToChild(pCur, chldPg);
	74987	+ ** if( rc ) break;
	74988	+ */
	74989	+ pCur->info.nSize = 0;
	74990	+ pCur->curFlags &= ~(BTCF_ValidNKey\|BTCF_ValidOvfl);
	74991	+ if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
	74992	+ return SQLITE_CORRUPT_BKPT;
	74993	+ }
	74994	+ pCur->aiIdx[pCur->iPage] = (u16)lwr;
	74995	+ pCur->apPage[pCur->iPage] = pCur->pPage;
	74996	+ pCur->ix = 0;
	74997	+ pCur->iPage++;
	74998	+ rc = getAndInitPage(pCur->pBt, chldPg, &pCur->pPage, pCur->curPagerFlags);
	74999	+ if( rc==SQLITE_OK
	75000	+ && (pCur->pPage->nCell<1 \|\| pCur->pPage->intKey!=pCur->curIntKey)
	75001	+ ){
	75002	+ releasePage(pCur->pPage);
	75003	+ rc = SQLITE_CORRUPT_PGNO(chldPg);
	75004	+ }
	75005	+ if( rc ){
	75006	+ pCur->pPage = pCur->apPage[--pCur->iPage];
	75007	+ break;
	75008	+ }
	75009	+ /*
	75010	+ ***** End of in-lined moveToChild() call */
	75011	+ }
74999	75012	moveto_index_finish:
75000	75013	pCur->info.nSize = 0;
75001	75014	assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
75002	75015	return rc;
75003	75016	}
		@@ -77047,11 +77060,11 @@
77047	77060	pRight = findCell(pParent, i+nxDiv-pParent->nOverflow);
77048	77061	}
77049	77062	pgno = get4byte(pRight);
77050	77063	while( 1 ){
77051	77064	if( rc==SQLITE_OK ){
77052		- rc = getAndInitPage(pBt, pgno, &apOld[i], 0, 0);
	77065	+ rc = getAndInitPage(pBt, pgno, &apOld[i], 0);
77053	77066	}
77054	77067	if( rc ){
77055	77068	memset(apOld, 0, (i+1)sizeof(MemPage));
77056	77069	goto balance_cleanup;
77057	77070	}
		@@ -78932,11 +78945,11 @@
78932	78945
78933	78946	assert( sqlite3_mutex_held(pBt->mutex) );
78934	78947	if( pgno>btreePagecount(pBt) ){
78935	78948	return SQLITE_CORRUPT_BKPT;
78936	78949	}
78937		- rc = getAndInitPage(pBt, pgno, &pPage, 0, 0);
	78950	+ rc = getAndInitPage(pBt, pgno, &pPage, 0);
78938	78951	if( rc ) return rc;
78939	78952	if( (pBt->openFlags & BTREE_SINGLE)==0
78940	78953	&& sqlite3PagerPageRefcount(pPage->pDbPage) != (1 + (pgno==1))
78941	78954	){
78942	78955	rc = SQLITE_CORRUPT_BKPT;
		@@ -83267,10 +83280,39 @@
83267	83280	(void)pc;
83268	83281	(void)pOp;
83269	83282	n++;
83270	83283	}
83271	83284	#endif
	83285	+
	83286	+/*
	83287	+** Slow paths for sqlite3VdbeAddOp3() and sqlite3VdbeAddOp4Int() for the
	83288	+** unusual case when we need to increase the size of the Vdbe.aOp[] array
	83289	+** before adding the new opcode.
	83290	+*/
	83291	+static SQLITE_NOINLINE int growOp3(Vdbe *p, int op, int p1, int p2, int p3){
	83292	+ assert( p->nOpAlloc<=p->nOp );
	83293	+ if( growOpArray(p, 1) ) return 1;
	83294	+ assert( p->nOpAlloc>p->nOp );
	83295	+ return sqlite3VdbeAddOp3(p, op, p1, p2, p3);
	83296	+}
	83297	+static SQLITE_NOINLINE int addOp4IntSlow(
	83298	+ Vdbe p, / Add the opcode to this VM */
	83299	+ int op, /* The new opcode */
	83300	+ int p1, /* The P1 operand */
	83301	+ int p2, /* The P2 operand */
	83302	+ int p3, /* The P3 operand */
	83303	+ int p4 /* The P4 operand as an integer */
	83304	+){
	83305	+ int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
	83306	+ if( p->db->mallocFailed==0 ){
	83307	+ VdbeOp *pOp = &p->aOp[addr];
	83308	+ pOp->p4type = P4_INT32;
	83309	+ pOp->p4.i = p4;
	83310	+ }
	83311	+ return addr;
	83312	+}
	83313	+
83272	83314
83273	83315	/*
83274	83316	** Add a new instruction to the list of instructions current in the
83275	83317	** VDBE. Return the address of the new instruction.
83276	83318	**
		@@ -83278,21 +83320,20 @@
83278	83320	**
83279	83321	** p Pointer to the VDBE
83280	83322	**
83281	83323	** op The opcode for this instruction
83282	83324	**
83283		-** p1, p2, p3 Operands
83284		-**
83285		-** Use the sqlite3VdbeResolveLabel() function to fix an address and
83286		-** the sqlite3VdbeChangeP4() function to change the value of the P4
83287		-** operand.
	83325	+** p1, p2, p3, p4 Operands
83288	83326	*/
83289		-static SQLITE_NOINLINE int growOp3(Vdbe *p, int op, int p1, int p2, int p3){
83290		- assert( p->nOpAlloc<=p->nOp );
83291		- if( growOpArray(p, 1) ) return 1;
83292		- assert( p->nOpAlloc>p->nOp );
83293		- return sqlite3VdbeAddOp3(p, op, p1, p2, p3);
	83327	+SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe *p, int op){
	83328	+ return sqlite3VdbeAddOp3(p, op, 0, 0, 0);
	83329	+}
	83330	+SQLITE_PRIVATE int sqlite3VdbeAddOp1(Vdbe *p, int op, int p1){
	83331	+ return sqlite3VdbeAddOp3(p, op, p1, 0, 0);
	83332	+}
	83333	+SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe *p, int op, int p1, int p2){
	83334	+ return sqlite3VdbeAddOp3(p, op, p1, p2, 0);
83294	83335	}
83295	83336	SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
83296	83337	int i;
83297	83338	VdbeOp *pOp;
83298	83339
		@@ -83311,10 +83352,62 @@
83311	83352	pOp->p1 = p1;
83312	83353	pOp->p2 = p2;
83313	83354	pOp->p3 = p3;
83314	83355	pOp->p4.p = 0;
83315	83356	pOp->p4type = P4_NOTUSED;
	83357	+
	83358	+ /* Replicate this logic in sqlite3VdbeAddOp4Int()
	83359	+ ** vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv */
	83360	+#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
	83361	+ pOp->zComment = 0;
	83362	+#endif
	83363	+#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) \|\| defined(VDBE_PROFILE)
	83364	+ pOp->nExec = 0;
	83365	+ pOp->nCycle = 0;
	83366	+#endif
	83367	+#ifdef SQLITE_DEBUG
	83368	+ if( p->db->flags & SQLITE_VdbeAddopTrace ){
	83369	+ sqlite3VdbePrintOp(0, i, &p->aOp[i]);
	83370	+ test_addop_breakpoint(i, &p->aOp[i]);
	83371	+ }
	83372	+#endif
	83373	+#ifdef SQLITE_VDBE_COVERAGE
	83374	+ pOp->iSrcLine = 0;
	83375	+#endif
	83376	+ /* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
	83377	+ ** Replicate in sqlite3VdbeAddOp4Int() */
	83378	+
	83379	+ return i;
	83380	+}
	83381	+SQLITE_PRIVATE int sqlite3VdbeAddOp4Int(
	83382	+ Vdbe p, / Add the opcode to this VM */
	83383	+ int op, /* The new opcode */
	83384	+ int p1, /* The P1 operand */
	83385	+ int p2, /* The P2 operand */
	83386	+ int p3, /* The P3 operand */
	83387	+ int p4 /* The P4 operand as an integer */
	83388	+){
	83389	+ int i;
	83390	+ VdbeOp *pOp;
	83391	+
	83392	+ i = p->nOp;
	83393	+ if( p->nOpAlloc<=i ){
	83394	+ return addOp4IntSlow(p, op, p1, p2, p3, p4);
	83395	+ }
	83396	+ p->nOp++;
	83397	+ pOp = &p->aOp[i];
	83398	+ assert( pOp!=0 );
	83399	+ pOp->opcode = (u8)op;
	83400	+ pOp->p5 = 0;
	83401	+ pOp->p1 = p1;
	83402	+ pOp->p2 = p2;
	83403	+ pOp->p3 = p3;
	83404	+ pOp->p4.i = p4;
	83405	+ pOp->p4type = P4_INT32;
	83406	+
	83407	+ /* Replicate this logic in sqlite3VdbeAddOp3()
	83408	+ ** vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv */
83316	83409	#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
83317	83410	pOp->zComment = 0;
83318	83411	#endif
83319	83412	#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) \|\| defined(VDBE_PROFILE)
83320	83413	pOp->nExec = 0;
		@@ -83327,21 +83420,15 @@
83327	83420	}
83328	83421	#endif
83329	83422	#ifdef SQLITE_VDBE_COVERAGE
83330	83423	pOp->iSrcLine = 0;
83331	83424	#endif
	83425	+ /* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
	83426	+ ** Replicate in sqlite3VdbeAddOp3() */
	83427	+
83332	83428	return i;
83333	83429	}
83334		-SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe *p, int op){
83335		- return sqlite3VdbeAddOp3(p, op, 0, 0, 0);
83336		-}
83337		-SQLITE_PRIVATE int sqlite3VdbeAddOp1(Vdbe *p, int op, int p1){
83338		- return sqlite3VdbeAddOp3(p, op, p1, 0, 0);
83339		-}
83340		-SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe *p, int op, int p1, int p2){
83341		- return sqlite3VdbeAddOp3(p, op, p1, p2, 0);
83342		-}
83343	83430
83344	83431	/* Generate code for an unconditional jump to instruction iDest
83345	83432	*/
83346	83433	SQLITE_PRIVATE int sqlite3VdbeGoto(Vdbe *p, int iDest){
83347	83434	return sqlite3VdbeAddOp3(p, OP_Goto, 0, iDest, 0);
		@@ -83544,30 +83631,10 @@
83544	83631	sqlite3VdbeChangeP5(p, p5);
83545	83632	for(j=0; j<p->db->nDb; j++) sqlite3VdbeUsesBtree(p, j);
83546	83633	sqlite3MayAbort(p->pParse);
83547	83634	}
83548	83635
83549		-/*
83550		-** Add an opcode that includes the p4 value as an integer.
83551		-*/
83552		-SQLITE_PRIVATE int sqlite3VdbeAddOp4Int(
83553		- Vdbe p, / Add the opcode to this VM */
83554		- int op, /* The new opcode */
83555		- int p1, /* The P1 operand */
83556		- int p2, /* The P2 operand */
83557		- int p3, /* The P3 operand */
83558		- int p4 /* The P4 operand as an integer */
83559		-){
83560		- int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
83561		- if( p->db->mallocFailed==0 ){
83562		- VdbeOp *pOp = &p->aOp[addr];
83563		- pOp->p4type = P4_INT32;
83564		- pOp->p4.i = p4;
83565		- }
83566		- return addr;
83567		-}
83568		-
83569	83636	/* Insert the end of a co-routine
83570	83637	*/
83571	83638	SQLITE_PRIVATE void sqlite3VdbeEndCoroutine(Vdbe *v, int regYield){
83572	83639	sqlite3VdbeAddOp1(v, OP_EndCoroutine, regYield);
83573	83640
		@@ -94029,14 +94096,18 @@
94029	94096	pDest->z[len] = 0;
94030	94097	pDest->z[len+1] = 0;
94031	94098	pDest->flags = aFlag[t&1];
94032	94099	}
94033	94100	}else{
	94101	+ u8 p5;
94034	94102	pDest->enc = encoding;
94035	94103	/* This branch happens only when content is on overflow pages */
94036		- if( ((pOp->p5 & (OPFLAG_LENGTHARG\|OPFLAG_TYPEOFARG))!=0
94037		- && ((t>=12 && (t&1)==0) \|\| (pOp->p5 & OPFLAG_TYPEOFARG)!=0))
	94104	+ if( ((p5 = (pOp->p5 & OPFLAG_BYTELENARG))!=0
	94105	+ && (p5==OPFLAG_TYPEOFARG
	94106	+ \|\| (t>=12 && ((t&1)==0 \|\| p5==OPFLAG_BYTELENARG))
	94107	+ )
	94108	+ )
94038	94109	\|\| (len = sqlite3VdbeSerialTypeLen(t))==0
94039	94110	){
94040	94111	/* Content is irrelevant for
94041	94112	** 1. the typeof() function,
94042	94113	** 2. the length(X) function if X is a blob, and
		@@ -104107,20 +104178,22 @@
104107	104178	** return from the top-level walk call.
104108	104179	**
104109	104180	** The return value from this routine is WRC_Abort to abandon the tree walk
104110	104181	** and WRC_Continue to continue.
104111	104182	*/
104112		-static SQLITE_NOINLINE int walkExpr(Walker pWalker, Expr pExpr){
	104183	+SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3WalkExprNN(Walker pWalker, Expr pExpr){
104113	104184	int rc;
104114	104185	testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
104115	104186	testcase( ExprHasProperty(pExpr, EP_Reduced) );
104116	104187	while(1){
104117	104188	rc = pWalker->xExprCallback(pWalker, pExpr);
104118	104189	if( rc ) return rc & WRC_Abort;
104119	104190	if( !ExprHasProperty(pExpr,(EP_TokenOnly\|EP_Leaf)) ){
104120	104191	assert( pExpr->x.pList==0 \|\| pExpr->pRight==0 );
104121		- if( pExpr->pLeft && walkExpr(pWalker, pExpr->pLeft) ) return WRC_Abort;
	104192	+ if( pExpr->pLeft && sqlite3WalkExprNN(pWalker, pExpr->pLeft) ){
	104193	+ return WRC_Abort;
	104194	+ }
104122	104195	if( pExpr->pRight ){
104123	104196	assert( !ExprHasProperty(pExpr, EP_WinFunc) );
104124	104197	pExpr = pExpr->pRight;
104125	104198	continue;
104126	104199	}else if( ExprUseXSelect(pExpr) ){
		@@ -104140,11 +104213,11 @@
104140	104213	break;
104141	104214	}
104142	104215	return WRC_Continue;
104143	104216	}
104144	104217	SQLITE_PRIVATE int sqlite3WalkExpr(Walker pWalker, Expr pExpr){
104145		- return pExpr ? walkExpr(pWalker,pExpr) : WRC_Continue;
	104218	+ return pExpr ? sqlite3WalkExprNN(pWalker,pExpr) : WRC_Continue;
104146	104219	}
104147	104220
104148	104221	/*
104149	104222	** Call sqlite3WalkExpr() for every expression in list p or until
104150	104223	** an abort request is seen.
		@@ -106323,11 +106396,12 @@
106323	106396	w.pParse->nHeight += pExpr->nHeight;
106324	106397	if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
106325	106398	return SQLITE_ERROR;
106326	106399	}
106327	106400	#endif
106328		- sqlite3WalkExpr(&w, pExpr);
	106401	+ assert( pExpr!=0 );
	106402	+ sqlite3WalkExprNN(&w, pExpr);
106329	106403	#if SQLITE_MAX_EXPR_DEPTH>0
106330	106404	w.pParse->nHeight -= pExpr->nHeight;
106331	106405	#endif
106332	106406	assert( EP_Agg==NC_HasAgg );
106333	106407	assert( EP_Win==NC_HasWin );
		@@ -106365,11 +106439,11 @@
106365	106439	w.pParse->nHeight += pExpr->nHeight;
106366	106440	if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
106367	106441	return WRC_Abort;
106368	106442	}
106369	106443	#endif
106370		- sqlite3WalkExpr(&w, pExpr);
	106444	+ sqlite3WalkExprNN(&w, pExpr);
106371	106445	#if SQLITE_MAX_EXPR_DEPTH>0
106372	106446	w.pParse->nHeight -= pExpr->nHeight;
106373	106447	#endif
106374	106448	assert( EP_Agg==NC_HasAgg );
106375	106449	assert( EP_Win==NC_HasWin );
		@@ -111138,26 +111212,29 @@
111138	111212	pParse->nMem += nFarg;
111139	111213	}else{
111140	111214	r1 = sqlite3GetTempRange(pParse, nFarg);
111141	111215	}
111142	111216
111143		- /* For length() and typeof() functions with a column argument,
	111217	+ /* For length() and typeof() and octet_length() functions,
111144	111218	** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG
111145		- ** or OPFLAG_TYPEOFARG respectively, to avoid unnecessary data
111146		- ** loading.
	111219	+ ** or OPFLAG_TYPEOFARG or OPFLAG_BYTELENARG respectively, to avoid
	111220	+ ** unnecessary data loading.
111147	111221	*/
111148	111222	if( (pDef->funcFlags & (SQLITE_FUNC_LENGTH\|SQLITE_FUNC_TYPEOF))!=0 ){
111149	111223	u8 exprOp;
111150	111224	assert( nFarg==1 );
111151	111225	assert( pFarg->a[0].pExpr!=0 );
111152	111226	exprOp = pFarg->a[0].pExpr->op;
111153	111227	if( exprOp==TK_COLUMN \|\| exprOp==TK_AGG_COLUMN ){
111154	111228	assert( SQLITE_FUNC_LENGTH==OPFLAG_LENGTHARG );
111155	111229	assert( SQLITE_FUNC_TYPEOF==OPFLAG_TYPEOFARG );
111156		- testcase( pDef->funcFlags & OPFLAG_LENGTHARG );
111157		- pFarg->a[0].pExpr->op2 =
111158		- pDef->funcFlags & (OPFLAG_LENGTHARG\|OPFLAG_TYPEOFARG);
	111230	+ assert( SQLITE_FUNC_BYTELEN==OPFLAG_BYTELENARG );
	111231	+ assert( (OPFLAG_LENGTHARG\|OPFLAG_TYPEOFARG)==OPFLAG_BYTELENARG );
	111232	+ testcase( (pDef->funcFlags & OPFLAG_BYTELENARG)==OPFLAG_LENGTHARG );
	111233	+ testcase( (pDef->funcFlags & OPFLAG_BYTELENARG)==OPFLAG_TYPEOFARG );
	111234	+ testcase( (pDef->funcFlags & OPFLAG_BYTELENARG)==OPFLAG_BYTELENARG);
	111235	+ pFarg->a[0].pExpr->op2 = pDef->funcFlags & OPFLAG_BYTELENARG;
111159	111236	}
111160	111237	}
111161	111238
111162	111239	sqlite3ExprCodeExprList(pParse, pFarg, r1, 0,
111163	111240	SQLITE_ECEL_DUP\|SQLITE_ECEL_FACTOR);
		@@ -118693,19 +118770,21 @@
118693	118770	sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB);
118694	118771	}
118695	118772	pParse->nVtabLock = 0;
118696	118773	#endif
118697	118774
	118775	+#ifndef SQLITE_OMIT_SHARED_CACHE
118698	118776	/* Once all the cookies have been verified and transactions opened,
118699	118777	** obtain the required table-locks. This is a no-op unless the
118700	118778	** shared-cache feature is enabled.
118701	118779	*/
118702		- codeTableLocks(pParse);
	118780	+ if( pParse->nTableLock ) codeTableLocks(pParse);
	118781	+#endif
118703	118782
118704	118783	/* Initialize any AUTOINCREMENT data structures required.
118705	118784	*/
118706		- sqlite3AutoincrementBegin(pParse);
	118785	+ if( pParse->pAinc ) sqlite3AutoincrementBegin(pParse);
118707	118786
118708	118787	/* Code constant expressions that where factored out of inner loops.
118709	118788	**
118710	118789	** The pConstExpr list might also contain expressions that we simply
118711	118790	** want to keep around until the Parse object is deleted. Such
		@@ -124730,11 +124809,11 @@
124730	124809	SQLITE_PRIVATE Table sqlite3SrcListLookup(Parse pParse, SrcList *pSrc){
124731	124810	SrcItem *pItem = pSrc->a;
124732	124811	Table *pTab;
124733	124812	assert( pItem && pSrc->nSrc>=1 );
124734	124813	pTab = sqlite3LocateTableItem(pParse, 0, pItem);
124735		- sqlite3DeleteTable(pParse->db, pItem->pTab);
	124814	+ if( pItem->pTab ) sqlite3DeleteTable(pParse->db, pItem->pTab);
124736	124815	pItem->pTab = pTab;
124737	124816	pItem->fg.notCte = 1;
124738	124817	if( pTab ){
124739	124818	pTab->nTabRef++;
124740	124819	if( pItem->fg.isIndexedBy && sqlite3IndexedByLookup(pParse, pItem) ){
		@@ -125559,13 +125638,15 @@
125559	125638	** handle rows (possibly in other tables) that refer via a foreign key
125560	125639	** to the row just deleted. */
125561	125640	sqlite3FkActions(pParse, pTab, 0, iOld, 0, 0);
125562	125641
125563	125642	/* Invoke AFTER DELETE trigger programs. */
125564		- sqlite3CodeRowTrigger(pParse, pTrigger,
125565		- TK_DELETE, 0, TRIGGER_AFTER, pTab, iOld, onconf, iLabel
125566		- );
	125643	+ if( pTrigger ){
	125644	+ sqlite3CodeRowTrigger(pParse, pTrigger,
	125645	+ TK_DELETE, 0, TRIGGER_AFTER, pTab, iOld, onconf, iLabel
	125646	+ );
	125647	+ }
125567	125648
125568	125649	/* Jump here if the row had already been deleted before any BEFORE
125569	125650	** trigger programs were invoked. Or if a trigger program throws a
125570	125651	** RAISE(IGNORE) exception. */
125571	125652	sqlite3VdbeResolveLabel(v, iLabel);
		@@ -125866,10 +125947,46 @@
125866	125947	while( (*z & 0xc0)==0x80 ){ z++; z0++; }
125867	125948	}
125868	125949	}
125869	125950	sqlite3_result_int(context, (int)(z-z0));
125870	125951	break;
	125952	+ }
	125953	+ default: {
	125954	+ sqlite3_result_null(context);
	125955	+ break;
	125956	+ }
	125957	+ }
	125958	+}
	125959	+
	125960	+/*
	125961	+** Implementation of the octet_length() function
	125962	+*/
	125963	+static void bytelengthFunc(
	125964	+ sqlite3_context *context,
	125965	+ int argc,
	125966	+ sqlite3_value **argv
	125967	+){
	125968	+ assert( argc==1 );
	125969	+ UNUSED_PARAMETER(argc);
	125970	+ switch( sqlite3_value_type(argv[0]) ){
	125971	+ case SQLITE_BLOB: {
	125972	+ sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));
	125973	+ break;
	125974	+ }
	125975	+ case SQLITE_INTEGER:
	125976	+ case SQLITE_FLOAT: {
	125977	+ i64 m = sqlite3_context_db_handle(context)->enc<=SQLITE_UTF8 ? 1 : 2;
	125978	+ sqlite3_result_int64(context, sqlite3_value_bytes(argv[0])*m);
	125979	+ break;
	125980	+ }
	125981	+ case SQLITE_TEXT: {
	125982	+ if( sqlite3_value_encoding(argv[0])<=SQLITE_UTF8 ){
	125983	+ sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));
	125984	+ }else{
	125985	+ sqlite3_result_int(context, sqlite3_value_bytes16(argv[0]));
	125986	+ }
	125987	+ break;
125871	125988	}
125872	125989	default: {
125873	125990	sqlite3_result_null(context);
125874	125991	break;
125875	125992	}
		@@ -128101,10 +128218,11 @@
128101	128218	WAGGREGATE(max, 1, 1, 1, minmaxStep, minMaxFinalize, minMaxValue, 0,
128102	128219	SQLITE_FUNC_MINMAX\|SQLITE_FUNC_ANYORDER ),
128103	128220	FUNCTION2(typeof, 1, 0, 0, typeofFunc, SQLITE_FUNC_TYPEOF),
128104	128221	FUNCTION2(subtype, 1, 0, 0, subtypeFunc, SQLITE_FUNC_TYPEOF),
128105	128222	FUNCTION2(length, 1, 0, 0, lengthFunc, SQLITE_FUNC_LENGTH),
	128223	+ FUNCTION2(octet_length, 1, 0, 0, bytelengthFunc,SQLITE_FUNC_BYTELEN),
128106	128224	FUNCTION(instr, 2, 0, 0, instrFunc ),
128107	128225	FUNCTION(printf, -1, 0, 0, printfFunc ),
128108	128226	FUNCTION(format, -1, 0, 0, printfFunc ),
128109	128227	FUNCTION(unicode, 1, 0, 0, unicodeFunc ),
128110	128228	FUNCTION(char, -1, 0, 0, charFunc ),
		@@ -129741,12 +129859,14 @@
129741	129859	Vdbe *v;
129742	129860	assert( !IsVirtual(pTab) );
129743	129861	assert( pParse->pVdbe!=0 );
129744	129862	v = pParse->pVdbe;
129745	129863	assert( opcode==OP_OpenWrite \|\| opcode==OP_OpenRead );
129746		- sqlite3TableLock(pParse, iDb, pTab->tnum,
129747		- (opcode==OP_OpenWrite)?1:0, pTab->zName);
	129864	+ if( !pParse->db->noSharedCache ){
	129865	+ sqlite3TableLock(pParse, iDb, pTab->tnum,
	129866	+ (opcode==OP_OpenWrite)?1:0, pTab->zName);
	129867	+ }
129748	129868	if( HasRowid(pTab) ){
129749	129869	sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nNVCol);
129750	129870	VdbeComment((v, "%s", pTab->zName));
129751	129871	}else{
129752	129872	Index *pPk = sqlite3PrimaryKeyIndex(pTab);
		@@ -132381,11 +132501,11 @@
132381	132501	if( iBase<0 ) iBase = pParse->nTab;
132382	132502	iDataCur = iBase++;
132383	132503	*piDataCur = iDataCur;
132384	132504	if( HasRowid(pTab) && (aToOpen==0 \|\| aToOpen[0]) ){
132385	132505	sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op);
132386		- }else{
	132506	+ }else if( pParse->db->noSharedCache==0 ){
132387	132507	sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
132388	132508	}
132389	132509	*piIdxCur = iBase;
132390	132510	for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
132391	132511	int iIdxCur = iBase++;
		@@ -150482,12 +150602,14 @@
150482	150602	*/
150483	150603	if( regRowCount ){
150484	150604	sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
150485	150605	}
150486	150606
150487		- sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
150488		- TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue);
	150607	+ if( pTrigger ){
	150608	+ sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
	150609	+ TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue);
	150610	+ }
150489	150611
150490	150612	/* Repeat the above with the next record to be updated, until
150491	150613	** all record selected by the WHERE clause have been updated.
150492	150614	*/
150493	150615	if( eOnePass==ONEPASS_SINGLE ){
		@@ -173943,184 +174065,183 @@
173943	174065	** parser symbol code for that keyword into *pType. Always
173944	174066	** return the integer n (the length of the token). */
173945	174067	static int keywordCode(const char z, int n, int pType){
173946	174068	int i, j;
173947	174069	const char *zKW;
173948		- if( n>=2 ){
173949		- i = ((charMap(z[0])4) ^ (charMap(z[n-1])3) ^ n*1) % 127;
173950		- for(i=(int)aKWHash[i]; i>0; i=aKWNext[i]){
173951		- if( aKWLen[i]!=n ) continue;
173952		- zKW = &zKWText[aKWOffset[i]];
	174070	+ assert( n>=2 );
	174071	+ i = ((charMap(z[0])4) ^ (charMap(z[n-1])3) ^ n*1) % 127;
	174072	+ for(i=(int)aKWHash[i]; i>0; i=aKWNext[i]){
	174073	+ if( aKWLen[i]!=n ) continue;
	174074	+ zKW = &zKWText[aKWOffset[i]];
173953	174075	#ifdef SQLITE_ASCII
173954		- if( (z[0]&~0x20)!=zKW[0] ) continue;
173955		- if( (z[1]&~0x20)!=zKW[1] ) continue;
173956		- j = 2;
173957		- while( j<n && (z[j]&~0x20)==zKW[j] ){ j++; }
	174076	+ if( (z[0]&~0x20)!=zKW[0] ) continue;
	174077	+ if( (z[1]&~0x20)!=zKW[1] ) continue;
	174078	+ j = 2;
	174079	+ while( j<n && (z[j]&~0x20)==zKW[j] ){ j++; }
173958	174080	#endif
173959	174081	#ifdef SQLITE_EBCDIC
173960		- if( toupper(z[0])!=zKW[0] ) continue;
173961		- if( toupper(z[1])!=zKW[1] ) continue;
173962		- j = 2;
173963		- while( j<n && toupper(z[j])==zKW[j] ){ j++; }
173964		-#endif
173965		- if( j<n ) continue;
173966		- testcase( i==1 ); /* REINDEX */
173967		- testcase( i==2 ); /* INDEXED */
173968		- testcase( i==3 ); /* INDEX */
173969		- testcase( i==4 ); /* DESC */
173970		- testcase( i==5 ); /* ESCAPE */
173971		- testcase( i==6 ); /* EACH */
173972		- testcase( i==7 ); /* CHECK */
173973		- testcase( i==8 ); /* KEY */
173974		- testcase( i==9 ); /* BEFORE */
173975		- testcase( i==10 ); /* FOREIGN */
173976		- testcase( i==11 ); /* FOR */
173977		- testcase( i==12 ); /* IGNORE */
173978		- testcase( i==13 ); /* REGEXP */
173979		- testcase( i==14 ); /* EXPLAIN */
173980		- testcase( i==15 ); /* INSTEAD */
173981		- testcase( i==16 ); /* ADD */
173982		- testcase( i==17 ); /* DATABASE */
173983		- testcase( i==18 ); /* AS */
173984		- testcase( i==19 ); /* SELECT */
173985		- testcase( i==20 ); /* TABLE */
173986		- testcase( i==21 ); /* LEFT */
173987		- testcase( i==22 ); /* THEN */
173988		- testcase( i==23 ); /* END */
173989		- testcase( i==24 ); /* DEFERRABLE */
173990		- testcase( i==25 ); /* ELSE */
173991		- testcase( i==26 ); /* EXCLUDE */
173992		- testcase( i==27 ); /* DELETE */
173993		- testcase( i==28 ); /* TEMPORARY */
173994		- testcase( i==29 ); /* TEMP */
173995		- testcase( i==30 ); /* OR */
173996		- testcase( i==31 ); /* ISNULL */
173997		- testcase( i==32 ); /* NULLS */
173998		- testcase( i==33 ); /* SAVEPOINT */
173999		- testcase( i==34 ); /* INTERSECT */
174000		- testcase( i==35 ); /* TIES */
174001		- testcase( i==36 ); /* NOTNULL */
174002		- testcase( i==37 ); /* NOT */
174003		- testcase( i==38 ); /* NO */
174004		- testcase( i==39 ); /* NULL */
174005		- testcase( i==40 ); /* LIKE */
174006		- testcase( i==41 ); /* EXCEPT */
174007		- testcase( i==42 ); /* TRANSACTION */
174008		- testcase( i==43 ); /* ACTION */
174009		- testcase( i==44 ); /* ON */
174010		- testcase( i==45 ); /* NATURAL */
174011		- testcase( i==46 ); /* ALTER */
174012		- testcase( i==47 ); /* RAISE */
174013		- testcase( i==48 ); /* EXCLUSIVE */
174014		- testcase( i==49 ); /* EXISTS */
174015		- testcase( i==50 ); /* CONSTRAINT */
174016		- testcase( i==51 ); /* INTO */
174017		- testcase( i==52 ); /* OFFSET */
174018		- testcase( i==53 ); /* OF */
174019		- testcase( i==54 ); /* SET */
174020		- testcase( i==55 ); /* TRIGGER */
174021		- testcase( i==56 ); /* RANGE */
174022		- testcase( i==57 ); /* GENERATED */
174023		- testcase( i==58 ); /* DETACH */
174024		- testcase( i==59 ); /* HAVING */
174025		- testcase( i==60 ); /* GLOB */
174026		- testcase( i==61 ); /* BEGIN */
174027		- testcase( i==62 ); /* INNER */
174028		- testcase( i==63 ); /* REFERENCES */
174029		- testcase( i==64 ); /* UNIQUE */
174030		- testcase( i==65 ); /* QUERY */
174031		- testcase( i==66 ); /* WITHOUT */
174032		- testcase( i==67 ); /* WITH */
174033		- testcase( i==68 ); /* OUTER */
174034		- testcase( i==69 ); /* RELEASE */
174035		- testcase( i==70 ); /* ATTACH */
174036		- testcase( i==71 ); /* BETWEEN */
174037		- testcase( i==72 ); /* NOTHING */
174038		- testcase( i==73 ); /* GROUPS */
174039		- testcase( i==74 ); /* GROUP */
174040		- testcase( i==75 ); /* CASCADE */
174041		- testcase( i==76 ); /* ASC */
174042		- testcase( i==77 ); /* DEFAULT */
174043		- testcase( i==78 ); /* CASE */
174044		- testcase( i==79 ); /* COLLATE */
174045		- testcase( i==80 ); /* CREATE */
174046		- testcase( i==81 ); /* CURRENT_DATE */
174047		- testcase( i==82 ); /* IMMEDIATE */
174048		- testcase( i==83 ); /* JOIN */
174049		- testcase( i==84 ); /* INSERT */
174050		- testcase( i==85 ); /* MATCH */
174051		- testcase( i==86 ); /* PLAN */
174052		- testcase( i==87 ); /* ANALYZE */
174053		- testcase( i==88 ); /* PRAGMA */
174054		- testcase( i==89 ); /* MATERIALIZED */
174055		- testcase( i==90 ); /* DEFERRED */
174056		- testcase( i==91 ); /* DISTINCT */
174057		- testcase( i==92 ); /* IS */
174058		- testcase( i==93 ); /* UPDATE */
174059		- testcase( i==94 ); /* VALUES */
174060		- testcase( i==95 ); /* VIRTUAL */
174061		- testcase( i==96 ); /* ALWAYS */
174062		- testcase( i==97 ); /* WHEN */
174063		- testcase( i==98 ); /* WHERE */
174064		- testcase( i==99 ); /* RECURSIVE */
174065		- testcase( i==100 ); /* ABORT */
174066		- testcase( i==101 ); /* AFTER */
174067		- testcase( i==102 ); /* RENAME */
174068		- testcase( i==103 ); /* AND */
174069		- testcase( i==104 ); /* DROP */
174070		- testcase( i==105 ); /* PARTITION */
174071		- testcase( i==106 ); /* AUTOINCREMENT */
174072		- testcase( i==107 ); /* TO */
174073		- testcase( i==108 ); /* IN */
174074		- testcase( i==109 ); /* CAST */
174075		- testcase( i==110 ); /* COLUMN */
174076		- testcase( i==111 ); /* COMMIT */
174077		- testcase( i==112 ); /* CONFLICT */
174078		- testcase( i==113 ); /* CROSS */
174079		- testcase( i==114 ); /* CURRENT_TIMESTAMP */
174080		- testcase( i==115 ); /* CURRENT_TIME */
174081		- testcase( i==116 ); /* CURRENT */
174082		- testcase( i==117 ); /* PRECEDING */
174083		- testcase( i==118 ); /* FAIL */
174084		- testcase( i==119 ); /* LAST */
174085		- testcase( i==120 ); /* FILTER */
174086		- testcase( i==121 ); /* REPLACE */
174087		- testcase( i==122 ); /* FIRST */
174088		- testcase( i==123 ); /* FOLLOWING */
174089		- testcase( i==124 ); /* FROM */
174090		- testcase( i==125 ); /* FULL */
174091		- testcase( i==126 ); /* LIMIT */
174092		- testcase( i==127 ); /* IF */
174093		- testcase( i==128 ); /* ORDER */
174094		- testcase( i==129 ); /* RESTRICT */
174095		- testcase( i==130 ); /* OTHERS */
174096		- testcase( i==131 ); /* OVER */
174097		- testcase( i==132 ); /* RETURNING */
174098		- testcase( i==133 ); /* RIGHT */
174099		- testcase( i==134 ); /* ROLLBACK */
174100		- testcase( i==135 ); /* ROWS */
174101		- testcase( i==136 ); /* ROW */
174102		- testcase( i==137 ); /* UNBOUNDED */
174103		- testcase( i==138 ); /* UNION */
174104		- testcase( i==139 ); /* USING */
174105		- testcase( i==140 ); /* VACUUM */
174106		- testcase( i==141 ); /* VIEW */
174107		- testcase( i==142 ); /* WINDOW */
174108		- testcase( i==143 ); /* DO */
174109		- testcase( i==144 ); /* BY */
174110		- testcase( i==145 ); /* INITIALLY */
174111		- testcase( i==146 ); /* ALL */
174112		- testcase( i==147 ); /* PRIMARY */
174113		- *pType = aKWCode[i];
174114		- break;
174115		- }
	174082	+ if( toupper(z[0])!=zKW[0] ) continue;
	174083	+ if( toupper(z[1])!=zKW[1] ) continue;
	174084	+ j = 2;
	174085	+ while( j<n && toupper(z[j])==zKW[j] ){ j++; }
	174086	+#endif
	174087	+ if( j<n ) continue;
	174088	+ testcase( i==1 ); /* REINDEX */
	174089	+ testcase( i==2 ); /* INDEXED */
	174090	+ testcase( i==3 ); /* INDEX */
	174091	+ testcase( i==4 ); /* DESC */
	174092	+ testcase( i==5 ); /* ESCAPE */
	174093	+ testcase( i==6 ); /* EACH */
	174094	+ testcase( i==7 ); /* CHECK */
	174095	+ testcase( i==8 ); /* KEY */
	174096	+ testcase( i==9 ); /* BEFORE */
	174097	+ testcase( i==10 ); /* FOREIGN */
	174098	+ testcase( i==11 ); /* FOR */
	174099	+ testcase( i==12 ); /* IGNORE */
	174100	+ testcase( i==13 ); /* REGEXP */
	174101	+ testcase( i==14 ); /* EXPLAIN */
	174102	+ testcase( i==15 ); /* INSTEAD */
	174103	+ testcase( i==16 ); /* ADD */
	174104	+ testcase( i==17 ); /* DATABASE */
	174105	+ testcase( i==18 ); /* AS */
	174106	+ testcase( i==19 ); /* SELECT */
	174107	+ testcase( i==20 ); /* TABLE */
	174108	+ testcase( i==21 ); /* LEFT */
	174109	+ testcase( i==22 ); /* THEN */
	174110	+ testcase( i==23 ); /* END */
	174111	+ testcase( i==24 ); /* DEFERRABLE */
	174112	+ testcase( i==25 ); /* ELSE */
	174113	+ testcase( i==26 ); /* EXCLUDE */
	174114	+ testcase( i==27 ); /* DELETE */
	174115	+ testcase( i==28 ); /* TEMPORARY */
	174116	+ testcase( i==29 ); /* TEMP */
	174117	+ testcase( i==30 ); /* OR */
	174118	+ testcase( i==31 ); /* ISNULL */
	174119	+ testcase( i==32 ); /* NULLS */
	174120	+ testcase( i==33 ); /* SAVEPOINT */
	174121	+ testcase( i==34 ); /* INTERSECT */
	174122	+ testcase( i==35 ); /* TIES */
	174123	+ testcase( i==36 ); /* NOTNULL */
	174124	+ testcase( i==37 ); /* NOT */
	174125	+ testcase( i==38 ); /* NO */
	174126	+ testcase( i==39 ); /* NULL */
	174127	+ testcase( i==40 ); /* LIKE */
	174128	+ testcase( i==41 ); /* EXCEPT */
	174129	+ testcase( i==42 ); /* TRANSACTION */
	174130	+ testcase( i==43 ); /* ACTION */
	174131	+ testcase( i==44 ); /* ON */
	174132	+ testcase( i==45 ); /* NATURAL */
	174133	+ testcase( i==46 ); /* ALTER */
	174134	+ testcase( i==47 ); /* RAISE */
	174135	+ testcase( i==48 ); /* EXCLUSIVE */
	174136	+ testcase( i==49 ); /* EXISTS */
	174137	+ testcase( i==50 ); /* CONSTRAINT */
	174138	+ testcase( i==51 ); /* INTO */
	174139	+ testcase( i==52 ); /* OFFSET */
	174140	+ testcase( i==53 ); /* OF */
	174141	+ testcase( i==54 ); /* SET */
	174142	+ testcase( i==55 ); /* TRIGGER */
	174143	+ testcase( i==56 ); /* RANGE */
	174144	+ testcase( i==57 ); /* GENERATED */
	174145	+ testcase( i==58 ); /* DETACH */
	174146	+ testcase( i==59 ); /* HAVING */
	174147	+ testcase( i==60 ); /* GLOB */
	174148	+ testcase( i==61 ); /* BEGIN */
	174149	+ testcase( i==62 ); /* INNER */
	174150	+ testcase( i==63 ); /* REFERENCES */
	174151	+ testcase( i==64 ); /* UNIQUE */
	174152	+ testcase( i==65 ); /* QUERY */
	174153	+ testcase( i==66 ); /* WITHOUT */
	174154	+ testcase( i==67 ); /* WITH */
	174155	+ testcase( i==68 ); /* OUTER */
	174156	+ testcase( i==69 ); /* RELEASE */
	174157	+ testcase( i==70 ); /* ATTACH */
	174158	+ testcase( i==71 ); /* BETWEEN */
	174159	+ testcase( i==72 ); /* NOTHING */
	174160	+ testcase( i==73 ); /* GROUPS */
	174161	+ testcase( i==74 ); /* GROUP */
	174162	+ testcase( i==75 ); /* CASCADE */
	174163	+ testcase( i==76 ); /* ASC */
	174164	+ testcase( i==77 ); /* DEFAULT */
	174165	+ testcase( i==78 ); /* CASE */
	174166	+ testcase( i==79 ); /* COLLATE */
	174167	+ testcase( i==80 ); /* CREATE */
	174168	+ testcase( i==81 ); /* CURRENT_DATE */
	174169	+ testcase( i==82 ); /* IMMEDIATE */
	174170	+ testcase( i==83 ); /* JOIN */
	174171	+ testcase( i==84 ); /* INSERT */
	174172	+ testcase( i==85 ); /* MATCH */
	174173	+ testcase( i==86 ); /* PLAN */
	174174	+ testcase( i==87 ); /* ANALYZE */
	174175	+ testcase( i==88 ); /* PRAGMA */
	174176	+ testcase( i==89 ); /* MATERIALIZED */
	174177	+ testcase( i==90 ); /* DEFERRED */
	174178	+ testcase( i==91 ); /* DISTINCT */
	174179	+ testcase( i==92 ); /* IS */
	174180	+ testcase( i==93 ); /* UPDATE */
	174181	+ testcase( i==94 ); /* VALUES */
	174182	+ testcase( i==95 ); /* VIRTUAL */
	174183	+ testcase( i==96 ); /* ALWAYS */
	174184	+ testcase( i==97 ); /* WHEN */
	174185	+ testcase( i==98 ); /* WHERE */
	174186	+ testcase( i==99 ); /* RECURSIVE */
	174187	+ testcase( i==100 ); /* ABORT */
	174188	+ testcase( i==101 ); /* AFTER */
	174189	+ testcase( i==102 ); /* RENAME */
	174190	+ testcase( i==103 ); /* AND */
	174191	+ testcase( i==104 ); /* DROP */
	174192	+ testcase( i==105 ); /* PARTITION */
	174193	+ testcase( i==106 ); /* AUTOINCREMENT */
	174194	+ testcase( i==107 ); /* TO */
	174195	+ testcase( i==108 ); /* IN */
	174196	+ testcase( i==109 ); /* CAST */
	174197	+ testcase( i==110 ); /* COLUMN */
	174198	+ testcase( i==111 ); /* COMMIT */
	174199	+ testcase( i==112 ); /* CONFLICT */
	174200	+ testcase( i==113 ); /* CROSS */
	174201	+ testcase( i==114 ); /* CURRENT_TIMESTAMP */
	174202	+ testcase( i==115 ); /* CURRENT_TIME */
	174203	+ testcase( i==116 ); /* CURRENT */
	174204	+ testcase( i==117 ); /* PRECEDING */
	174205	+ testcase( i==118 ); /* FAIL */
	174206	+ testcase( i==119 ); /* LAST */
	174207	+ testcase( i==120 ); /* FILTER */
	174208	+ testcase( i==121 ); /* REPLACE */
	174209	+ testcase( i==122 ); /* FIRST */
	174210	+ testcase( i==123 ); /* FOLLOWING */
	174211	+ testcase( i==124 ); /* FROM */
	174212	+ testcase( i==125 ); /* FULL */
	174213	+ testcase( i==126 ); /* LIMIT */
	174214	+ testcase( i==127 ); /* IF */
	174215	+ testcase( i==128 ); /* ORDER */
	174216	+ testcase( i==129 ); /* RESTRICT */
	174217	+ testcase( i==130 ); /* OTHERS */
	174218	+ testcase( i==131 ); /* OVER */
	174219	+ testcase( i==132 ); /* RETURNING */
	174220	+ testcase( i==133 ); /* RIGHT */
	174221	+ testcase( i==134 ); /* ROLLBACK */
	174222	+ testcase( i==135 ); /* ROWS */
	174223	+ testcase( i==136 ); /* ROW */
	174224	+ testcase( i==137 ); /* UNBOUNDED */
	174225	+ testcase( i==138 ); /* UNION */
	174226	+ testcase( i==139 ); /* USING */
	174227	+ testcase( i==140 ); /* VACUUM */
	174228	+ testcase( i==141 ); /* VIEW */
	174229	+ testcase( i==142 ); /* WINDOW */
	174230	+ testcase( i==143 ); /* DO */
	174231	+ testcase( i==144 ); /* BY */
	174232	+ testcase( i==145 ); /* INITIALLY */
	174233	+ testcase( i==146 ); /* ALL */
	174234	+ testcase( i==147 ); /* PRIMARY */
	174235	+ *pType = aKWCode[i];
	174236	+ break;
174116	174237	}
174117	174238	return n;
174118	174239	}
174119	174240	SQLITE_PRIVATE int sqlite3KeywordCode(const unsigned char *z, int n){
174120	174241	int id = TK_ID;
174121		- keywordCode((char*)z, n, &id);
	174242	+ if( n>=2 ) keywordCode((char*)z, n, &id);
174122	174243	return id;
174123	174244	}
174124	174245	#define SQLITE_N_KEYWORD 147
174125	174246	SQLITE_API int sqlite3_keyword_name(int i,const char *pzName,int pnName){
174126	174247	if( i<0 \|\| i>=SQLITE_N_KEYWORD ) return SQLITE_ERROR;
		@@ -174493,11 +174614,12 @@
174493	174614	}
174494	174615	if( n==0 ) *tokenType = TK_ILLEGAL;
174495	174616	return i;
174496	174617	}
174497	174618	case CC_KYWD0: {
174498		- for(i=1; aiClass[z[i]]<=CC_KYWD; i++){}
	174619	+ if( aiClass[z[1]]>CC_KYWD ){ i = 1; break; }
	174620	+ for(i=2; aiClass[z[i]]<=CC_KYWD; i++){}
174499	174621	if( IdChar(z[i]) ){
174500	174622	/* This token started out using characters that can appear in keywords,
174501	174623	** but z[i] is a character not allowed within keywords, so this must
174502	174624	** be an identifier instead */
174503	174625	i++;
		@@ -242988,11 +243110,11 @@
242988	243110	int nArg, /* Number of args */
242989	243111	sqlite3_value *apUnused / Function arguments */
242990	243112	){
242991	243113	assert( nArg==0 );
242992	243114	UNUSED_PARAM2(nArg, apUnused);
242993		- sqlite3_result_text(pCtx, "fts5: 2023-06-19 13:09:16 3c94f87806a8b408d8204fc7deec16d01c085ee199ff21a1f20b6346ce816cfe", -1, SQLITE_TRANSIENT);
	243115	+ sqlite3_result_text(pCtx, "fts5: 2023-06-22 13:01:02 d35c214811aac7dec0000ca2aa77231f74a7963dd0c53cf25a65ade5ef0f8dc0", -1, SQLITE_TRANSIENT);
242994	243116	}
242995	243117
242996	243118	/*
242997	243119	** Return true if zName is the extension on one of the shadow tables used
242998	243120	** by this module.
242999	243121

	--- extsrc/sqlite3.c
	+++ extsrc/sqlite3.c
	@@ -16,11 +16,11 @@
16	** if you want a wrapper to interface SQLite with your choice of programming
17	** language. The code for the "sqlite3" command-line shell is also in a
18	** separate file. This file contains only code for the core SQLite library.
19	**
20	** The content in this amalgamation comes from Fossil check-in
21	** c94f87806a8b408d8204fc7deec16d01c08.
22	*/
23	#define SQLITE_CORE 1
24	#define SQLITE_AMALGAMATION 1
25	#ifndef SQLITE_PRIVATE
26	# define SQLITE_PRIVATE static
	@@ -459,11 +459,11 @@
459	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
460	** [sqlite_version()] and [sqlite_source_id()].
461	*/
462	#define SQLITE_VERSION "3.43.0"
463	#define SQLITE_VERSION_NUMBER 3043000
464	#define SQLITE_SOURCE_ID "2023-06-19 13:09:16 3c94f87806a8b408d8204fc7deec16d01c085ee199ff21a1f20b6346ce816cfe"
465
466	/*
467	** CAPI3REF: Run-Time Library Version Numbers
468	** KEYWORDS: sqlite3_version sqlite3_sourceid
469	**
	@@ -17548,10 +17548,11 @@
17548	** Value constraints (enforced via assert()):
17549	** SQLITE_FUNC_MINMAX == NC_MinMaxAgg == SF_MinMaxAgg
17550	** SQLITE_FUNC_ANYORDER == NC_OrderAgg == SF_OrderByReqd
17551	** SQLITE_FUNC_LENGTH == OPFLAG_LENGTHARG
17552	** SQLITE_FUNC_TYPEOF == OPFLAG_TYPEOFARG

17553	** SQLITE_FUNC_CONSTANT == SQLITE_DETERMINISTIC from the API
17554	** SQLITE_FUNC_DIRECT == SQLITE_DIRECTONLY from the API
17555	** SQLITE_FUNC_UNSAFE == SQLITE_INNOCUOUS -- opposite meanings!!!
17556	** SQLITE_FUNC_ENCMASK depends on SQLITE_UTF* macros in the API
17557	**
	@@ -17566,10 +17567,11 @@
17566	#define SQLITE_FUNC_CASE 0x0008 /* Case-sensitive LIKE-type function */
17567	#define SQLITE_FUNC_EPHEM 0x0010 /* Ephemeral. Delete with VDBE */
17568	#define SQLITE_FUNC_NEEDCOLL 0x0020 /* sqlite3GetFuncCollSeq() might be called*/
17569	#define SQLITE_FUNC_LENGTH 0x0040 /* Built-in length() function */
17570	#define SQLITE_FUNC_TYPEOF 0x0080 /* Built-in typeof() function */

17571	#define SQLITE_FUNC_COUNT 0x0100 /* Built-in count() aggregate /
17572	/* 0x0200 -- available for reuse */
17573	#define SQLITE_FUNC_UNLIKELY 0x0400 /* Built-in unlikely() function */
17574	#define SQLITE_FUNC_CONSTANT 0x0800 /* Constant inputs give a constant output */
17575	#define SQLITE_FUNC_MINMAX 0x1000 /* True for min() and max() aggregates */
	@@ -19509,10 +19511,11 @@
19509	#define OPFLAG_APPEND 0x08 /* This is likely to be an append */
19510	#define OPFLAG_USESEEKRESULT 0x10 /* Try to avoid a seek in BtreeInsert() */
19511	#define OPFLAG_ISNOOP 0x40 /* OP_Delete does pre-update-hook only */
19512	#define OPFLAG_LENGTHARG 0x40 /* OP_Column only used for length() */
19513	#define OPFLAG_TYPEOFARG 0x80 /* OP_Column only used for typeof() */

19514	#define OPFLAG_BULKCSR 0x01 /* OP_Open** used to open bulk cursor */
19515	#define OPFLAG_SEEKEQ 0x02 /* OP_Open** cursor uses EQ seek only */
19516	#define OPFLAG_FORDELETE 0x08 /* OP_Open should use BTREE_FORDELETE */
19517	#define OPFLAG_P2ISREG 0x10 /* P2 to OP_Open** is a register number */
19518	#define OPFLAG_PERMUTE 0x01 /* OP_Compare: use the permutation */
	@@ -19829,10 +19832,11 @@
19829	const Token pName; / Name of the container - used for error messages */
19830	};
19831
19832	/* Forward declarations */
19833	SQLITE_PRIVATE int sqlite3WalkExpr(Walker, Expr);

19834	SQLITE_PRIVATE int sqlite3WalkExprList(Walker, ExprList);
19835	SQLITE_PRIVATE int sqlite3WalkSelect(Walker, Select);
19836	SQLITE_PRIVATE int sqlite3WalkSelectExpr(Walker, Select);
19837	SQLITE_PRIVATE int sqlite3WalkSelectFrom(Walker, Select);
19838	SQLITE_PRIVATE int sqlite3ExprWalkNoop(Walker, Expr);
	@@ -71221,72 +71225,45 @@
71221	return btreePagecount(p->pBt);
71222	}
71223
71224	/*
71225	** Get a page from the pager and initialize it.
71226	**
71227	** If pCur!=0 then the page is being fetched as part of a moveToChild()
71228	** call. Do additional sanity checking on the page in this case.
71229	** And if the fetch fails, this routine must decrement pCur->iPage.
71230	**
71231	** The page is fetched as read-write unless pCur is not NULL and is
71232	** a read-only cursor.
71233	**
71234	** If an error occurs, then *ppPage is undefined. It
71235	** may remain unchanged, or it may be set to an invalid value.
71236	*/
71237	static int getAndInitPage(
71238	BtShared pBt, / The database file */
71239	Pgno pgno, /* Number of the page to get */
71240	MemPage *ppPage, / Write the page pointer here */
71241	BtCursor pCur, / Cursor to receive the page, or NULL */
71242	int bReadOnly /* True for a read-only page */
71243	){
71244	int rc;
71245	DbPage *pDbPage;

71246	assert( sqlite3_mutex_held(pBt->mutex) );
71247	assert( pCur==0 \|\| ppPage==&pCur->pPage );
71248	assert( pCur==0 \|\| bReadOnly==pCur->curPagerFlags );
71249	assert( pCur==0 \|\| pCur->iPage>0 );
71250
71251	if( pgno>btreePagecount(pBt) ){
71252	rc = SQLITE_CORRUPT_BKPT;
71253	goto getAndInitPage_error1;
71254	}
71255	rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, bReadOnly);
71256	if( rc ){
71257	goto getAndInitPage_error1;

71258	}
71259	ppPage = (MemPage)sqlite3PagerGetExtra(pDbPage);
71260	if( (*ppPage)->isInit==0 ){
71261	btreePageFromDbPage(pDbPage, pgno, pBt);
71262	rc = btreeInitPage(*ppPage);
71263	if( rc!=SQLITE_OK ){
71264	goto getAndInitPage_error2;
71265	}
71266	}
71267	assert( (*ppPage)->pgno==pgno \|\| CORRUPT_DB );
71268	assert( (*ppPage)->aData==sqlite3PagerGetData(pDbPage) );
71269
71270	/* If obtaining a child page for a cursor, we must verify that the page is
71271	** compatible with the root page. */
71272	if( pCur && ((ppPage)->nCell<1 \|\| (ppPage)->intKey!=pCur->curIntKey) ){
71273	rc = SQLITE_CORRUPT_PGNO(pgno);
71274	goto getAndInitPage_error2;
71275	}
71276	return SQLITE_OK;
71277
71278	getAndInitPage_error2:
71279	releasePage(*ppPage);
71280	getAndInitPage_error1:
71281	if( pCur ){
71282	pCur->iPage--;
71283	pCur->pPage = pCur->apPage[pCur->iPage];
71284	}
71285	testcase( pgno==0 );
71286	assert( pgno!=0 \|\| rc!=SQLITE_OK );
71287	return rc;
71288	}
71289
71290	/*
71291	** Release a MemPage. This should be called once for each prior
71292	** call to btreeGetPage.
	@@ -74256,10 +74233,11 @@
74256	** the new child page does not match the flags field of the parent (i.e.
74257	** if an intkey page appears to be the parent of a non-intkey page, or
74258	** vice-versa).
74259	*/
74260	static int moveToChild(BtCursor *pCur, u32 newPgno){

74261	assert( cursorOwnsBtShared(pCur) );
74262	assert( pCur->eState==CURSOR_VALID );
74263	assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
74264	assert( pCur->iPage>=0 );
74265	if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
	@@ -74269,12 +74247,21 @@
74269	pCur->curFlags &= ~(BTCF_ValidNKey\|BTCF_ValidOvfl);
74270	pCur->aiIdx[pCur->iPage] = pCur->ix;
74271	pCur->apPage[pCur->iPage] = pCur->pPage;
74272	pCur->ix = 0;
74273	pCur->iPage++;
74274	return getAndInitPage(pCur->pBt, newPgno, &pCur->pPage, pCur,
74275	pCur->curPagerFlags);









74276	}
74277
74278	#ifdef SQLITE_DEBUG
74279	/*
74280	** Page pParent is an internal (non-leaf) tree page. This function
	@@ -74377,11 +74364,11 @@
74377	return pCur->skipNext;
74378	}
74379	sqlite3BtreeClearCursor(pCur);
74380	}
74381	rc = getAndInitPage(pCur->pBt, pCur->pgnoRoot, &pCur->pPage,
74382	0, pCur->curPagerFlags);
74383	if( rc!=SQLITE_OK ){
74384	pCur->eState = CURSOR_INVALID;
74385	return rc;
74386	}
74387	pCur->iPage = 0;
	@@ -74990,14 +74977,40 @@
74990	if( lwr>=pPage->nCell ){
74991	chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]);
74992	}else{
74993	chldPg = get4byte(findCell(pPage, lwr));
74994	}
74995	pCur->ix = (u16)lwr;
74996	rc = moveToChild(pCur, chldPg);
74997	if( rc ) break;
74998	}


























74999	moveto_index_finish:
75000	pCur->info.nSize = 0;
75001	assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
75002	return rc;
75003	}
	@@ -77047,11 +77060,11 @@
77047	pRight = findCell(pParent, i+nxDiv-pParent->nOverflow);
77048	}
77049	pgno = get4byte(pRight);
77050	while( 1 ){
77051	if( rc==SQLITE_OK ){
77052	rc = getAndInitPage(pBt, pgno, &apOld[i], 0, 0);
77053	}
77054	if( rc ){
77055	memset(apOld, 0, (i+1)sizeof(MemPage));
77056	goto balance_cleanup;
77057	}
	@@ -78932,11 +78945,11 @@
78932
78933	assert( sqlite3_mutex_held(pBt->mutex) );
78934	if( pgno>btreePagecount(pBt) ){
78935	return SQLITE_CORRUPT_BKPT;
78936	}
78937	rc = getAndInitPage(pBt, pgno, &pPage, 0, 0);
78938	if( rc ) return rc;
78939	if( (pBt->openFlags & BTREE_SINGLE)==0
78940	&& sqlite3PagerPageRefcount(pPage->pDbPage) != (1 + (pgno==1))
78941	){
78942	rc = SQLITE_CORRUPT_BKPT;
	@@ -83267,10 +83280,39 @@
83267	(void)pc;
83268	(void)pOp;
83269	n++;
83270	}
83271	#endif





























83272
83273	/*
83274	** Add a new instruction to the list of instructions current in the
83275	** VDBE. Return the address of the new instruction.
83276	**
	@@ -83278,21 +83320,20 @@
83278	**
83279	** p Pointer to the VDBE
83280	**
83281	** op The opcode for this instruction
83282	**
83283	** p1, p2, p3 Operands
83284	**
83285	** Use the sqlite3VdbeResolveLabel() function to fix an address and
83286	** the sqlite3VdbeChangeP4() function to change the value of the P4
83287	** operand.
83288	*/
83289	static SQLITE_NOINLINE int growOp3(Vdbe *p, int op, int p1, int p2, int p3){
83290	assert( p->nOpAlloc<=p->nOp );
83291	if( growOpArray(p, 1) ) return 1;
83292	assert( p->nOpAlloc>p->nOp );
83293	return sqlite3VdbeAddOp3(p, op, p1, p2, p3);



83294	}
83295	SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
83296	int i;
83297	VdbeOp *pOp;
83298
	@@ -83311,10 +83352,62 @@
83311	pOp->p1 = p1;
83312	pOp->p2 = p2;
83313	pOp->p3 = p3;
83314	pOp->p4.p = 0;
83315	pOp->p4type = P4_NOTUSED;




















































83316	#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
83317	pOp->zComment = 0;
83318	#endif
83319	#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) \|\| defined(VDBE_PROFILE)
83320	pOp->nExec = 0;
	@@ -83327,21 +83420,15 @@
83327	}
83328	#endif
83329	#ifdef SQLITE_VDBE_COVERAGE
83330	pOp->iSrcLine = 0;
83331	#endif



83332	return i;
83333	}
83334	SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe *p, int op){
83335	return sqlite3VdbeAddOp3(p, op, 0, 0, 0);
83336	}
83337	SQLITE_PRIVATE int sqlite3VdbeAddOp1(Vdbe *p, int op, int p1){
83338	return sqlite3VdbeAddOp3(p, op, p1, 0, 0);
83339	}
83340	SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe *p, int op, int p1, int p2){
83341	return sqlite3VdbeAddOp3(p, op, p1, p2, 0);
83342	}
83343
83344	/* Generate code for an unconditional jump to instruction iDest
83345	*/
83346	SQLITE_PRIVATE int sqlite3VdbeGoto(Vdbe *p, int iDest){
83347	return sqlite3VdbeAddOp3(p, OP_Goto, 0, iDest, 0);
	@@ -83544,30 +83631,10 @@
83544	sqlite3VdbeChangeP5(p, p5);
83545	for(j=0; j<p->db->nDb; j++) sqlite3VdbeUsesBtree(p, j);
83546	sqlite3MayAbort(p->pParse);
83547	}
83548
83549	/*
83550	** Add an opcode that includes the p4 value as an integer.
83551	*/
83552	SQLITE_PRIVATE int sqlite3VdbeAddOp4Int(
83553	Vdbe p, / Add the opcode to this VM */
83554	int op, /* The new opcode */
83555	int p1, /* The P1 operand */
83556	int p2, /* The P2 operand */
83557	int p3, /* The P3 operand */
83558	int p4 /* The P4 operand as an integer */
83559	){
83560	int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
83561	if( p->db->mallocFailed==0 ){
83562	VdbeOp *pOp = &p->aOp[addr];
83563	pOp->p4type = P4_INT32;
83564	pOp->p4.i = p4;
83565	}
83566	return addr;
83567	}
83568
83569	/* Insert the end of a co-routine
83570	*/
83571	SQLITE_PRIVATE void sqlite3VdbeEndCoroutine(Vdbe *v, int regYield){
83572	sqlite3VdbeAddOp1(v, OP_EndCoroutine, regYield);
83573
	@@ -94029,14 +94096,18 @@
94029	pDest->z[len] = 0;
94030	pDest->z[len+1] = 0;
94031	pDest->flags = aFlag[t&1];
94032	}
94033	}else{

94034	pDest->enc = encoding;
94035	/* This branch happens only when content is on overflow pages */
94036	if( ((pOp->p5 & (OPFLAG_LENGTHARG\|OPFLAG_TYPEOFARG))!=0
94037	&& ((t>=12 && (t&1)==0) \|\| (pOp->p5 & OPFLAG_TYPEOFARG)!=0))



94038	\|\| (len = sqlite3VdbeSerialTypeLen(t))==0
94039	){
94040	/* Content is irrelevant for
94041	** 1. the typeof() function,
94042	** 2. the length(X) function if X is a blob, and
	@@ -104107,20 +104178,22 @@
104107	** return from the top-level walk call.
104108	**
104109	** The return value from this routine is WRC_Abort to abandon the tree walk
104110	** and WRC_Continue to continue.
104111	*/
104112	static SQLITE_NOINLINE int walkExpr(Walker pWalker, Expr pExpr){
104113	int rc;
104114	testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
104115	testcase( ExprHasProperty(pExpr, EP_Reduced) );
104116	while(1){
104117	rc = pWalker->xExprCallback(pWalker, pExpr);
104118	if( rc ) return rc & WRC_Abort;
104119	if( !ExprHasProperty(pExpr,(EP_TokenOnly\|EP_Leaf)) ){
104120	assert( pExpr->x.pList==0 \|\| pExpr->pRight==0 );
104121	if( pExpr->pLeft && walkExpr(pWalker, pExpr->pLeft) ) return WRC_Abort;


104122	if( pExpr->pRight ){
104123	assert( !ExprHasProperty(pExpr, EP_WinFunc) );
104124	pExpr = pExpr->pRight;
104125	continue;
104126	}else if( ExprUseXSelect(pExpr) ){
	@@ -104140,11 +104213,11 @@
104140	break;
104141	}
104142	return WRC_Continue;
104143	}
104144	SQLITE_PRIVATE int sqlite3WalkExpr(Walker pWalker, Expr pExpr){
104145	return pExpr ? walkExpr(pWalker,pExpr) : WRC_Continue;
104146	}
104147
104148	/*
104149	** Call sqlite3WalkExpr() for every expression in list p or until
104150	** an abort request is seen.
	@@ -106323,11 +106396,12 @@
106323	w.pParse->nHeight += pExpr->nHeight;
106324	if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
106325	return SQLITE_ERROR;
106326	}
106327	#endif
106328	sqlite3WalkExpr(&w, pExpr);

106329	#if SQLITE_MAX_EXPR_DEPTH>0
106330	w.pParse->nHeight -= pExpr->nHeight;
106331	#endif
106332	assert( EP_Agg==NC_HasAgg );
106333	assert( EP_Win==NC_HasWin );
	@@ -106365,11 +106439,11 @@
106365	w.pParse->nHeight += pExpr->nHeight;
106366	if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
106367	return WRC_Abort;
106368	}
106369	#endif
106370	sqlite3WalkExpr(&w, pExpr);
106371	#if SQLITE_MAX_EXPR_DEPTH>0
106372	w.pParse->nHeight -= pExpr->nHeight;
106373	#endif
106374	assert( EP_Agg==NC_HasAgg );
106375	assert( EP_Win==NC_HasWin );
	@@ -111138,26 +111212,29 @@
111138	pParse->nMem += nFarg;
111139	}else{
111140	r1 = sqlite3GetTempRange(pParse, nFarg);
111141	}
111142
111143	/* For length() and typeof() functions with a column argument,
111144	** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG
111145	** or OPFLAG_TYPEOFARG respectively, to avoid unnecessary data
111146	** loading.
111147	*/
111148	if( (pDef->funcFlags & (SQLITE_FUNC_LENGTH\|SQLITE_FUNC_TYPEOF))!=0 ){
111149	u8 exprOp;
111150	assert( nFarg==1 );
111151	assert( pFarg->a[0].pExpr!=0 );
111152	exprOp = pFarg->a[0].pExpr->op;
111153	if( exprOp==TK_COLUMN \|\| exprOp==TK_AGG_COLUMN ){
111154	assert( SQLITE_FUNC_LENGTH==OPFLAG_LENGTHARG );
111155	assert( SQLITE_FUNC_TYPEOF==OPFLAG_TYPEOFARG );
111156	testcase( pDef->funcFlags & OPFLAG_LENGTHARG );
111157	pFarg->a[0].pExpr->op2 =
111158	pDef->funcFlags & (OPFLAG_LENGTHARG\|OPFLAG_TYPEOFARG);



111159	}
111160	}
111161
111162	sqlite3ExprCodeExprList(pParse, pFarg, r1, 0,
111163	SQLITE_ECEL_DUP\|SQLITE_ECEL_FACTOR);
	@@ -118693,19 +118770,21 @@
118693	sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB);
118694	}
118695	pParse->nVtabLock = 0;
118696	#endif
118697

118698	/* Once all the cookies have been verified and transactions opened,
118699	** obtain the required table-locks. This is a no-op unless the
118700	** shared-cache feature is enabled.
118701	*/
118702	codeTableLocks(pParse);

118703
118704	/* Initialize any AUTOINCREMENT data structures required.
118705	*/
118706	sqlite3AutoincrementBegin(pParse);
118707
118708	/* Code constant expressions that where factored out of inner loops.
118709	**
118710	** The pConstExpr list might also contain expressions that we simply
118711	** want to keep around until the Parse object is deleted. Such
	@@ -124730,11 +124809,11 @@
124730	SQLITE_PRIVATE Table sqlite3SrcListLookup(Parse pParse, SrcList *pSrc){
124731	SrcItem *pItem = pSrc->a;
124732	Table *pTab;
124733	assert( pItem && pSrc->nSrc>=1 );
124734	pTab = sqlite3LocateTableItem(pParse, 0, pItem);
124735	sqlite3DeleteTable(pParse->db, pItem->pTab);
124736	pItem->pTab = pTab;
124737	pItem->fg.notCte = 1;
124738	if( pTab ){
124739	pTab->nTabRef++;
124740	if( pItem->fg.isIndexedBy && sqlite3IndexedByLookup(pParse, pItem) ){
	@@ -125559,13 +125638,15 @@
125559	** handle rows (possibly in other tables) that refer via a foreign key
125560	** to the row just deleted. */
125561	sqlite3FkActions(pParse, pTab, 0, iOld, 0, 0);
125562
125563	/* Invoke AFTER DELETE trigger programs. */
125564	sqlite3CodeRowTrigger(pParse, pTrigger,
125565	TK_DELETE, 0, TRIGGER_AFTER, pTab, iOld, onconf, iLabel
125566	);


125567
125568	/* Jump here if the row had already been deleted before any BEFORE
125569	** trigger programs were invoked. Or if a trigger program throws a
125570	** RAISE(IGNORE) exception. */
125571	sqlite3VdbeResolveLabel(v, iLabel);
	@@ -125866,10 +125947,46 @@
125866	while( (*z & 0xc0)==0x80 ){ z++; z0++; }
125867	}
125868	}
125869	sqlite3_result_int(context, (int)(z-z0));
125870	break;




































125871	}
125872	default: {
125873	sqlite3_result_null(context);
125874	break;
125875	}
	@@ -128101,10 +128218,11 @@
128101	WAGGREGATE(max, 1, 1, 1, minmaxStep, minMaxFinalize, minMaxValue, 0,
128102	SQLITE_FUNC_MINMAX\|SQLITE_FUNC_ANYORDER ),
128103	FUNCTION2(typeof, 1, 0, 0, typeofFunc, SQLITE_FUNC_TYPEOF),
128104	FUNCTION2(subtype, 1, 0, 0, subtypeFunc, SQLITE_FUNC_TYPEOF),
128105	FUNCTION2(length, 1, 0, 0, lengthFunc, SQLITE_FUNC_LENGTH),

128106	FUNCTION(instr, 2, 0, 0, instrFunc ),
128107	FUNCTION(printf, -1, 0, 0, printfFunc ),
128108	FUNCTION(format, -1, 0, 0, printfFunc ),
128109	FUNCTION(unicode, 1, 0, 0, unicodeFunc ),
128110	FUNCTION(char, -1, 0, 0, charFunc ),
	@@ -129741,12 +129859,14 @@
129741	Vdbe *v;
129742	assert( !IsVirtual(pTab) );
129743	assert( pParse->pVdbe!=0 );
129744	v = pParse->pVdbe;
129745	assert( opcode==OP_OpenWrite \|\| opcode==OP_OpenRead );
129746	sqlite3TableLock(pParse, iDb, pTab->tnum,
129747	(opcode==OP_OpenWrite)?1:0, pTab->zName);


129748	if( HasRowid(pTab) ){
129749	sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nNVCol);
129750	VdbeComment((v, "%s", pTab->zName));
129751	}else{
129752	Index *pPk = sqlite3PrimaryKeyIndex(pTab);
	@@ -132381,11 +132501,11 @@
132381	if( iBase<0 ) iBase = pParse->nTab;
132382	iDataCur = iBase++;
132383	*piDataCur = iDataCur;
132384	if( HasRowid(pTab) && (aToOpen==0 \|\| aToOpen[0]) ){
132385	sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op);
132386	}else{
132387	sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
132388	}
132389	*piIdxCur = iBase;
132390	for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
132391	int iIdxCur = iBase++;
	@@ -150482,12 +150602,14 @@
150482	*/
150483	if( regRowCount ){
150484	sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
150485	}
150486
150487	sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
150488	TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue);


150489
150490	/* Repeat the above with the next record to be updated, until
150491	** all record selected by the WHERE clause have been updated.
150492	*/
150493	if( eOnePass==ONEPASS_SINGLE ){
	@@ -173943,184 +174065,183 @@
173943	** parser symbol code for that keyword into *pType. Always
173944	** return the integer n (the length of the token). */
173945	static int keywordCode(const char z, int n, int pType){
173946	int i, j;
173947	const char *zKW;
173948	if( n>=2 ){
173949	i = ((charMap(z[0])4) ^ (charMap(z[n-1])3) ^ n*1) % 127;
173950	for(i=(int)aKWHash[i]; i>0; i=aKWNext[i]){
173951	if( aKWLen[i]!=n ) continue;
173952	zKW = &zKWText[aKWOffset[i]];
173953	#ifdef SQLITE_ASCII
173954	if( (z[0]&~0x20)!=zKW[0] ) continue;
173955	if( (z[1]&~0x20)!=zKW[1] ) continue;
173956	j = 2;
173957	while( j<n && (z[j]&~0x20)==zKW[j] ){ j++; }
173958	#endif
173959	#ifdef SQLITE_EBCDIC
173960	if( toupper(z[0])!=zKW[0] ) continue;
173961	if( toupper(z[1])!=zKW[1] ) continue;
173962	j = 2;
173963	while( j<n && toupper(z[j])==zKW[j] ){ j++; }
173964	#endif
173965	if( j<n ) continue;
173966	testcase( i==1 ); /* REINDEX */
173967	testcase( i==2 ); /* INDEXED */
173968	testcase( i==3 ); /* INDEX */
173969	testcase( i==4 ); /* DESC */
173970	testcase( i==5 ); /* ESCAPE */
173971	testcase( i==6 ); /* EACH */
173972	testcase( i==7 ); /* CHECK */
173973	testcase( i==8 ); /* KEY */
173974	testcase( i==9 ); /* BEFORE */
173975	testcase( i==10 ); /* FOREIGN */
173976	testcase( i==11 ); /* FOR */
173977	testcase( i==12 ); /* IGNORE */
173978	testcase( i==13 ); /* REGEXP */
173979	testcase( i==14 ); /* EXPLAIN */
173980	testcase( i==15 ); /* INSTEAD */
173981	testcase( i==16 ); /* ADD */
173982	testcase( i==17 ); /* DATABASE */
173983	testcase( i==18 ); /* AS */
173984	testcase( i==19 ); /* SELECT */
173985	testcase( i==20 ); /* TABLE */
173986	testcase( i==21 ); /* LEFT */
173987	testcase( i==22 ); /* THEN */
173988	testcase( i==23 ); /* END */
173989	testcase( i==24 ); /* DEFERRABLE */
173990	testcase( i==25 ); /* ELSE */
173991	testcase( i==26 ); /* EXCLUDE */
173992	testcase( i==27 ); /* DELETE */
173993	testcase( i==28 ); /* TEMPORARY */
173994	testcase( i==29 ); /* TEMP */
173995	testcase( i==30 ); /* OR */
173996	testcase( i==31 ); /* ISNULL */
173997	testcase( i==32 ); /* NULLS */
173998	testcase( i==33 ); /* SAVEPOINT */
173999	testcase( i==34 ); /* INTERSECT */
174000	testcase( i==35 ); /* TIES */
174001	testcase( i==36 ); /* NOTNULL */
174002	testcase( i==37 ); /* NOT */
174003	testcase( i==38 ); /* NO */
174004	testcase( i==39 ); /* NULL */
174005	testcase( i==40 ); /* LIKE */
174006	testcase( i==41 ); /* EXCEPT */
174007	testcase( i==42 ); /* TRANSACTION */
174008	testcase( i==43 ); /* ACTION */
174009	testcase( i==44 ); /* ON */
174010	testcase( i==45 ); /* NATURAL */
174011	testcase( i==46 ); /* ALTER */
174012	testcase( i==47 ); /* RAISE */
174013	testcase( i==48 ); /* EXCLUSIVE */
174014	testcase( i==49 ); /* EXISTS */
174015	testcase( i==50 ); /* CONSTRAINT */
174016	testcase( i==51 ); /* INTO */
174017	testcase( i==52 ); /* OFFSET */
174018	testcase( i==53 ); /* OF */
174019	testcase( i==54 ); /* SET */
174020	testcase( i==55 ); /* TRIGGER */
174021	testcase( i==56 ); /* RANGE */
174022	testcase( i==57 ); /* GENERATED */
174023	testcase( i==58 ); /* DETACH */
174024	testcase( i==59 ); /* HAVING */
174025	testcase( i==60 ); /* GLOB */
174026	testcase( i==61 ); /* BEGIN */
174027	testcase( i==62 ); /* INNER */
174028	testcase( i==63 ); /* REFERENCES */
174029	testcase( i==64 ); /* UNIQUE */
174030	testcase( i==65 ); /* QUERY */
174031	testcase( i==66 ); /* WITHOUT */
174032	testcase( i==67 ); /* WITH */
174033	testcase( i==68 ); /* OUTER */
174034	testcase( i==69 ); /* RELEASE */
174035	testcase( i==70 ); /* ATTACH */
174036	testcase( i==71 ); /* BETWEEN */
174037	testcase( i==72 ); /* NOTHING */
174038	testcase( i==73 ); /* GROUPS */
174039	testcase( i==74 ); /* GROUP */
174040	testcase( i==75 ); /* CASCADE */
174041	testcase( i==76 ); /* ASC */
174042	testcase( i==77 ); /* DEFAULT */
174043	testcase( i==78 ); /* CASE */
174044	testcase( i==79 ); /* COLLATE */
174045	testcase( i==80 ); /* CREATE */
174046	testcase( i==81 ); /* CURRENT_DATE */
174047	testcase( i==82 ); /* IMMEDIATE */
174048	testcase( i==83 ); /* JOIN */
174049	testcase( i==84 ); /* INSERT */
174050	testcase( i==85 ); /* MATCH */
174051	testcase( i==86 ); /* PLAN */
174052	testcase( i==87 ); /* ANALYZE */
174053	testcase( i==88 ); /* PRAGMA */
174054	testcase( i==89 ); /* MATERIALIZED */
174055	testcase( i==90 ); /* DEFERRED */
174056	testcase( i==91 ); /* DISTINCT */
174057	testcase( i==92 ); /* IS */
174058	testcase( i==93 ); /* UPDATE */
174059	testcase( i==94 ); /* VALUES */
174060	testcase( i==95 ); /* VIRTUAL */
174061	testcase( i==96 ); /* ALWAYS */
174062	testcase( i==97 ); /* WHEN */
174063	testcase( i==98 ); /* WHERE */
174064	testcase( i==99 ); /* RECURSIVE */
174065	testcase( i==100 ); /* ABORT */
174066	testcase( i==101 ); /* AFTER */
174067	testcase( i==102 ); /* RENAME */
174068	testcase( i==103 ); /* AND */
174069	testcase( i==104 ); /* DROP */
174070	testcase( i==105 ); /* PARTITION */
174071	testcase( i==106 ); /* AUTOINCREMENT */
174072	testcase( i==107 ); /* TO */
174073	testcase( i==108 ); /* IN */
174074	testcase( i==109 ); /* CAST */
174075	testcase( i==110 ); /* COLUMN */
174076	testcase( i==111 ); /* COMMIT */
174077	testcase( i==112 ); /* CONFLICT */
174078	testcase( i==113 ); /* CROSS */
174079	testcase( i==114 ); /* CURRENT_TIMESTAMP */
174080	testcase( i==115 ); /* CURRENT_TIME */
174081	testcase( i==116 ); /* CURRENT */
174082	testcase( i==117 ); /* PRECEDING */
174083	testcase( i==118 ); /* FAIL */
174084	testcase( i==119 ); /* LAST */
174085	testcase( i==120 ); /* FILTER */
174086	testcase( i==121 ); /* REPLACE */
174087	testcase( i==122 ); /* FIRST */
174088	testcase( i==123 ); /* FOLLOWING */
174089	testcase( i==124 ); /* FROM */
174090	testcase( i==125 ); /* FULL */
174091	testcase( i==126 ); /* LIMIT */
174092	testcase( i==127 ); /* IF */
174093	testcase( i==128 ); /* ORDER */
174094	testcase( i==129 ); /* RESTRICT */
174095	testcase( i==130 ); /* OTHERS */
174096	testcase( i==131 ); /* OVER */
174097	testcase( i==132 ); /* RETURNING */
174098	testcase( i==133 ); /* RIGHT */
174099	testcase( i==134 ); /* ROLLBACK */
174100	testcase( i==135 ); /* ROWS */
174101	testcase( i==136 ); /* ROW */
174102	testcase( i==137 ); /* UNBOUNDED */
174103	testcase( i==138 ); /* UNION */
174104	testcase( i==139 ); /* USING */
174105	testcase( i==140 ); /* VACUUM */
174106	testcase( i==141 ); /* VIEW */
174107	testcase( i==142 ); /* WINDOW */
174108	testcase( i==143 ); /* DO */
174109	testcase( i==144 ); /* BY */
174110	testcase( i==145 ); /* INITIALLY */
174111	testcase( i==146 ); /* ALL */
174112	testcase( i==147 ); /* PRIMARY */
174113	*pType = aKWCode[i];
174114	break;
174115	}
174116	}
174117	return n;
174118	}
174119	SQLITE_PRIVATE int sqlite3KeywordCode(const unsigned char *z, int n){
174120	int id = TK_ID;
174121	keywordCode((char*)z, n, &id);
174122	return id;
174123	}
174124	#define SQLITE_N_KEYWORD 147
174125	SQLITE_API int sqlite3_keyword_name(int i,const char *pzName,int pnName){
174126	if( i<0 \|\| i>=SQLITE_N_KEYWORD ) return SQLITE_ERROR;
	@@ -174493,11 +174614,12 @@
174493	}
174494	if( n==0 ) *tokenType = TK_ILLEGAL;
174495	return i;
174496	}
174497	case CC_KYWD0: {
174498	for(i=1; aiClass[z[i]]<=CC_KYWD; i++){}

174499	if( IdChar(z[i]) ){
174500	/* This token started out using characters that can appear in keywords,
174501	** but z[i] is a character not allowed within keywords, so this must
174502	** be an identifier instead */
174503	i++;
	@@ -242988,11 +243110,11 @@
242988	int nArg, /* Number of args */
242989	sqlite3_value *apUnused / Function arguments */
242990	){
242991	assert( nArg==0 );
242992	UNUSED_PARAM2(nArg, apUnused);
242993	sqlite3_result_text(pCtx, "fts5: 2023-06-19 13:09:16 3c94f87806a8b408d8204fc7deec16d01c085ee199ff21a1f20b6346ce816cfe", -1, SQLITE_TRANSIENT);
242994	}
242995
242996	/*
242997	** Return true if zName is the extension on one of the shadow tables used
242998	** by this module.
242999

	--- extsrc/sqlite3.c
	+++ extsrc/sqlite3.c
	@@ -16,11 +16,11 @@
16	** if you want a wrapper to interface SQLite with your choice of programming
17	** language. The code for the "sqlite3" command-line shell is also in a
18	** separate file. This file contains only code for the core SQLite library.
19	**
20	** The content in this amalgamation comes from Fossil check-in
21	** a5f77862c0fe0189aa4246a1e55bb7c537c.
22	*/
23	#define SQLITE_CORE 1
24	#define SQLITE_AMALGAMATION 1
25	#ifndef SQLITE_PRIVATE
26	# define SQLITE_PRIVATE static
	@@ -459,11 +459,11 @@
459	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
460	** [sqlite_version()] and [sqlite_source_id()].
461	*/
462	#define SQLITE_VERSION "3.43.0"
463	#define SQLITE_VERSION_NUMBER 3043000
464	#define SQLITE_SOURCE_ID "2023-06-23 11:10:13 fa5f77862c0fe0189aa4246a1e55bb7c537c28c436ec10b75f5fa141e5e4aff0"
465
466	/*
467	** CAPI3REF: Run-Time Library Version Numbers
468	** KEYWORDS: sqlite3_version sqlite3_sourceid
469	**
	@@ -17548,10 +17548,11 @@
17548	** Value constraints (enforced via assert()):
17549	** SQLITE_FUNC_MINMAX == NC_MinMaxAgg == SF_MinMaxAgg
17550	** SQLITE_FUNC_ANYORDER == NC_OrderAgg == SF_OrderByReqd
17551	** SQLITE_FUNC_LENGTH == OPFLAG_LENGTHARG
17552	** SQLITE_FUNC_TYPEOF == OPFLAG_TYPEOFARG
17553	** SQLITE_FUNC_BYTELEN == OPFLAG_BYTELENARG
17554	** SQLITE_FUNC_CONSTANT == SQLITE_DETERMINISTIC from the API
17555	** SQLITE_FUNC_DIRECT == SQLITE_DIRECTONLY from the API
17556	** SQLITE_FUNC_UNSAFE == SQLITE_INNOCUOUS -- opposite meanings!!!
17557	** SQLITE_FUNC_ENCMASK depends on SQLITE_UTF* macros in the API
17558	**
	@@ -17566,10 +17567,11 @@
17567	#define SQLITE_FUNC_CASE 0x0008 /* Case-sensitive LIKE-type function */
17568	#define SQLITE_FUNC_EPHEM 0x0010 /* Ephemeral. Delete with VDBE */
17569	#define SQLITE_FUNC_NEEDCOLL 0x0020 /* sqlite3GetFuncCollSeq() might be called*/
17570	#define SQLITE_FUNC_LENGTH 0x0040 /* Built-in length() function */
17571	#define SQLITE_FUNC_TYPEOF 0x0080 /* Built-in typeof() function */
17572	#define SQLITE_FUNC_BYTELEN 0x00c0 /* Built-in octet_length() function */
17573	#define SQLITE_FUNC_COUNT 0x0100 /* Built-in count() aggregate /
17574	/* 0x0200 -- available for reuse */
17575	#define SQLITE_FUNC_UNLIKELY 0x0400 /* Built-in unlikely() function */
17576	#define SQLITE_FUNC_CONSTANT 0x0800 /* Constant inputs give a constant output */
17577	#define SQLITE_FUNC_MINMAX 0x1000 /* True for min() and max() aggregates */
	@@ -19509,10 +19511,11 @@
19511	#define OPFLAG_APPEND 0x08 /* This is likely to be an append */
19512	#define OPFLAG_USESEEKRESULT 0x10 /* Try to avoid a seek in BtreeInsert() */
19513	#define OPFLAG_ISNOOP 0x40 /* OP_Delete does pre-update-hook only */
19514	#define OPFLAG_LENGTHARG 0x40 /* OP_Column only used for length() */
19515	#define OPFLAG_TYPEOFARG 0x80 /* OP_Column only used for typeof() */
19516	#define OPFLAG_BYTELENARG 0xc0 /* OP_Column only for octet_length() */
19517	#define OPFLAG_BULKCSR 0x01 /* OP_Open** used to open bulk cursor */
19518	#define OPFLAG_SEEKEQ 0x02 /* OP_Open** cursor uses EQ seek only */
19519	#define OPFLAG_FORDELETE 0x08 /* OP_Open should use BTREE_FORDELETE */
19520	#define OPFLAG_P2ISREG 0x10 /* P2 to OP_Open** is a register number */
19521	#define OPFLAG_PERMUTE 0x01 /* OP_Compare: use the permutation */
	@@ -19829,10 +19832,11 @@
19832	const Token pName; / Name of the container - used for error messages */
19833	};
19834
19835	/* Forward declarations */
19836	SQLITE_PRIVATE int sqlite3WalkExpr(Walker, Expr);
19837	SQLITE_PRIVATE int sqlite3WalkExprNN(Walker, Expr);
19838	SQLITE_PRIVATE int sqlite3WalkExprList(Walker, ExprList);
19839	SQLITE_PRIVATE int sqlite3WalkSelect(Walker, Select);
19840	SQLITE_PRIVATE int sqlite3WalkSelectExpr(Walker, Select);
19841	SQLITE_PRIVATE int sqlite3WalkSelectFrom(Walker, Select);
19842	SQLITE_PRIVATE int sqlite3ExprWalkNoop(Walker, Expr);
	@@ -71221,72 +71225,45 @@
71225	return btreePagecount(p->pBt);
71226	}
71227
71228	/*
71229	** Get a page from the pager and initialize it.










71230	*/
71231	static int getAndInitPage(
71232	BtShared pBt, / The database file */
71233	Pgno pgno, /* Number of the page to get */
71234	MemPage *ppPage, / Write the page pointer here */

71235	int bReadOnly /* True for a read-only page */
71236	){
71237	int rc;
71238	DbPage *pDbPage;
71239	MemPage *pPage;
71240	assert( sqlite3_mutex_held(pBt->mutex) );



71241
71242	if( pgno>btreePagecount(pBt) ){
71243	*ppPage = 0;
71244	return SQLITE_CORRUPT_BKPT;
71245	}
71246	rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, bReadOnly);
71247	if( rc ){
71248	*ppPage = 0;
71249	return rc;
71250	}
71251	pPage = (MemPage*)sqlite3PagerGetExtra(pDbPage);
71252	if( pPage->isInit==0 ){
71253	btreePageFromDbPage(pDbPage, pgno, pBt);
71254	rc = btreeInitPage(pPage);
71255	if( rc!=SQLITE_OK ){
71256	releasePage(pPage);
71257	*ppPage = 0;
71258	return rc;
71259	}
71260	}
71261	assert( pPage->pgno==pgno \|\| CORRUPT_DB );
71262	assert( pPage->aData==sqlite3PagerGetData(pDbPage) );
71263	*ppPage = pPage;
71264	return SQLITE_OK;















71265	}
71266
71267	/*
71268	** Release a MemPage. This should be called once for each prior
71269	** call to btreeGetPage.
	@@ -74256,10 +74233,11 @@
74233	** the new child page does not match the flags field of the parent (i.e.
74234	** if an intkey page appears to be the parent of a non-intkey page, or
74235	** vice-versa).
74236	*/
74237	static int moveToChild(BtCursor *pCur, u32 newPgno){
74238	int rc;
74239	assert( cursorOwnsBtShared(pCur) );
74240	assert( pCur->eState==CURSOR_VALID );
74241	assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
74242	assert( pCur->iPage>=0 );
74243	if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
	@@ -74269,12 +74247,21 @@
74247	pCur->curFlags &= ~(BTCF_ValidNKey\|BTCF_ValidOvfl);
74248	pCur->aiIdx[pCur->iPage] = pCur->ix;
74249	pCur->apPage[pCur->iPage] = pCur->pPage;
74250	pCur->ix = 0;
74251	pCur->iPage++;
74252	rc = getAndInitPage(pCur->pBt, newPgno, &pCur->pPage, pCur->curPagerFlags);
74253	if( rc==SQLITE_OK
74254	&& (pCur->pPage->nCell<1 \|\| pCur->pPage->intKey!=pCur->curIntKey)
74255	){
74256	releasePage(pCur->pPage);
74257	rc = SQLITE_CORRUPT_PGNO(newPgno);
74258	}
74259	if( rc ){
74260	pCur->pPage = pCur->apPage[--pCur->iPage];
74261	}
74262	return rc;
74263	}
74264
74265	#ifdef SQLITE_DEBUG
74266	/*
74267	** Page pParent is an internal (non-leaf) tree page. This function
	@@ -74377,11 +74364,11 @@
74364	return pCur->skipNext;
74365	}
74366	sqlite3BtreeClearCursor(pCur);
74367	}
74368	rc = getAndInitPage(pCur->pBt, pCur->pgnoRoot, &pCur->pPage,
74369	pCur->curPagerFlags);
74370	if( rc!=SQLITE_OK ){
74371	pCur->eState = CURSOR_INVALID;
74372	return rc;
74373	}
74374	pCur->iPage = 0;
	@@ -74990,14 +74977,40 @@
74977	if( lwr>=pPage->nCell ){
74978	chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]);
74979	}else{
74980	chldPg = get4byte(findCell(pPage, lwr));
74981	}
74982
74983	/* This block is similar to an in-lined version of:
74984	**
74985	** pCur->ix = (u16)lwr;
74986	** rc = moveToChild(pCur, chldPg);
74987	** if( rc ) break;
74988	*/
74989	pCur->info.nSize = 0;
74990	pCur->curFlags &= ~(BTCF_ValidNKey\|BTCF_ValidOvfl);
74991	if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
74992	return SQLITE_CORRUPT_BKPT;
74993	}
74994	pCur->aiIdx[pCur->iPage] = (u16)lwr;
74995	pCur->apPage[pCur->iPage] = pCur->pPage;
74996	pCur->ix = 0;
74997	pCur->iPage++;
74998	rc = getAndInitPage(pCur->pBt, chldPg, &pCur->pPage, pCur->curPagerFlags);
74999	if( rc==SQLITE_OK
75000	&& (pCur->pPage->nCell<1 \|\| pCur->pPage->intKey!=pCur->curIntKey)
75001	){
75002	releasePage(pCur->pPage);
75003	rc = SQLITE_CORRUPT_PGNO(chldPg);
75004	}
75005	if( rc ){
75006	pCur->pPage = pCur->apPage[--pCur->iPage];
75007	break;
75008	}
75009	/*
75010	***** End of in-lined moveToChild() call */
75011	}
75012	moveto_index_finish:
75013	pCur->info.nSize = 0;
75014	assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
75015	return rc;
75016	}
	@@ -77047,11 +77060,11 @@
77060	pRight = findCell(pParent, i+nxDiv-pParent->nOverflow);
77061	}
77062	pgno = get4byte(pRight);
77063	while( 1 ){
77064	if( rc==SQLITE_OK ){
77065	rc = getAndInitPage(pBt, pgno, &apOld[i], 0);
77066	}
77067	if( rc ){
77068	memset(apOld, 0, (i+1)sizeof(MemPage));
77069	goto balance_cleanup;
77070	}
	@@ -78932,11 +78945,11 @@
78945
78946	assert( sqlite3_mutex_held(pBt->mutex) );
78947	if( pgno>btreePagecount(pBt) ){
78948	return SQLITE_CORRUPT_BKPT;
78949	}
78950	rc = getAndInitPage(pBt, pgno, &pPage, 0);
78951	if( rc ) return rc;
78952	if( (pBt->openFlags & BTREE_SINGLE)==0
78953	&& sqlite3PagerPageRefcount(pPage->pDbPage) != (1 + (pgno==1))
78954	){
78955	rc = SQLITE_CORRUPT_BKPT;
	@@ -83267,10 +83280,39 @@
83280	(void)pc;
83281	(void)pOp;
83282	n++;
83283	}
83284	#endif
83285
83286	/*
83287	** Slow paths for sqlite3VdbeAddOp3() and sqlite3VdbeAddOp4Int() for the
83288	** unusual case when we need to increase the size of the Vdbe.aOp[] array
83289	** before adding the new opcode.
83290	*/
83291	static SQLITE_NOINLINE int growOp3(Vdbe *p, int op, int p1, int p2, int p3){
83292	assert( p->nOpAlloc<=p->nOp );
83293	if( growOpArray(p, 1) ) return 1;
83294	assert( p->nOpAlloc>p->nOp );
83295	return sqlite3VdbeAddOp3(p, op, p1, p2, p3);
83296	}
83297	static SQLITE_NOINLINE int addOp4IntSlow(
83298	Vdbe p, / Add the opcode to this VM */
83299	int op, /* The new opcode */
83300	int p1, /* The P1 operand */
83301	int p2, /* The P2 operand */
83302	int p3, /* The P3 operand */
83303	int p4 /* The P4 operand as an integer */
83304	){
83305	int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
83306	if( p->db->mallocFailed==0 ){
83307	VdbeOp *pOp = &p->aOp[addr];
83308	pOp->p4type = P4_INT32;
83309	pOp->p4.i = p4;
83310	}
83311	return addr;
83312	}
83313
83314
83315	/*
83316	** Add a new instruction to the list of instructions current in the
83317	** VDBE. Return the address of the new instruction.
83318	**
	@@ -83278,21 +83320,20 @@
83320	**
83321	** p Pointer to the VDBE
83322	**
83323	** op The opcode for this instruction
83324	**
83325	** p1, p2, p3, p4 Operands




83326	*/
83327	SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe *p, int op){
83328	return sqlite3VdbeAddOp3(p, op, 0, 0, 0);
83329	}
83330	SQLITE_PRIVATE int sqlite3VdbeAddOp1(Vdbe *p, int op, int p1){
83331	return sqlite3VdbeAddOp3(p, op, p1, 0, 0);
83332	}
83333	SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe *p, int op, int p1, int p2){
83334	return sqlite3VdbeAddOp3(p, op, p1, p2, 0);
83335	}
83336	SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
83337	int i;
83338	VdbeOp *pOp;
83339
	@@ -83311,10 +83352,62 @@
83352	pOp->p1 = p1;
83353	pOp->p2 = p2;
83354	pOp->p3 = p3;
83355	pOp->p4.p = 0;
83356	pOp->p4type = P4_NOTUSED;
83357
83358	/* Replicate this logic in sqlite3VdbeAddOp4Int()
83359	** vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv */
83360	#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
83361	pOp->zComment = 0;
83362	#endif
83363	#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) \|\| defined(VDBE_PROFILE)
83364	pOp->nExec = 0;
83365	pOp->nCycle = 0;
83366	#endif
83367	#ifdef SQLITE_DEBUG
83368	if( p->db->flags & SQLITE_VdbeAddopTrace ){
83369	sqlite3VdbePrintOp(0, i, &p->aOp[i]);
83370	test_addop_breakpoint(i, &p->aOp[i]);
83371	}
83372	#endif
83373	#ifdef SQLITE_VDBE_COVERAGE
83374	pOp->iSrcLine = 0;
83375	#endif
83376	/* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
83377	** Replicate in sqlite3VdbeAddOp4Int() */
83378
83379	return i;
83380	}
83381	SQLITE_PRIVATE int sqlite3VdbeAddOp4Int(
83382	Vdbe p, / Add the opcode to this VM */
83383	int op, /* The new opcode */
83384	int p1, /* The P1 operand */
83385	int p2, /* The P2 operand */
83386	int p3, /* The P3 operand */
83387	int p4 /* The P4 operand as an integer */
83388	){
83389	int i;
83390	VdbeOp *pOp;
83391
83392	i = p->nOp;
83393	if( p->nOpAlloc<=i ){
83394	return addOp4IntSlow(p, op, p1, p2, p3, p4);
83395	}
83396	p->nOp++;
83397	pOp = &p->aOp[i];
83398	assert( pOp!=0 );
83399	pOp->opcode = (u8)op;
83400	pOp->p5 = 0;
83401	pOp->p1 = p1;
83402	pOp->p2 = p2;
83403	pOp->p3 = p3;
83404	pOp->p4.i = p4;
83405	pOp->p4type = P4_INT32;
83406
83407	/* Replicate this logic in sqlite3VdbeAddOp3()
83408	** vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv */
83409	#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
83410	pOp->zComment = 0;
83411	#endif
83412	#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) \|\| defined(VDBE_PROFILE)
83413	pOp->nExec = 0;
	@@ -83327,21 +83420,15 @@
83420	}
83421	#endif
83422	#ifdef SQLITE_VDBE_COVERAGE
83423	pOp->iSrcLine = 0;
83424	#endif
83425	/* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
83426	** Replicate in sqlite3VdbeAddOp3() */
83427
83428	return i;
83429	}









83430
83431	/* Generate code for an unconditional jump to instruction iDest
83432	*/
83433	SQLITE_PRIVATE int sqlite3VdbeGoto(Vdbe *p, int iDest){
83434	return sqlite3VdbeAddOp3(p, OP_Goto, 0, iDest, 0);
	@@ -83544,30 +83631,10 @@
83631	sqlite3VdbeChangeP5(p, p5);
83632	for(j=0; j<p->db->nDb; j++) sqlite3VdbeUsesBtree(p, j);
83633	sqlite3MayAbort(p->pParse);
83634	}
83635




















83636	/* Insert the end of a co-routine
83637	*/
83638	SQLITE_PRIVATE void sqlite3VdbeEndCoroutine(Vdbe *v, int regYield){
83639	sqlite3VdbeAddOp1(v, OP_EndCoroutine, regYield);
83640
	@@ -94029,14 +94096,18 @@
94096	pDest->z[len] = 0;
94097	pDest->z[len+1] = 0;
94098	pDest->flags = aFlag[t&1];
94099	}
94100	}else{
94101	u8 p5;
94102	pDest->enc = encoding;
94103	/* This branch happens only when content is on overflow pages */
94104	if( ((p5 = (pOp->p5 & OPFLAG_BYTELENARG))!=0
94105	&& (p5==OPFLAG_TYPEOFARG
94106	\|\| (t>=12 && ((t&1)==0 \|\| p5==OPFLAG_BYTELENARG))
94107	)
94108	)
94109	\|\| (len = sqlite3VdbeSerialTypeLen(t))==0
94110	){
94111	/* Content is irrelevant for
94112	** 1. the typeof() function,
94113	** 2. the length(X) function if X is a blob, and
	@@ -104107,20 +104178,22 @@
104178	** return from the top-level walk call.
104179	**
104180	** The return value from this routine is WRC_Abort to abandon the tree walk
104181	** and WRC_Continue to continue.
104182	*/
104183	SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3WalkExprNN(Walker pWalker, Expr pExpr){
104184	int rc;
104185	testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
104186	testcase( ExprHasProperty(pExpr, EP_Reduced) );
104187	while(1){
104188	rc = pWalker->xExprCallback(pWalker, pExpr);
104189	if( rc ) return rc & WRC_Abort;
104190	if( !ExprHasProperty(pExpr,(EP_TokenOnly\|EP_Leaf)) ){
104191	assert( pExpr->x.pList==0 \|\| pExpr->pRight==0 );
104192	if( pExpr->pLeft && sqlite3WalkExprNN(pWalker, pExpr->pLeft) ){
104193	return WRC_Abort;
104194	}
104195	if( pExpr->pRight ){
104196	assert( !ExprHasProperty(pExpr, EP_WinFunc) );
104197	pExpr = pExpr->pRight;
104198	continue;
104199	}else if( ExprUseXSelect(pExpr) ){
	@@ -104140,11 +104213,11 @@
104213	break;
104214	}
104215	return WRC_Continue;
104216	}
104217	SQLITE_PRIVATE int sqlite3WalkExpr(Walker pWalker, Expr pExpr){
104218	return pExpr ? sqlite3WalkExprNN(pWalker,pExpr) : WRC_Continue;
104219	}
104220
104221	/*
104222	** Call sqlite3WalkExpr() for every expression in list p or until
104223	** an abort request is seen.
	@@ -106323,11 +106396,12 @@
106396	w.pParse->nHeight += pExpr->nHeight;
106397	if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
106398	return SQLITE_ERROR;
106399	}
106400	#endif
106401	assert( pExpr!=0 );
106402	sqlite3WalkExprNN(&w, pExpr);
106403	#if SQLITE_MAX_EXPR_DEPTH>0
106404	w.pParse->nHeight -= pExpr->nHeight;
106405	#endif
106406	assert( EP_Agg==NC_HasAgg );
106407	assert( EP_Win==NC_HasWin );
	@@ -106365,11 +106439,11 @@
106439	w.pParse->nHeight += pExpr->nHeight;
106440	if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
106441	return WRC_Abort;
106442	}
106443	#endif
106444	sqlite3WalkExprNN(&w, pExpr);
106445	#if SQLITE_MAX_EXPR_DEPTH>0
106446	w.pParse->nHeight -= pExpr->nHeight;
106447	#endif
106448	assert( EP_Agg==NC_HasAgg );
106449	assert( EP_Win==NC_HasWin );
	@@ -111138,26 +111212,29 @@
111212	pParse->nMem += nFarg;
111213	}else{
111214	r1 = sqlite3GetTempRange(pParse, nFarg);
111215	}
111216
111217	/* For length() and typeof() and octet_length() functions,
111218	** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG
111219	** or OPFLAG_TYPEOFARG or OPFLAG_BYTELENARG respectively, to avoid
111220	** unnecessary data loading.
111221	*/
111222	if( (pDef->funcFlags & (SQLITE_FUNC_LENGTH\|SQLITE_FUNC_TYPEOF))!=0 ){
111223	u8 exprOp;
111224	assert( nFarg==1 );
111225	assert( pFarg->a[0].pExpr!=0 );
111226	exprOp = pFarg->a[0].pExpr->op;
111227	if( exprOp==TK_COLUMN \|\| exprOp==TK_AGG_COLUMN ){
111228	assert( SQLITE_FUNC_LENGTH==OPFLAG_LENGTHARG );
111229	assert( SQLITE_FUNC_TYPEOF==OPFLAG_TYPEOFARG );
111230	assert( SQLITE_FUNC_BYTELEN==OPFLAG_BYTELENARG );
111231	assert( (OPFLAG_LENGTHARG\|OPFLAG_TYPEOFARG)==OPFLAG_BYTELENARG );
111232	testcase( (pDef->funcFlags & OPFLAG_BYTELENARG)==OPFLAG_LENGTHARG );
111233	testcase( (pDef->funcFlags & OPFLAG_BYTELENARG)==OPFLAG_TYPEOFARG );
111234	testcase( (pDef->funcFlags & OPFLAG_BYTELENARG)==OPFLAG_BYTELENARG);
111235	pFarg->a[0].pExpr->op2 = pDef->funcFlags & OPFLAG_BYTELENARG;
111236	}
111237	}
111238
111239	sqlite3ExprCodeExprList(pParse, pFarg, r1, 0,
111240	SQLITE_ECEL_DUP\|SQLITE_ECEL_FACTOR);
	@@ -118693,19 +118770,21 @@
118770	sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB);
118771	}
118772	pParse->nVtabLock = 0;
118773	#endif
118774
118775	#ifndef SQLITE_OMIT_SHARED_CACHE
118776	/* Once all the cookies have been verified and transactions opened,
118777	** obtain the required table-locks. This is a no-op unless the
118778	** shared-cache feature is enabled.
118779	*/
118780	if( pParse->nTableLock ) codeTableLocks(pParse);
118781	#endif
118782
118783	/* Initialize any AUTOINCREMENT data structures required.
118784	*/
118785	if( pParse->pAinc ) sqlite3AutoincrementBegin(pParse);
118786
118787	/* Code constant expressions that where factored out of inner loops.
118788	**
118789	** The pConstExpr list might also contain expressions that we simply
118790	** want to keep around until the Parse object is deleted. Such
	@@ -124730,11 +124809,11 @@
124809	SQLITE_PRIVATE Table sqlite3SrcListLookup(Parse pParse, SrcList *pSrc){
124810	SrcItem *pItem = pSrc->a;
124811	Table *pTab;
124812	assert( pItem && pSrc->nSrc>=1 );
124813	pTab = sqlite3LocateTableItem(pParse, 0, pItem);
124814	if( pItem->pTab ) sqlite3DeleteTable(pParse->db, pItem->pTab);
124815	pItem->pTab = pTab;
124816	pItem->fg.notCte = 1;
124817	if( pTab ){
124818	pTab->nTabRef++;
124819	if( pItem->fg.isIndexedBy && sqlite3IndexedByLookup(pParse, pItem) ){
	@@ -125559,13 +125638,15 @@
125638	** handle rows (possibly in other tables) that refer via a foreign key
125639	** to the row just deleted. */
125640	sqlite3FkActions(pParse, pTab, 0, iOld, 0, 0);
125641
125642	/* Invoke AFTER DELETE trigger programs. */
125643	if( pTrigger ){
125644	sqlite3CodeRowTrigger(pParse, pTrigger,
125645	TK_DELETE, 0, TRIGGER_AFTER, pTab, iOld, onconf, iLabel
125646	);
125647	}
125648
125649	/* Jump here if the row had already been deleted before any BEFORE
125650	** trigger programs were invoked. Or if a trigger program throws a
125651	** RAISE(IGNORE) exception. */
125652	sqlite3VdbeResolveLabel(v, iLabel);
	@@ -125866,10 +125947,46 @@
125947	while( (*z & 0xc0)==0x80 ){ z++; z0++; }
125948	}
125949	}
125950	sqlite3_result_int(context, (int)(z-z0));
125951	break;
125952	}
125953	default: {
125954	sqlite3_result_null(context);
125955	break;
125956	}
125957	}
125958	}
125959
125960	/*
125961	** Implementation of the octet_length() function
125962	*/
125963	static void bytelengthFunc(
125964	sqlite3_context *context,
125965	int argc,
125966	sqlite3_value **argv
125967	){
125968	assert( argc==1 );
125969	UNUSED_PARAMETER(argc);
125970	switch( sqlite3_value_type(argv[0]) ){
125971	case SQLITE_BLOB: {
125972	sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));
125973	break;
125974	}
125975	case SQLITE_INTEGER:
125976	case SQLITE_FLOAT: {
125977	i64 m = sqlite3_context_db_handle(context)->enc<=SQLITE_UTF8 ? 1 : 2;
125978	sqlite3_result_int64(context, sqlite3_value_bytes(argv[0])*m);
125979	break;
125980	}
125981	case SQLITE_TEXT: {
125982	if( sqlite3_value_encoding(argv[0])<=SQLITE_UTF8 ){
125983	sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));
125984	}else{
125985	sqlite3_result_int(context, sqlite3_value_bytes16(argv[0]));
125986	}
125987	break;
125988	}
125989	default: {
125990	sqlite3_result_null(context);
125991	break;
125992	}
	@@ -128101,10 +128218,11 @@
128218	WAGGREGATE(max, 1, 1, 1, minmaxStep, minMaxFinalize, minMaxValue, 0,
128219	SQLITE_FUNC_MINMAX\|SQLITE_FUNC_ANYORDER ),
128220	FUNCTION2(typeof, 1, 0, 0, typeofFunc, SQLITE_FUNC_TYPEOF),
128221	FUNCTION2(subtype, 1, 0, 0, subtypeFunc, SQLITE_FUNC_TYPEOF),
128222	FUNCTION2(length, 1, 0, 0, lengthFunc, SQLITE_FUNC_LENGTH),
128223	FUNCTION2(octet_length, 1, 0, 0, bytelengthFunc,SQLITE_FUNC_BYTELEN),
128224	FUNCTION(instr, 2, 0, 0, instrFunc ),
128225	FUNCTION(printf, -1, 0, 0, printfFunc ),
128226	FUNCTION(format, -1, 0, 0, printfFunc ),
128227	FUNCTION(unicode, 1, 0, 0, unicodeFunc ),
128228	FUNCTION(char, -1, 0, 0, charFunc ),
	@@ -129741,12 +129859,14 @@
129859	Vdbe *v;
129860	assert( !IsVirtual(pTab) );
129861	assert( pParse->pVdbe!=0 );
129862	v = pParse->pVdbe;
129863	assert( opcode==OP_OpenWrite \|\| opcode==OP_OpenRead );
129864	if( !pParse->db->noSharedCache ){
129865	sqlite3TableLock(pParse, iDb, pTab->tnum,
129866	(opcode==OP_OpenWrite)?1:0, pTab->zName);
129867	}
129868	if( HasRowid(pTab) ){
129869	sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nNVCol);
129870	VdbeComment((v, "%s", pTab->zName));
129871	}else{
129872	Index *pPk = sqlite3PrimaryKeyIndex(pTab);
	@@ -132381,11 +132501,11 @@
132501	if( iBase<0 ) iBase = pParse->nTab;
132502	iDataCur = iBase++;
132503	*piDataCur = iDataCur;
132504	if( HasRowid(pTab) && (aToOpen==0 \|\| aToOpen[0]) ){
132505	sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op);
132506	}else if( pParse->db->noSharedCache==0 ){
132507	sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
132508	}
132509	*piIdxCur = iBase;
132510	for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
132511	int iIdxCur = iBase++;
	@@ -150482,12 +150602,14 @@
150602	*/
150603	if( regRowCount ){
150604	sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
150605	}
150606
150607	if( pTrigger ){
150608	sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
150609	TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue);
150610	}
150611
150612	/* Repeat the above with the next record to be updated, until
150613	** all record selected by the WHERE clause have been updated.
150614	*/
150615	if( eOnePass==ONEPASS_SINGLE ){
	@@ -173943,184 +174065,183 @@
174065	** parser symbol code for that keyword into *pType. Always
174066	** return the integer n (the length of the token). */
174067	static int keywordCode(const char z, int n, int pType){
174068	int i, j;
174069	const char *zKW;
174070	assert( n>=2 );
174071	i = ((charMap(z[0])4) ^ (charMap(z[n-1])3) ^ n*1) % 127;
174072	for(i=(int)aKWHash[i]; i>0; i=aKWNext[i]){
174073	if( aKWLen[i]!=n ) continue;
174074	zKW = &zKWText[aKWOffset[i]];
174075	#ifdef SQLITE_ASCII
174076	if( (z[0]&~0x20)!=zKW[0] ) continue;
174077	if( (z[1]&~0x20)!=zKW[1] ) continue;
174078	j = 2;
174079	while( j<n && (z[j]&~0x20)==zKW[j] ){ j++; }
174080	#endif
174081	#ifdef SQLITE_EBCDIC
174082	if( toupper(z[0])!=zKW[0] ) continue;
174083	if( toupper(z[1])!=zKW[1] ) continue;
174084	j = 2;
174085	while( j<n && toupper(z[j])==zKW[j] ){ j++; }
174086	#endif
174087	if( j<n ) continue;
174088	testcase( i==1 ); /* REINDEX */
174089	testcase( i==2 ); /* INDEXED */
174090	testcase( i==3 ); /* INDEX */
174091	testcase( i==4 ); /* DESC */
174092	testcase( i==5 ); /* ESCAPE */
174093	testcase( i==6 ); /* EACH */
174094	testcase( i==7 ); /* CHECK */
174095	testcase( i==8 ); /* KEY */
174096	testcase( i==9 ); /* BEFORE */
174097	testcase( i==10 ); /* FOREIGN */
174098	testcase( i==11 ); /* FOR */
174099	testcase( i==12 ); /* IGNORE */
174100	testcase( i==13 ); /* REGEXP */
174101	testcase( i==14 ); /* EXPLAIN */
174102	testcase( i==15 ); /* INSTEAD */
174103	testcase( i==16 ); /* ADD */
174104	testcase( i==17 ); /* DATABASE */
174105	testcase( i==18 ); /* AS */
174106	testcase( i==19 ); /* SELECT */
174107	testcase( i==20 ); /* TABLE */
174108	testcase( i==21 ); /* LEFT */
174109	testcase( i==22 ); /* THEN */
174110	testcase( i==23 ); /* END */
174111	testcase( i==24 ); /* DEFERRABLE */
174112	testcase( i==25 ); /* ELSE */
174113	testcase( i==26 ); /* EXCLUDE */
174114	testcase( i==27 ); /* DELETE */
174115	testcase( i==28 ); /* TEMPORARY */
174116	testcase( i==29 ); /* TEMP */
174117	testcase( i==30 ); /* OR */
174118	testcase( i==31 ); /* ISNULL */
174119	testcase( i==32 ); /* NULLS */
174120	testcase( i==33 ); /* SAVEPOINT */
174121	testcase( i==34 ); /* INTERSECT */
174122	testcase( i==35 ); /* TIES */
174123	testcase( i==36 ); /* NOTNULL */
174124	testcase( i==37 ); /* NOT */
174125	testcase( i==38 ); /* NO */
174126	testcase( i==39 ); /* NULL */
174127	testcase( i==40 ); /* LIKE */
174128	testcase( i==41 ); /* EXCEPT */
174129	testcase( i==42 ); /* TRANSACTION */
174130	testcase( i==43 ); /* ACTION */
174131	testcase( i==44 ); /* ON */
174132	testcase( i==45 ); /* NATURAL */
174133	testcase( i==46 ); /* ALTER */
174134	testcase( i==47 ); /* RAISE */
174135	testcase( i==48 ); /* EXCLUSIVE */
174136	testcase( i==49 ); /* EXISTS */
174137	testcase( i==50 ); /* CONSTRAINT */
174138	testcase( i==51 ); /* INTO */
174139	testcase( i==52 ); /* OFFSET */
174140	testcase( i==53 ); /* OF */
174141	testcase( i==54 ); /* SET */
174142	testcase( i==55 ); /* TRIGGER */
174143	testcase( i==56 ); /* RANGE */
174144	testcase( i==57 ); /* GENERATED */
174145	testcase( i==58 ); /* DETACH */
174146	testcase( i==59 ); /* HAVING */
174147	testcase( i==60 ); /* GLOB */
174148	testcase( i==61 ); /* BEGIN */
174149	testcase( i==62 ); /* INNER */
174150	testcase( i==63 ); /* REFERENCES */
174151	testcase( i==64 ); /* UNIQUE */
174152	testcase( i==65 ); /* QUERY */
174153	testcase( i==66 ); /* WITHOUT */
174154	testcase( i==67 ); /* WITH */
174155	testcase( i==68 ); /* OUTER */
174156	testcase( i==69 ); /* RELEASE */
174157	testcase( i==70 ); /* ATTACH */
174158	testcase( i==71 ); /* BETWEEN */
174159	testcase( i==72 ); /* NOTHING */
174160	testcase( i==73 ); /* GROUPS */
174161	testcase( i==74 ); /* GROUP */
174162	testcase( i==75 ); /* CASCADE */
174163	testcase( i==76 ); /* ASC */
174164	testcase( i==77 ); /* DEFAULT */
174165	testcase( i==78 ); /* CASE */
174166	testcase( i==79 ); /* COLLATE */
174167	testcase( i==80 ); /* CREATE */
174168	testcase( i==81 ); /* CURRENT_DATE */
174169	testcase( i==82 ); /* IMMEDIATE */
174170	testcase( i==83 ); /* JOIN */
174171	testcase( i==84 ); /* INSERT */
174172	testcase( i==85 ); /* MATCH */
174173	testcase( i==86 ); /* PLAN */
174174	testcase( i==87 ); /* ANALYZE */
174175	testcase( i==88 ); /* PRAGMA */
174176	testcase( i==89 ); /* MATERIALIZED */
174177	testcase( i==90 ); /* DEFERRED */
174178	testcase( i==91 ); /* DISTINCT */
174179	testcase( i==92 ); /* IS */
174180	testcase( i==93 ); /* UPDATE */
174181	testcase( i==94 ); /* VALUES */
174182	testcase( i==95 ); /* VIRTUAL */
174183	testcase( i==96 ); /* ALWAYS */
174184	testcase( i==97 ); /* WHEN */
174185	testcase( i==98 ); /* WHERE */
174186	testcase( i==99 ); /* RECURSIVE */
174187	testcase( i==100 ); /* ABORT */
174188	testcase( i==101 ); /* AFTER */
174189	testcase( i==102 ); /* RENAME */
174190	testcase( i==103 ); /* AND */
174191	testcase( i==104 ); /* DROP */
174192	testcase( i==105 ); /* PARTITION */
174193	testcase( i==106 ); /* AUTOINCREMENT */
174194	testcase( i==107 ); /* TO */
174195	testcase( i==108 ); /* IN */
174196	testcase( i==109 ); /* CAST */
174197	testcase( i==110 ); /* COLUMN */
174198	testcase( i==111 ); /* COMMIT */
174199	testcase( i==112 ); /* CONFLICT */
174200	testcase( i==113 ); /* CROSS */
174201	testcase( i==114 ); /* CURRENT_TIMESTAMP */
174202	testcase( i==115 ); /* CURRENT_TIME */
174203	testcase( i==116 ); /* CURRENT */
174204	testcase( i==117 ); /* PRECEDING */
174205	testcase( i==118 ); /* FAIL */
174206	testcase( i==119 ); /* LAST */
174207	testcase( i==120 ); /* FILTER */
174208	testcase( i==121 ); /* REPLACE */
174209	testcase( i==122 ); /* FIRST */
174210	testcase( i==123 ); /* FOLLOWING */
174211	testcase( i==124 ); /* FROM */
174212	testcase( i==125 ); /* FULL */
174213	testcase( i==126 ); /* LIMIT */
174214	testcase( i==127 ); /* IF */
174215	testcase( i==128 ); /* ORDER */
174216	testcase( i==129 ); /* RESTRICT */
174217	testcase( i==130 ); /* OTHERS */
174218	testcase( i==131 ); /* OVER */
174219	testcase( i==132 ); /* RETURNING */
174220	testcase( i==133 ); /* RIGHT */
174221	testcase( i==134 ); /* ROLLBACK */
174222	testcase( i==135 ); /* ROWS */
174223	testcase( i==136 ); /* ROW */
174224	testcase( i==137 ); /* UNBOUNDED */
174225	testcase( i==138 ); /* UNION */
174226	testcase( i==139 ); /* USING */
174227	testcase( i==140 ); /* VACUUM */
174228	testcase( i==141 ); /* VIEW */
174229	testcase( i==142 ); /* WINDOW */
174230	testcase( i==143 ); /* DO */
174231	testcase( i==144 ); /* BY */
174232	testcase( i==145 ); /* INITIALLY */
174233	testcase( i==146 ); /* ALL */
174234	testcase( i==147 ); /* PRIMARY */
174235	*pType = aKWCode[i];
174236	break;

174237	}
174238	return n;
174239	}
174240	SQLITE_PRIVATE int sqlite3KeywordCode(const unsigned char *z, int n){
174241	int id = TK_ID;
174242	if( n>=2 ) keywordCode((char*)z, n, &id);
174243	return id;
174244	}
174245	#define SQLITE_N_KEYWORD 147
174246	SQLITE_API int sqlite3_keyword_name(int i,const char *pzName,int pnName){
174247	if( i<0 \|\| i>=SQLITE_N_KEYWORD ) return SQLITE_ERROR;
	@@ -174493,11 +174614,12 @@
174614	}
174615	if( n==0 ) *tokenType = TK_ILLEGAL;
174616	return i;
174617	}
174618	case CC_KYWD0: {
174619	if( aiClass[z[1]]>CC_KYWD ){ i = 1; break; }
174620	for(i=2; aiClass[z[i]]<=CC_KYWD; i++){}
174621	if( IdChar(z[i]) ){
174622	/* This token started out using characters that can appear in keywords,
174623	** but z[i] is a character not allowed within keywords, so this must
174624	** be an identifier instead */
174625	i++;
	@@ -242988,11 +243110,11 @@
243110	int nArg, /* Number of args */
243111	sqlite3_value *apUnused / Function arguments */
243112	){
243113	assert( nArg==0 );
243114	UNUSED_PARAM2(nArg, apUnused);
243115	sqlite3_result_text(pCtx, "fts5: 2023-06-22 13:01:02 d35c214811aac7dec0000ca2aa77231f74a7963dd0c53cf25a65ade5ef0f8dc0", -1, SQLITE_TRANSIENT);
243116	}
243117
243118	/*
243119	** Return true if zName is the extension on one of the shadow tables used
243120	** by this module.
243121

M extsrc/sqlite3.h

+1 -1

		--- extsrc/sqlite3.h
		+++ extsrc/sqlite3.h
		@@ -146,11 +146,11 @@
146	146	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
147	147	** [sqlite_version()] and [sqlite_source_id()].
148	148	*/
149	149	#define SQLITE_VERSION "3.43.0"
150	150	#define SQLITE_VERSION_NUMBER 3043000
151		-#define SQLITE_SOURCE_ID "2023-06-19 13:09:16 3c94f87806a8b408d8204fc7deec16d01c085ee199ff21a1f20b6346ce816cfe"
	151	+#define SQLITE_SOURCE_ID "2023-06-23 11:10:13 fa5f77862c0fe0189aa4246a1e55bb7c537c28c436ec10b75f5fa141e5e4aff0"
152	152
153	153	/*
154	154	** CAPI3REF: Run-Time Library Version Numbers
155	155	** KEYWORDS: sqlite3_version sqlite3_sourceid
156	156	**
157	157

	--- extsrc/sqlite3.h
	+++ extsrc/sqlite3.h
	@@ -146,11 +146,11 @@
146	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
147	** [sqlite_version()] and [sqlite_source_id()].
148	*/
149	#define SQLITE_VERSION "3.43.0"
150	#define SQLITE_VERSION_NUMBER 3043000
151	#define SQLITE_SOURCE_ID "2023-06-19 13:09:16 3c94f87806a8b408d8204fc7deec16d01c085ee199ff21a1f20b6346ce816cfe"
152
153	/*
154	** CAPI3REF: Run-Time Library Version Numbers
155	** KEYWORDS: sqlite3_version sqlite3_sourceid
156	**
157

	--- extsrc/sqlite3.h
	+++ extsrc/sqlite3.h
	@@ -146,11 +146,11 @@
146	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
147	** [sqlite_version()] and [sqlite_source_id()].
148	*/
149	#define SQLITE_VERSION "3.43.0"
150	#define SQLITE_VERSION_NUMBER 3043000
151	#define SQLITE_SOURCE_ID "2023-06-23 11:10:13 fa5f77862c0fe0189aa4246a1e55bb7c537c28c436ec10b75f5fa141e5e4aff0"
152
153	/*
154	** CAPI3REF: Run-Time Library Version Numbers
155	** KEYWORDS: sqlite3_version sqlite3_sourceid
156	**
157

Fossil SCM

Keyboard Shortcuts