Fossil SCM

Bring in the latest SQLite 3.8.0 alpha version from upstream, for testing.

drh 2013-06-29 15:26 trunk

Commit c3e723e308bbd4f23cd543da869e8a39640f8dde

Parent 8dc6873d44d685b…

3 files changed +38 -12 +139 -66 +3 -1

~ src/shell.c ~ src/sqlite3.c ~ src/sqlite3.h

M src/shell.c

+38 -12

		--- src/shell.c
		+++ src/shell.c
		@@ -1490,10 +1490,11 @@
1490	1490	** Do C-language style dequoting.
1491	1491	**
1492	1492	** \t -> tab
1493	1493	** \n -> newline
1494	1494	** \r -> carriage return
	1495	+** \" -> "
1495	1496	** \NNN -> ascii character NNN in octal
1496	1497	** \\ -> backslash
1497	1498	*/
1498	1499	static void resolve_backslashes(char *z){
1499	1500	int i, j;
		@@ -1505,10 +1506,12 @@
1505	1506	c = '\n';
1506	1507	}else if( c=='t' ){
1507	1508	c = '\t';
1508	1509	}else if( c=='r' ){
1509	1510	c = '\r';
	1511	+ }else if( c=='\\' ){
	1512	+ c = '\\';
1510	1513	}else if( c>='0' && c<='7' ){
1511	1514	c -= '0';
1512	1515	if( z[i+1]>='0' && z[i+1]<='7' ){
1513	1516	i++;
1514	1517	c = (c<<3) + z[i] - '0';
		@@ -1770,11 +1773,14 @@
1770	1773	while( IsSpace(zLine[i]) ){ i++; }
1771	1774	if( zLine[i]==0 ) break;
1772	1775	if( zLine[i]=='\'' \|\| zLine[i]=='"' ){
1773	1776	int delim = zLine[i++];
1774	1777	azArg[nArg++] = &zLine[i];
1775		- while( zLine[i] && zLine[i]!=delim ){ i++; }
	1778	+ while( zLine[i] && zLine[i]!=delim ){
	1779	+ if( zLine[i]=='\\' && delim=='"' && zLine[i+1]!=0 ) i++;
	1780	+ i++;
	1781	+ }
1776	1782	if( zLine[i]==delim ){
1777	1783	zLine[i++] = 0;
1778	1784	}
1779	1785	if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
1780	1786	}else{
		@@ -1987,22 +1993,22 @@
1987	1993	}
1988	1994	}else
1989	1995
1990	1996	if( c=='i' && strncmp(azArg[0], "import", n)==0 && nArg==3 ){
1991	1997	char zTable = azArg[2]; / Insert data into this table */
	1998	+ char zFile = azArg[1]; / Name of file to extra content from */
1992	1999	sqlite3_stmt pStmt = NULL; / A statement */
1993	2000	int nCol; /* Number of columns in the table */
1994	2001	int nByte; /* Number of bytes in an SQL string */
1995	2002	int i, j; /* Loop counters */
1996	2003	int nSep; /* Number of bytes in p->separator[] */
1997	2004	char zSql; / An SQL statement */
1998	2005	CSVReader sCsv; /* Reader context */
	2006	+ int (xCloser)(FILE); /* Procedure to close th3 connection */
1999	2007
2000	2008	seenInterrupt = 0;
2001	2009	memset(&sCsv, 0, sizeof(sCsv));
2002		- sCsv.zFile = azArg[1];
2003		- sCsv.nLine = 1;
2004	2010	open_db(p);
2005	2011	nSep = strlen30(p->separator);
2006	2012	if( nSep==0 ){
2007	2013	fprintf(stderr, "Error: non-null separator required for import\n");
2008	2014	return 1;
		@@ -2010,20 +2016,29 @@
2010	2016	if( nSep>1 ){
2011	2017	fprintf(stderr, "Error: multi-character separators not allowed"
2012	2018	" for import\n");
2013	2019	return 1;
2014	2020	}
2015		- sCsv.in = fopen(sCsv.zFile, "rb");
	2021	+ sCsv.zFile = zFile;
	2022	+ sCsv.nLine = 1;
	2023	+ if( sCsv.zFile[0]=='\|' ){
	2024	+ sCsv.in = popen(sCsv.zFile+1, "r");
	2025	+ sCsv.zFile = "<pipe>";
	2026	+ xCloser = pclose;
	2027	+ }else{
	2028	+ sCsv.in = fopen(sCsv.zFile, "rb");
	2029	+ xCloser = fclose;
	2030	+ }
2016	2031	if( sCsv.in==0 ){
2017		- fprintf(stderr, "Error: cannot open \"%s\"\n", sCsv.zFile);
	2032	+ fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
2018	2033	return 1;
2019	2034	}
2020	2035	sCsv.cSeparator = p->separator[0];
2021	2036	zSql = sqlite3_mprintf("SELECT * FROM %s", zTable);
2022	2037	if( zSql==0 ){
2023	2038	fprintf(stderr, "Error: out of memory\n");
2024		- fclose(sCsv.in);
	2039	+ xCloser(sCsv.in);
2025	2040	return 1;
2026	2041	}
2027	2042	nByte = strlen30(zSql);
2028	2043	rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
2029	2044	if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(db))==0 ){
		@@ -2031,38 +2046,45 @@
2031	2046	char cSep = '(';
2032	2047	while( csv_read_one_field(&sCsv) ){
2033	2048	zCreate = sqlite3_mprintf("%z%c\n \"%s\" TEXT", zCreate, cSep, sCsv.z);
2034	2049	cSep = ',';
2035	2050	if( sCsv.cTerm!=sCsv.cSeparator ) break;
	2051	+ }
	2052	+ if( cSep=='(' ){
	2053	+ sqlite3_free(zCreate);
	2054	+ sqlite3_free(sCsv.z);
	2055	+ xCloser(sCsv.in);
	2056	+ fprintf(stderr,"%s: empty file\n", sCsv.zFile);
	2057	+ return 1;
2036	2058	}
2037	2059	zCreate = sqlite3_mprintf("%z\n)", zCreate);
2038	2060	rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
2039	2061	sqlite3_free(zCreate);
2040	2062	if( rc ){
2041	2063	fprintf(stderr, "CREATE TABLE %s(...) failed: %s\n", zTable,
2042	2064	sqlite3_errmsg(db));
2043	2065	sqlite3_free(sCsv.z);
2044		- fclose(sCsv.in);
	2066	+ xCloser(sCsv.in);
2045	2067	return 1;
2046	2068	}
2047	2069	rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
2048	2070	}
2049	2071	sqlite3_free(zSql);
2050	2072	if( rc ){
2051	2073	if (pStmt) sqlite3_finalize(pStmt);
2052	2074	fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
2053		- fclose(sCsv.in);
	2075	+ xCloser(sCsv.in);
2054	2076	return 1;
2055	2077	}
2056	2078	nCol = sqlite3_column_count(pStmt);
2057	2079	sqlite3_finalize(pStmt);
2058	2080	pStmt = 0;
2059	2081	if( nCol==0 ) return 0; /* no columns, no error */
2060	2082	zSql = sqlite3_malloc( nByte2 + 20 + nCol2 );
2061	2083	if( zSql==0 ){
2062	2084	fprintf(stderr, "Error: out of memory\n");
2063		- fclose(sCsv.in);
	2085	+ xCloser(sCsv.in);
2064	2086	return 1;
2065	2087	}
2066	2088	sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable);
2067	2089	j = strlen30(zSql);
2068	2090	for(i=1; i<nCol; i++){
		@@ -2074,11 +2096,11 @@
2074	2096	rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
2075	2097	sqlite3_free(zSql);
2076	2098	if( rc ){
2077	2099	fprintf(stderr, "Error: %s\n", sqlite3_errmsg(db));
2078	2100	if (pStmt) sqlite3_finalize(pStmt);
2079		- fclose(sCsv.in);
	2101	+ xCloser(sCsv.in);
2080	2102	return 1;
2081	2103	}
2082	2104	do{
2083	2105	int startLine = sCsv.nLine;
2084	2106	for(i=0; i<nCol; i++){
		@@ -2110,11 +2132,11 @@
2110	2132	sqlite3_errmsg(db));
2111	2133	}
2112	2134	}
2113	2135	}while( sCsv.cTerm!=EOF );
2114	2136
2115		- fclose(sCsv.in);
	2137	+ xCloser(sCsv.in);
2116	2138	sqlite3_free(sCsv.z);
2117	2139	sqlite3_finalize(pStmt);
2118	2140	sqlite3_exec(p->db, "COMMIT", 0, 0, 0);
2119	2141	}else
2120	2142
		@@ -2435,10 +2457,11 @@
2435	2457	}else{
2436	2458	rc = 0;
2437	2459	}
2438	2460	}else
2439	2461
	2462	+#ifdef SQLITE_DEBUG
2440	2463	/* Undocumented commands for internal testing. Subject to change
2441	2464	** without notice. */
2442	2465	if( c=='s' && n>=10 && strncmp(azArg[0], "selftest-", 9)==0 ){
2443	2466	if( strncmp(azArg[0]+9, "boolean", n-9)==0 ){
2444	2467	int i, v;
		@@ -2448,15 +2471,18 @@
2448	2471	}
2449	2472	}
2450	2473	if( strncmp(azArg[0]+9, "integer", n-9)==0 ){
2451	2474	int i; sqlite3_int64 v;
2452	2475	for(i=1; i<nArg; i++){
	2476	+ char zBuf[200];
2453	2477	v = integerValue(azArg[i]);
2454		- fprintf(p->out, "%s: %lld 0x%llx\n", azArg[i], v, v);
	2478	+ sqlite3_snprintf(sizeof(zBuf), zBuf, "%s: %lld 0x%llx\n", azArg[i], v, v);
	2479	+ fprintf(p->out, "%s", zBuf);
2455	2480	}
2456	2481	}
2457	2482	}else
	2483	+#endif
2458	2484
2459	2485	if( c=='s' && strncmp(azArg[0], "separator", n)==0 && nArg==2 ){
2460	2486	sqlite3_snprintf(sizeof(p->separator), p->separator,
2461	2487	"%.*s", (int)sizeof(p->separator)-1, azArg[1]);
2462	2488	}else
2463	2489

	--- src/shell.c
	+++ src/shell.c
	@@ -1490,10 +1490,11 @@
1490	** Do C-language style dequoting.
1491	**
1492	** \t -> tab
1493	** \n -> newline
1494	** \r -> carriage return

1495	** \NNN -> ascii character NNN in octal
1496	** \\ -> backslash
1497	*/
1498	static void resolve_backslashes(char *z){
1499	int i, j;
	@@ -1505,10 +1506,12 @@
1505	c = '\n';
1506	}else if( c=='t' ){
1507	c = '\t';
1508	}else if( c=='r' ){
1509	c = '\r';


1510	}else if( c>='0' && c<='7' ){
1511	c -= '0';
1512	if( z[i+1]>='0' && z[i+1]<='7' ){
1513	i++;
1514	c = (c<<3) + z[i] - '0';
	@@ -1770,11 +1773,14 @@
1770	while( IsSpace(zLine[i]) ){ i++; }
1771	if( zLine[i]==0 ) break;
1772	if( zLine[i]=='\'' \|\| zLine[i]=='"' ){
1773	int delim = zLine[i++];
1774	azArg[nArg++] = &zLine[i];
1775	while( zLine[i] && zLine[i]!=delim ){ i++; }



1776	if( zLine[i]==delim ){
1777	zLine[i++] = 0;
1778	}
1779	if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
1780	}else{
	@@ -1987,22 +1993,22 @@
1987	}
1988	}else
1989
1990	if( c=='i' && strncmp(azArg[0], "import", n)==0 && nArg==3 ){
1991	char zTable = azArg[2]; / Insert data into this table */

1992	sqlite3_stmt pStmt = NULL; / A statement */
1993	int nCol; /* Number of columns in the table */
1994	int nByte; /* Number of bytes in an SQL string */
1995	int i, j; /* Loop counters */
1996	int nSep; /* Number of bytes in p->separator[] */
1997	char zSql; / An SQL statement */
1998	CSVReader sCsv; /* Reader context */

1999
2000	seenInterrupt = 0;
2001	memset(&sCsv, 0, sizeof(sCsv));
2002	sCsv.zFile = azArg[1];
2003	sCsv.nLine = 1;
2004	open_db(p);
2005	nSep = strlen30(p->separator);
2006	if( nSep==0 ){
2007	fprintf(stderr, "Error: non-null separator required for import\n");
2008	return 1;
	@@ -2010,20 +2016,29 @@
2010	if( nSep>1 ){
2011	fprintf(stderr, "Error: multi-character separators not allowed"
2012	" for import\n");
2013	return 1;
2014	}
2015	sCsv.in = fopen(sCsv.zFile, "rb");









2016	if( sCsv.in==0 ){
2017	fprintf(stderr, "Error: cannot open \"%s\"\n", sCsv.zFile);
2018	return 1;
2019	}
2020	sCsv.cSeparator = p->separator[0];
2021	zSql = sqlite3_mprintf("SELECT * FROM %s", zTable);
2022	if( zSql==0 ){
2023	fprintf(stderr, "Error: out of memory\n");
2024	fclose(sCsv.in);
2025	return 1;
2026	}
2027	nByte = strlen30(zSql);
2028	rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
2029	if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(db))==0 ){
	@@ -2031,38 +2046,45 @@
2031	char cSep = '(';
2032	while( csv_read_one_field(&sCsv) ){
2033	zCreate = sqlite3_mprintf("%z%c\n \"%s\" TEXT", zCreate, cSep, sCsv.z);
2034	cSep = ',';
2035	if( sCsv.cTerm!=sCsv.cSeparator ) break;







2036	}
2037	zCreate = sqlite3_mprintf("%z\n)", zCreate);
2038	rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
2039	sqlite3_free(zCreate);
2040	if( rc ){
2041	fprintf(stderr, "CREATE TABLE %s(...) failed: %s\n", zTable,
2042	sqlite3_errmsg(db));
2043	sqlite3_free(sCsv.z);
2044	fclose(sCsv.in);
2045	return 1;
2046	}
2047	rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
2048	}
2049	sqlite3_free(zSql);
2050	if( rc ){
2051	if (pStmt) sqlite3_finalize(pStmt);
2052	fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
2053	fclose(sCsv.in);
2054	return 1;
2055	}
2056	nCol = sqlite3_column_count(pStmt);
2057	sqlite3_finalize(pStmt);
2058	pStmt = 0;
2059	if( nCol==0 ) return 0; /* no columns, no error */
2060	zSql = sqlite3_malloc( nByte2 + 20 + nCol2 );
2061	if( zSql==0 ){
2062	fprintf(stderr, "Error: out of memory\n");
2063	fclose(sCsv.in);
2064	return 1;
2065	}
2066	sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable);
2067	j = strlen30(zSql);
2068	for(i=1; i<nCol; i++){
	@@ -2074,11 +2096,11 @@
2074	rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
2075	sqlite3_free(zSql);
2076	if( rc ){
2077	fprintf(stderr, "Error: %s\n", sqlite3_errmsg(db));
2078	if (pStmt) sqlite3_finalize(pStmt);
2079	fclose(sCsv.in);
2080	return 1;
2081	}
2082	do{
2083	int startLine = sCsv.nLine;
2084	for(i=0; i<nCol; i++){
	@@ -2110,11 +2132,11 @@
2110	sqlite3_errmsg(db));
2111	}
2112	}
2113	}while( sCsv.cTerm!=EOF );
2114
2115	fclose(sCsv.in);
2116	sqlite3_free(sCsv.z);
2117	sqlite3_finalize(pStmt);
2118	sqlite3_exec(p->db, "COMMIT", 0, 0, 0);
2119	}else
2120
	@@ -2435,10 +2457,11 @@
2435	}else{
2436	rc = 0;
2437	}
2438	}else
2439

2440	/* Undocumented commands for internal testing. Subject to change
2441	** without notice. */
2442	if( c=='s' && n>=10 && strncmp(azArg[0], "selftest-", 9)==0 ){
2443	if( strncmp(azArg[0]+9, "boolean", n-9)==0 ){
2444	int i, v;
	@@ -2448,15 +2471,18 @@
2448	}
2449	}
2450	if( strncmp(azArg[0]+9, "integer", n-9)==0 ){
2451	int i; sqlite3_int64 v;
2452	for(i=1; i<nArg; i++){

2453	v = integerValue(azArg[i]);
2454	fprintf(p->out, "%s: %lld 0x%llx\n", azArg[i], v, v);

2455	}
2456	}
2457	}else

2458
2459	if( c=='s' && strncmp(azArg[0], "separator", n)==0 && nArg==2 ){
2460	sqlite3_snprintf(sizeof(p->separator), p->separator,
2461	"%.*s", (int)sizeof(p->separator)-1, azArg[1]);
2462	}else
2463

	--- src/shell.c
	+++ src/shell.c
	@@ -1490,10 +1490,11 @@
1490	** Do C-language style dequoting.
1491	**
1492	** \t -> tab
1493	** \n -> newline
1494	** \r -> carriage return
1495	** \" -> "
1496	** \NNN -> ascii character NNN in octal
1497	** \\ -> backslash
1498	*/
1499	static void resolve_backslashes(char *z){
1500	int i, j;
	@@ -1505,10 +1506,12 @@
1506	c = '\n';
1507	}else if( c=='t' ){
1508	c = '\t';
1509	}else if( c=='r' ){
1510	c = '\r';
1511	}else if( c=='\\' ){
1512	c = '\\';
1513	}else if( c>='0' && c<='7' ){
1514	c -= '0';
1515	if( z[i+1]>='0' && z[i+1]<='7' ){
1516	i++;
1517	c = (c<<3) + z[i] - '0';
	@@ -1770,11 +1773,14 @@
1773	while( IsSpace(zLine[i]) ){ i++; }
1774	if( zLine[i]==0 ) break;
1775	if( zLine[i]=='\'' \|\| zLine[i]=='"' ){
1776	int delim = zLine[i++];
1777	azArg[nArg++] = &zLine[i];
1778	while( zLine[i] && zLine[i]!=delim ){
1779	if( zLine[i]=='\\' && delim=='"' && zLine[i+1]!=0 ) i++;
1780	i++;
1781	}
1782	if( zLine[i]==delim ){
1783	zLine[i++] = 0;
1784	}
1785	if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
1786	}else{
	@@ -1987,22 +1993,22 @@
1993	}
1994	}else
1995
1996	if( c=='i' && strncmp(azArg[0], "import", n)==0 && nArg==3 ){
1997	char zTable = azArg[2]; / Insert data into this table */
1998	char zFile = azArg[1]; / Name of file to extra content from */
1999	sqlite3_stmt pStmt = NULL; / A statement */
2000	int nCol; /* Number of columns in the table */
2001	int nByte; /* Number of bytes in an SQL string */
2002	int i, j; /* Loop counters */
2003	int nSep; /* Number of bytes in p->separator[] */
2004	char zSql; / An SQL statement */
2005	CSVReader sCsv; /* Reader context */
2006	int (xCloser)(FILE); /* Procedure to close th3 connection */
2007
2008	seenInterrupt = 0;
2009	memset(&sCsv, 0, sizeof(sCsv));


2010	open_db(p);
2011	nSep = strlen30(p->separator);
2012	if( nSep==0 ){
2013	fprintf(stderr, "Error: non-null separator required for import\n");
2014	return 1;
	@@ -2010,20 +2016,29 @@
2016	if( nSep>1 ){
2017	fprintf(stderr, "Error: multi-character separators not allowed"
2018	" for import\n");
2019	return 1;
2020	}
2021	sCsv.zFile = zFile;
2022	sCsv.nLine = 1;
2023	if( sCsv.zFile[0]=='\|' ){
2024	sCsv.in = popen(sCsv.zFile+1, "r");
2025	sCsv.zFile = "<pipe>";
2026	xCloser = pclose;
2027	}else{
2028	sCsv.in = fopen(sCsv.zFile, "rb");
2029	xCloser = fclose;
2030	}
2031	if( sCsv.in==0 ){
2032	fprintf(stderr, "Error: cannot open \"%s\"\n", zFile);
2033	return 1;
2034	}
2035	sCsv.cSeparator = p->separator[0];
2036	zSql = sqlite3_mprintf("SELECT * FROM %s", zTable);
2037	if( zSql==0 ){
2038	fprintf(stderr, "Error: out of memory\n");
2039	xCloser(sCsv.in);
2040	return 1;
2041	}
2042	nByte = strlen30(zSql);
2043	rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
2044	if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(db))==0 ){
	@@ -2031,38 +2046,45 @@
2046	char cSep = '(';
2047	while( csv_read_one_field(&sCsv) ){
2048	zCreate = sqlite3_mprintf("%z%c\n \"%s\" TEXT", zCreate, cSep, sCsv.z);
2049	cSep = ',';
2050	if( sCsv.cTerm!=sCsv.cSeparator ) break;
2051	}
2052	if( cSep=='(' ){
2053	sqlite3_free(zCreate);
2054	sqlite3_free(sCsv.z);
2055	xCloser(sCsv.in);
2056	fprintf(stderr,"%s: empty file\n", sCsv.zFile);
2057	return 1;
2058	}
2059	zCreate = sqlite3_mprintf("%z\n)", zCreate);
2060	rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
2061	sqlite3_free(zCreate);
2062	if( rc ){
2063	fprintf(stderr, "CREATE TABLE %s(...) failed: %s\n", zTable,
2064	sqlite3_errmsg(db));
2065	sqlite3_free(sCsv.z);
2066	xCloser(sCsv.in);
2067	return 1;
2068	}
2069	rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
2070	}
2071	sqlite3_free(zSql);
2072	if( rc ){
2073	if (pStmt) sqlite3_finalize(pStmt);
2074	fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
2075	xCloser(sCsv.in);
2076	return 1;
2077	}
2078	nCol = sqlite3_column_count(pStmt);
2079	sqlite3_finalize(pStmt);
2080	pStmt = 0;
2081	if( nCol==0 ) return 0; /* no columns, no error */
2082	zSql = sqlite3_malloc( nByte2 + 20 + nCol2 );
2083	if( zSql==0 ){
2084	fprintf(stderr, "Error: out of memory\n");
2085	xCloser(sCsv.in);
2086	return 1;
2087	}
2088	sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable);
2089	j = strlen30(zSql);
2090	for(i=1; i<nCol; i++){
	@@ -2074,11 +2096,11 @@
2096	rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
2097	sqlite3_free(zSql);
2098	if( rc ){
2099	fprintf(stderr, "Error: %s\n", sqlite3_errmsg(db));
2100	if (pStmt) sqlite3_finalize(pStmt);
2101	xCloser(sCsv.in);
2102	return 1;
2103	}
2104	do{
2105	int startLine = sCsv.nLine;
2106	for(i=0; i<nCol; i++){
	@@ -2110,11 +2132,11 @@
2132	sqlite3_errmsg(db));
2133	}
2134	}
2135	}while( sCsv.cTerm!=EOF );
2136
2137	xCloser(sCsv.in);
2138	sqlite3_free(sCsv.z);
2139	sqlite3_finalize(pStmt);
2140	sqlite3_exec(p->db, "COMMIT", 0, 0, 0);
2141	}else
2142
	@@ -2435,10 +2457,11 @@
2457	}else{
2458	rc = 0;
2459	}
2460	}else
2461
2462	#ifdef SQLITE_DEBUG
2463	/* Undocumented commands for internal testing. Subject to change
2464	** without notice. */
2465	if( c=='s' && n>=10 && strncmp(azArg[0], "selftest-", 9)==0 ){
2466	if( strncmp(azArg[0]+9, "boolean", n-9)==0 ){
2467	int i, v;
	@@ -2448,15 +2471,18 @@
2471	}
2472	}
2473	if( strncmp(azArg[0]+9, "integer", n-9)==0 ){
2474	int i; sqlite3_int64 v;
2475	for(i=1; i<nArg; i++){
2476	char zBuf[200];
2477	v = integerValue(azArg[i]);
2478	sqlite3_snprintf(sizeof(zBuf), zBuf, "%s: %lld 0x%llx\n", azArg[i], v, v);
2479	fprintf(p->out, "%s", zBuf);
2480	}
2481	}
2482	}else
2483	#endif
2484
2485	if( c=='s' && strncmp(azArg[0], "separator", n)==0 && nArg==2 ){
2486	sqlite3_snprintf(sizeof(p->separator), p->separator,
2487	"%.*s", (int)sizeof(p->separator)-1, azArg[1]);
2488	}else
2489

M src/sqlite3.c

+139 -66

		--- src/sqlite3.c
		+++ src/sqlite3.c
		@@ -670,11 +670,11 @@
670	670	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
671	671	** [sqlite_version()] and [sqlite_source_id()].
672	672	*/
673	673	#define SQLITE_VERSION "3.8.0"
674	674	#define SQLITE_VERSION_NUMBER 3008000
675		-#define SQLITE_SOURCE_ID "2013-06-26 22:46:00 93f632152e464a89322a0130adaf9f342411bf7d"
	675	+#define SQLITE_SOURCE_ID "2013-06-28 23:55:45 338826ef3f8a209b14f8d42370855cab9ac9ed45"
676	676
677	677	/*
678	678	** CAPI3REF: Run-Time Library Version Numbers
679	679	** KEYWORDS: sqlite3_version, sqlite3_sourceid
680	680	**
		@@ -1041,10 +1041,11 @@
1041	1041	#define SQLITE_IOERR_SEEK (SQLITE_IOERR \| (22<<8))
1042	1042	#define SQLITE_IOERR_DELETE_NOENT (SQLITE_IOERR \| (23<<8))
1043	1043	#define SQLITE_IOERR_MMAP (SQLITE_IOERR \| (24<<8))
1044	1044	#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED \| (1<<8))
1045	1045	#define SQLITE_BUSY_RECOVERY (SQLITE_BUSY \| (1<<8))
	1046	+#define SQLITE_BUSY_SNAPSHOT (SQLITE_BUSY \| (2<<8))
1046	1047	#define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN \| (1<<8))
1047	1048	#define SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN \| (2<<8))
1048	1049	#define SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN \| (3<<8))
1049	1050	#define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT \| (1<<8))
1050	1051	#define SQLITE_READONLY_RECOVERY (SQLITE_READONLY \| (1<<8))
		@@ -1060,10 +1061,11 @@
1060	1061	#define SQLITE_CONSTRAINT_TRIGGER (SQLITE_CONSTRAINT \| (7<<8))
1061	1062	#define SQLITE_CONSTRAINT_UNIQUE (SQLITE_CONSTRAINT \| (8<<8))
1062	1063	#define SQLITE_CONSTRAINT_VTAB (SQLITE_CONSTRAINT \| (9<<8))
1063	1064	#define SQLITE_NOTICE_RECOVER_WAL (SQLITE_NOTICE \| (1<<8))
1064	1065	#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE \| (2<<8))
	1066	+#define SQLITE_WARNING_AUTOINDEX (SQLITE_WARNING \| (1<<8))
1065	1067
1066	1068	/*
1067	1069	** CAPI3REF: Flags For File Open Operations
1068	1070	**
1069	1071	** These bit values are intended for use in the
		@@ -10076,13 +10078,14 @@
10076	10078	int newTnum; /* Rootpage of table being initialized */
10077	10079	u8 iDb; /* Which db file is being initialized */
10078	10080	u8 busy; /* TRUE if currently initializing */
10079	10081	u8 orphanTrigger; /* Last statement is orphaned TEMP trigger */
10080	10082	} init;
10081		- int activeVdbeCnt; /* Number of VDBEs currently executing */
10082		- int writeVdbeCnt; /* Number of active VDBEs that are writing */
10083		- int vdbeExecCnt; /* Number of nested calls to VdbeExec() */
	10083	+ int nVdbeActive; /* Number of VDBEs currently running */
	10084	+ int nVdbeRead; /* Number of active VDBEs that read or write */
	10085	+ int nVdbeWrite; /* Number of active VDBEs that read and write */
	10086	+ int nVdbeExec; /* Number of nested calls to VdbeExec() */
10084	10087	int nExtension; /* Number of loaded extensions */
10085	10088	void *aExtension; / Array of shared library handles */
10086	10089	void (xTrace)(void,const char); / Trace function */
10087	10090	void pTraceArg; / Argument to the trace function */
10088	10091	void (xProfile)(void,const char,u64); / Profiling function */
		@@ -10204,10 +10207,11 @@
10204	10207	#define SQLITE_CoverIdxScan 0x0040 /* Covering index scans */
10205	10208	#define SQLITE_OrderByIdxJoin 0x0080 /* ORDER BY of joins via index */
10206	10209	#define SQLITE_SubqCoroutine 0x0100 /* Evaluate subqueries as coroutines */
10207	10210	#define SQLITE_Transitive 0x0200 /* Transitive constraints */
10208	10211	#define SQLITE_OmitNoopJoin 0x0400 /* Omit unused tables in joins */
	10212	+#define SQLITE_Stat3 0x0800 /* Use the SQLITE_STAT3 table */
10209	10213	#define SQLITE_AllOpts 0xffff /* All optimizations */
10210	10214
10211	10215	/*
10212	10216	** Macros for testing whether or not optimizations are enabled or disabled.
10213	10217	*/
		@@ -13512,11 +13516,12 @@
13512	13516	bft inVtabMethod:2; /* See comments above */
13513	13517	bft changeCntOn:1; /* True to update the change-counter */
13514	13518	bft expired:1; /* True if the VM needs to be recompiled */
13515	13519	bft runOnlyOnce:1; /* Automatically expire on reset */
13516	13520	bft usesStmtJournal:1; /* True if uses a statement journal */
13517		- bft readOnly:1; /* True for read-only statements */
	13521	+ bft readOnly:1; /* True for statements that do not write */
	13522	+ bft bIsReader:1; /* True for statements that read */
13518	13523	bft isPrepareV2:1; /* True if prepared with prepare_v2() */
13519	13524	bft doingRerun:1; /* True if rerunning after an auto-reprepare */
13520	13525	int nChange; /* Number of db changes made since last reset */
13521	13526	yDbMask btreeMask; /* Bitmask of db->aDb[] entries referenced */
13522	13527	yDbMask lockMask; /* Subset of btreeMask that requires a lock */
		@@ -47891,11 +47896,11 @@
47891	47896	** the write is disallowed.
47892	47897	*/
47893	47898	if( memcmp(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr))!=0 ){
47894	47899	walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
47895	47900	pWal->writeLock = 0;
47896		- rc = SQLITE_BUSY;
	47901	+ rc = SQLITE_BUSY_SNAPSHOT;
47897	47902	}
47898	47903
47899	47904	return rc;
47900	47905	}
47901	47906
		@@ -52751,16 +52756,17 @@
52751	52756	** This function is called from both BtreeCommitPhaseTwo() and BtreeRollback()
52752	52757	** at the conclusion of a transaction.
52753	52758	*/
52754	52759	static void btreeEndTransaction(Btree *p){
52755	52760	BtShared *pBt = p->pBt;
	52761	+ sqlite3 *db = p->db;
52756	52762	assert( sqlite3BtreeHoldsMutex(p) );
52757	52763
52758	52764	#ifndef SQLITE_OMIT_AUTOVACUUM
52759	52765	pBt->bDoTruncate = 0;
52760	52766	#endif
52761		- if( p->inTrans>TRANS_NONE && p->db->activeVdbeCnt>1 ){
	52767	+ if( p->inTrans>TRANS_NONE && db->nVdbeRead>1 ){
52762	52768	/* If there are other active statements that belong to this database
52763	52769	** handle, downgrade to a read-only transaction. The other statements
52764	52770	** may still be reading from the database. */
52765	52771	downgradeAllSharedCacheTableLocks(p);
52766	52772	p->inTrans = TRANS_READ;
		@@ -60277,18 +60283,30 @@
60277	60283	int i;
60278	60284	int nMaxArgs = *pMaxFuncArgs;
60279	60285	Op *pOp;
60280	60286	int *aLabel = p->aLabel;
60281	60287	p->readOnly = 1;
	60288	+ p->bIsReader = 0;
60282	60289	for(pOp=p->aOp, i=p->nOp-1; i>=0; i--, pOp++){
60283	60290	u8 opcode = pOp->opcode;
60284	60291
60285	60292	pOp->opflags = sqlite3OpcodeProperty[opcode];
60286	60293	if( opcode==OP_Function \|\| opcode==OP_AggStep ){
60287	60294	if( pOp->p5>nMaxArgs ) nMaxArgs = pOp->p5;
60288		- }else if( (opcode==OP_Transaction && pOp->p2!=0) \|\| opcode==OP_Vacuum ){
	60295	+ }else if( opcode==OP_Transaction ){
	60296	+ if( pOp->p2!=0 ) p->readOnly = 0;
	60297	+ p->bIsReader = 1;
	60298	+ }else if( opcode==OP_AutoCommit \|\| opcode==OP_Savepoint ){
	60299	+ p->bIsReader = 1;
	60300	+ }else if( opcode==OP_Vacuum
	60301	+ \|\| opcode==OP_JournalMode
	60302	+#ifndef SQLITE_OMIT_VIRTUALTABLE
	60303	+ \|\| opcode==OP_Checkpoint
	60304	+#endif
	60305	+ ){
60289	60306	p->readOnly = 0;
	60307	+ p->bIsReader = 1;
60290	60308	#ifndef SQLITE_OMIT_VIRTUALTABLE
60291	60309	}else if( opcode==OP_VUpdate ){
60292	60310	if( pOp->p2>nMaxArgs ) nMaxArgs = pOp->p2;
60293	60311	}else if( opcode==OP_VFilter ){
60294	60312	int n;
		@@ -60310,12 +60328,12 @@
60310	60328	pOp->p2 = aLabel[-1-pOp->p2];
60311	60329	}
60312	60330	}
60313	60331	sqlite3DbFree(p->db, p->aLabel);
60314	60332	p->aLabel = 0;
60315		-
60316	60333	*pMaxFuncArgs = nMaxArgs;
	60334	+ assert( p->bIsReader!=0 \|\| p->btreeMask==0 );
60317	60335	}
60318	60336
60319	60337	/*
60320	60338	** Return the address of the next instruction to be inserted.
60321	60339	*/
		@@ -61837,11 +61855,11 @@
61837	61855
61838	61856	return rc;
61839	61857	}
61840	61858
61841	61859	/*
61842		-** This routine checks that the sqlite3.activeVdbeCnt count variable
	61860	+** This routine checks that the sqlite3.nVdbeActive count variable
61843	61861	** matches the number of vdbe's in the list sqlite3.pVdbe that are
61844	61862	** currently active. An assertion fails if the two counts do not match.
61845	61863	** This is an internal self-check only - it is not an essential processing
61846	61864	** step.
61847	61865	**
		@@ -61850,20 +61868,23 @@
61850	61868	#ifndef NDEBUG
61851	61869	static void checkActiveVdbeCnt(sqlite3 *db){
61852	61870	Vdbe *p;
61853	61871	int cnt = 0;
61854	61872	int nWrite = 0;
	61873	+ int nRead = 0;
61855	61874	p = db->pVdbe;
61856	61875	while( p ){
61857	61876	if( p->magic==VDBE_MAGIC_RUN && p->pc>=0 ){
61858	61877	cnt++;
61859	61878	if( p->readOnly==0 ) nWrite++;
	61879	+ if( p->bIsReader ) nRead++;
61860	61880	}
61861	61881	p = p->pNext;
61862	61882	}
61863		- assert( cnt==db->activeVdbeCnt );
61864		- assert( nWrite==db->writeVdbeCnt );
	61883	+ assert( cnt==db->nVdbeActive );
	61884	+ assert( nWrite==db->nVdbeWrite );
	61885	+ assert( nRead==db->nVdbeRead );
61865	61886	}
61866	61887	#else
61867	61888	#define checkActiveVdbeCnt(x)
61868	61889	#endif
61869	61890
		@@ -61995,12 +62016,13 @@
61995	62016	if( p->magic!=VDBE_MAGIC_RUN ){
61996	62017	return SQLITE_OK;
61997	62018	}
61998	62019	checkActiveVdbeCnt(db);
61999	62020
62000		- /* No commit or rollback needed if the program never started */
62001		- if( p->pc>=0 ){
	62021	+ /* No commit or rollback needed if the program never started or if the
	62022	+ ** SQL statement does not read or write a database file. */
	62023	+ if( p->pc>=0 && p->bIsReader ){
62002	62024	int mrc; /* Primary error code from p->rc */
62003	62025	int eStatementOp = 0;
62004	62026	int isSpecialError; /* Set to true if a 'special' error */
62005	62027
62006	62028	/* Lock all btrees used by the statement */
		@@ -62049,11 +62071,11 @@
62049	62071	** Note: This block also runs if one of the special errors handled
62050	62072	** above has occurred.
62051	62073	*/
62052	62074	if( !sqlite3VtabInSync(db)
62053	62075	&& db->autoCommit
62054		- && db->writeVdbeCnt==(p->readOnly==0)
	62076	+ && db->nVdbeWrite==(p->readOnly==0)
62055	62077	){
62056	62078	if( p->rc==SQLITE_OK \|\| (p->errorAction==OE_Fail && !isSpecialError) ){
62057	62079	rc = sqlite3VdbeCheckFk(p, 1);
62058	62080	if( rc!=SQLITE_OK ){
62059	62081	if( NEVER(p->readOnly) ){
		@@ -62130,15 +62152,16 @@
62130	62152	sqlite3VdbeLeave(p);
62131	62153	}
62132	62154
62133	62155	/* We have successfully halted and closed the VM. Record this fact. */
62134	62156	if( p->pc>=0 ){
62135		- db->activeVdbeCnt--;
62136		- if( !p->readOnly ){
62137		- db->writeVdbeCnt--;
62138		- }
62139		- assert( db->activeVdbeCnt>=db->writeVdbeCnt );
	62157	+ db->nVdbeActive--;
	62158	+ if( !p->readOnly ) db->nVdbeWrite--;
	62159	+ if( p->bIsReader ) db->nVdbeRead--;
	62160	+ assert( db->nVdbeActive>=db->nVdbeRead );
	62161	+ assert( db->nVdbeRead>=db->nVdbeWrite );
	62162	+ assert( db->nVdbeWrite>=0 );
62140	62163	}
62141	62164	p->magic = VDBE_MAGIC_HALT;
62142	62165	checkActiveVdbeCnt(db);
62143	62166	if( p->db->mallocFailed ){
62144	62167	p->rc = SQLITE_NOMEM;
		@@ -62150,11 +62173,11 @@
62150	62173	*/
62151	62174	if( db->autoCommit ){
62152	62175	sqlite3ConnectionUnlocked(db);
62153	62176	}
62154	62177
62155		- assert( db->activeVdbeCnt>0 \|\| db->autoCommit==0 \|\| db->nStatement==0 );
	62178	+ assert( db->nVdbeActive>0 \|\| db->autoCommit==0 \|\| db->nStatement==0 );
62156	62179	return (p->rc==SQLITE_BUSY ? SQLITE_BUSY : SQLITE_OK);
62157	62180	}
62158	62181
62159	62182
62160	62183	/*
		@@ -63508,35 +63531,36 @@
63508	63531	if( p->pc<0 ){
63509	63532	/* If there are no other statements currently running, then
63510	63533	** reset the interrupt flag. This prevents a call to sqlite3_interrupt
63511	63534	** from interrupting a statement that has not yet started.
63512	63535	*/
63513		- if( db->activeVdbeCnt==0 ){
	63536	+ if( db->nVdbeActive==0 ){
63514	63537	db->u1.isInterrupted = 0;
63515	63538	}
63516	63539
63517		- assert( db->writeVdbeCnt>0 \|\| db->autoCommit==0 \|\| db->nDeferredCons==0 );
	63540	+ assert( db->nVdbeWrite>0 \|\| db->autoCommit==0 \|\| db->nDeferredCons==0 );
63518	63541
63519	63542	#ifndef SQLITE_OMIT_TRACE
63520	63543	if( db->xProfile && !db->init.busy ){
63521	63544	sqlite3OsCurrentTimeInt64(db->pVfs, &p->startTime);
63522	63545	}
63523	63546	#endif
63524	63547
63525		- db->activeVdbeCnt++;
63526		- if( p->readOnly==0 ) db->writeVdbeCnt++;
	63548	+ db->nVdbeActive++;
	63549	+ if( p->readOnly==0 ) db->nVdbeWrite++;
	63550	+ if( p->bIsReader ) db->nVdbeRead++;
63527	63551	p->pc = 0;
63528	63552	}
63529	63553	#ifndef SQLITE_OMIT_EXPLAIN
63530	63554	if( p->explain ){
63531	63555	rc = sqlite3VdbeList(p);
63532	63556	}else
63533	63557	#endif /* SQLITE_OMIT_EXPLAIN */
63534	63558	{
63535		- db->vdbeExecCnt++;
	63559	+ db->nVdbeExec++;
63536	63560	rc = sqlite3VdbeExec(p);
63537		- db->vdbeExecCnt--;
	63561	+ db->nVdbeExec--;
63538	63562	}
63539	63563
63540	63564	#ifndef SQLITE_OMIT_TRACE
63541	63565	/* Invoke the profile callback if there is one
63542	63566	*/
		@@ -64469,13 +64493,13 @@
64469	64493	return nTotal;
64470	64494	}
64471	64495
64472	64496	/*
64473	64497	** This function returns a pointer to a nul-terminated string in memory
64474		-** obtained from sqlite3DbMalloc(). If sqlite3.vdbeExecCnt is 1, then the
	64498	+** obtained from sqlite3DbMalloc(). If sqlite3.nVdbeExec is 1, then the
64475	64499	** string contains a copy of zRawSql but with host parameters expanded to
64476		-** their current bindings. Or, if sqlite3.vdbeExecCnt is greater than 1,
	64500	+** their current bindings. Or, if sqlite3.nVdbeExec is greater than 1,
64477	64501	** then the returned string holds a copy of zRawSql with "-- " prepended
64478	64502	** to each line of text.
64479	64503	**
64480	64504	** If the SQLITE_TRACE_SIZE_LIMIT macro is defined to an integer, then
64481	64505	** then long strings and blobs are truncated to that many bytes. This
		@@ -64509,11 +64533,11 @@
64509	64533
64510	64534	db = p->db;
64511	64535	sqlite3StrAccumInit(&out, zBase, sizeof(zBase),
64512	64536	db->aLimit[SQLITE_LIMIT_LENGTH]);
64513	64537	out.db = db;
64514		- if( db->vdbeExecCnt>1 ){
	64538	+ if( db->nVdbeExec>1 ){
64515	64539	while( *zRawSql ){
64516	64540	const char *zStart = zRawSql;
64517	64541	while( (zRawSql++)!='\n' && zRawSql );
64518	64542	sqlite3StrAccumAppend(&out, "-- ", 3);
64519	64543	sqlite3StrAccumAppend(&out, zStart, (int)(zRawSql-zStart));
		@@ -65815,10 +65839,11 @@
65815	65839	/* This happens if a malloc() inside a call to sqlite3_column_text() or
65816	65840	** sqlite3_column_text16() failed. */
65817	65841	goto no_mem;
65818	65842	}
65819	65843	assert( p->rc==SQLITE_OK \|\| p->rc==SQLITE_BUSY );
	65844	+ assert( p->bIsReader \|\| p->readOnly!=0 );
65820	65845	p->rc = SQLITE_OK;
65821	65846	assert( p->explain==0 );
65822	65847	p->pResultSet = 0;
65823	65848	db->busyHandler.nBusy = 0;
65824	65849	CHECK_FOR_INTERRUPT;
		@@ -67959,13 +67984,14 @@
67959	67984	*/
67960	67985	assert( db->pSavepoint==0 \|\| db->autoCommit==0 );
67961	67986	assert( u.as.p1==SAVEPOINT_BEGIN\|\|u.as.p1==SAVEPOINT_RELEASE\|\|u.as.p1==SAVEPOINT_ROLLBACK );
67962	67987	assert( db->pSavepoint \|\| db->isTransactionSavepoint==0 );
67963	67988	assert( checkSavepointCount(db) );
	67989	+ assert( p->bIsReader );
67964	67990
67965	67991	if( u.as.p1==SAVEPOINT_BEGIN ){
67966		- if( db->writeVdbeCnt>0 ){
	67992	+ if( db->nVdbeWrite>0 ){
67967	67993	/* A new savepoint cannot be created if there are active write
67968	67994	** statements (i.e. open read/write incremental blob handles).
67969	67995	*/
67970	67996	sqlite3SetString(&p->zErrMsg, db, "cannot open savepoint - "
67971	67997	"SQL statements in progress");
		@@ -68018,11 +68044,11 @@
68018	68044	u.as.iSavepoint++;
68019	68045	}
68020	68046	if( !u.as.pSavepoint ){
68021	68047	sqlite3SetString(&p->zErrMsg, db, "no such savepoint: %s", u.as.zName);
68022	68048	rc = SQLITE_ERROR;
68023		- }else if( db->writeVdbeCnt>0 && u.as.p1==SAVEPOINT_RELEASE ){
	68049	+ }else if( db->nVdbeWrite>0 && u.as.p1==SAVEPOINT_RELEASE ){
68024	68050	/* It is not possible to release (commit) a savepoint if there are
68025	68051	** active write statements.
68026	68052	*/
68027	68053	sqlite3SetString(&p->zErrMsg, db,
68028	68054	"cannot release savepoint - SQL statements in progress"
		@@ -68121,24 +68147,25 @@
68121	68147	u.at.desiredAutoCommit = pOp->p1;
68122	68148	u.at.iRollback = pOp->p2;
68123	68149	u.at.turnOnAC = u.at.desiredAutoCommit && !db->autoCommit;
68124	68150	assert( u.at.desiredAutoCommit==1 \|\| u.at.desiredAutoCommit==0 );
68125	68151	assert( u.at.desiredAutoCommit==1 \|\| u.at.iRollback==0 );
68126		- assert( db->activeVdbeCnt>0 ); /* At least this one VM is active */
	68152	+ assert( db->nVdbeActive>0 ); /* At least this one VM is active */
	68153	+ assert( p->bIsReader );
68127	68154
68128	68155	#if 0
68129		- if( u.at.turnOnAC && u.at.iRollback && db->activeVdbeCnt>1 ){
	68156	+ if( u.at.turnOnAC && u.at.iRollback && db->nVdbeActive>1 ){
68130	68157	/* If this instruction implements a ROLLBACK and other VMs are
68131	68158	** still running, and a transaction is active, return an error indicating
68132	68159	** that the other VMs must complete first.
68133	68160	*/
68134	68161	sqlite3SetString(&p->zErrMsg, db, "cannot rollback transaction - "
68135	68162	"SQL statements in progress");
68136	68163	rc = SQLITE_BUSY;
68137	68164	}else
68138	68165	#endif
68139		- if( u.at.turnOnAC && !u.at.iRollback && db->writeVdbeCnt>0 ){
	68166	+ if( u.at.turnOnAC && !u.at.iRollback && db->nVdbeWrite>0 ){
68140	68167	/* If this instruction implements a COMMIT and other VMs are writing
68141	68168	** return an error indicating that the other VMs must complete first.
68142	68169	*/
68143	68170	sqlite3SetString(&p->zErrMsg, db, "cannot commit transaction - "
68144	68171	"SQL statements in progress");
		@@ -68212,10 +68239,12 @@
68212	68239	case OP_Transaction: {
68213	68240	#if 0 /* local variables moved into u.au */
68214	68241	Btree *pBt;
68215	68242	#endif /* local variables moved into u.au */
68216	68243
	68244	+ assert( p->bIsReader );
	68245	+ assert( p->readOnly==0 \|\| pOp->p2==0 );
68217	68246	assert( pOp->p1>=0 && pOp->p1<db->nDb );
68218	68247	assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
68219	68248	u.au.pBt = db->aDb[pOp->p1].pBt;
68220	68249
68221	68250	if( u.au.pBt ){
		@@ -68228,11 +68257,11 @@
68228	68257	if( rc!=SQLITE_OK ){
68229	68258	goto abort_due_to_error;
68230	68259	}
68231	68260
68232	68261	if( pOp->p2 && p->usesStmtJournal
68233		- && (db->autoCommit==0 \|\| db->activeVdbeCnt>1)
	68262	+ && (db->autoCommit==0 \|\| db->nVdbeRead>1)
68234	68263	){
68235	68264	assert( sqlite3BtreeIsInTrans(u.au.pBt) );
68236	68265	if( p->iStatement==0 ){
68237	68266	assert( db->nStatement>=0 && db->nSavepoint>=0 );
68238	68267	db->nStatement++;
		@@ -68270,10 +68299,11 @@
68270	68299	int iMeta;
68271	68300	int iDb;
68272	68301	int iCookie;
68273	68302	#endif /* local variables moved into u.av */
68274	68303
	68304	+ assert( p->bIsReader );
68275	68305	u.av.iDb = pOp->p1;
68276	68306	u.av.iCookie = pOp->p3;
68277	68307	assert( pOp->p3<SQLITE_N_BTREE_META );
68278	68308	assert( u.av.iDb>=0 && u.av.iDb<db->nDb );
68279	68309	assert( db->aDb[u.av.iDb].pBt!=0 );
		@@ -68299,10 +68329,11 @@
68299	68329	Db *pDb;
68300	68330	#endif /* local variables moved into u.aw */
68301	68331	assert( pOp->p2<SQLITE_N_BTREE_META );
68302	68332	assert( pOp->p1>=0 && pOp->p1<db->nDb );
68303	68333	assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
	68334	+ assert( p->readOnly==0 );
68304	68335	u.aw.pDb = &db->aDb[pOp->p1];
68305	68336	assert( u.aw.pDb->pBt!=0 );
68306	68337	assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
68307	68338	pIn3 = &aMem[pOp->p3];
68308	68339	sqlite3VdbeMemIntegerify(pIn3);
		@@ -68351,10 +68382,11 @@
68351	68382	#endif /* local variables moved into u.ax */
68352	68383
68353	68384	assert( pOp->p1>=0 && pOp->p1<db->nDb );
68354	68385	assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
68355	68386	assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
	68387	+ assert( p->bIsReader );
68356	68388	u.ax.pBt = db->aDb[pOp->p1].pBt;
68357	68389	if( u.ax.pBt ){
68358	68390	sqlite3BtreeGetMeta(u.ax.pBt, BTREE_SCHEMA_VERSION, (u32 *)&u.ax.iMeta);
68359	68391	u.ax.iGen = db->aDb[pOp->p1].pSchema->iGeneration;
68360	68392	}else{
		@@ -68448,10 +68480,12 @@
68448	68480	Db *pDb;
68449	68481	#endif /* local variables moved into u.ay */
68450	68482
68451	68483	assert( (pOp->p5&(OPFLAG_P2ISREG\|OPFLAG_BULKCSR))==pOp->p5 );
68452	68484	assert( pOp->opcode==OP_OpenWrite \|\| pOp->p5==0 );
	68485	+ assert( p->bIsReader );
	68486	+ assert( pOp->opcode==OP_OpenRead \|\| p->readOnly==0 );
68453	68487
68454	68488	if( p->expired ){
68455	68489	rc = SQLITE_ABORT;
68456	68490	break;
68457	68491	}
		@@ -70066,19 +70100,22 @@
70066	70100	int iCnt;
70067	70101	Vdbe *pVdbe;
70068	70102	int iDb;
70069	70103	#endif /* local variables moved into u.bw */
70070	70104
	70105	+ assert( p->readOnly==0 );
70071	70106	#ifndef SQLITE_OMIT_VIRTUALTABLE
70072	70107	u.bw.iCnt = 0;
70073	70108	for(u.bw.pVdbe=db->pVdbe; u.bw.pVdbe; u.bw.pVdbe = u.bw.pVdbe->pNext){
70074		- if( u.bw.pVdbe->magic==VDBE_MAGIC_RUN && u.bw.pVdbe->inVtabMethod<2 && u.bw.pVdbe->pc>=0 ){
	70109	+ if( u.bw.pVdbe->magic==VDBE_MAGIC_RUN && u.bw.pVdbe->bIsReader
	70110	+ && u.bw.pVdbe->inVtabMethod<2 && u.bw.pVdbe->pc>=0
	70111	+ ){
70075	70112	u.bw.iCnt++;
70076	70113	}
70077	70114	}
70078	70115	#else
70079		- u.bw.iCnt = db->activeVdbeCnt;
	70116	+ u.bw.iCnt = db->nVdbeRead;
70080	70117	#endif
70081	70118	pOut->flags = MEM_Null;
70082	70119	if( u.bw.iCnt>1 ){
70083	70120	rc = SQLITE_LOCKED;
70084	70121	p->errorAction = OE_Abort;
		@@ -70123,10 +70160,11 @@
70123	70160	#if 0 /* local variables moved into u.bx */
70124	70161	int nChange;
70125	70162	#endif /* local variables moved into u.bx */
70126	70163
70127	70164	u.bx.nChange = 0;
	70165	+ assert( p->readOnly==0 );
70128	70166	assert( (p->btreeMask & (((yDbMask)1)<<pOp->p2))!=0 );
70129	70167	rc = sqlite3BtreeClearTable(
70130	70168	db->aDb[pOp->p2].pBt, pOp->p1, (pOp->p3 ? &u.bx.nChange : 0)
70131	70169	);
70132	70170	if( pOp->p3 ){
		@@ -70171,10 +70209,11 @@
70171	70209	#endif /* local variables moved into u.by */
70172	70210
70173	70211	u.by.pgno = 0;
70174	70212	assert( pOp->p1>=0 && pOp->p1<db->nDb );
70175	70213	assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
	70214	+ assert( p->readOnly==0 );
70176	70215	u.by.pDb = &db->aDb[pOp->p1];
70177	70216	assert( u.by.pDb->pBt!=0 );
70178	70217	if( pOp->opcode==OP_CreateTable ){
70179	70218	/* u.by.flags = BTREE_INTKEY; */
70180	70219	u.by.flags = BTREE_INTKEY;
		@@ -70323,10 +70362,11 @@
70323	70362	int nErr; /* Number of errors reported */
70324	70363	char z; / Text of the error report */
70325	70364	Mem pnErr; / Register keeping track of errors remaining */
70326	70365	#endif /* local variables moved into u.ca */
70327	70366
	70367	+ assert( p->bIsReader );
70328	70368	u.ca.nRoot = pOp->p2;
70329	70369	assert( u.ca.nRoot>0 );
70330	70370	u.ca.aRoot = sqlite3DbMallocRaw(db, sizeof(int)*(u.ca.nRoot+1) );
70331	70371	if( u.ca.aRoot==0 ) goto no_mem;
70332	70372	assert( pOp->p3>0 && pOp->p3<=p->nMem );
		@@ -70844,10 +70884,11 @@
70844	70884	int i; /* Loop counter */
70845	70885	int aRes[3]; /* Results */
70846	70886	Mem pMem; / Write results here */
70847	70887	#endif /* local variables moved into u.ci */
70848	70888
	70889	+ assert( p->readOnly==0 );
70849	70890	u.ci.aRes[0] = 0;
70850	70891	u.ci.aRes[1] = u.ci.aRes[2] = -1;
70851	70892	assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE
70852	70893	\|\| pOp->p2==SQLITE_CHECKPOINT_FULL
70853	70894	\|\| pOp->p2==SQLITE_CHECKPOINT_RESTART
		@@ -70895,10 +70936,11 @@
70895	70936	\|\| u.cj.eNew==PAGER_JOURNALMODE_MEMORY
70896	70937	\|\| u.cj.eNew==PAGER_JOURNALMODE_WAL
70897	70938	\|\| u.cj.eNew==PAGER_JOURNALMODE_QUERY
70898	70939	);
70899	70940	assert( pOp->p1>=0 && pOp->p1<db->nDb );
	70941	+ assert( p->readOnly==0 );
70900	70942
70901	70943	u.cj.pBt = db->aDb[pOp->p1].pBt;
70902	70944	u.cj.pPager = sqlite3BtreePager(u.cj.pBt);
70903	70945	u.cj.eOld = sqlite3PagerGetJournalMode(u.cj.pPager);
70904	70946	if( u.cj.eNew==PAGER_JOURNALMODE_QUERY ) u.cj.eNew = u.cj.eOld;
		@@ -70918,11 +70960,11 @@
70918	70960	}
70919	70961
70920	70962	if( (u.cj.eNew!=u.cj.eOld)
70921	70963	&& (u.cj.eOld==PAGER_JOURNALMODE_WAL \|\| u.cj.eNew==PAGER_JOURNALMODE_WAL)
70922	70964	){
70923		- if( !db->autoCommit \|\| db->activeVdbeCnt>1 ){
	70965	+ if( !db->autoCommit \|\| db->nVdbeRead>1 ){
70924	70966	rc = SQLITE_ERROR;
70925	70967	sqlite3SetString(&p->zErrMsg, db,
70926	70968	"cannot change %s wal mode from within a transaction",
70927	70969	(u.cj.eNew==PAGER_JOURNALMODE_WAL ? "into" : "out of")
70928	70970	);
		@@ -70977,10 +71019,11 @@
70977	71019	** Vacuum the entire database. This opcode will cause other virtual
70978	71020	** machines to be created and run. It may not be called from within
70979	71021	** a transaction.
70980	71022	*/
70981	71023	case OP_Vacuum: {
	71024	+ assert( p->readOnly==0 );
70982	71025	rc = sqlite3RunVacuum(&p->zErrMsg, db);
70983	71026	break;
70984	71027	}
70985	71028	#endif
70986	71029
		@@ -70996,10 +71039,11 @@
70996	71039	Btree *pBt;
70997	71040	#endif /* local variables moved into u.ck */
70998	71041
70999	71042	assert( pOp->p1>=0 && pOp->p1<db->nDb );
71000	71043	assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
	71044	+ assert( p->readOnly==0 );
71001	71045	u.ck.pBt = db->aDb[pOp->p1].pBt;
71002	71046	rc = sqlite3BtreeIncrVacuum(u.ck.pBt);
71003	71047	if( rc==SQLITE_DONE ){
71004	71048	pc = pOp->p2 - 1;
71005	71049	rc = SQLITE_OK;
		@@ -71118,10 +71162,11 @@
71118	71162	sqlite3_vtab_cursor *pVtabCursor;
71119	71163	sqlite3_vtab *pVtab;
71120	71164	sqlite3_module *pModule;
71121	71165	#endif /* local variables moved into u.cm */
71122	71166
	71167	+ assert( p->bIsReader );
71123	71168	u.cm.pCur = 0;
71124	71169	u.cm.pVtabCursor = 0;
71125	71170	u.cm.pVtab = pOp->p4.pVtab->pVtab;
71126	71171	u.cm.pModule = (sqlite3_module *)u.cm.pVtab->pModule;
71127	71172	assert(u.cm.pVtab && u.cm.pModule);
		@@ -71342,10 +71387,11 @@
71342	71387
71343	71388	u.cq.pVtab = pOp->p4.pVtab->pVtab;
71344	71389	u.cq.pName = &aMem[pOp->p1];
71345	71390	assert( u.cq.pVtab->pModule->xRename );
71346	71391	assert( memIsValid(u.cq.pName) );
	71392	+ assert( p->readOnly==0 );
71347	71393	REGISTER_TRACE(pOp->p1, u.cq.pName);
71348	71394	assert( u.cq.pName->flags & MEM_Str );
71349	71395	testcase( u.cq.pName->enc==SQLITE_UTF8 );
71350	71396	testcase( u.cq.pName->enc==SQLITE_UTF16BE );
71351	71397	testcase( u.cq.pName->enc==SQLITE_UTF16LE );
		@@ -71395,10 +71441,11 @@
71395	71441	#endif /* local variables moved into u.cr */
71396	71442
71397	71443	assert( pOp->p2==1 \|\| pOp->p5==OE_Fail \|\| pOp->p5==OE_Rollback
71398	71444	\|\| pOp->p5==OE_Abort \|\| pOp->p5==OE_Ignore \|\| pOp->p5==OE_Replace
71399	71445	);
	71446	+ assert( p->readOnly==0 );
71400	71447	u.cr.pVtab = pOp->p4.pVtab->pVtab;
71401	71448	u.cr.pModule = (sqlite3_module *)u.cr.pVtab->pModule;
71402	71449	u.cr.nArg = pOp->p2;
71403	71450	assert( pOp->p4type==P4_VTAB );
71404	71451	if( ALWAYS(u.cr.pModule->xUpdate) ){
		@@ -102957,11 +103004,11 @@
102957	103004
102958	103005	if( !db->autoCommit ){
102959	103006	sqlite3SetString(pzErrMsg, db, "cannot VACUUM from within a transaction");
102960	103007	return SQLITE_ERROR;
102961	103008	}
102962		- if( db->activeVdbeCnt>1 ){
	103009	+ if( db->nVdbeActive>1 ){
102963	103010	sqlite3SetString(pzErrMsg, db,"cannot VACUUM - SQL statements in progress");
102964	103011	return SQLITE_ERROR;
102965	103012	}
102966	103013
102967	103014	/* Save the current value of the database flags so that it can be
		@@ -104742,11 +104789,11 @@
104742	104789	#define WHERE_INDEXED 0x00000200 /* WhereLoop.u.btree.pIndex is valid */
104743	104790	#define WHERE_VIRTUALTABLE 0x00000400 /* WhereLoop.u.vtab is valid */
104744	104791	#define WHERE_IN_ABLE 0x00000800 /* Able to support an IN operator */
104745	104792	#define WHERE_ONEROW 0x00001000 /* Selects no more than one row */
104746	104793	#define WHERE_MULTI_OR 0x00002000 /* OR using multiple indices */
104747		-#define WHERE_TEMP_INDEX 0x00004000 /* Uses an ephemeral index */
	104794	+#define WHERE_AUTO_INDEX 0x00004000 /* Uses an ephemeral index */
104748	104795
104749	104796
104750	104797	/* Convert a WhereCost value (10 times log2(X)) into its integer value X.
104751	104798	** A rough approximation is used. The value returned is not exact.
104752	104799	*/
		@@ -106036,10 +106083,11 @@
106036	106083	** the start of the loop will prevent any results from being returned.
106037	106084	*/
106038	106085	if( pExpr->op==TK_NOTNULL
106039	106086	&& pExpr->pLeft->op==TK_COLUMN
106040	106087	&& pExpr->pLeft->iColumn>=0
	106088	+ && OptimizationEnabled(db, SQLITE_Stat3)
106041	106089	){
106042	106090	Expr *pNewExpr;
106043	106091	Expr *pLeft = pExpr->pLeft;
106044	106092	int idxNew;
106045	106093	WhereTerm *pNewTerm;
		@@ -106339,10 +106387,11 @@
106339	106387	int mxBitCol; /* Maximum column in pSrc->colUsed */
106340	106388	CollSeq pColl; / Collating sequence to on a column */
106341	106389	WhereLoop pLoop; / The Loop object */
106342	106390	Bitmask idxCols; /* Bitmap of columns used for indexing */
106343	106391	Bitmask extraCols; /* Bitmap of additional columns */
	106392	+ u8 sentWarning = 0; /* True if a warnning has been issued */
106344	106393
106345	106394	/* Generate code to skip over the creation and initialization of the
106346	106395	** transient index on 2nd and subsequent iterations of the loop. */
106347	106396	v = pParse->pVdbe;
106348	106397	assert( v!=0 );
		@@ -106359,10 +106408,16 @@
106359	106408	if( termCanDriveIndex(pTerm, pSrc, notReady) ){
106360	106409	int iCol = pTerm->u.leftColumn;
106361	106410	Bitmask cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
106362	106411	testcase( iCol==BMS );
106363	106412	testcase( iCol==BMS-1 );
	106413	+ if( !sentWarning ){
	106414	+ sqlite3_log(SQLITE_WARNING_AUTOINDEX,
	106415	+ "automatic index on %s(%s)", pTable->zName,
	106416	+ pTable->aCol[iCol].zName);
	106417	+ sentWarning = 1;
	106418	+ }
106364	106419	if( (idxCols & cMask)==0 ){
106365	106420	if( whereLoopResize(pParse->db, pLoop, nColumn+1) ) return;
106366	106421	pLoop->aLTerm[nColumn++] = pTerm;
106367	106422	idxCols \|= cMask;
106368	106423	}
		@@ -106369,11 +106424,11 @@
106369	106424	}
106370	106425	}
106371	106426	assert( nColumn>0 );
106372	106427	pLoop->u.btree.nEq = pLoop->nLTerm = nColumn;
106373	106428	pLoop->wsFlags = WHERE_COLUMN_EQ \| WHERE_IDX_ONLY \| WHERE_INDEXED
106374		- \| WHERE_TEMP_INDEX;
	106429	+ \| WHERE_AUTO_INDEX;
106375	106430
106376	106431	/* Count the number of additional columns needed to create a
106377	106432	** covering index. A "covering index" is an index that contains all
106378	106433	** columns that are needed by the query. With a covering index, the
106379	106434	** original table never needs to be accessed. Automatic indices must
		@@ -106869,11 +106924,11 @@
106869	106924	){
106870	106925	int rc = SQLITE_OK;
106871	106926
106872	106927	#ifdef SQLITE_ENABLE_STAT3
106873	106928
106874		- if( nEq==0 && p->nSample ){
	106929	+ if( nEq==0 && p->nSample && OptimizationEnabled(pParse->db, SQLITE_Stat3) ){
106875	106930	sqlite3_value *pRangeVal;
106876	106931	tRowcnt iLower = 0;
106877	106932	tRowcnt iUpper = p->aiRowEst[0];
106878	106933	tRowcnt a[2];
106879	106934	u8 aff = p->pTable->aCol[p->aiColumn[0]].affinity;
		@@ -107415,17 +107470,16 @@
107415	107470	}
107416	107471	if( (flags & (WHERE_IPK\|WHERE_VIRTUALTABLE))==0
107417	107472	&& ALWAYS(pLoop->u.btree.pIndex!=0)
107418	107473	){
107419	107474	char *zWhere = explainIndexRange(db, pLoop, pItem->pTab);
107420		- zMsg = sqlite3MAppendf(db, zMsg, "%s USING %s%sINDEX%s%s%s", zMsg,
107421		- ((flags & WHERE_TEMP_INDEX)?"AUTOMATIC ":""),
107422		- ((flags & WHERE_IDX_ONLY)?"COVERING ":""),
107423		- ((flags & WHERE_TEMP_INDEX)?"":" "),
107424		- ((flags & WHERE_TEMP_INDEX)?"": pLoop->u.btree.pIndex->zName),
107425		- zWhere
107426		- );
	107475	+ zMsg = sqlite3MAppendf(db, zMsg,
	107476	+ ((flags & WHERE_AUTO_INDEX) ?
	107477	+ "%s USING AUTOMATIC %sINDEX%.0s%s" :
	107478	+ "%s USING %sINDEX %s%s"),
	107479	+ zMsg, ((flags & WHERE_IDX_ONLY) ? "COVERING " : ""),
	107480	+ pLoop->u.btree.pIndex->zName, zWhere);
107427	107481	sqlite3DbFree(db, zWhere);
107428	107482	}else if( (flags & WHERE_IPK)!=0 && (flags & WHERE_CONSTRAINT)!=0 ){
107429	107483	zMsg = sqlite3MAppendf(db, zMsg, "%s USING INTEGER PRIMARY KEY", zMsg);
107430	107484
107431	107485	if( flags&(WHERE_COLUMN_EQ\|WHERE_COLUMN_IN) ){
		@@ -108092,11 +108146,11 @@
108092	108146	** terms, set pCov to the candidate covering index. Otherwise, set
108093	108147	** pCov to NULL to indicate that no candidate covering index will
108094	108148	** be available.
108095	108149	*/
108096	108150	pSubLoop = pSubWInfo->a[0].pWLoop;
108097		- assert( (pSubLoop->wsFlags & WHERE_TEMP_INDEX)==0 );
	108151	+ assert( (pSubLoop->wsFlags & WHERE_AUTO_INDEX)==0 );
108098	108152	if( (pSubLoop->wsFlags & WHERE_INDEXED)!=0
108099	108153	&& (ii==0 \|\| pSubLoop->u.btree.pIndex==pCov)
108100	108154	){
108101	108155	assert( pSubWInfo->a[0].iIdxCur==iCovCur );
108102	108156	pCov = pSubLoop->u.btree.pIndex;
		@@ -108274,16 +108328,16 @@
108274	108328
108275	108329	/*
108276	108330	** Clear the WhereLoop.u union. Leave WhereLoop.pLTerm intact.
108277	108331	*/
108278	108332	static void whereLoopClearUnion(sqlite3 db, WhereLoop p){
108279		- if( p->wsFlags & (WHERE_VIRTUALTABLE\|WHERE_TEMP_INDEX) ){
	108333	+ if( p->wsFlags & (WHERE_VIRTUALTABLE\|WHERE_AUTO_INDEX) ){
108280	108334	if( (p->wsFlags & WHERE_VIRTUALTABLE)!=0 && p->u.vtab.needFree ){
108281	108335	sqlite3_free(p->u.vtab.idxStr);
108282	108336	p->u.vtab.needFree = 0;
108283	108337	p->u.vtab.idxStr = 0;
108284		- }else if( (p->wsFlags & WHERE_TEMP_INDEX)!=0 && p->u.btree.pIndex!=0 ){
	108338	+ }else if( (p->wsFlags & WHERE_AUTO_INDEX)!=0 && p->u.btree.pIndex!=0 ){
108285	108339	sqlite3DbFree(db, p->u.btree.pIndex->zColAff);
108286	108340	sqlite3DbFree(db, p->u.btree.pIndex);
108287	108341	p->u.btree.pIndex = 0;
108288	108342	}
108289	108343	}
		@@ -108322,11 +108376,11 @@
108322	108376	whereLoopClearUnion(db, pTo);
108323	108377	memcpy(pTo, pFrom, WHERE_LOOP_XFER_SZ);
108324	108378	memcpy(pTo->aLTerm, pFrom->aLTerm, pTo->nLTerm*sizeof(pTo->aLTerm[0]));
108325	108379	if( pFrom->wsFlags & WHERE_VIRTUALTABLE ){
108326	108380	pFrom->u.vtab.needFree = 0;
108327		- }else if( (pFrom->wsFlags & WHERE_TEMP_INDEX)!=0 ){
	108381	+ }else if( (pFrom->wsFlags & WHERE_AUTO_INDEX)!=0 ){
108328	108382	pFrom->u.btree.pIndex = 0;
108329	108383	}
108330	108384	return SQLITE_OK;
108331	108385	}
108332	108386
		@@ -108634,11 +108688,12 @@
108634	108688	whereRangeScanEst(pParse, pProbe, pNew->u.btree.nEq,
108635	108689	pBtm, pTop, &rDiv);
108636	108690	pNew->nOut = saved_nOut>rDiv+10 ? saved_nOut - rDiv : 10;
108637	108691	}
108638	108692	#ifdef SQLITE_ENABLE_STAT3
108639		- if( pNew->u.btree.nEq==1 && pProbe->nSample ){
	108693	+ if( pNew->u.btree.nEq==1 && pProbe->nSample
	108694	+ && OptimizationEnabled(db, SQLITE_Stat3) ){
108640	108695	tRowcnt nOut = 0;
108641	108696	if( (pTerm->eOperator & (WO_EQ\|WO_ISNULL))!=0 ){
108642	108697	testcase( pTerm->eOperator & WO_EQ );
108643	108698	testcase( pTerm->eOperator & WO_ISNULL );
108644	108699	rc = whereEqualScanEst(pParse, pProbe, pTerm->pExpr->pRight, &nOut);
		@@ -108794,17 +108849,20 @@
108794	108849	pNew->u.btree.nEq = 1;
108795	108850	pNew->u.btree.pIndex = 0;
108796	108851	pNew->nLTerm = 1;
108797	108852	pNew->aLTerm[0] = pTerm;
108798	108853	/* TUNING: One-time cost for computing the automatic index is
108799		- ** approximately 6Nlog2(N) where N is the number of rows in
	108854	+ ** approximately 7Nlog2(N) where N is the number of rows in
108800	108855	** the table being indexed. */
108801		- pNew->rSetup = rLogSize + rSize + 26; assert( 26==whereCost(6) );
108802		- /* TUNING: Each index lookup yields 10 rows in the table */
108803		- pNew->nOut = 33; assert( 33==whereCost(10) );
	108856	+ pNew->rSetup = rLogSize + rSize + 28; assert( 28==whereCost(7) );
	108857	+ /* TUNING: Each index lookup yields 20 rows in the table. This
	108858	+ ** is more than the usual guess of 10 rows, since we have no way
	108859	+ ** of knowning how selective the index will ultimately be. It would
	108860	+ ** not be unreasonable to make this value much larger. */
	108861	+ pNew->nOut = 43; assert( 43==whereCost(20) );
108804	108862	pNew->rRun = whereCostAdd(rLogSize,pNew->nOut);
108805		- pNew->wsFlags = WHERE_TEMP_INDEX;
	108863	+ pNew->wsFlags = WHERE_AUTO_INDEX;
108806	108864	pNew->prereq = mExtra \| pTerm->prereqRight;
108807	108865	rc = whereLoopInsert(pBuilder, pNew);
108808	108866	}
108809	108867	}
108810	108868	}
		@@ -110094,18 +110152,28 @@
110094	110152	&& OptimizationEnabled(db, SQLITE_OmitNoopJoin)
110095	110153	){
110096	110154	Bitmask tabUsed = exprListTableUsage(pMaskSet, pResultSet);
110097	110155	if( pOrderBy ) tabUsed \|= exprListTableUsage(pMaskSet, pOrderBy);
110098	110156	while( pWInfo->nLevel>=2 ){
	110157	+ WhereTerm pTerm, pEnd;
110099	110158	pLoop = pWInfo->a[pWInfo->nLevel-1].pWLoop;
110100	110159	if( (pWInfo->pTabList->a[pLoop->iTab].jointype & JT_LEFT)==0 ) break;
110101	110160	if( (wctrlFlags & WHERE_WANT_DISTINCT)==0
110102	110161	&& (pLoop->wsFlags & WHERE_ONEROW)==0
110103	110162	){
110104	110163	break;
110105	110164	}
110106	110165	if( (tabUsed & pLoop->maskSelf)!=0 ) break;
	110166	+ pEnd = sWLB.pWC->a + sWLB.pWC->nTerm;
	110167	+ for(pTerm=sWLB.pWC->a; pTerm<pEnd; pTerm++){
	110168	+ if( (pTerm->prereqAll & pLoop->maskSelf)!=0
	110169	+ && !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
	110170	+ ){
	110171	+ break;
	110172	+ }
	110173	+ }
	110174	+ if( pTerm<pEnd ) break;
110107	110175	WHERETRACE(0xffff, ("-> drop loop %c not used\n", pLoop->cId));
110108	110176	pWInfo->nLevel--;
110109	110177	nTabList--;
110110	110178	}
110111	110179	}
		@@ -110167,11 +110235,11 @@
110167	110235	}
110168	110236	}else{
110169	110237	sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
110170	110238	}
110171	110239	#ifndef SQLITE_OMIT_AUTOMATIC_INDEX
110172		- if( (pLoop->wsFlags & WHERE_TEMP_INDEX)!=0 ){
	110240	+ if( (pLoop->wsFlags & WHERE_AUTO_INDEX)!=0 ){
110173	110241	constructAutomaticIndex(pParse, &pWInfo->sWC, pTabItem, notReady, pLevel);
110174	110242	}else
110175	110243	#endif
110176	110244	if( pLoop->wsFlags & WHERE_INDEXED ){
110177	110245	Index *pIx = pLoop->u.btree.pIndex;
		@@ -110290,11 +110358,11 @@
110290	110358	){
110291	110359	int ws = pLoop->wsFlags;
110292	110360	if( !pWInfo->okOnePass && (ws & WHERE_IDX_ONLY)==0 ){
110293	110361	sqlite3VdbeAddOp1(v, OP_Close, pTabItem->iCursor);
110294	110362	}
110295		- if( (ws & WHERE_INDEXED)!=0 && (ws & (WHERE_IPK\|WHERE_TEMP_INDEX))==0 ){
	110363	+ if( (ws & WHERE_INDEXED)!=0 && (ws & (WHERE_IPK\|WHERE_AUTO_INDEX))==0 ){
110296	110364	sqlite3VdbeAddOp1(v, OP_Close, pLevel->iIdxCur);
110297	110365	}
110298	110366	}
110299	110367
110300	110368	/* If this scan uses an index, make VDBE code substitutions to read data
		@@ -114501,11 +114569,11 @@
114501	114569	sqlite3 db = pParse->db; / The database connection */
114502	114570	int mxSqlLen; /* Max length of an SQL string */
114503	114571
114504	114572
114505	114573	mxSqlLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH];
114506		- if( db->activeVdbeCnt==0 ){
	114574	+ if( db->nVdbeActive==0 ){
114507	114575	db->u1.isInterrupted = 0;
114508	114576	}
114509	114577	pParse->rc = SQLITE_OK;
114510	114578	pParse->zTail = zSql;
114511	114579	i = 0;
		@@ -116069,10 +116137,11 @@
116069	116137	case SQLITE_PERM: zName = "SQLITE_PERM"; break;
116070	116138	case SQLITE_ABORT: zName = "SQLITE_ABORT"; break;
116071	116139	case SQLITE_ABORT_ROLLBACK: zName = "SQLITE_ABORT_ROLLBACK"; break;
116072	116140	case SQLITE_BUSY: zName = "SQLITE_BUSY"; break;
116073	116141	case SQLITE_BUSY_RECOVERY: zName = "SQLITE_BUSY_RECOVERY"; break;
	116142	+ case SQLITE_BUSY_SNAPSHOT: zName = "SQLITE_BUSY_SNAPSHOT"; break;
116074	116143	case SQLITE_LOCKED: zName = "SQLITE_LOCKED"; break;
116075	116144	case SQLITE_LOCKED_SHAREDCACHE: zName = "SQLITE_LOCKED_SHAREDCACHE";break;
116076	116145	case SQLITE_NOMEM: zName = "SQLITE_NOMEM"; break;
116077	116146	case SQLITE_READONLY: zName = "SQLITE_READONLY"; break;
116078	116147	case SQLITE_READONLY_RECOVERY: zName = "SQLITE_READONLY_RECOVERY"; break;
		@@ -116142,10 +116211,11 @@
116142	116211	case SQLITE_NOTICE: zName = "SQLITE_NOTICE"; break;
116143	116212	case SQLITE_NOTICE_RECOVER_WAL: zName = "SQLITE_NOTICE_RECOVER_WAL";break;
116144	116213	case SQLITE_NOTICE_RECOVER_ROLLBACK:
116145	116214	zName = "SQLITE_NOTICE_RECOVER_ROLLBACK"; break;
116146	116215	case SQLITE_WARNING: zName = "SQLITE_WARNING"; break;
	116216	+ case SQLITE_WARNING_AUTOINDEX: zName = "SQLITE_WARNING_AUTOINDEX"; break;
116147	116217	case SQLITE_DONE: zName = "SQLITE_DONE"; break;
116148	116218	}
116149	116219	}
116150	116220	if( zName==0 ){
116151	116221	static char zBuf[50];
		@@ -116400,11 +116470,11 @@
116400	116470	** is being overridden/deleted but there are no active VMs, allow the
116401	116471	** operation to continue but invalidate all precompiled statements.
116402	116472	*/
116403	116473	p = sqlite3FindFunction(db, zFunctionName, nName, nArg, (u8)enc, 0);
116404	116474	if( p && p->iPrefEnc==enc && p->nArg==nArg ){
116405		- if( db->activeVdbeCnt ){
	116475	+ if( db->nVdbeActive ){
116406	116476	sqlite3Error(db, SQLITE_BUSY,
116407	116477	"unable to delete/modify user-function due to active statements");
116408	116478	assert( !db->mallocFailed );
116409	116479	return SQLITE_BUSY;
116410	116480	}else{
		@@ -116981,11 +117051,11 @@
116981	117051	** sequence. If so, and there are active VMs, return busy. If there
116982	117052	** are no active VMs, invalidate any pre-compiled statements.
116983	117053	*/
116984	117054	pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0);
116985	117055	if( pColl && pColl->xCmp ){
116986		- if( db->activeVdbeCnt ){
	117056	+ if( db->nVdbeActive ){
116987	117057	sqlite3Error(db, SQLITE_BUSY,
116988	117058	"unable to delete/modify collation sequence due to active statements");
116989	117059	return SQLITE_BUSY;
116990	117060	}
116991	117061	sqlite3ExpirePreparedStatements(db);
		@@ -117456,11 +117526,14 @@
117456	117526	memcpy(db->aLimit, aHardLimit, sizeof(db->aLimit));
117457	117527	db->autoCommit = 1;
117458	117528	db->nextAutovac = -1;
117459	117529	db->szMmap = sqlite3GlobalConfig.szMmap;
117460	117530	db->nextPagesize = 0;
117461		- db->flags \|= SQLITE_ShortColNames \| SQLITE_AutoIndex \| SQLITE_EnableTrigger
	117531	+ db->flags \|= SQLITE_ShortColNames \| SQLITE_EnableTrigger
	117532	+#if !defined(SQLITE_DEAULT_AUTOMATIC_INDEX) \|\| SQLITE_DEFAULT_AUTOMATIC_INDEX
	117533	+ \| SQLITE_AutoIndex
	117534	+#endif
117462	117535	#if SQLITE_DEFAULT_FILE_FORMAT<4
117463	117536	\| SQLITE_LegacyFileFmt
117464	117537	#endif
117465	117538	#ifdef SQLITE_ENABLE_LOAD_EXTENSION
117466	117539	\| SQLITE_LoadExtension
117467	117540

	--- src/sqlite3.c
	+++ src/sqlite3.c
	@@ -670,11 +670,11 @@
670	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
671	** [sqlite_version()] and [sqlite_source_id()].
672	*/
673	#define SQLITE_VERSION "3.8.0"
674	#define SQLITE_VERSION_NUMBER 3008000
675	#define SQLITE_SOURCE_ID "2013-06-26 22:46:00 93f632152e464a89322a0130adaf9f342411bf7d"
676
677	/*
678	** CAPI3REF: Run-Time Library Version Numbers
679	** KEYWORDS: sqlite3_version, sqlite3_sourceid
680	**
	@@ -1041,10 +1041,11 @@
1041	#define SQLITE_IOERR_SEEK (SQLITE_IOERR \| (22<<8))
1042	#define SQLITE_IOERR_DELETE_NOENT (SQLITE_IOERR \| (23<<8))
1043	#define SQLITE_IOERR_MMAP (SQLITE_IOERR \| (24<<8))
1044	#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED \| (1<<8))
1045	#define SQLITE_BUSY_RECOVERY (SQLITE_BUSY \| (1<<8))

1046	#define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN \| (1<<8))
1047	#define SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN \| (2<<8))
1048	#define SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN \| (3<<8))
1049	#define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT \| (1<<8))
1050	#define SQLITE_READONLY_RECOVERY (SQLITE_READONLY \| (1<<8))
	@@ -1060,10 +1061,11 @@
1060	#define SQLITE_CONSTRAINT_TRIGGER (SQLITE_CONSTRAINT \| (7<<8))
1061	#define SQLITE_CONSTRAINT_UNIQUE (SQLITE_CONSTRAINT \| (8<<8))
1062	#define SQLITE_CONSTRAINT_VTAB (SQLITE_CONSTRAINT \| (9<<8))
1063	#define SQLITE_NOTICE_RECOVER_WAL (SQLITE_NOTICE \| (1<<8))
1064	#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE \| (2<<8))

1065
1066	/*
1067	** CAPI3REF: Flags For File Open Operations
1068	**
1069	** These bit values are intended for use in the
	@@ -10076,13 +10078,14 @@
10076	int newTnum; /* Rootpage of table being initialized */
10077	u8 iDb; /* Which db file is being initialized */
10078	u8 busy; /* TRUE if currently initializing */
10079	u8 orphanTrigger; /* Last statement is orphaned TEMP trigger */
10080	} init;
10081	int activeVdbeCnt; /* Number of VDBEs currently executing */
10082	int writeVdbeCnt; /* Number of active VDBEs that are writing */
10083	int vdbeExecCnt; /* Number of nested calls to VdbeExec() */

10084	int nExtension; /* Number of loaded extensions */
10085	void *aExtension; / Array of shared library handles */
10086	void (xTrace)(void,const char); / Trace function */
10087	void pTraceArg; / Argument to the trace function */
10088	void (xProfile)(void,const char,u64); / Profiling function */
	@@ -10204,10 +10207,11 @@
10204	#define SQLITE_CoverIdxScan 0x0040 /* Covering index scans */
10205	#define SQLITE_OrderByIdxJoin 0x0080 /* ORDER BY of joins via index */
10206	#define SQLITE_SubqCoroutine 0x0100 /* Evaluate subqueries as coroutines */
10207	#define SQLITE_Transitive 0x0200 /* Transitive constraints */
10208	#define SQLITE_OmitNoopJoin 0x0400 /* Omit unused tables in joins */

10209	#define SQLITE_AllOpts 0xffff /* All optimizations */
10210
10211	/*
10212	** Macros for testing whether or not optimizations are enabled or disabled.
10213	*/
	@@ -13512,11 +13516,12 @@
13512	bft inVtabMethod:2; /* See comments above */
13513	bft changeCntOn:1; /* True to update the change-counter */
13514	bft expired:1; /* True if the VM needs to be recompiled */
13515	bft runOnlyOnce:1; /* Automatically expire on reset */
13516	bft usesStmtJournal:1; /* True if uses a statement journal */
13517	bft readOnly:1; /* True for read-only statements */

13518	bft isPrepareV2:1; /* True if prepared with prepare_v2() */
13519	bft doingRerun:1; /* True if rerunning after an auto-reprepare */
13520	int nChange; /* Number of db changes made since last reset */
13521	yDbMask btreeMask; /* Bitmask of db->aDb[] entries referenced */
13522	yDbMask lockMask; /* Subset of btreeMask that requires a lock */
	@@ -47891,11 +47896,11 @@
47891	** the write is disallowed.
47892	*/
47893	if( memcmp(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr))!=0 ){
47894	walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
47895	pWal->writeLock = 0;
47896	rc = SQLITE_BUSY;
47897	}
47898
47899	return rc;
47900	}
47901
	@@ -52751,16 +52756,17 @@
52751	** This function is called from both BtreeCommitPhaseTwo() and BtreeRollback()
52752	** at the conclusion of a transaction.
52753	*/
52754	static void btreeEndTransaction(Btree *p){
52755	BtShared *pBt = p->pBt;

52756	assert( sqlite3BtreeHoldsMutex(p) );
52757
52758	#ifndef SQLITE_OMIT_AUTOVACUUM
52759	pBt->bDoTruncate = 0;
52760	#endif
52761	if( p->inTrans>TRANS_NONE && p->db->activeVdbeCnt>1 ){
52762	/* If there are other active statements that belong to this database
52763	** handle, downgrade to a read-only transaction. The other statements
52764	** may still be reading from the database. */
52765	downgradeAllSharedCacheTableLocks(p);
52766	p->inTrans = TRANS_READ;
	@@ -60277,18 +60283,30 @@
60277	int i;
60278	int nMaxArgs = *pMaxFuncArgs;
60279	Op *pOp;
60280	int *aLabel = p->aLabel;
60281	p->readOnly = 1;

60282	for(pOp=p->aOp, i=p->nOp-1; i>=0; i--, pOp++){
60283	u8 opcode = pOp->opcode;
60284
60285	pOp->opflags = sqlite3OpcodeProperty[opcode];
60286	if( opcode==OP_Function \|\| opcode==OP_AggStep ){
60287	if( pOp->p5>nMaxArgs ) nMaxArgs = pOp->p5;
60288	}else if( (opcode==OP_Transaction && pOp->p2!=0) \|\| opcode==OP_Vacuum ){










60289	p->readOnly = 0;

60290	#ifndef SQLITE_OMIT_VIRTUALTABLE
60291	}else if( opcode==OP_VUpdate ){
60292	if( pOp->p2>nMaxArgs ) nMaxArgs = pOp->p2;
60293	}else if( opcode==OP_VFilter ){
60294	int n;
	@@ -60310,12 +60328,12 @@
60310	pOp->p2 = aLabel[-1-pOp->p2];
60311	}
60312	}
60313	sqlite3DbFree(p->db, p->aLabel);
60314	p->aLabel = 0;
60315
60316	*pMaxFuncArgs = nMaxArgs;

60317	}
60318
60319	/*
60320	** Return the address of the next instruction to be inserted.
60321	*/
	@@ -61837,11 +61855,11 @@
61837
61838	return rc;
61839	}
61840
61841	/*
61842	** This routine checks that the sqlite3.activeVdbeCnt count variable
61843	** matches the number of vdbe's in the list sqlite3.pVdbe that are
61844	** currently active. An assertion fails if the two counts do not match.
61845	** This is an internal self-check only - it is not an essential processing
61846	** step.
61847	**
	@@ -61850,20 +61868,23 @@
61850	#ifndef NDEBUG
61851	static void checkActiveVdbeCnt(sqlite3 *db){
61852	Vdbe *p;
61853	int cnt = 0;
61854	int nWrite = 0;

61855	p = db->pVdbe;
61856	while( p ){
61857	if( p->magic==VDBE_MAGIC_RUN && p->pc>=0 ){
61858	cnt++;
61859	if( p->readOnly==0 ) nWrite++;

61860	}
61861	p = p->pNext;
61862	}
61863	assert( cnt==db->activeVdbeCnt );
61864	assert( nWrite==db->writeVdbeCnt );

61865	}
61866	#else
61867	#define checkActiveVdbeCnt(x)
61868	#endif
61869
	@@ -61995,12 +62016,13 @@
61995	if( p->magic!=VDBE_MAGIC_RUN ){
61996	return SQLITE_OK;
61997	}
61998	checkActiveVdbeCnt(db);
61999
62000	/* No commit or rollback needed if the program never started */
62001	if( p->pc>=0 ){

62002	int mrc; /* Primary error code from p->rc */
62003	int eStatementOp = 0;
62004	int isSpecialError; /* Set to true if a 'special' error */
62005
62006	/* Lock all btrees used by the statement */
	@@ -62049,11 +62071,11 @@
62049	** Note: This block also runs if one of the special errors handled
62050	** above has occurred.
62051	*/
62052	if( !sqlite3VtabInSync(db)
62053	&& db->autoCommit
62054	&& db->writeVdbeCnt==(p->readOnly==0)
62055	){
62056	if( p->rc==SQLITE_OK \|\| (p->errorAction==OE_Fail && !isSpecialError) ){
62057	rc = sqlite3VdbeCheckFk(p, 1);
62058	if( rc!=SQLITE_OK ){
62059	if( NEVER(p->readOnly) ){
	@@ -62130,15 +62152,16 @@
62130	sqlite3VdbeLeave(p);
62131	}
62132
62133	/* We have successfully halted and closed the VM. Record this fact. */
62134	if( p->pc>=0 ){
62135	db->activeVdbeCnt--;
62136	if( !p->readOnly ){
62137	db->writeVdbeCnt--;
62138	}
62139	assert( db->activeVdbeCnt>=db->writeVdbeCnt );

62140	}
62141	p->magic = VDBE_MAGIC_HALT;
62142	checkActiveVdbeCnt(db);
62143	if( p->db->mallocFailed ){
62144	p->rc = SQLITE_NOMEM;
	@@ -62150,11 +62173,11 @@
62150	*/
62151	if( db->autoCommit ){
62152	sqlite3ConnectionUnlocked(db);
62153	}
62154
62155	assert( db->activeVdbeCnt>0 \|\| db->autoCommit==0 \|\| db->nStatement==0 );
62156	return (p->rc==SQLITE_BUSY ? SQLITE_BUSY : SQLITE_OK);
62157	}
62158
62159
62160	/*
	@@ -63508,35 +63531,36 @@
63508	if( p->pc<0 ){
63509	/* If there are no other statements currently running, then
63510	** reset the interrupt flag. This prevents a call to sqlite3_interrupt
63511	** from interrupting a statement that has not yet started.
63512	*/
63513	if( db->activeVdbeCnt==0 ){
63514	db->u1.isInterrupted = 0;
63515	}
63516
63517	assert( db->writeVdbeCnt>0 \|\| db->autoCommit==0 \|\| db->nDeferredCons==0 );
63518
63519	#ifndef SQLITE_OMIT_TRACE
63520	if( db->xProfile && !db->init.busy ){
63521	sqlite3OsCurrentTimeInt64(db->pVfs, &p->startTime);
63522	}
63523	#endif
63524
63525	db->activeVdbeCnt++;
63526	if( p->readOnly==0 ) db->writeVdbeCnt++;

63527	p->pc = 0;
63528	}
63529	#ifndef SQLITE_OMIT_EXPLAIN
63530	if( p->explain ){
63531	rc = sqlite3VdbeList(p);
63532	}else
63533	#endif /* SQLITE_OMIT_EXPLAIN */
63534	{
63535	db->vdbeExecCnt++;
63536	rc = sqlite3VdbeExec(p);
63537	db->vdbeExecCnt--;
63538	}
63539
63540	#ifndef SQLITE_OMIT_TRACE
63541	/* Invoke the profile callback if there is one
63542	*/
	@@ -64469,13 +64493,13 @@
64469	return nTotal;
64470	}
64471
64472	/*
64473	** This function returns a pointer to a nul-terminated string in memory
64474	** obtained from sqlite3DbMalloc(). If sqlite3.vdbeExecCnt is 1, then the
64475	** string contains a copy of zRawSql but with host parameters expanded to
64476	** their current bindings. Or, if sqlite3.vdbeExecCnt is greater than 1,
64477	** then the returned string holds a copy of zRawSql with "-- " prepended
64478	** to each line of text.
64479	**
64480	** If the SQLITE_TRACE_SIZE_LIMIT macro is defined to an integer, then
64481	** then long strings and blobs are truncated to that many bytes. This
	@@ -64509,11 +64533,11 @@
64509
64510	db = p->db;
64511	sqlite3StrAccumInit(&out, zBase, sizeof(zBase),
64512	db->aLimit[SQLITE_LIMIT_LENGTH]);
64513	out.db = db;
64514	if( db->vdbeExecCnt>1 ){
64515	while( *zRawSql ){
64516	const char *zStart = zRawSql;
64517	while( (zRawSql++)!='\n' && zRawSql );
64518	sqlite3StrAccumAppend(&out, "-- ", 3);
64519	sqlite3StrAccumAppend(&out, zStart, (int)(zRawSql-zStart));
	@@ -65815,10 +65839,11 @@
65815	/* This happens if a malloc() inside a call to sqlite3_column_text() or
65816	** sqlite3_column_text16() failed. */
65817	goto no_mem;
65818	}
65819	assert( p->rc==SQLITE_OK \|\| p->rc==SQLITE_BUSY );

65820	p->rc = SQLITE_OK;
65821	assert( p->explain==0 );
65822	p->pResultSet = 0;
65823	db->busyHandler.nBusy = 0;
65824	CHECK_FOR_INTERRUPT;
	@@ -67959,13 +67984,14 @@
67959	*/
67960	assert( db->pSavepoint==0 \|\| db->autoCommit==0 );
67961	assert( u.as.p1==SAVEPOINT_BEGIN\|\|u.as.p1==SAVEPOINT_RELEASE\|\|u.as.p1==SAVEPOINT_ROLLBACK );
67962	assert( db->pSavepoint \|\| db->isTransactionSavepoint==0 );
67963	assert( checkSavepointCount(db) );

67964
67965	if( u.as.p1==SAVEPOINT_BEGIN ){
67966	if( db->writeVdbeCnt>0 ){
67967	/* A new savepoint cannot be created if there are active write
67968	** statements (i.e. open read/write incremental blob handles).
67969	*/
67970	sqlite3SetString(&p->zErrMsg, db, "cannot open savepoint - "
67971	"SQL statements in progress");
	@@ -68018,11 +68044,11 @@
68018	u.as.iSavepoint++;
68019	}
68020	if( !u.as.pSavepoint ){
68021	sqlite3SetString(&p->zErrMsg, db, "no such savepoint: %s", u.as.zName);
68022	rc = SQLITE_ERROR;
68023	}else if( db->writeVdbeCnt>0 && u.as.p1==SAVEPOINT_RELEASE ){
68024	/* It is not possible to release (commit) a savepoint if there are
68025	** active write statements.
68026	*/
68027	sqlite3SetString(&p->zErrMsg, db,
68028	"cannot release savepoint - SQL statements in progress"
	@@ -68121,24 +68147,25 @@
68121	u.at.desiredAutoCommit = pOp->p1;
68122	u.at.iRollback = pOp->p2;
68123	u.at.turnOnAC = u.at.desiredAutoCommit && !db->autoCommit;
68124	assert( u.at.desiredAutoCommit==1 \|\| u.at.desiredAutoCommit==0 );
68125	assert( u.at.desiredAutoCommit==1 \|\| u.at.iRollback==0 );
68126	assert( db->activeVdbeCnt>0 ); /* At least this one VM is active */

68127
68128	#if 0
68129	if( u.at.turnOnAC && u.at.iRollback && db->activeVdbeCnt>1 ){
68130	/* If this instruction implements a ROLLBACK and other VMs are
68131	** still running, and a transaction is active, return an error indicating
68132	** that the other VMs must complete first.
68133	*/
68134	sqlite3SetString(&p->zErrMsg, db, "cannot rollback transaction - "
68135	"SQL statements in progress");
68136	rc = SQLITE_BUSY;
68137	}else
68138	#endif
68139	if( u.at.turnOnAC && !u.at.iRollback && db->writeVdbeCnt>0 ){
68140	/* If this instruction implements a COMMIT and other VMs are writing
68141	** return an error indicating that the other VMs must complete first.
68142	*/
68143	sqlite3SetString(&p->zErrMsg, db, "cannot commit transaction - "
68144	"SQL statements in progress");
	@@ -68212,10 +68239,12 @@
68212	case OP_Transaction: {
68213	#if 0 /* local variables moved into u.au */
68214	Btree *pBt;
68215	#endif /* local variables moved into u.au */
68216


68217	assert( pOp->p1>=0 && pOp->p1<db->nDb );
68218	assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
68219	u.au.pBt = db->aDb[pOp->p1].pBt;
68220
68221	if( u.au.pBt ){
	@@ -68228,11 +68257,11 @@
68228	if( rc!=SQLITE_OK ){
68229	goto abort_due_to_error;
68230	}
68231
68232	if( pOp->p2 && p->usesStmtJournal
68233	&& (db->autoCommit==0 \|\| db->activeVdbeCnt>1)
68234	){
68235	assert( sqlite3BtreeIsInTrans(u.au.pBt) );
68236	if( p->iStatement==0 ){
68237	assert( db->nStatement>=0 && db->nSavepoint>=0 );
68238	db->nStatement++;
	@@ -68270,10 +68299,11 @@
68270	int iMeta;
68271	int iDb;
68272	int iCookie;
68273	#endif /* local variables moved into u.av */
68274

68275	u.av.iDb = pOp->p1;
68276	u.av.iCookie = pOp->p3;
68277	assert( pOp->p3<SQLITE_N_BTREE_META );
68278	assert( u.av.iDb>=0 && u.av.iDb<db->nDb );
68279	assert( db->aDb[u.av.iDb].pBt!=0 );
	@@ -68299,10 +68329,11 @@
68299	Db *pDb;
68300	#endif /* local variables moved into u.aw */
68301	assert( pOp->p2<SQLITE_N_BTREE_META );
68302	assert( pOp->p1>=0 && pOp->p1<db->nDb );
68303	assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );

68304	u.aw.pDb = &db->aDb[pOp->p1];
68305	assert( u.aw.pDb->pBt!=0 );
68306	assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
68307	pIn3 = &aMem[pOp->p3];
68308	sqlite3VdbeMemIntegerify(pIn3);
	@@ -68351,10 +68382,11 @@
68351	#endif /* local variables moved into u.ax */
68352
68353	assert( pOp->p1>=0 && pOp->p1<db->nDb );
68354	assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
68355	assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );

68356	u.ax.pBt = db->aDb[pOp->p1].pBt;
68357	if( u.ax.pBt ){
68358	sqlite3BtreeGetMeta(u.ax.pBt, BTREE_SCHEMA_VERSION, (u32 *)&u.ax.iMeta);
68359	u.ax.iGen = db->aDb[pOp->p1].pSchema->iGeneration;
68360	}else{
	@@ -68448,10 +68480,12 @@
68448	Db *pDb;
68449	#endif /* local variables moved into u.ay */
68450
68451	assert( (pOp->p5&(OPFLAG_P2ISREG\|OPFLAG_BULKCSR))==pOp->p5 );
68452	assert( pOp->opcode==OP_OpenWrite \|\| pOp->p5==0 );


68453
68454	if( p->expired ){
68455	rc = SQLITE_ABORT;
68456	break;
68457	}
	@@ -70066,19 +70100,22 @@
70066	int iCnt;
70067	Vdbe *pVdbe;
70068	int iDb;
70069	#endif /* local variables moved into u.bw */
70070

70071	#ifndef SQLITE_OMIT_VIRTUALTABLE
70072	u.bw.iCnt = 0;
70073	for(u.bw.pVdbe=db->pVdbe; u.bw.pVdbe; u.bw.pVdbe = u.bw.pVdbe->pNext){
70074	if( u.bw.pVdbe->magic==VDBE_MAGIC_RUN && u.bw.pVdbe->inVtabMethod<2 && u.bw.pVdbe->pc>=0 ){


70075	u.bw.iCnt++;
70076	}
70077	}
70078	#else
70079	u.bw.iCnt = db->activeVdbeCnt;
70080	#endif
70081	pOut->flags = MEM_Null;
70082	if( u.bw.iCnt>1 ){
70083	rc = SQLITE_LOCKED;
70084	p->errorAction = OE_Abort;
	@@ -70123,10 +70160,11 @@
70123	#if 0 /* local variables moved into u.bx */
70124	int nChange;
70125	#endif /* local variables moved into u.bx */
70126
70127	u.bx.nChange = 0;

70128	assert( (p->btreeMask & (((yDbMask)1)<<pOp->p2))!=0 );
70129	rc = sqlite3BtreeClearTable(
70130	db->aDb[pOp->p2].pBt, pOp->p1, (pOp->p3 ? &u.bx.nChange : 0)
70131	);
70132	if( pOp->p3 ){
	@@ -70171,10 +70209,11 @@
70171	#endif /* local variables moved into u.by */
70172
70173	u.by.pgno = 0;
70174	assert( pOp->p1>=0 && pOp->p1<db->nDb );
70175	assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );

70176	u.by.pDb = &db->aDb[pOp->p1];
70177	assert( u.by.pDb->pBt!=0 );
70178	if( pOp->opcode==OP_CreateTable ){
70179	/* u.by.flags = BTREE_INTKEY; */
70180	u.by.flags = BTREE_INTKEY;
	@@ -70323,10 +70362,11 @@
70323	int nErr; /* Number of errors reported */
70324	char z; / Text of the error report */
70325	Mem pnErr; / Register keeping track of errors remaining */
70326	#endif /* local variables moved into u.ca */
70327

70328	u.ca.nRoot = pOp->p2;
70329	assert( u.ca.nRoot>0 );
70330	u.ca.aRoot = sqlite3DbMallocRaw(db, sizeof(int)*(u.ca.nRoot+1) );
70331	if( u.ca.aRoot==0 ) goto no_mem;
70332	assert( pOp->p3>0 && pOp->p3<=p->nMem );
	@@ -70844,10 +70884,11 @@
70844	int i; /* Loop counter */
70845	int aRes[3]; /* Results */
70846	Mem pMem; / Write results here */
70847	#endif /* local variables moved into u.ci */
70848

70849	u.ci.aRes[0] = 0;
70850	u.ci.aRes[1] = u.ci.aRes[2] = -1;
70851	assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE
70852	\|\| pOp->p2==SQLITE_CHECKPOINT_FULL
70853	\|\| pOp->p2==SQLITE_CHECKPOINT_RESTART
	@@ -70895,10 +70936,11 @@
70895	\|\| u.cj.eNew==PAGER_JOURNALMODE_MEMORY
70896	\|\| u.cj.eNew==PAGER_JOURNALMODE_WAL
70897	\|\| u.cj.eNew==PAGER_JOURNALMODE_QUERY
70898	);
70899	assert( pOp->p1>=0 && pOp->p1<db->nDb );

70900
70901	u.cj.pBt = db->aDb[pOp->p1].pBt;
70902	u.cj.pPager = sqlite3BtreePager(u.cj.pBt);
70903	u.cj.eOld = sqlite3PagerGetJournalMode(u.cj.pPager);
70904	if( u.cj.eNew==PAGER_JOURNALMODE_QUERY ) u.cj.eNew = u.cj.eOld;
	@@ -70918,11 +70960,11 @@
70918	}
70919
70920	if( (u.cj.eNew!=u.cj.eOld)
70921	&& (u.cj.eOld==PAGER_JOURNALMODE_WAL \|\| u.cj.eNew==PAGER_JOURNALMODE_WAL)
70922	){
70923	if( !db->autoCommit \|\| db->activeVdbeCnt>1 ){
70924	rc = SQLITE_ERROR;
70925	sqlite3SetString(&p->zErrMsg, db,
70926	"cannot change %s wal mode from within a transaction",
70927	(u.cj.eNew==PAGER_JOURNALMODE_WAL ? "into" : "out of")
70928	);
	@@ -70977,10 +71019,11 @@
70977	** Vacuum the entire database. This opcode will cause other virtual
70978	** machines to be created and run. It may not be called from within
70979	** a transaction.
70980	*/
70981	case OP_Vacuum: {

70982	rc = sqlite3RunVacuum(&p->zErrMsg, db);
70983	break;
70984	}
70985	#endif
70986
	@@ -70996,10 +71039,11 @@
70996	Btree *pBt;
70997	#endif /* local variables moved into u.ck */
70998
70999	assert( pOp->p1>=0 && pOp->p1<db->nDb );
71000	assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );

71001	u.ck.pBt = db->aDb[pOp->p1].pBt;
71002	rc = sqlite3BtreeIncrVacuum(u.ck.pBt);
71003	if( rc==SQLITE_DONE ){
71004	pc = pOp->p2 - 1;
71005	rc = SQLITE_OK;
	@@ -71118,10 +71162,11 @@
71118	sqlite3_vtab_cursor *pVtabCursor;
71119	sqlite3_vtab *pVtab;
71120	sqlite3_module *pModule;
71121	#endif /* local variables moved into u.cm */
71122

71123	u.cm.pCur = 0;
71124	u.cm.pVtabCursor = 0;
71125	u.cm.pVtab = pOp->p4.pVtab->pVtab;
71126	u.cm.pModule = (sqlite3_module *)u.cm.pVtab->pModule;
71127	assert(u.cm.pVtab && u.cm.pModule);
	@@ -71342,10 +71387,11 @@
71342
71343	u.cq.pVtab = pOp->p4.pVtab->pVtab;
71344	u.cq.pName = &aMem[pOp->p1];
71345	assert( u.cq.pVtab->pModule->xRename );
71346	assert( memIsValid(u.cq.pName) );

71347	REGISTER_TRACE(pOp->p1, u.cq.pName);
71348	assert( u.cq.pName->flags & MEM_Str );
71349	testcase( u.cq.pName->enc==SQLITE_UTF8 );
71350	testcase( u.cq.pName->enc==SQLITE_UTF16BE );
71351	testcase( u.cq.pName->enc==SQLITE_UTF16LE );
	@@ -71395,10 +71441,11 @@
71395	#endif /* local variables moved into u.cr */
71396
71397	assert( pOp->p2==1 \|\| pOp->p5==OE_Fail \|\| pOp->p5==OE_Rollback
71398	\|\| pOp->p5==OE_Abort \|\| pOp->p5==OE_Ignore \|\| pOp->p5==OE_Replace
71399	);

71400	u.cr.pVtab = pOp->p4.pVtab->pVtab;
71401	u.cr.pModule = (sqlite3_module *)u.cr.pVtab->pModule;
71402	u.cr.nArg = pOp->p2;
71403	assert( pOp->p4type==P4_VTAB );
71404	if( ALWAYS(u.cr.pModule->xUpdate) ){
	@@ -102957,11 +103004,11 @@
102957
102958	if( !db->autoCommit ){
102959	sqlite3SetString(pzErrMsg, db, "cannot VACUUM from within a transaction");
102960	return SQLITE_ERROR;
102961	}
102962	if( db->activeVdbeCnt>1 ){
102963	sqlite3SetString(pzErrMsg, db,"cannot VACUUM - SQL statements in progress");
102964	return SQLITE_ERROR;
102965	}
102966
102967	/* Save the current value of the database flags so that it can be
	@@ -104742,11 +104789,11 @@
104742	#define WHERE_INDEXED 0x00000200 /* WhereLoop.u.btree.pIndex is valid */
104743	#define WHERE_VIRTUALTABLE 0x00000400 /* WhereLoop.u.vtab is valid */
104744	#define WHERE_IN_ABLE 0x00000800 /* Able to support an IN operator */
104745	#define WHERE_ONEROW 0x00001000 /* Selects no more than one row */
104746	#define WHERE_MULTI_OR 0x00002000 /* OR using multiple indices */
104747	#define WHERE_TEMP_INDEX 0x00004000 /* Uses an ephemeral index */
104748
104749
104750	/* Convert a WhereCost value (10 times log2(X)) into its integer value X.
104751	** A rough approximation is used. The value returned is not exact.
104752	*/
	@@ -106036,10 +106083,11 @@
106036	** the start of the loop will prevent any results from being returned.
106037	*/
106038	if( pExpr->op==TK_NOTNULL
106039	&& pExpr->pLeft->op==TK_COLUMN
106040	&& pExpr->pLeft->iColumn>=0

106041	){
106042	Expr *pNewExpr;
106043	Expr *pLeft = pExpr->pLeft;
106044	int idxNew;
106045	WhereTerm *pNewTerm;
	@@ -106339,10 +106387,11 @@
106339	int mxBitCol; /* Maximum column in pSrc->colUsed */
106340	CollSeq pColl; / Collating sequence to on a column */
106341	WhereLoop pLoop; / The Loop object */
106342	Bitmask idxCols; /* Bitmap of columns used for indexing */
106343	Bitmask extraCols; /* Bitmap of additional columns */

106344
106345	/* Generate code to skip over the creation and initialization of the
106346	** transient index on 2nd and subsequent iterations of the loop. */
106347	v = pParse->pVdbe;
106348	assert( v!=0 );
	@@ -106359,10 +106408,16 @@
106359	if( termCanDriveIndex(pTerm, pSrc, notReady) ){
106360	int iCol = pTerm->u.leftColumn;
106361	Bitmask cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
106362	testcase( iCol==BMS );
106363	testcase( iCol==BMS-1 );






106364	if( (idxCols & cMask)==0 ){
106365	if( whereLoopResize(pParse->db, pLoop, nColumn+1) ) return;
106366	pLoop->aLTerm[nColumn++] = pTerm;
106367	idxCols \|= cMask;
106368	}
	@@ -106369,11 +106424,11 @@
106369	}
106370	}
106371	assert( nColumn>0 );
106372	pLoop->u.btree.nEq = pLoop->nLTerm = nColumn;
106373	pLoop->wsFlags = WHERE_COLUMN_EQ \| WHERE_IDX_ONLY \| WHERE_INDEXED
106374	\| WHERE_TEMP_INDEX;
106375
106376	/* Count the number of additional columns needed to create a
106377	** covering index. A "covering index" is an index that contains all
106378	** columns that are needed by the query. With a covering index, the
106379	** original table never needs to be accessed. Automatic indices must
	@@ -106869,11 +106924,11 @@
106869	){
106870	int rc = SQLITE_OK;
106871
106872	#ifdef SQLITE_ENABLE_STAT3
106873
106874	if( nEq==0 && p->nSample ){
106875	sqlite3_value *pRangeVal;
106876	tRowcnt iLower = 0;
106877	tRowcnt iUpper = p->aiRowEst[0];
106878	tRowcnt a[2];
106879	u8 aff = p->pTable->aCol[p->aiColumn[0]].affinity;
	@@ -107415,17 +107470,16 @@
107415	}
107416	if( (flags & (WHERE_IPK\|WHERE_VIRTUALTABLE))==0
107417	&& ALWAYS(pLoop->u.btree.pIndex!=0)
107418	){
107419	char *zWhere = explainIndexRange(db, pLoop, pItem->pTab);
107420	zMsg = sqlite3MAppendf(db, zMsg, "%s USING %s%sINDEX%s%s%s", zMsg,
107421	((flags & WHERE_TEMP_INDEX)?"AUTOMATIC ":""),
107422	((flags & WHERE_IDX_ONLY)?"COVERING ":""),
107423	((flags & WHERE_TEMP_INDEX)?"":" "),
107424	((flags & WHERE_TEMP_INDEX)?"": pLoop->u.btree.pIndex->zName),
107425	zWhere
107426	);
107427	sqlite3DbFree(db, zWhere);
107428	}else if( (flags & WHERE_IPK)!=0 && (flags & WHERE_CONSTRAINT)!=0 ){
107429	zMsg = sqlite3MAppendf(db, zMsg, "%s USING INTEGER PRIMARY KEY", zMsg);
107430
107431	if( flags&(WHERE_COLUMN_EQ\|WHERE_COLUMN_IN) ){
	@@ -108092,11 +108146,11 @@
108092	** terms, set pCov to the candidate covering index. Otherwise, set
108093	** pCov to NULL to indicate that no candidate covering index will
108094	** be available.
108095	*/
108096	pSubLoop = pSubWInfo->a[0].pWLoop;
108097	assert( (pSubLoop->wsFlags & WHERE_TEMP_INDEX)==0 );
108098	if( (pSubLoop->wsFlags & WHERE_INDEXED)!=0
108099	&& (ii==0 \|\| pSubLoop->u.btree.pIndex==pCov)
108100	){
108101	assert( pSubWInfo->a[0].iIdxCur==iCovCur );
108102	pCov = pSubLoop->u.btree.pIndex;
	@@ -108274,16 +108328,16 @@
108274
108275	/*
108276	** Clear the WhereLoop.u union. Leave WhereLoop.pLTerm intact.
108277	*/
108278	static void whereLoopClearUnion(sqlite3 db, WhereLoop p){
108279	if( p->wsFlags & (WHERE_VIRTUALTABLE\|WHERE_TEMP_INDEX) ){
108280	if( (p->wsFlags & WHERE_VIRTUALTABLE)!=0 && p->u.vtab.needFree ){
108281	sqlite3_free(p->u.vtab.idxStr);
108282	p->u.vtab.needFree = 0;
108283	p->u.vtab.idxStr = 0;
108284	}else if( (p->wsFlags & WHERE_TEMP_INDEX)!=0 && p->u.btree.pIndex!=0 ){
108285	sqlite3DbFree(db, p->u.btree.pIndex->zColAff);
108286	sqlite3DbFree(db, p->u.btree.pIndex);
108287	p->u.btree.pIndex = 0;
108288	}
108289	}
	@@ -108322,11 +108376,11 @@
108322	whereLoopClearUnion(db, pTo);
108323	memcpy(pTo, pFrom, WHERE_LOOP_XFER_SZ);
108324	memcpy(pTo->aLTerm, pFrom->aLTerm, pTo->nLTerm*sizeof(pTo->aLTerm[0]));
108325	if( pFrom->wsFlags & WHERE_VIRTUALTABLE ){
108326	pFrom->u.vtab.needFree = 0;
108327	}else if( (pFrom->wsFlags & WHERE_TEMP_INDEX)!=0 ){
108328	pFrom->u.btree.pIndex = 0;
108329	}
108330	return SQLITE_OK;
108331	}
108332
	@@ -108634,11 +108688,12 @@
108634	whereRangeScanEst(pParse, pProbe, pNew->u.btree.nEq,
108635	pBtm, pTop, &rDiv);
108636	pNew->nOut = saved_nOut>rDiv+10 ? saved_nOut - rDiv : 10;
108637	}
108638	#ifdef SQLITE_ENABLE_STAT3
108639	if( pNew->u.btree.nEq==1 && pProbe->nSample ){

108640	tRowcnt nOut = 0;
108641	if( (pTerm->eOperator & (WO_EQ\|WO_ISNULL))!=0 ){
108642	testcase( pTerm->eOperator & WO_EQ );
108643	testcase( pTerm->eOperator & WO_ISNULL );
108644	rc = whereEqualScanEst(pParse, pProbe, pTerm->pExpr->pRight, &nOut);
	@@ -108794,17 +108849,20 @@
108794	pNew->u.btree.nEq = 1;
108795	pNew->u.btree.pIndex = 0;
108796	pNew->nLTerm = 1;
108797	pNew->aLTerm[0] = pTerm;
108798	/* TUNING: One-time cost for computing the automatic index is
108799	** approximately 6Nlog2(N) where N is the number of rows in
108800	** the table being indexed. */
108801	pNew->rSetup = rLogSize + rSize + 26; assert( 26==whereCost(6) );
108802	/* TUNING: Each index lookup yields 10 rows in the table */
108803	pNew->nOut = 33; assert( 33==whereCost(10) );



108804	pNew->rRun = whereCostAdd(rLogSize,pNew->nOut);
108805	pNew->wsFlags = WHERE_TEMP_INDEX;
108806	pNew->prereq = mExtra \| pTerm->prereqRight;
108807	rc = whereLoopInsert(pBuilder, pNew);
108808	}
108809	}
108810	}
	@@ -110094,18 +110152,28 @@
110094	&& OptimizationEnabled(db, SQLITE_OmitNoopJoin)
110095	){
110096	Bitmask tabUsed = exprListTableUsage(pMaskSet, pResultSet);
110097	if( pOrderBy ) tabUsed \|= exprListTableUsage(pMaskSet, pOrderBy);
110098	while( pWInfo->nLevel>=2 ){

110099	pLoop = pWInfo->a[pWInfo->nLevel-1].pWLoop;
110100	if( (pWInfo->pTabList->a[pLoop->iTab].jointype & JT_LEFT)==0 ) break;
110101	if( (wctrlFlags & WHERE_WANT_DISTINCT)==0
110102	&& (pLoop->wsFlags & WHERE_ONEROW)==0
110103	){
110104	break;
110105	}
110106	if( (tabUsed & pLoop->maskSelf)!=0 ) break;









110107	WHERETRACE(0xffff, ("-> drop loop %c not used\n", pLoop->cId));
110108	pWInfo->nLevel--;
110109	nTabList--;
110110	}
110111	}
	@@ -110167,11 +110235,11 @@
110167	}
110168	}else{
110169	sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
110170	}
110171	#ifndef SQLITE_OMIT_AUTOMATIC_INDEX
110172	if( (pLoop->wsFlags & WHERE_TEMP_INDEX)!=0 ){
110173	constructAutomaticIndex(pParse, &pWInfo->sWC, pTabItem, notReady, pLevel);
110174	}else
110175	#endif
110176	if( pLoop->wsFlags & WHERE_INDEXED ){
110177	Index *pIx = pLoop->u.btree.pIndex;
	@@ -110290,11 +110358,11 @@
110290	){
110291	int ws = pLoop->wsFlags;
110292	if( !pWInfo->okOnePass && (ws & WHERE_IDX_ONLY)==0 ){
110293	sqlite3VdbeAddOp1(v, OP_Close, pTabItem->iCursor);
110294	}
110295	if( (ws & WHERE_INDEXED)!=0 && (ws & (WHERE_IPK\|WHERE_TEMP_INDEX))==0 ){
110296	sqlite3VdbeAddOp1(v, OP_Close, pLevel->iIdxCur);
110297	}
110298	}
110299
110300	/* If this scan uses an index, make VDBE code substitutions to read data
	@@ -114501,11 +114569,11 @@
114501	sqlite3 db = pParse->db; / The database connection */
114502	int mxSqlLen; /* Max length of an SQL string */
114503
114504
114505	mxSqlLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH];
114506	if( db->activeVdbeCnt==0 ){
114507	db->u1.isInterrupted = 0;
114508	}
114509	pParse->rc = SQLITE_OK;
114510	pParse->zTail = zSql;
114511	i = 0;
	@@ -116069,10 +116137,11 @@
116069	case SQLITE_PERM: zName = "SQLITE_PERM"; break;
116070	case SQLITE_ABORT: zName = "SQLITE_ABORT"; break;
116071	case SQLITE_ABORT_ROLLBACK: zName = "SQLITE_ABORT_ROLLBACK"; break;
116072	case SQLITE_BUSY: zName = "SQLITE_BUSY"; break;
116073	case SQLITE_BUSY_RECOVERY: zName = "SQLITE_BUSY_RECOVERY"; break;

116074	case SQLITE_LOCKED: zName = "SQLITE_LOCKED"; break;
116075	case SQLITE_LOCKED_SHAREDCACHE: zName = "SQLITE_LOCKED_SHAREDCACHE";break;
116076	case SQLITE_NOMEM: zName = "SQLITE_NOMEM"; break;
116077	case SQLITE_READONLY: zName = "SQLITE_READONLY"; break;
116078	case SQLITE_READONLY_RECOVERY: zName = "SQLITE_READONLY_RECOVERY"; break;
	@@ -116142,10 +116211,11 @@
116142	case SQLITE_NOTICE: zName = "SQLITE_NOTICE"; break;
116143	case SQLITE_NOTICE_RECOVER_WAL: zName = "SQLITE_NOTICE_RECOVER_WAL";break;
116144	case SQLITE_NOTICE_RECOVER_ROLLBACK:
116145	zName = "SQLITE_NOTICE_RECOVER_ROLLBACK"; break;
116146	case SQLITE_WARNING: zName = "SQLITE_WARNING"; break;

116147	case SQLITE_DONE: zName = "SQLITE_DONE"; break;
116148	}
116149	}
116150	if( zName==0 ){
116151	static char zBuf[50];
	@@ -116400,11 +116470,11 @@
116400	** is being overridden/deleted but there are no active VMs, allow the
116401	** operation to continue but invalidate all precompiled statements.
116402	*/
116403	p = sqlite3FindFunction(db, zFunctionName, nName, nArg, (u8)enc, 0);
116404	if( p && p->iPrefEnc==enc && p->nArg==nArg ){
116405	if( db->activeVdbeCnt ){
116406	sqlite3Error(db, SQLITE_BUSY,
116407	"unable to delete/modify user-function due to active statements");
116408	assert( !db->mallocFailed );
116409	return SQLITE_BUSY;
116410	}else{
	@@ -116981,11 +117051,11 @@
116981	** sequence. If so, and there are active VMs, return busy. If there
116982	** are no active VMs, invalidate any pre-compiled statements.
116983	*/
116984	pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0);
116985	if( pColl && pColl->xCmp ){
116986	if( db->activeVdbeCnt ){
116987	sqlite3Error(db, SQLITE_BUSY,
116988	"unable to delete/modify collation sequence due to active statements");
116989	return SQLITE_BUSY;
116990	}
116991	sqlite3ExpirePreparedStatements(db);
	@@ -117456,11 +117526,14 @@
117456	memcpy(db->aLimit, aHardLimit, sizeof(db->aLimit));
117457	db->autoCommit = 1;
117458	db->nextAutovac = -1;
117459	db->szMmap = sqlite3GlobalConfig.szMmap;
117460	db->nextPagesize = 0;
117461	db->flags \|= SQLITE_ShortColNames \| SQLITE_AutoIndex \| SQLITE_EnableTrigger



117462	#if SQLITE_DEFAULT_FILE_FORMAT<4
117463	\| SQLITE_LegacyFileFmt
117464	#endif
117465	#ifdef SQLITE_ENABLE_LOAD_EXTENSION
117466	\| SQLITE_LoadExtension
117467

	--- src/sqlite3.c
	+++ src/sqlite3.c
	@@ -670,11 +670,11 @@
670	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
671	** [sqlite_version()] and [sqlite_source_id()].
672	*/
673	#define SQLITE_VERSION "3.8.0"
674	#define SQLITE_VERSION_NUMBER 3008000
675	#define SQLITE_SOURCE_ID "2013-06-28 23:55:45 338826ef3f8a209b14f8d42370855cab9ac9ed45"
676
677	/*
678	** CAPI3REF: Run-Time Library Version Numbers
679	** KEYWORDS: sqlite3_version, sqlite3_sourceid
680	**
	@@ -1041,10 +1041,11 @@
1041	#define SQLITE_IOERR_SEEK (SQLITE_IOERR \| (22<<8))
1042	#define SQLITE_IOERR_DELETE_NOENT (SQLITE_IOERR \| (23<<8))
1043	#define SQLITE_IOERR_MMAP (SQLITE_IOERR \| (24<<8))
1044	#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED \| (1<<8))
1045	#define SQLITE_BUSY_RECOVERY (SQLITE_BUSY \| (1<<8))
1046	#define SQLITE_BUSY_SNAPSHOT (SQLITE_BUSY \| (2<<8))
1047	#define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN \| (1<<8))
1048	#define SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN \| (2<<8))
1049	#define SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN \| (3<<8))
1050	#define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT \| (1<<8))
1051	#define SQLITE_READONLY_RECOVERY (SQLITE_READONLY \| (1<<8))
	@@ -1060,10 +1061,11 @@
1061	#define SQLITE_CONSTRAINT_TRIGGER (SQLITE_CONSTRAINT \| (7<<8))
1062	#define SQLITE_CONSTRAINT_UNIQUE (SQLITE_CONSTRAINT \| (8<<8))
1063	#define SQLITE_CONSTRAINT_VTAB (SQLITE_CONSTRAINT \| (9<<8))
1064	#define SQLITE_NOTICE_RECOVER_WAL (SQLITE_NOTICE \| (1<<8))
1065	#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE \| (2<<8))
1066	#define SQLITE_WARNING_AUTOINDEX (SQLITE_WARNING \| (1<<8))
1067
1068	/*
1069	** CAPI3REF: Flags For File Open Operations
1070	**
1071	** These bit values are intended for use in the
	@@ -10076,13 +10078,14 @@
10078	int newTnum; /* Rootpage of table being initialized */
10079	u8 iDb; /* Which db file is being initialized */
10080	u8 busy; /* TRUE if currently initializing */
10081	u8 orphanTrigger; /* Last statement is orphaned TEMP trigger */
10082	} init;
10083	int nVdbeActive; /* Number of VDBEs currently running */
10084	int nVdbeRead; /* Number of active VDBEs that read or write */
10085	int nVdbeWrite; /* Number of active VDBEs that read and write */
10086	int nVdbeExec; /* Number of nested calls to VdbeExec() */
10087	int nExtension; /* Number of loaded extensions */
10088	void *aExtension; / Array of shared library handles */
10089	void (xTrace)(void,const char); / Trace function */
10090	void pTraceArg; / Argument to the trace function */
10091	void (xProfile)(void,const char,u64); / Profiling function */
	@@ -10204,10 +10207,11 @@
10207	#define SQLITE_CoverIdxScan 0x0040 /* Covering index scans */
10208	#define SQLITE_OrderByIdxJoin 0x0080 /* ORDER BY of joins via index */
10209	#define SQLITE_SubqCoroutine 0x0100 /* Evaluate subqueries as coroutines */
10210	#define SQLITE_Transitive 0x0200 /* Transitive constraints */
10211	#define SQLITE_OmitNoopJoin 0x0400 /* Omit unused tables in joins */
10212	#define SQLITE_Stat3 0x0800 /* Use the SQLITE_STAT3 table */
10213	#define SQLITE_AllOpts 0xffff /* All optimizations */
10214
10215	/*
10216	** Macros for testing whether or not optimizations are enabled or disabled.
10217	*/
	@@ -13512,11 +13516,12 @@
13516	bft inVtabMethod:2; /* See comments above */
13517	bft changeCntOn:1; /* True to update the change-counter */
13518	bft expired:1; /* True if the VM needs to be recompiled */
13519	bft runOnlyOnce:1; /* Automatically expire on reset */
13520	bft usesStmtJournal:1; /* True if uses a statement journal */
13521	bft readOnly:1; /* True for statements that do not write */
13522	bft bIsReader:1; /* True for statements that read */
13523	bft isPrepareV2:1; /* True if prepared with prepare_v2() */
13524	bft doingRerun:1; /* True if rerunning after an auto-reprepare */
13525	int nChange; /* Number of db changes made since last reset */
13526	yDbMask btreeMask; /* Bitmask of db->aDb[] entries referenced */
13527	yDbMask lockMask; /* Subset of btreeMask that requires a lock */
	@@ -47891,11 +47896,11 @@
47896	** the write is disallowed.
47897	*/
47898	if( memcmp(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr))!=0 ){
47899	walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
47900	pWal->writeLock = 0;
47901	rc = SQLITE_BUSY_SNAPSHOT;
47902	}
47903
47904	return rc;
47905	}
47906
	@@ -52751,16 +52756,17 @@
52756	** This function is called from both BtreeCommitPhaseTwo() and BtreeRollback()
52757	** at the conclusion of a transaction.
52758	*/
52759	static void btreeEndTransaction(Btree *p){
52760	BtShared *pBt = p->pBt;
52761	sqlite3 *db = p->db;
52762	assert( sqlite3BtreeHoldsMutex(p) );
52763
52764	#ifndef SQLITE_OMIT_AUTOVACUUM
52765	pBt->bDoTruncate = 0;
52766	#endif
52767	if( p->inTrans>TRANS_NONE && db->nVdbeRead>1 ){
52768	/* If there are other active statements that belong to this database
52769	** handle, downgrade to a read-only transaction. The other statements
52770	** may still be reading from the database. */
52771	downgradeAllSharedCacheTableLocks(p);
52772	p->inTrans = TRANS_READ;
	@@ -60277,18 +60283,30 @@
60283	int i;
60284	int nMaxArgs = *pMaxFuncArgs;
60285	Op *pOp;
60286	int *aLabel = p->aLabel;
60287	p->readOnly = 1;
60288	p->bIsReader = 0;
60289	for(pOp=p->aOp, i=p->nOp-1; i>=0; i--, pOp++){
60290	u8 opcode = pOp->opcode;
60291
60292	pOp->opflags = sqlite3OpcodeProperty[opcode];
60293	if( opcode==OP_Function \|\| opcode==OP_AggStep ){
60294	if( pOp->p5>nMaxArgs ) nMaxArgs = pOp->p5;
60295	}else if( opcode==OP_Transaction ){
60296	if( pOp->p2!=0 ) p->readOnly = 0;
60297	p->bIsReader = 1;
60298	}else if( opcode==OP_AutoCommit \|\| opcode==OP_Savepoint ){
60299	p->bIsReader = 1;
60300	}else if( opcode==OP_Vacuum
60301	\|\| opcode==OP_JournalMode
60302	#ifndef SQLITE_OMIT_VIRTUALTABLE
60303	\|\| opcode==OP_Checkpoint
60304	#endif
60305	){
60306	p->readOnly = 0;
60307	p->bIsReader = 1;
60308	#ifndef SQLITE_OMIT_VIRTUALTABLE
60309	}else if( opcode==OP_VUpdate ){
60310	if( pOp->p2>nMaxArgs ) nMaxArgs = pOp->p2;
60311	}else if( opcode==OP_VFilter ){
60312	int n;
	@@ -60310,12 +60328,12 @@
60328	pOp->p2 = aLabel[-1-pOp->p2];
60329	}
60330	}
60331	sqlite3DbFree(p->db, p->aLabel);
60332	p->aLabel = 0;

60333	*pMaxFuncArgs = nMaxArgs;
60334	assert( p->bIsReader!=0 \|\| p->btreeMask==0 );
60335	}
60336
60337	/*
60338	** Return the address of the next instruction to be inserted.
60339	*/
	@@ -61837,11 +61855,11 @@
61855
61856	return rc;
61857	}
61858
61859	/*
61860	** This routine checks that the sqlite3.nVdbeActive count variable
61861	** matches the number of vdbe's in the list sqlite3.pVdbe that are
61862	** currently active. An assertion fails if the two counts do not match.
61863	** This is an internal self-check only - it is not an essential processing
61864	** step.
61865	**
	@@ -61850,20 +61868,23 @@
61868	#ifndef NDEBUG
61869	static void checkActiveVdbeCnt(sqlite3 *db){
61870	Vdbe *p;
61871	int cnt = 0;
61872	int nWrite = 0;
61873	int nRead = 0;
61874	p = db->pVdbe;
61875	while( p ){
61876	if( p->magic==VDBE_MAGIC_RUN && p->pc>=0 ){
61877	cnt++;
61878	if( p->readOnly==0 ) nWrite++;
61879	if( p->bIsReader ) nRead++;
61880	}
61881	p = p->pNext;
61882	}
61883	assert( cnt==db->nVdbeActive );
61884	assert( nWrite==db->nVdbeWrite );
61885	assert( nRead==db->nVdbeRead );
61886	}
61887	#else
61888	#define checkActiveVdbeCnt(x)
61889	#endif
61890
	@@ -61995,12 +62016,13 @@
62016	if( p->magic!=VDBE_MAGIC_RUN ){
62017	return SQLITE_OK;
62018	}
62019	checkActiveVdbeCnt(db);
62020
62021	/* No commit or rollback needed if the program never started or if the
62022	** SQL statement does not read or write a database file. */
62023	if( p->pc>=0 && p->bIsReader ){
62024	int mrc; /* Primary error code from p->rc */
62025	int eStatementOp = 0;
62026	int isSpecialError; /* Set to true if a 'special' error */
62027
62028	/* Lock all btrees used by the statement */
	@@ -62049,11 +62071,11 @@
62071	** Note: This block also runs if one of the special errors handled
62072	** above has occurred.
62073	*/
62074	if( !sqlite3VtabInSync(db)
62075	&& db->autoCommit
62076	&& db->nVdbeWrite==(p->readOnly==0)
62077	){
62078	if( p->rc==SQLITE_OK \|\| (p->errorAction==OE_Fail && !isSpecialError) ){
62079	rc = sqlite3VdbeCheckFk(p, 1);
62080	if( rc!=SQLITE_OK ){
62081	if( NEVER(p->readOnly) ){
	@@ -62130,15 +62152,16 @@
62152	sqlite3VdbeLeave(p);
62153	}
62154
62155	/* We have successfully halted and closed the VM. Record this fact. */
62156	if( p->pc>=0 ){
62157	db->nVdbeActive--;
62158	if( !p->readOnly ) db->nVdbeWrite--;
62159	if( p->bIsReader ) db->nVdbeRead--;
62160	assert( db->nVdbeActive>=db->nVdbeRead );
62161	assert( db->nVdbeRead>=db->nVdbeWrite );
62162	assert( db->nVdbeWrite>=0 );
62163	}
62164	p->magic = VDBE_MAGIC_HALT;
62165	checkActiveVdbeCnt(db);
62166	if( p->db->mallocFailed ){
62167	p->rc = SQLITE_NOMEM;
	@@ -62150,11 +62173,11 @@
62173	*/
62174	if( db->autoCommit ){
62175	sqlite3ConnectionUnlocked(db);
62176	}
62177
62178	assert( db->nVdbeActive>0 \|\| db->autoCommit==0 \|\| db->nStatement==0 );
62179	return (p->rc==SQLITE_BUSY ? SQLITE_BUSY : SQLITE_OK);
62180	}
62181
62182
62183	/*
	@@ -63508,35 +63531,36 @@
63531	if( p->pc<0 ){
63532	/* If there are no other statements currently running, then
63533	** reset the interrupt flag. This prevents a call to sqlite3_interrupt
63534	** from interrupting a statement that has not yet started.
63535	*/
63536	if( db->nVdbeActive==0 ){
63537	db->u1.isInterrupted = 0;
63538	}
63539
63540	assert( db->nVdbeWrite>0 \|\| db->autoCommit==0 \|\| db->nDeferredCons==0 );
63541
63542	#ifndef SQLITE_OMIT_TRACE
63543	if( db->xProfile && !db->init.busy ){
63544	sqlite3OsCurrentTimeInt64(db->pVfs, &p->startTime);
63545	}
63546	#endif
63547
63548	db->nVdbeActive++;
63549	if( p->readOnly==0 ) db->nVdbeWrite++;
63550	if( p->bIsReader ) db->nVdbeRead++;
63551	p->pc = 0;
63552	}
63553	#ifndef SQLITE_OMIT_EXPLAIN
63554	if( p->explain ){
63555	rc = sqlite3VdbeList(p);
63556	}else
63557	#endif /* SQLITE_OMIT_EXPLAIN */
63558	{
63559	db->nVdbeExec++;
63560	rc = sqlite3VdbeExec(p);
63561	db->nVdbeExec--;
63562	}
63563
63564	#ifndef SQLITE_OMIT_TRACE
63565	/* Invoke the profile callback if there is one
63566	*/
	@@ -64469,13 +64493,13 @@
64493	return nTotal;
64494	}
64495
64496	/*
64497	** This function returns a pointer to a nul-terminated string in memory
64498	** obtained from sqlite3DbMalloc(). If sqlite3.nVdbeExec is 1, then the
64499	** string contains a copy of zRawSql but with host parameters expanded to
64500	** their current bindings. Or, if sqlite3.nVdbeExec is greater than 1,
64501	** then the returned string holds a copy of zRawSql with "-- " prepended
64502	** to each line of text.
64503	**
64504	** If the SQLITE_TRACE_SIZE_LIMIT macro is defined to an integer, then
64505	** then long strings and blobs are truncated to that many bytes. This
	@@ -64509,11 +64533,11 @@
64533
64534	db = p->db;
64535	sqlite3StrAccumInit(&out, zBase, sizeof(zBase),
64536	db->aLimit[SQLITE_LIMIT_LENGTH]);
64537	out.db = db;
64538	if( db->nVdbeExec>1 ){
64539	while( *zRawSql ){
64540	const char *zStart = zRawSql;
64541	while( (zRawSql++)!='\n' && zRawSql );
64542	sqlite3StrAccumAppend(&out, "-- ", 3);
64543	sqlite3StrAccumAppend(&out, zStart, (int)(zRawSql-zStart));
	@@ -65815,10 +65839,11 @@
65839	/* This happens if a malloc() inside a call to sqlite3_column_text() or
65840	** sqlite3_column_text16() failed. */
65841	goto no_mem;
65842	}
65843	assert( p->rc==SQLITE_OK \|\| p->rc==SQLITE_BUSY );
65844	assert( p->bIsReader \|\| p->readOnly!=0 );
65845	p->rc = SQLITE_OK;
65846	assert( p->explain==0 );
65847	p->pResultSet = 0;
65848	db->busyHandler.nBusy = 0;
65849	CHECK_FOR_INTERRUPT;
	@@ -67959,13 +67984,14 @@
67984	*/
67985	assert( db->pSavepoint==0 \|\| db->autoCommit==0 );
67986	assert( u.as.p1==SAVEPOINT_BEGIN\|\|u.as.p1==SAVEPOINT_RELEASE\|\|u.as.p1==SAVEPOINT_ROLLBACK );
67987	assert( db->pSavepoint \|\| db->isTransactionSavepoint==0 );
67988	assert( checkSavepointCount(db) );
67989	assert( p->bIsReader );
67990
67991	if( u.as.p1==SAVEPOINT_BEGIN ){
67992	if( db->nVdbeWrite>0 ){
67993	/* A new savepoint cannot be created if there are active write
67994	** statements (i.e. open read/write incremental blob handles).
67995	*/
67996	sqlite3SetString(&p->zErrMsg, db, "cannot open savepoint - "
67997	"SQL statements in progress");
	@@ -68018,11 +68044,11 @@
68044	u.as.iSavepoint++;
68045	}
68046	if( !u.as.pSavepoint ){
68047	sqlite3SetString(&p->zErrMsg, db, "no such savepoint: %s", u.as.zName);
68048	rc = SQLITE_ERROR;
68049	}else if( db->nVdbeWrite>0 && u.as.p1==SAVEPOINT_RELEASE ){
68050	/* It is not possible to release (commit) a savepoint if there are
68051	** active write statements.
68052	*/
68053	sqlite3SetString(&p->zErrMsg, db,
68054	"cannot release savepoint - SQL statements in progress"
	@@ -68121,24 +68147,25 @@
68147	u.at.desiredAutoCommit = pOp->p1;
68148	u.at.iRollback = pOp->p2;
68149	u.at.turnOnAC = u.at.desiredAutoCommit && !db->autoCommit;
68150	assert( u.at.desiredAutoCommit==1 \|\| u.at.desiredAutoCommit==0 );
68151	assert( u.at.desiredAutoCommit==1 \|\| u.at.iRollback==0 );
68152	assert( db->nVdbeActive>0 ); /* At least this one VM is active */
68153	assert( p->bIsReader );
68154
68155	#if 0
68156	if( u.at.turnOnAC && u.at.iRollback && db->nVdbeActive>1 ){
68157	/* If this instruction implements a ROLLBACK and other VMs are
68158	** still running, and a transaction is active, return an error indicating
68159	** that the other VMs must complete first.
68160	*/
68161	sqlite3SetString(&p->zErrMsg, db, "cannot rollback transaction - "
68162	"SQL statements in progress");
68163	rc = SQLITE_BUSY;
68164	}else
68165	#endif
68166	if( u.at.turnOnAC && !u.at.iRollback && db->nVdbeWrite>0 ){
68167	/* If this instruction implements a COMMIT and other VMs are writing
68168	** return an error indicating that the other VMs must complete first.
68169	*/
68170	sqlite3SetString(&p->zErrMsg, db, "cannot commit transaction - "
68171	"SQL statements in progress");
	@@ -68212,10 +68239,12 @@
68239	case OP_Transaction: {
68240	#if 0 /* local variables moved into u.au */
68241	Btree *pBt;
68242	#endif /* local variables moved into u.au */
68243
68244	assert( p->bIsReader );
68245	assert( p->readOnly==0 \|\| pOp->p2==0 );
68246	assert( pOp->p1>=0 && pOp->p1<db->nDb );
68247	assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
68248	u.au.pBt = db->aDb[pOp->p1].pBt;
68249
68250	if( u.au.pBt ){
	@@ -68228,11 +68257,11 @@
68257	if( rc!=SQLITE_OK ){
68258	goto abort_due_to_error;
68259	}
68260
68261	if( pOp->p2 && p->usesStmtJournal
68262	&& (db->autoCommit==0 \|\| db->nVdbeRead>1)
68263	){
68264	assert( sqlite3BtreeIsInTrans(u.au.pBt) );
68265	if( p->iStatement==0 ){
68266	assert( db->nStatement>=0 && db->nSavepoint>=0 );
68267	db->nStatement++;
	@@ -68270,10 +68299,11 @@
68299	int iMeta;
68300	int iDb;
68301	int iCookie;
68302	#endif /* local variables moved into u.av */
68303
68304	assert( p->bIsReader );
68305	u.av.iDb = pOp->p1;
68306	u.av.iCookie = pOp->p3;
68307	assert( pOp->p3<SQLITE_N_BTREE_META );
68308	assert( u.av.iDb>=0 && u.av.iDb<db->nDb );
68309	assert( db->aDb[u.av.iDb].pBt!=0 );
	@@ -68299,10 +68329,11 @@
68329	Db *pDb;
68330	#endif /* local variables moved into u.aw */
68331	assert( pOp->p2<SQLITE_N_BTREE_META );
68332	assert( pOp->p1>=0 && pOp->p1<db->nDb );
68333	assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
68334	assert( p->readOnly==0 );
68335	u.aw.pDb = &db->aDb[pOp->p1];
68336	assert( u.aw.pDb->pBt!=0 );
68337	assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
68338	pIn3 = &aMem[pOp->p3];
68339	sqlite3VdbeMemIntegerify(pIn3);
	@@ -68351,10 +68382,11 @@
68382	#endif /* local variables moved into u.ax */
68383
68384	assert( pOp->p1>=0 && pOp->p1<db->nDb );
68385	assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
68386	assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
68387	assert( p->bIsReader );
68388	u.ax.pBt = db->aDb[pOp->p1].pBt;
68389	if( u.ax.pBt ){
68390	sqlite3BtreeGetMeta(u.ax.pBt, BTREE_SCHEMA_VERSION, (u32 *)&u.ax.iMeta);
68391	u.ax.iGen = db->aDb[pOp->p1].pSchema->iGeneration;
68392	}else{
	@@ -68448,10 +68480,12 @@
68480	Db *pDb;
68481	#endif /* local variables moved into u.ay */
68482
68483	assert( (pOp->p5&(OPFLAG_P2ISREG\|OPFLAG_BULKCSR))==pOp->p5 );
68484	assert( pOp->opcode==OP_OpenWrite \|\| pOp->p5==0 );
68485	assert( p->bIsReader );
68486	assert( pOp->opcode==OP_OpenRead \|\| p->readOnly==0 );
68487
68488	if( p->expired ){
68489	rc = SQLITE_ABORT;
68490	break;
68491	}
	@@ -70066,19 +70100,22 @@
70100	int iCnt;
70101	Vdbe *pVdbe;
70102	int iDb;
70103	#endif /* local variables moved into u.bw */
70104
70105	assert( p->readOnly==0 );
70106	#ifndef SQLITE_OMIT_VIRTUALTABLE
70107	u.bw.iCnt = 0;
70108	for(u.bw.pVdbe=db->pVdbe; u.bw.pVdbe; u.bw.pVdbe = u.bw.pVdbe->pNext){
70109	if( u.bw.pVdbe->magic==VDBE_MAGIC_RUN && u.bw.pVdbe->bIsReader
70110	&& u.bw.pVdbe->inVtabMethod<2 && u.bw.pVdbe->pc>=0
70111	){
70112	u.bw.iCnt++;
70113	}
70114	}
70115	#else
70116	u.bw.iCnt = db->nVdbeRead;
70117	#endif
70118	pOut->flags = MEM_Null;
70119	if( u.bw.iCnt>1 ){
70120	rc = SQLITE_LOCKED;
70121	p->errorAction = OE_Abort;
	@@ -70123,10 +70160,11 @@
70160	#if 0 /* local variables moved into u.bx */
70161	int nChange;
70162	#endif /* local variables moved into u.bx */
70163
70164	u.bx.nChange = 0;
70165	assert( p->readOnly==0 );
70166	assert( (p->btreeMask & (((yDbMask)1)<<pOp->p2))!=0 );
70167	rc = sqlite3BtreeClearTable(
70168	db->aDb[pOp->p2].pBt, pOp->p1, (pOp->p3 ? &u.bx.nChange : 0)
70169	);
70170	if( pOp->p3 ){
	@@ -70171,10 +70209,11 @@
70209	#endif /* local variables moved into u.by */
70210
70211	u.by.pgno = 0;
70212	assert( pOp->p1>=0 && pOp->p1<db->nDb );
70213	assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
70214	assert( p->readOnly==0 );
70215	u.by.pDb = &db->aDb[pOp->p1];
70216	assert( u.by.pDb->pBt!=0 );
70217	if( pOp->opcode==OP_CreateTable ){
70218	/* u.by.flags = BTREE_INTKEY; */
70219	u.by.flags = BTREE_INTKEY;
	@@ -70323,10 +70362,11 @@
70362	int nErr; /* Number of errors reported */
70363	char z; / Text of the error report */
70364	Mem pnErr; / Register keeping track of errors remaining */
70365	#endif /* local variables moved into u.ca */
70366
70367	assert( p->bIsReader );
70368	u.ca.nRoot = pOp->p2;
70369	assert( u.ca.nRoot>0 );
70370	u.ca.aRoot = sqlite3DbMallocRaw(db, sizeof(int)*(u.ca.nRoot+1) );
70371	if( u.ca.aRoot==0 ) goto no_mem;
70372	assert( pOp->p3>0 && pOp->p3<=p->nMem );
	@@ -70844,10 +70884,11 @@
70884	int i; /* Loop counter */
70885	int aRes[3]; /* Results */
70886	Mem pMem; / Write results here */
70887	#endif /* local variables moved into u.ci */
70888
70889	assert( p->readOnly==0 );
70890	u.ci.aRes[0] = 0;
70891	u.ci.aRes[1] = u.ci.aRes[2] = -1;
70892	assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE
70893	\|\| pOp->p2==SQLITE_CHECKPOINT_FULL
70894	\|\| pOp->p2==SQLITE_CHECKPOINT_RESTART
	@@ -70895,10 +70936,11 @@
70936	\|\| u.cj.eNew==PAGER_JOURNALMODE_MEMORY
70937	\|\| u.cj.eNew==PAGER_JOURNALMODE_WAL
70938	\|\| u.cj.eNew==PAGER_JOURNALMODE_QUERY
70939	);
70940	assert( pOp->p1>=0 && pOp->p1<db->nDb );
70941	assert( p->readOnly==0 );
70942
70943	u.cj.pBt = db->aDb[pOp->p1].pBt;
70944	u.cj.pPager = sqlite3BtreePager(u.cj.pBt);
70945	u.cj.eOld = sqlite3PagerGetJournalMode(u.cj.pPager);
70946	if( u.cj.eNew==PAGER_JOURNALMODE_QUERY ) u.cj.eNew = u.cj.eOld;
	@@ -70918,11 +70960,11 @@
70960	}
70961
70962	if( (u.cj.eNew!=u.cj.eOld)
70963	&& (u.cj.eOld==PAGER_JOURNALMODE_WAL \|\| u.cj.eNew==PAGER_JOURNALMODE_WAL)
70964	){
70965	if( !db->autoCommit \|\| db->nVdbeRead>1 ){
70966	rc = SQLITE_ERROR;
70967	sqlite3SetString(&p->zErrMsg, db,
70968	"cannot change %s wal mode from within a transaction",
70969	(u.cj.eNew==PAGER_JOURNALMODE_WAL ? "into" : "out of")
70970	);
	@@ -70977,10 +71019,11 @@
71019	** Vacuum the entire database. This opcode will cause other virtual
71020	** machines to be created and run. It may not be called from within
71021	** a transaction.
71022	*/
71023	case OP_Vacuum: {
71024	assert( p->readOnly==0 );
71025	rc = sqlite3RunVacuum(&p->zErrMsg, db);
71026	break;
71027	}
71028	#endif
71029
	@@ -70996,10 +71039,11 @@
71039	Btree *pBt;
71040	#endif /* local variables moved into u.ck */
71041
71042	assert( pOp->p1>=0 && pOp->p1<db->nDb );
71043	assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
71044	assert( p->readOnly==0 );
71045	u.ck.pBt = db->aDb[pOp->p1].pBt;
71046	rc = sqlite3BtreeIncrVacuum(u.ck.pBt);
71047	if( rc==SQLITE_DONE ){
71048	pc = pOp->p2 - 1;
71049	rc = SQLITE_OK;
	@@ -71118,10 +71162,11 @@
71162	sqlite3_vtab_cursor *pVtabCursor;
71163	sqlite3_vtab *pVtab;
71164	sqlite3_module *pModule;
71165	#endif /* local variables moved into u.cm */
71166
71167	assert( p->bIsReader );
71168	u.cm.pCur = 0;
71169	u.cm.pVtabCursor = 0;
71170	u.cm.pVtab = pOp->p4.pVtab->pVtab;
71171	u.cm.pModule = (sqlite3_module *)u.cm.pVtab->pModule;
71172	assert(u.cm.pVtab && u.cm.pModule);
	@@ -71342,10 +71387,11 @@
71387
71388	u.cq.pVtab = pOp->p4.pVtab->pVtab;
71389	u.cq.pName = &aMem[pOp->p1];
71390	assert( u.cq.pVtab->pModule->xRename );
71391	assert( memIsValid(u.cq.pName) );
71392	assert( p->readOnly==0 );
71393	REGISTER_TRACE(pOp->p1, u.cq.pName);
71394	assert( u.cq.pName->flags & MEM_Str );
71395	testcase( u.cq.pName->enc==SQLITE_UTF8 );
71396	testcase( u.cq.pName->enc==SQLITE_UTF16BE );
71397	testcase( u.cq.pName->enc==SQLITE_UTF16LE );
	@@ -71395,10 +71441,11 @@
71441	#endif /* local variables moved into u.cr */
71442
71443	assert( pOp->p2==1 \|\| pOp->p5==OE_Fail \|\| pOp->p5==OE_Rollback
71444	\|\| pOp->p5==OE_Abort \|\| pOp->p5==OE_Ignore \|\| pOp->p5==OE_Replace
71445	);
71446	assert( p->readOnly==0 );
71447	u.cr.pVtab = pOp->p4.pVtab->pVtab;
71448	u.cr.pModule = (sqlite3_module *)u.cr.pVtab->pModule;
71449	u.cr.nArg = pOp->p2;
71450	assert( pOp->p4type==P4_VTAB );
71451	if( ALWAYS(u.cr.pModule->xUpdate) ){
	@@ -102957,11 +103004,11 @@
103004
103005	if( !db->autoCommit ){
103006	sqlite3SetString(pzErrMsg, db, "cannot VACUUM from within a transaction");
103007	return SQLITE_ERROR;
103008	}
103009	if( db->nVdbeActive>1 ){
103010	sqlite3SetString(pzErrMsg, db,"cannot VACUUM - SQL statements in progress");
103011	return SQLITE_ERROR;
103012	}
103013
103014	/* Save the current value of the database flags so that it can be
	@@ -104742,11 +104789,11 @@
104789	#define WHERE_INDEXED 0x00000200 /* WhereLoop.u.btree.pIndex is valid */
104790	#define WHERE_VIRTUALTABLE 0x00000400 /* WhereLoop.u.vtab is valid */
104791	#define WHERE_IN_ABLE 0x00000800 /* Able to support an IN operator */
104792	#define WHERE_ONEROW 0x00001000 /* Selects no more than one row */
104793	#define WHERE_MULTI_OR 0x00002000 /* OR using multiple indices */
104794	#define WHERE_AUTO_INDEX 0x00004000 /* Uses an ephemeral index */
104795
104796
104797	/* Convert a WhereCost value (10 times log2(X)) into its integer value X.
104798	** A rough approximation is used. The value returned is not exact.
104799	*/
	@@ -106036,10 +106083,11 @@
106083	** the start of the loop will prevent any results from being returned.
106084	*/
106085	if( pExpr->op==TK_NOTNULL
106086	&& pExpr->pLeft->op==TK_COLUMN
106087	&& pExpr->pLeft->iColumn>=0
106088	&& OptimizationEnabled(db, SQLITE_Stat3)
106089	){
106090	Expr *pNewExpr;
106091	Expr *pLeft = pExpr->pLeft;
106092	int idxNew;
106093	WhereTerm *pNewTerm;
	@@ -106339,10 +106387,11 @@
106387	int mxBitCol; /* Maximum column in pSrc->colUsed */
106388	CollSeq pColl; / Collating sequence to on a column */
106389	WhereLoop pLoop; / The Loop object */
106390	Bitmask idxCols; /* Bitmap of columns used for indexing */
106391	Bitmask extraCols; /* Bitmap of additional columns */
106392	u8 sentWarning = 0; /* True if a warnning has been issued */
106393
106394	/* Generate code to skip over the creation and initialization of the
106395	** transient index on 2nd and subsequent iterations of the loop. */
106396	v = pParse->pVdbe;
106397	assert( v!=0 );
	@@ -106359,10 +106408,16 @@
106408	if( termCanDriveIndex(pTerm, pSrc, notReady) ){
106409	int iCol = pTerm->u.leftColumn;
106410	Bitmask cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
106411	testcase( iCol==BMS );
106412	testcase( iCol==BMS-1 );
106413	if( !sentWarning ){
106414	sqlite3_log(SQLITE_WARNING_AUTOINDEX,
106415	"automatic index on %s(%s)", pTable->zName,
106416	pTable->aCol[iCol].zName);
106417	sentWarning = 1;
106418	}
106419	if( (idxCols & cMask)==0 ){
106420	if( whereLoopResize(pParse->db, pLoop, nColumn+1) ) return;
106421	pLoop->aLTerm[nColumn++] = pTerm;
106422	idxCols \|= cMask;
106423	}
	@@ -106369,11 +106424,11 @@
106424	}
106425	}
106426	assert( nColumn>0 );
106427	pLoop->u.btree.nEq = pLoop->nLTerm = nColumn;
106428	pLoop->wsFlags = WHERE_COLUMN_EQ \| WHERE_IDX_ONLY \| WHERE_INDEXED
106429	\| WHERE_AUTO_INDEX;
106430
106431	/* Count the number of additional columns needed to create a
106432	** covering index. A "covering index" is an index that contains all
106433	** columns that are needed by the query. With a covering index, the
106434	** original table never needs to be accessed. Automatic indices must
	@@ -106869,11 +106924,11 @@
106924	){
106925	int rc = SQLITE_OK;
106926
106927	#ifdef SQLITE_ENABLE_STAT3
106928
106929	if( nEq==0 && p->nSample && OptimizationEnabled(pParse->db, SQLITE_Stat3) ){
106930	sqlite3_value *pRangeVal;
106931	tRowcnt iLower = 0;
106932	tRowcnt iUpper = p->aiRowEst[0];
106933	tRowcnt a[2];
106934	u8 aff = p->pTable->aCol[p->aiColumn[0]].affinity;
	@@ -107415,17 +107470,16 @@
107470	}
107471	if( (flags & (WHERE_IPK\|WHERE_VIRTUALTABLE))==0
107472	&& ALWAYS(pLoop->u.btree.pIndex!=0)
107473	){
107474	char *zWhere = explainIndexRange(db, pLoop, pItem->pTab);
107475	zMsg = sqlite3MAppendf(db, zMsg,
107476	((flags & WHERE_AUTO_INDEX) ?
107477	"%s USING AUTOMATIC %sINDEX%.0s%s" :
107478	"%s USING %sINDEX %s%s"),
107479	zMsg, ((flags & WHERE_IDX_ONLY) ? "COVERING " : ""),
107480	pLoop->u.btree.pIndex->zName, zWhere);

107481	sqlite3DbFree(db, zWhere);
107482	}else if( (flags & WHERE_IPK)!=0 && (flags & WHERE_CONSTRAINT)!=0 ){
107483	zMsg = sqlite3MAppendf(db, zMsg, "%s USING INTEGER PRIMARY KEY", zMsg);
107484
107485	if( flags&(WHERE_COLUMN_EQ\|WHERE_COLUMN_IN) ){
	@@ -108092,11 +108146,11 @@
108146	** terms, set pCov to the candidate covering index. Otherwise, set
108147	** pCov to NULL to indicate that no candidate covering index will
108148	** be available.
108149	*/
108150	pSubLoop = pSubWInfo->a[0].pWLoop;
108151	assert( (pSubLoop->wsFlags & WHERE_AUTO_INDEX)==0 );
108152	if( (pSubLoop->wsFlags & WHERE_INDEXED)!=0
108153	&& (ii==0 \|\| pSubLoop->u.btree.pIndex==pCov)
108154	){
108155	assert( pSubWInfo->a[0].iIdxCur==iCovCur );
108156	pCov = pSubLoop->u.btree.pIndex;
	@@ -108274,16 +108328,16 @@
108328
108329	/*
108330	** Clear the WhereLoop.u union. Leave WhereLoop.pLTerm intact.
108331	*/
108332	static void whereLoopClearUnion(sqlite3 db, WhereLoop p){
108333	if( p->wsFlags & (WHERE_VIRTUALTABLE\|WHERE_AUTO_INDEX) ){
108334	if( (p->wsFlags & WHERE_VIRTUALTABLE)!=0 && p->u.vtab.needFree ){
108335	sqlite3_free(p->u.vtab.idxStr);
108336	p->u.vtab.needFree = 0;
108337	p->u.vtab.idxStr = 0;
108338	}else if( (p->wsFlags & WHERE_AUTO_INDEX)!=0 && p->u.btree.pIndex!=0 ){
108339	sqlite3DbFree(db, p->u.btree.pIndex->zColAff);
108340	sqlite3DbFree(db, p->u.btree.pIndex);
108341	p->u.btree.pIndex = 0;
108342	}
108343	}
	@@ -108322,11 +108376,11 @@
108376	whereLoopClearUnion(db, pTo);
108377	memcpy(pTo, pFrom, WHERE_LOOP_XFER_SZ);
108378	memcpy(pTo->aLTerm, pFrom->aLTerm, pTo->nLTerm*sizeof(pTo->aLTerm[0]));
108379	if( pFrom->wsFlags & WHERE_VIRTUALTABLE ){
108380	pFrom->u.vtab.needFree = 0;
108381	}else if( (pFrom->wsFlags & WHERE_AUTO_INDEX)!=0 ){
108382	pFrom->u.btree.pIndex = 0;
108383	}
108384	return SQLITE_OK;
108385	}
108386
	@@ -108634,11 +108688,12 @@
108688	whereRangeScanEst(pParse, pProbe, pNew->u.btree.nEq,
108689	pBtm, pTop, &rDiv);
108690	pNew->nOut = saved_nOut>rDiv+10 ? saved_nOut - rDiv : 10;
108691	}
108692	#ifdef SQLITE_ENABLE_STAT3
108693	if( pNew->u.btree.nEq==1 && pProbe->nSample
108694	&& OptimizationEnabled(db, SQLITE_Stat3) ){
108695	tRowcnt nOut = 0;
108696	if( (pTerm->eOperator & (WO_EQ\|WO_ISNULL))!=0 ){
108697	testcase( pTerm->eOperator & WO_EQ );
108698	testcase( pTerm->eOperator & WO_ISNULL );
108699	rc = whereEqualScanEst(pParse, pProbe, pTerm->pExpr->pRight, &nOut);
	@@ -108794,17 +108849,20 @@
108849	pNew->u.btree.nEq = 1;
108850	pNew->u.btree.pIndex = 0;
108851	pNew->nLTerm = 1;
108852	pNew->aLTerm[0] = pTerm;
108853	/* TUNING: One-time cost for computing the automatic index is
108854	** approximately 7Nlog2(N) where N is the number of rows in
108855	** the table being indexed. */
108856	pNew->rSetup = rLogSize + rSize + 28; assert( 28==whereCost(7) );
108857	/* TUNING: Each index lookup yields 20 rows in the table. This
108858	** is more than the usual guess of 10 rows, since we have no way
108859	** of knowning how selective the index will ultimately be. It would
108860	** not be unreasonable to make this value much larger. */
108861	pNew->nOut = 43; assert( 43==whereCost(20) );
108862	pNew->rRun = whereCostAdd(rLogSize,pNew->nOut);
108863	pNew->wsFlags = WHERE_AUTO_INDEX;
108864	pNew->prereq = mExtra \| pTerm->prereqRight;
108865	rc = whereLoopInsert(pBuilder, pNew);
108866	}
108867	}
108868	}
	@@ -110094,18 +110152,28 @@
110152	&& OptimizationEnabled(db, SQLITE_OmitNoopJoin)
110153	){
110154	Bitmask tabUsed = exprListTableUsage(pMaskSet, pResultSet);
110155	if( pOrderBy ) tabUsed \|= exprListTableUsage(pMaskSet, pOrderBy);
110156	while( pWInfo->nLevel>=2 ){
110157	WhereTerm pTerm, pEnd;
110158	pLoop = pWInfo->a[pWInfo->nLevel-1].pWLoop;
110159	if( (pWInfo->pTabList->a[pLoop->iTab].jointype & JT_LEFT)==0 ) break;
110160	if( (wctrlFlags & WHERE_WANT_DISTINCT)==0
110161	&& (pLoop->wsFlags & WHERE_ONEROW)==0
110162	){
110163	break;
110164	}
110165	if( (tabUsed & pLoop->maskSelf)!=0 ) break;
110166	pEnd = sWLB.pWC->a + sWLB.pWC->nTerm;
110167	for(pTerm=sWLB.pWC->a; pTerm<pEnd; pTerm++){
110168	if( (pTerm->prereqAll & pLoop->maskSelf)!=0
110169	&& !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
110170	){
110171	break;
110172	}
110173	}
110174	if( pTerm<pEnd ) break;
110175	WHERETRACE(0xffff, ("-> drop loop %c not used\n", pLoop->cId));
110176	pWInfo->nLevel--;
110177	nTabList--;
110178	}
110179	}
	@@ -110167,11 +110235,11 @@
110235	}
110236	}else{
110237	sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
110238	}
110239	#ifndef SQLITE_OMIT_AUTOMATIC_INDEX
110240	if( (pLoop->wsFlags & WHERE_AUTO_INDEX)!=0 ){
110241	constructAutomaticIndex(pParse, &pWInfo->sWC, pTabItem, notReady, pLevel);
110242	}else
110243	#endif
110244	if( pLoop->wsFlags & WHERE_INDEXED ){
110245	Index *pIx = pLoop->u.btree.pIndex;
	@@ -110290,11 +110358,11 @@
110358	){
110359	int ws = pLoop->wsFlags;
110360	if( !pWInfo->okOnePass && (ws & WHERE_IDX_ONLY)==0 ){
110361	sqlite3VdbeAddOp1(v, OP_Close, pTabItem->iCursor);
110362	}
110363	if( (ws & WHERE_INDEXED)!=0 && (ws & (WHERE_IPK\|WHERE_AUTO_INDEX))==0 ){
110364	sqlite3VdbeAddOp1(v, OP_Close, pLevel->iIdxCur);
110365	}
110366	}
110367
110368	/* If this scan uses an index, make VDBE code substitutions to read data
	@@ -114501,11 +114569,11 @@
114569	sqlite3 db = pParse->db; / The database connection */
114570	int mxSqlLen; /* Max length of an SQL string */
114571
114572
114573	mxSqlLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH];
114574	if( db->nVdbeActive==0 ){
114575	db->u1.isInterrupted = 0;
114576	}
114577	pParse->rc = SQLITE_OK;
114578	pParse->zTail = zSql;
114579	i = 0;
	@@ -116069,10 +116137,11 @@
116137	case SQLITE_PERM: zName = "SQLITE_PERM"; break;
116138	case SQLITE_ABORT: zName = "SQLITE_ABORT"; break;
116139	case SQLITE_ABORT_ROLLBACK: zName = "SQLITE_ABORT_ROLLBACK"; break;
116140	case SQLITE_BUSY: zName = "SQLITE_BUSY"; break;
116141	case SQLITE_BUSY_RECOVERY: zName = "SQLITE_BUSY_RECOVERY"; break;
116142	case SQLITE_BUSY_SNAPSHOT: zName = "SQLITE_BUSY_SNAPSHOT"; break;
116143	case SQLITE_LOCKED: zName = "SQLITE_LOCKED"; break;
116144	case SQLITE_LOCKED_SHAREDCACHE: zName = "SQLITE_LOCKED_SHAREDCACHE";break;
116145	case SQLITE_NOMEM: zName = "SQLITE_NOMEM"; break;
116146	case SQLITE_READONLY: zName = "SQLITE_READONLY"; break;
116147	case SQLITE_READONLY_RECOVERY: zName = "SQLITE_READONLY_RECOVERY"; break;
	@@ -116142,10 +116211,11 @@
116211	case SQLITE_NOTICE: zName = "SQLITE_NOTICE"; break;
116212	case SQLITE_NOTICE_RECOVER_WAL: zName = "SQLITE_NOTICE_RECOVER_WAL";break;
116213	case SQLITE_NOTICE_RECOVER_ROLLBACK:
116214	zName = "SQLITE_NOTICE_RECOVER_ROLLBACK"; break;
116215	case SQLITE_WARNING: zName = "SQLITE_WARNING"; break;
116216	case SQLITE_WARNING_AUTOINDEX: zName = "SQLITE_WARNING_AUTOINDEX"; break;
116217	case SQLITE_DONE: zName = "SQLITE_DONE"; break;
116218	}
116219	}
116220	if( zName==0 ){
116221	static char zBuf[50];
	@@ -116400,11 +116470,11 @@
116470	** is being overridden/deleted but there are no active VMs, allow the
116471	** operation to continue but invalidate all precompiled statements.
116472	*/
116473	p = sqlite3FindFunction(db, zFunctionName, nName, nArg, (u8)enc, 0);
116474	if( p && p->iPrefEnc==enc && p->nArg==nArg ){
116475	if( db->nVdbeActive ){
116476	sqlite3Error(db, SQLITE_BUSY,
116477	"unable to delete/modify user-function due to active statements");
116478	assert( !db->mallocFailed );
116479	return SQLITE_BUSY;
116480	}else{
	@@ -116981,11 +117051,11 @@
117051	** sequence. If so, and there are active VMs, return busy. If there
117052	** are no active VMs, invalidate any pre-compiled statements.
117053	*/
117054	pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0);
117055	if( pColl && pColl->xCmp ){
117056	if( db->nVdbeActive ){
117057	sqlite3Error(db, SQLITE_BUSY,
117058	"unable to delete/modify collation sequence due to active statements");
117059	return SQLITE_BUSY;
117060	}
117061	sqlite3ExpirePreparedStatements(db);
	@@ -117456,11 +117526,14 @@
117526	memcpy(db->aLimit, aHardLimit, sizeof(db->aLimit));
117527	db->autoCommit = 1;
117528	db->nextAutovac = -1;
117529	db->szMmap = sqlite3GlobalConfig.szMmap;
117530	db->nextPagesize = 0;
117531	db->flags \|= SQLITE_ShortColNames \| SQLITE_EnableTrigger
117532	#if !defined(SQLITE_DEAULT_AUTOMATIC_INDEX) \|\| SQLITE_DEFAULT_AUTOMATIC_INDEX
117533	\| SQLITE_AutoIndex
117534	#endif
117535	#if SQLITE_DEFAULT_FILE_FORMAT<4
117536	\| SQLITE_LegacyFileFmt
117537	#endif
117538	#ifdef SQLITE_ENABLE_LOAD_EXTENSION
117539	\| SQLITE_LoadExtension
117540

M src/sqlite3.h

+3 -1

		--- src/sqlite3.h
		+++ src/sqlite3.h
		@@ -107,11 +107,11 @@
107	107	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
108	108	** [sqlite_version()] and [sqlite_source_id()].
109	109	*/
110	110	#define SQLITE_VERSION "3.8.0"
111	111	#define SQLITE_VERSION_NUMBER 3008000
112		-#define SQLITE_SOURCE_ID "2013-06-26 22:46:00 93f632152e464a89322a0130adaf9f342411bf7d"
	112	+#define SQLITE_SOURCE_ID "2013-06-28 23:55:45 338826ef3f8a209b14f8d42370855cab9ac9ed45"
113	113
114	114	/*
115	115	** CAPI3REF: Run-Time Library Version Numbers
116	116	** KEYWORDS: sqlite3_version, sqlite3_sourceid
117	117	**
		@@ -478,10 +478,11 @@
478	478	#define SQLITE_IOERR_SEEK (SQLITE_IOERR \| (22<<8))
479	479	#define SQLITE_IOERR_DELETE_NOENT (SQLITE_IOERR \| (23<<8))
480	480	#define SQLITE_IOERR_MMAP (SQLITE_IOERR \| (24<<8))
481	481	#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED \| (1<<8))
482	482	#define SQLITE_BUSY_RECOVERY (SQLITE_BUSY \| (1<<8))
	483	+#define SQLITE_BUSY_SNAPSHOT (SQLITE_BUSY \| (2<<8))
483	484	#define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN \| (1<<8))
484	485	#define SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN \| (2<<8))
485	486	#define SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN \| (3<<8))
486	487	#define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT \| (1<<8))
487	488	#define SQLITE_READONLY_RECOVERY (SQLITE_READONLY \| (1<<8))
		@@ -497,10 +498,11 @@
497	498	#define SQLITE_CONSTRAINT_TRIGGER (SQLITE_CONSTRAINT \| (7<<8))
498	499	#define SQLITE_CONSTRAINT_UNIQUE (SQLITE_CONSTRAINT \| (8<<8))
499	500	#define SQLITE_CONSTRAINT_VTAB (SQLITE_CONSTRAINT \| (9<<8))
500	501	#define SQLITE_NOTICE_RECOVER_WAL (SQLITE_NOTICE \| (1<<8))
501	502	#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE \| (2<<8))
	503	+#define SQLITE_WARNING_AUTOINDEX (SQLITE_WARNING \| (1<<8))
502	504
503	505	/*
504	506	** CAPI3REF: Flags For File Open Operations
505	507	**
506	508	** These bit values are intended for use in the
507	509

	--- src/sqlite3.h
	+++ src/sqlite3.h
	@@ -107,11 +107,11 @@
107	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
108	** [sqlite_version()] and [sqlite_source_id()].
109	*/
110	#define SQLITE_VERSION "3.8.0"
111	#define SQLITE_VERSION_NUMBER 3008000
112	#define SQLITE_SOURCE_ID "2013-06-26 22:46:00 93f632152e464a89322a0130adaf9f342411bf7d"
113
114	/*
115	** CAPI3REF: Run-Time Library Version Numbers
116	** KEYWORDS: sqlite3_version, sqlite3_sourceid
117	**
	@@ -478,10 +478,11 @@
478	#define SQLITE_IOERR_SEEK (SQLITE_IOERR \| (22<<8))
479	#define SQLITE_IOERR_DELETE_NOENT (SQLITE_IOERR \| (23<<8))
480	#define SQLITE_IOERR_MMAP (SQLITE_IOERR \| (24<<8))
481	#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED \| (1<<8))
482	#define SQLITE_BUSY_RECOVERY (SQLITE_BUSY \| (1<<8))

483	#define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN \| (1<<8))
484	#define SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN \| (2<<8))
485	#define SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN \| (3<<8))
486	#define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT \| (1<<8))
487	#define SQLITE_READONLY_RECOVERY (SQLITE_READONLY \| (1<<8))
	@@ -497,10 +498,11 @@
497	#define SQLITE_CONSTRAINT_TRIGGER (SQLITE_CONSTRAINT \| (7<<8))
498	#define SQLITE_CONSTRAINT_UNIQUE (SQLITE_CONSTRAINT \| (8<<8))
499	#define SQLITE_CONSTRAINT_VTAB (SQLITE_CONSTRAINT \| (9<<8))
500	#define SQLITE_NOTICE_RECOVER_WAL (SQLITE_NOTICE \| (1<<8))
501	#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE \| (2<<8))

502
503	/*
504	** CAPI3REF: Flags For File Open Operations
505	**
506	** These bit values are intended for use in the
507

	--- src/sqlite3.h
	+++ src/sqlite3.h
	@@ -107,11 +107,11 @@
107	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
108	** [sqlite_version()] and [sqlite_source_id()].
109	*/
110	#define SQLITE_VERSION "3.8.0"
111	#define SQLITE_VERSION_NUMBER 3008000
112	#define SQLITE_SOURCE_ID "2013-06-28 23:55:45 338826ef3f8a209b14f8d42370855cab9ac9ed45"
113
114	/*
115	** CAPI3REF: Run-Time Library Version Numbers
116	** KEYWORDS: sqlite3_version, sqlite3_sourceid
117	**
	@@ -478,10 +478,11 @@
478	#define SQLITE_IOERR_SEEK (SQLITE_IOERR \| (22<<8))
479	#define SQLITE_IOERR_DELETE_NOENT (SQLITE_IOERR \| (23<<8))
480	#define SQLITE_IOERR_MMAP (SQLITE_IOERR \| (24<<8))
481	#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED \| (1<<8))
482	#define SQLITE_BUSY_RECOVERY (SQLITE_BUSY \| (1<<8))
483	#define SQLITE_BUSY_SNAPSHOT (SQLITE_BUSY \| (2<<8))
484	#define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN \| (1<<8))
485	#define SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN \| (2<<8))
486	#define SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN \| (3<<8))
487	#define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT \| (1<<8))
488	#define SQLITE_READONLY_RECOVERY (SQLITE_READONLY \| (1<<8))
	@@ -497,10 +498,11 @@
498	#define SQLITE_CONSTRAINT_TRIGGER (SQLITE_CONSTRAINT \| (7<<8))
499	#define SQLITE_CONSTRAINT_UNIQUE (SQLITE_CONSTRAINT \| (8<<8))
500	#define SQLITE_CONSTRAINT_VTAB (SQLITE_CONSTRAINT \| (9<<8))
501	#define SQLITE_NOTICE_RECOVER_WAL (SQLITE_NOTICE \| (1<<8))
502	#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE \| (2<<8))
503	#define SQLITE_WARNING_AUTOINDEX (SQLITE_WARNING \| (1<<8))
504
505	/*
506	** CAPI3REF: Flags For File Open Operations
507	**
508	** These bit values are intended for use in the
509

Fossil SCM

Keyboard Shortcuts